public List <Tuple <Instance, double> >[] CreateChildrenInstances(IEnumerable <Tuple <Instance, double> > instances,
IChildSelector selector, double threshold = 0)
{
List <Tuple <Instance, double> >[] result = new List <Tuple <Instance, double> > [selector.ChildrenCount];
for (int i = 0; i < selector.ChildrenCount; i++)
{
result[i] = new List <Tuple <Instance, double> >();
}
foreach (var tuple in instances)
{
double[] selection = selector.Select(tuple.Item1);
if (selection != null)
{
for (int i = 0; i < selection.Length; i++)
{
if (selection[i] > 0)
{
double newMembership = selection[i] * tuple.Item2;
if (newMembership >= threshold)
{
result[i].Add(Tuple.Create(tuple.Item1, newMembership));
}
}
}
}
}
return(result);
}
public override Item GetItem(IChildSelector generalSelector, int index)
{
CutPointSelector selector = (CutPointSelector)generalSelector;
if (index == 0)
{
return new LessOrEqualThanItem
{
Feature = selector.Feature,
Value = selector.CutPoint
}
}
;
else if (index == 1)
{
return new GreatherThanItem
{
Feature = selector.Feature,
Value = selector.CutPoint
}
}
;
else
{
throw new InvalidOperationException("Invalid index value for CutPointSelector");
}
}
public override Item GetItem(IChildSelector generalSelector, int index)
{
MultivariateCutPointSelector selector = (MultivariateCutPointSelector)generalSelector;
if (index == 0)
{
return new MultivariateLessOrEqualThanItem(selector.Weights)
{
Features = selector.Features,
Value = selector.CutPoint,
FeaturesHash = ((IStructuralEquatable)selector.Features).GetHashCode(EqualityComparer <Feature> .Default),
}
}
;
else if (index == 1)
{
return new MultivariateGreatherThanItem(selector.Weights)
{
Features = selector.Features,
Value = selector.CutPoint,
FeaturesHash = ((IStructuralEquatable)selector.Features).GetHashCode(EqualityComparer <Feature> .Default),
}
}
;
else
{
throw new InvalidOperationException("Invalid index value for CutPointSelector");
}
}
public override Item GetItem(IChildSelector generalSelector, int index)
{
ValueAndComplementSelector selector = (ValueAndComplementSelector)generalSelector;
if (index == 0)
{
return new EqualThanItem()
{
Feature = selector.Feature,
Value = selector.Value
}
}
;
else if (index == 1)
{
return new DifferentThanItem()
{
Feature = selector.Feature,
Value = selector.Value
}
}
;
else
{
throw new InvalidOperationException("Invalid index value for ValueAndComplementSelector");
}
}
public IEnumerable <IEmergingPattern> Mine(InstanceModel model, IEnumerable <Instance> instances, Feature classFeature)
{
EmergingPatternCreator EpCreator = new EmergingPatternCreator();
IEmergingPatternSimplifier simplifier;
if (Multivariate)
{
simplifier = new EmergingPatternSimplifier(new MultivariateItemComparer());
}
else
{
simplifier = new EmergingPatternSimplifier(new ItemComparer());
}
List <IEmergingPattern> patternsList = new List <IEmergingPattern>();
if (MinePatternsWhileBuildingTree)
{
DecisionTreeBuilder.OnSplitEvaluation =
delegate(IDecisionTreeNode node, ISplitIterator iterator, List <SelectorContext> currentContext)
{
IChildSelector currentSelector = null;
for (int i = 0; i < iterator.CurrentDistribution.Length; i++)
{
double[] distribution = iterator.CurrentDistribution[i];
if (EPTester.Test(distribution, model, classFeature))
{
if (currentSelector == null)
{
currentSelector = iterator.CreateCurrentChildSelector();
}
EmergingPattern ep = EpCreator.ExtractPattern(currentContext, model, classFeature,
currentSelector, i);
ep.Counts = (double[])distribution.Clone();
patternsList.Add(simplifier.Simplify(ep));
}
}
};
DoMine(model, instances, classFeature, EpCreator, null);
}
else
{
DoMine(model, instances, classFeature, EpCreator, p =>
{
if (EPTester.Test(p.Counts, model, classFeature))
{
patternsList.Add(simplifier.Simplify(p));
}
}
);
}
return(patternsList);
}
public EmergingPattern ExtractPattern(List <SelectorContext> currentContext, InstanceModel model,
Feature classFeature, IChildSelector selector, int index)
{
return
(Create(
currentContext.Union(new List <SelectorContext>
{
new SelectorContext
{
Selector = selector,
Index = index
}
}), model, classFeature));
}
public override Item GetItem(IChildSelector generalSelector, int index)
{
MultipleValuesSelector selector = (MultipleValuesSelector)generalSelector;
if (index < 0 || index >= selector.Values.Length)
{
throw new InvalidOperationException("Invalid index value for MultipleValuesSelector");
}
return(new EqualThanItem
{
Feature = selector.Feature,
Value = selector.Values[index]
});
}
public EmergingPattern Create(IEnumerable <SelectorContext> contexes, InstanceModel model, Feature classFeature)
{
EmergingPattern result = new EmergingPattern(model, classFeature, 0);
foreach (SelectorContext context in contexes)
{
IChildSelector childSelector = context.Selector;
ItemBuilder builder;
if (!builderForType.TryGetValue(childSelector.GetType(), out builder))
{
throw new InvalidOperationException(string.Format("Unknown selector: '{0}'", childSelector.GetType().Name));
}
Item item = builder.GetItem(childSelector, context.Index);
item.Model = model;
result.Items.Add(item);
}
return(result);
}
public bool EvaluateThis(double currentGain, ISplitIterator splitIterator, int level)
{
if (list.Count < _whichBetterToFind || currentGain > minStoredValue)
{
IChildSelector currentChildSelector = splitIterator.CreateCurrentChildSelector();
if (CanAcceptChildSelector(currentChildSelector, level))
{
list.Add(Tuple.Create(currentGain, currentChildSelector,
splitIterator.CurrentDistribution.CloneArray()));
list.Sort(comparer);
if (list.Count > _whichBetterToFind)
{
list.RemoveAt(_whichBetterToFind);
}
int index = Math.Min(_whichBetterToFind - 1, list.Count - 1);
minStoredValue = list[index].Item1;
return(true);
}
}
return(false);
}
private void FillNode(ref Dictionary <IDecisionTreeNode, double> validityIndexByNode, InstanceModel model, ref Dictionary <IDecisionTreeNode, IEnumerable <Tuple <Instance, double> > > instancesByNode,
Feature classFeature, ref Dictionary <IDecisionTreeNode, int> levelByNode, List <SelectorContext> currentContext, ref int leafCount)
{
IDecisionTreeNode node = null;
double bestIndexValue = Double.MinValue;
foreach (var currentNode in validityIndexByNode.Keys)
{
if (bestIndexValue < validityIndexByNode[currentNode])
{
bestIndexValue = validityIndexByNode[currentNode];
node = currentNode;
}
}
if (node != null)
{
int level = levelByNode[node];
var instances = instancesByNode[node];
int whichBetterToFind = 1;
if (OnSelectingWhichBetterSplit != null)
{
whichBetterToFind = OnSelectingWhichBetterSplit(node, level);
}
WiningSplitSelector winingSplitSelector = new WiningSplitSelector(whichBetterToFind)
{
CanAcceptChildSelector = this.CanAcceptChildSelector,
};
foreach (var feature in OnSelectingFeaturesToConsider(model.Features, level))
{
if (feature != classFeature)
{
ISplitIterator splitIterator = SplitIteratorProvider.GetSplitIterator(model, feature, classFeature);
if (splitIterator == null)
{
throw new InvalidOperationException(string.Format("Undefined iterator for feature {0}",
feature));
}
splitIterator.Initialize(feature, instances);
while (splitIterator.FindNext())
{
double currentGain = DistributionEvaluator.Evaluate(node.Data,
splitIterator.CurrentDistribution);
if (currentGain > MinimalSplitGain || leafCount < ClusterCount)
{
if (OnSplitEvaluation != null)
{
OnSplitEvaluation(node, splitIterator, currentContext);
}
winingSplitSelector.EvaluateThis(currentGain, splitIterator, level);
}
}
}
}
if (winingSplitSelector.IsWinner())
{
IChildSelector maxSelector = winingSplitSelector.WinningSelector;
node.ChildSelector = maxSelector;
node.Children = new IDecisionTreeNode[maxSelector.ChildrenCount];
var instancesPerChildNode =
childrenInstanceCreator.CreateChildrenInstances(instances, maxSelector, double.MinValue);
for (int i = 0; i < maxSelector.ChildrenCount; i++)
{
var childNode = new DecisionTreeNode {
Parent = node
};
node.Children[i] = childNode;
childNode.Data = winingSplitSelector.WinningDistribution[i];
SelectorContext context = null;
if (OnSplitEvaluation != null)
{
context = new SelectorContext
{
Index = i,
Selector = node.ChildSelector,
};
currentContext.Add(context);
}
double currentBestValidityIndex = double.MinValue;
foreach (var feature in OnSelectingFeaturesToConsider(model.Features, level))
{
if (feature != classFeature)
{
ISplitIterator splitIterator = SplitIteratorProvider.GetSplitIterator(model, feature, classFeature);
if (splitIterator == null)
{
throw new InvalidOperationException(string.Format("Undefined iterator for feature {0}",
feature));
}
splitIterator.Initialize(feature, instancesPerChildNode[i]);
while (splitIterator.FindNext())
{
double currentGain = DistributionEvaluator.Evaluate(node.Data,
splitIterator.CurrentDistribution);
if (currentGain > currentBestValidityIndex)
{
if (OnSplitEvaluation != null)
{
OnSplitEvaluation(node, splitIterator, currentContext);
}
currentBestValidityIndex = currentGain;
}
}
}
}
if (currentBestValidityIndex > validityIndexByNode[node] || leafCount < ClusterCount)
{
validityIndexByNode.Add(childNode, currentBestValidityIndex);
instancesByNode.Add(childNode, instancesPerChildNode[i]);
levelByNode.Add(childNode, level + 1);
}
if (OnSplitEvaluation != null)
{
currentContext.Remove(context);
}
}
validityIndexByNode.Remove(node);
instancesByNode.Remove(node);
levelByNode.Remove(node);
leafCount++;
if (leafCount < 4 * ClusterCount)
{
FillNode(ref validityIndexByNode, model, ref instancesByNode, classFeature, ref levelByNode, currentContext, ref leafCount);
}
}
}
}
public abstract Item GetItem(IChildSelector generalSelector, int index);
public DecisionTreeNode(double[] data, IChildSelector selector = null, params IDecisionTreeNode[] children)
{
Data = data;
ChildSelector = selector;
Children = children;
}
