bestSuggestions = new LinkedList<>();
+ double[] preSplitDist = observedClassDistribution.getArrayCopy();
+ if (!noPrePrune) {
+ // add null split as an option
+ bestSuggestions.add(new AttributeSplitSuggestion(null,
+ new double[0][], criterion.getMeritOfSplit(
+ preSplitDist, new double[][]{preSplitDist})));
+ }
+ for (int i = 0; i < attributeObservers.size(); i++) {
+ AttributeClassObserver obs = attributeObservers.get(i);
+ if (obs != null) {
+ AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(
+ criterion, preSplitDist, i, binaryOnly
+ );
+ if (bestSuggestion != null) {
+ bestSuggestions.add(bestSuggestion);
+ }
+ }
+ }
+ return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+ }
+
+ /**
+ * Train on the provided instance. Re-evaluate the tree
+ *
+ * @param instance the instance to train on
+ * @param totalNumInstances the total number of instances observed so far. (not used in EFDT but might be overwritten by subclasses)
+ **/
+ public void learnInstance(Instance instance, int totalNumInstances) {
+ seenWeight += instance.weight();
+ nodeTime++;
+ updateStatistics(instance);
+ updateObservers(instance);
+
+ if (isLeaf() && nodeTime % gracePeriod == 0) {
+ attemptInitialSplit(instance);
+ }
+ if (!isLeaf() && nodeTime % minSamplesReevaluate == 0) {
+ reevaluateSplit(instance);
+ }
+ if (!isLeaf()) {
+ propagateToSuccessors(instance, totalNumInstances);
+ }
+
+ if (!"MC".equals(leafPrediction))
+ updateNaiveBayesAdaptive(instance);
+ }
+
+ public void updateNaiveBayesAdaptive(Instance inst) {
+ int trueClass = (int) inst.classValue();
+ if (this.observedClassDistribution.maxIndex() == trueClass) {
+ this.mcCorrectWeight += inst.weight();
+ }
+ if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
+ this.observedClassDistribution, this.attributeObservers)) == trueClass) {
+ this.nbCorrectWeight += inst.weight();
+ }
+ }
+
+ /**
+ * Predict the provided instance
+ *
+ * Traverses the tree until reaching a leaf and then returns the class votes of that leaf.
+ *
+ *
+ * @param instance the instance to predict
+ * @return the class votes
+ **/
+ public double[] predict(Instance instance) {
+ if (!isLeaf()) {
+ CustomEFDTNode successor = getSuccessor(instance);
+ if (successor == null)
+ return getClassVotes();
+ return successor.predict(instance);
+ }
+ if ("MC".equals(leafPrediction))
+ return getClassVotes();
+ else if ("NB".equals(leafPrediction))
+ return NaiveBayes.doNaiveBayesPrediction(instance, this.observedClassDistribution, this.attributeObservers);
+ else
+ return doNBAdaptive(instance);
+ }
+
+ private double[] doNBAdaptive(Instance instance) {
+ if (this.mcCorrectWeight > this.nbCorrectWeight) {
+ return this.observedClassDistribution.getArrayCopy();
+ }
+ return NaiveBayes.doNaiveBayesPrediction(instance,
+ this.observedClassDistribution, this.attributeObservers);
+ }
+
+ /**
+ * Finds the successor of the current node based on the provided instance.
+ *
+ * @param instance the instance
+ * @return the successor node if it exists. Else, returns null.
+ **/
+ CustomEFDTNode getSuccessor(Instance instance) {
+ if (isLeaf())
+ return null;
+ Double attVal = instance.value(splitAttribute);
+ return successors.getSuccessorNode(attVal);
+ }
+
+ /**
+ * Attempts to split this leaf
+ *
+ * @param instance the current instance
+ **/
+ protected void attemptInitialSplit(Instance instance) {
+ if (depth >= maxDepth) {
+ return;
+ }
+ if (isPure())
+ return;
+
+ numSplitAttempts++;
+
+ AttributeSplitSuggestion[] bestSuggestions = getBestSplitSuggestions(splitCriterion);
+ Arrays.sort(bestSuggestions);
+ AttributeSplitSuggestion xBest = bestSuggestions[bestSuggestions.length - 1];
+ xBest = replaceBestSuggestionIfAttributeIsBlocked(xBest, bestSuggestions, blockedAttributeIndex);
+
+ if (!shouldSplitLeaf(bestSuggestions, currentConfidence(), observedClassDistribution))
+ return;
+ if (xBest.splitTest == null) {
+ // preprune - null wins
+ System.out.println("preprune - null wins");
+ killSubtree();
+ resetSplitAttribute();
+ return;
+ }
+ int instanceIndex = modelAttIndexToInstanceAttIndex(xBest.splitTest.getAttsTestDependsOn()[0], instance);
+ Attribute newSplitAttribute = instance.attribute(instanceIndex);
+ makeSplit(newSplitAttribute, xBest);
+ classDistributionAtTimeOfCreation = new DoubleVector(observedClassDistribution.getArrayCopy());
+ }
+
+ /**
+ * Reevaluates a split decision that was already made
+ *
+ * @param instance the current instance
+ **/
+ protected void reevaluateSplit(Instance instance) {
+ numSplitAttempts++;
+
+ AttributeSplitSuggestion[] bestSuggestions = getBestSplitSuggestions(splitCriterion);
+ Arrays.sort(bestSuggestions);
+ if (bestSuggestions.length == 0)
+ return;
+
+ // get best split suggestions
+ AttributeSplitSuggestion[] bestSplitSuggestions = getBestSplitSuggestions(splitCriterion);
+ Arrays.sort(bestSplitSuggestions);
+ AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+ double bestSuggestionAverageMerit = bestSuggestion.splitTest == null ? 0.0 : bestSuggestion.merit;
+ double currentAverageMerit = getCurrentSuggestionAverageMerit(bestSuggestions);
+ double deltaG = bestSuggestionAverageMerit - currentAverageMerit;
+ double eps = computeHoeffdingBound();
+
+ if (deltaG > eps || (eps < tauReevaluate && deltaG > tauReevaluate * relMinDeltaG)) {
+
+ if (bestSuggestion.splitTest == null) {
+ System.out.println("preprune - null wins");
+ killSubtree();
+ resetSplitAttribute();
+ } else {
+ boolean doResplit = true;
+ if (
+ getSplitTest() instanceof NumericAttributeBinaryTest
+ && getSplitTest().getAttsTestDependsOn()[0] == bestSuggestion.splitTest.getAttsTestDependsOn()[0]
+ ) {
+ Set keys = successors.getKeyset();
+ for (SuccessorIdentifier key: keys) {
+ if (key.isLower()) {
+ if (argmax(bestSuggestion.resultingClassDistributions[0]) == argmax(successors.getSuccessorNode(key).observedClassDistribution.getArrayRef())) {
+ doResplit = false;
+ break;
+ }
+ }
+ else {
+ if (argmax(bestSuggestion.resultingClassDistributions[1]) == argmax(successors.getSuccessorNode(key).observedClassDistribution.getArrayRef())) {
+ doResplit = false;
+ break;
+ }
+ }
+ }
+ }
+ performedTreeRevision = true;
+ if (!doResplit) {
+ NumericAttributeBinaryTest test = (NumericAttributeBinaryTest) bestSuggestion.splitTest;
+ successors.adjustThreshold(test.getSplitValue());
+ setSplitTest(bestSuggestion.splitTest);
+ nodeTime = 0;
+ seenWeight = 0.0;
+ }
+ else {
+ int instanceIndex = modelAttIndexToInstanceAttIndex(bestSuggestion.splitTest.getAttsTestDependsOn()[0], instance);
+ Attribute newSplitAttribute = instance.attribute(instanceIndex);
+ makeSplit(newSplitAttribute, bestSuggestion);
+ nodeTime = 0;
+ seenWeight = 0.0;
+ }
+ }
+ }
+ }
+
+ /**
+ * Initializes the successor nodes when performing a split
+ *
+ * @param xBest the split suggestion for the best split
+ * @param splitAttribute the attribute to split on
+ * @return if the initialization was successful.
+ **/
+ protected boolean initializeSuccessors(AttributeSplitSuggestion xBest, Attribute splitAttribute) {
+ boolean isNominal = splitAttribute.isNominal();
+ boolean isBinary = !(xBest.splitTest instanceof NominalAttributeMultiwayTest);
+ Double splitValue = null;
+ if (isNominal && isBinary)
+ splitValue = ((NominalAttributeBinaryTest) xBest.splitTest).getValue();
+ else if (!isNominal)
+ splitValue = ((NumericAttributeBinaryTest) xBest.splitTest).getSplitValue();
+
+ Integer splitAttributeIndex = xBest.splitTest.getAttsTestDependsOn()[0];
+ if (splitAttribute.isNominal()) {
+ if (!isBinary) {
+ for (int i = 0; i < xBest.numSplits(); i++) {
+ double[] stats = xBest.resultingClassDistributionFromSplit(i);
+ if (stats.length == 0)
+ continue;
+ CustomEFDTNode s = newNode(
+ depth + 1,
+ new DoubleVector(stats),
+ getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex));
+ boolean success = successors.addSuccessorNominalMultiway((double) i, s);
+ if (!success) {
+ successors = null;
+ return false;
+ }
+ }
+ return !isLeaf();
+ } else {
+ double[] stats1 = xBest.resultingClassDistributionFromSplit(0);
+ double[] stats2 = xBest.resultingClassDistributionFromSplit(1);
+ CustomEFDTNode s1 = newNode(depth + 1, new DoubleVector(stats1), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex));
+ CustomEFDTNode s2 = newNode(depth + 1, new DoubleVector(stats2), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex));
+ boolean success = successors.addSuccessorNominalBinary(splitValue, s1);
+ success = success && successors.addDefaultSuccessorNominalBinary(s2);
+ if (!success) {
+ successors = null;
+ return false;
+ }
+ return !isLeaf();
+ }
+ } else {
+ boolean success = successors.addSuccessorNumeric(
+ splitValue,
+ newNode(depth + 1, new DoubleVector(xBest.resultingClassDistributionFromSplit(0)), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex)),
+ true
+ );
+ success = success && successors.addSuccessorNumeric(
+ splitValue,
+ newNode(depth + 1, new DoubleVector(xBest.resultingClassDistributionFromSplit(1)), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex)),
+ false
+ );
+ if (!success) {
+ successors = null;
+ return false;
+ }
+ return !isLeaf();
+ }
+ }
+
+ /**
+ * Sets the split attribute for this node
+ *
+ * @param xBest the split suggestion for the best split
+ * @param splitAttribute the attribute to split on
+ **/
+ protected void setSplitAttribute(AttributeSplitSuggestion xBest, Attribute splitAttribute) {
+ this.splitAttribute = splitAttribute;
+ setSplitTest(xBest.splitTest);
+ }
+
+ protected void resetSplitAttribute() {
+ splitAttribute = null;
+ splitTest = null;
+ }
+
+ /**
+ * Kills the subtree by removing the link to the successors
+ */
+ protected void killSubtree() {
+ successors = null;
+ }
+
+ double[] getClassVotes() {
+ return observedClassDistribution.getArrayCopy();
+ }
+
+ /**
+ * Updates the class statistics (which class occurred how often)
+ * @param instance the current instance
+ */
+ protected void updateStatistics(Instance instance) {
+ observedClassDistribution.addToValue((int) instance.classValue(), instance.weight());
+ }
+
+ /**
+ * Propagates the instance down the tree
+ * @param instance the current instance
+ * @param totalNumInstances the number of instances seen so far
+ */
+ protected void propagateToSuccessors(Instance instance, int totalNumInstances) {
+ Double attValue = instance.value(splitAttribute);
+ CustomEFDTNode successor = successors.getSuccessorNode(attValue);
+ if (successor == null)
+ successor = addSuccessor(instance);
+ if (successor != null)
+ successor.learnInstance(instance, totalNumInstances);
+ }
+
+ /**
+ * Add a successor to the children
+ * @param instance the current instance
+ * @return the creates successor. Null, if the successor could not be created
+ */
+ protected CustomEFDTNode addSuccessor(Instance instance) {
+ List usedNomAttributes = new ArrayList<>(usedNominalAttributes); //deep copy
+ CustomEFDTNode successor = newNode(depth + 1, null, usedNomAttributes);
+ double value = instance.value(splitAttribute);
+ if (splitAttribute.isNominal()) {
+ if (!successors.isBinary()) {
+ boolean success = successors.addSuccessorNominalMultiway(value, successor);
+ return success ? successor : null;
+ } else {
+ boolean success = successors.addSuccessorNominalBinary(value, successor);
+ if (!success) // this is the case if the split is binary nominal but the "left" successor exists.
+ success = successors.addDefaultSuccessorNominalBinary(successor);
+ return success ? successor : null;
+ }
+ } else {
+ if (successors.lowerIsMissing()) {
+ boolean success = successors.addSuccessorNumeric(value, successor, true);
+ return success ? successor : null;
+ } else if (successors.upperIsMissing()) {
+ boolean success = successors.addSuccessorNumeric(value, successor, false);
+ return success ? successor : null;
+ }
+ }
+ return null;
+ }
+
+ protected CustomEFDTNode newNode(int depth, DoubleVector classDistribution, List usedNominalAttributes) {
+ return new CustomEFDTNode(
+ splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence,
+ leafPrediction, minSamplesReevaluate, depth, maxDepth,
+ tau, tauReevaluate, relMinDeltaG, binaryOnly, noPrePrune, nominalObserverBlueprint,
+ classDistribution, usedNominalAttributes, -1 // we don't block attributes in EFDT
+ );
+ }
+
+ protected void updateObservers(Instance instance) {
+ for (int i = 0; i < instance.numAttributes() - 1; i++) { //update likelihood
+ int instAttIndex = modelAttIndexToInstanceAttIndex(i, instance);
+ AttributeClassObserver obs = this.attributeObservers.get(i);
+ if (obs == null) {
+ obs = instance.attribute(instAttIndex).isNominal() ? newNominalClassObserver() : newNumericClassObserver();
+ this.attributeObservers.set(i, obs);
+ }
+ obs.observeAttributeClass(instance.value(instAttIndex), (int) instance.classValue(), instance.weight());
+ }
+ }
+
+ /**
+ * If this node is a leaf node
+ * @return true if the node is a leaf
+ */
+ boolean isLeaf() {
+ if (successors == null)
+ return true;
+ return successors.size() == 0;
+ }
+
+ /**
+ * If this node only has seen instances of the same class
+ * @return true if the number of observed classes is less than 2
+ */
+ boolean isPure() {
+ return observedClassDistribution.numNonZeroEntries() < 2;
+ }
+
+ protected NominalAttributeClassObserver newNominalClassObserver() {
+ return (NominalAttributeClassObserver) nominalObserverBlueprint.copy();
+ }
+
+ protected NumericAttributeClassObserver newNumericClassObserver() {
+ return (NumericAttributeClassObserver) numericObserverBlueprint.copy();
+ }
+
+ protected List getUsedNominalAttributesForSuccessor(Attribute splitAttribute, Integer splitAttributeIndex) {
+ List usedNomAttributesCpy = new ArrayList<>(usedNominalAttributes); //deep copy
+ if (splitAttribute.isNominal())
+ usedNomAttributesCpy.add(splitAttributeIndex);
+ return usedNomAttributesCpy;
+ }
+
+ protected void updateInfogainSum(AttributeSplitSuggestion[] suggestions) {
+ for (AttributeSplitSuggestion sugg : suggestions) {
+ if (sugg.splitTest != null) {
+ if (!infogainSum.containsKey((sugg.splitTest.getAttsTestDependsOn()[0]))) {
+ infogainSum.put((sugg.splitTest.getAttsTestDependsOn()[0]), 0.0);
+ }
+ double currentSum = infogainSum.get((sugg.splitTest.getAttsTestDependsOn()[0]));
+ infogainSum.put((sugg.splitTest.getAttsTestDependsOn()[0]), currentSum + sugg.merit);
+ } else { // handle the null attribute
+ double currentSum = infogainSum.get(-1); // null split
+ infogainSum.put(-1, Math.max(0.0, currentSum + sugg.merit));
+ assert infogainSum.get(-1) >= 0.0 : "Negative infogain shouldn't be possible here.";
+ }
+ }
+ }
+
+ protected boolean shouldSplitLeaf(AttributeSplitSuggestion[] suggestions,
+ double confidence,
+ DoubleVector observedClassDistribution
+ ) {
+ boolean shouldSplit = false;
+ if (suggestions.length < 2) {
+ shouldSplit = suggestions.length > 0;
+ } else {
+ AttributeSplitSuggestion bestSuggestion = suggestions[suggestions.length - 1];
+
+ double bestSuggestionAverageMerit = bestSuggestion.merit;
+ double currentAverageMerit = 0.0;
+ double eps = computeHoeffdingBound();
+
+ shouldSplit = bestSuggestionAverageMerit - currentAverageMerit > eps || eps < tau;
+ if (bestSuggestion.merit < 1e-10)
+ shouldSplit = false; // we don't use average here
+
+ if (shouldSplit) {
+ for (Integer i : usedNominalAttributes) {
+ if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i) {
+ shouldSplit = false;
+ break;
+ }
+ }
+ }
+ }
+ return shouldSplit;
+ }
+
+ /**
+ * Get the merit if the current split
+ * @param suggestions the suggestions for the possible splits
+ * @return the merit of the current split
+ */
+ double getCurrentSuggestionAverageMerit(AttributeSplitSuggestion[] suggestions) {
+ double merit = 0.0;
+ if (splitTest != null) {
+ if (splitTest instanceof NominalAttributeMultiwayTest) {
+ for (AttributeSplitSuggestion s: suggestions) {
+ if (s.splitTest == null)
+ continue;
+ if (s.splitTest.getAttsTestDependsOn()[0] == getSplitAttributeIndex()) {
+ merit = s.merit;
+ break;
+ }
+ }
+ }
+ else if (splitTest instanceof NominalAttributeBinaryTest) {
+ double currentValue = successors.getReferenceValue();
+ NominalAttributeClassObserver obs = (NominalAttributeClassObserver) attributeObservers.get(getSplitAttributeIndex());
+ AttributeSplitSuggestion xCurrent = obs.forceSplit(splitCriterion, observedClassDistribution.getArrayCopy(), getSplitAttributeIndex(), true, currentValue);
+ merit = xCurrent == null ? 0.0 : xCurrent.merit;
+ if (xCurrent != null)
+ merit = xCurrent.splitTest == null ? 0.0 : xCurrent.merit;
+ }
+ else if (splitTest instanceof NumericAttributeBinaryTest) {
+ double currentThreshold = successors.getReferenceValue();
+ GaussianNumericAttributeClassObserver obs = (GaussianNumericAttributeClassObserver) attributeObservers.get(getSplitAttributeIndex());
+ AttributeSplitSuggestion xCurrent = obs.forceSplit(splitCriterion, observedClassDistribution.getArrayCopy(), getSplitAttributeIndex(), currentThreshold);
+ merit = xCurrent == null ? 0.0 : xCurrent.merit;
+ if (xCurrent != null)
+ merit = xCurrent.splitTest == null ? 0.0 : xCurrent.merit;
+ }
+ }
+ return merit == Double.NEGATIVE_INFINITY ? 0.0 : merit;
+ }
+
+ double getSuggestionAverageMerit(InstanceConditionalTest splitTest) {
+ double averageMerit;
+
+ if (splitTest == null) {
+ averageMerit = infogainSum.get(-1) / Math.max(numSplitAttempts, 1.0);
+ } else {
+ Integer key = splitTest.getAttsTestDependsOn()[0];
+ if (!infogainSum.containsKey(key)) {
+ infogainSum.put(key, 0.0);
+ }
+ averageMerit = infogainSum.get(key) / Math.max(numSplitAttempts, 1.0);
+ }
+ return averageMerit;
+ }
+
+ int argmax(double[] array) {
+ double max = array[0];
+ int maxarg = 0;
+
+ for (int i = 1; i < array.length; i++) {
+
+ if (array[i] > max) {
+ max = array[i];
+ maxarg = i;
+ }
+ }
+ return maxarg;
+ }
+
+ public int getSubtreeDepth() {
+ if (isLeaf())
+ return depth;
+ Set succDepths = new HashSet<>();
+ for (CustomEFDTNode successor: successors.getAllSuccessors()) {
+ succDepths.add(successor.getSubtreeDepth());
+ }
+ return Collections.max(succDepths);
+ }
+
+ /**
+ * Replaces the best split suggestion if the node is not allowed to split on that attribute.
+ * This is the case when the parent node splits on that attribute. It prevents splitting the space into thinner and thinner slices.
+ * @param bestSuggestion the best split suggestion
+ * @param suggestions all suggestions
+ * @param blockedAttributeIndex the attribute index of the blocked attribute
+ * @return
+ */
+ AttributeSplitSuggestion replaceBestSuggestionIfAttributeIsBlocked(AttributeSplitSuggestion bestSuggestion, AttributeSplitSuggestion[] suggestions, int blockedAttributeIndex) {
+ if (suggestions.length == 0)
+ return null;
+ if (bestSuggestion.splitTest == null)
+ return bestSuggestion;
+ if (suggestions.length == 1)
+ return bestSuggestion;
+ if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == blockedAttributeIndex) {
+ ArrayUtils.remove(suggestions, suggestions.length - 1);
+ return suggestions[suggestions.length - 1];
+ }
+ return bestSuggestion;
+ }
+
+ protected boolean makeSplit(Attribute splitAttribute, AttributeSplitSuggestion suggestion) {
+ boolean isNominal = splitAttribute.isNominal();
+ boolean isBinary = !(suggestion.splitTest instanceof NominalAttributeMultiwayTest);
+ Double splitValue = null;
+ if (isNominal && isBinary)
+ splitValue = ((NominalAttributeBinaryTest) suggestion.splitTest).getValue();
+ else if (!isNominal)
+ splitValue = ((NumericAttributeBinaryTest) suggestion.splitTest).getSplitValue();
+
+ successors = new Successors(isBinary, !isNominal, splitValue);
+
+ setSplitAttribute(suggestion, splitAttribute);
+ return initializeSuccessors(suggestion, splitAttribute);
+ }
+
+ /**
+ * Checks if the subtree of this node performed split revision
+ * @return true if any node in the subtree performed a split revision
+ */
+ @Override
+ public boolean didPerformTreeRevision() {
+ boolean didRevise = performedTreeRevision;
+ performedTreeRevision = false;
+ if (isLeaf()) {
+ return didRevise;
+ }
+ for (CustomEFDTNode child: successors.getAllSuccessors()) {
+ didRevise |= child.didPerformTreeRevision();
+ }
+ return didRevise;
+ }
+
+ @Override
+ public int getLeafNumber() {
+ if (isLeaf())
+ return 1;
+ int sum = 0;
+ for (CustomEFDTNode s: successors.getAllSuccessors()) {
+ sum += s.getLeafNumber();
+ }
+ return sum;
+ }
+
+ @Override
+ public void getDescription(StringBuilder sb, int indent) {
+
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/CustomHTNode.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/CustomHTNode.java
new file mode 100644
index 000000000..9ab193dec
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/CustomHTNode.java
@@ -0,0 +1,80 @@
+package moa.classifiers.trees.plastic_util;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.DoubleVector;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class CustomHTNode extends CustomEFDTNode {
+
+ public CustomHTNode(SplitCriterion splitCriterion,
+ int gracePeriod,
+ Double confidence,
+ Double adaptiveConfidence,
+ boolean useAdaptiveConfidence,
+ String leafPrediction,
+ Integer depth,
+ Integer maxDepth,
+ Double tau,
+ boolean binaryOnly,
+ boolean noPrePrune,
+ NominalAttributeClassObserver nominalObserverBlueprint,
+ DoubleVector observedClassDistribution,
+ List usedNominalAttributes,
+ int blockedAttributeIndex) {
+ super(splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence, leafPrediction,
+ Integer.MAX_VALUE, depth, maxDepth, tau, 0.0, 0.0, binaryOnly, noPrePrune,
+ nominalObserverBlueprint, observedClassDistribution, usedNominalAttributes, blockedAttributeIndex);
+
+ }
+
+ @Override
+ protected void reevaluateSplit(Instance instance) {
+ }
+
+ @Override
+ protected CustomHTNode newNode(int depth, DoubleVector classDistribution, List usedNominalAttributes) {
+ return new CustomHTNode(
+ splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence,
+ leafPrediction, depth, maxDepth,
+ tau, binaryOnly, noPrePrune, nominalObserverBlueprint,
+ classDistribution, new LinkedList<>(), -1 // we don't block attributes in HT
+ );
+ }
+
+ @Override
+ protected boolean shouldSplitLeaf(AttributeSplitSuggestion[] suggestions,
+ double confidence,
+ DoubleVector observedClassDistribution
+ ) {
+ boolean shouldSplit;
+ if (suggestions.length < 2) {
+ shouldSplit = suggestions.length > 0;
+ } else {
+ AttributeSplitSuggestion bestSuggestion = suggestions[suggestions.length - 1];
+ AttributeSplitSuggestion secondBestSuggestion = suggestions[suggestions.length - 2];
+
+ double bestSuggestionAverageMerit = bestSuggestion.merit;
+ double currentAverageMerit = secondBestSuggestion.merit;
+ double eps = computeHoeffdingBound();
+
+ shouldSplit = bestSuggestionAverageMerit - currentAverageMerit > eps || eps < tau;
+ if (bestSuggestion.merit < 1e-10)
+ shouldSplit = false; // we don't use average here
+
+ if (shouldSplit) {
+ for (Integer i : usedNominalAttributes) {
+ if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i) {
+ shouldSplit = false;
+ break;
+ }
+ }
+ }
+ }
+ return shouldSplit;
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/EFHATNode.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/EFHATNode.java
new file mode 100644
index 000000000..c76596c0c
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/EFHATNode.java
@@ -0,0 +1,174 @@
+package moa.classifiers.trees.plastic_util;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.DoubleVector;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class EFHATNode extends CustomEFDTNode {
+
+ private CustomADWINChangeDetector changeDetector; // we need to access the width of adwin to compute switch significance. This is not possible with the default adwin change detector class.
+ private EFHATNode backgroundLearner;
+ private LinkedList predictions = new LinkedList<>();
+ private boolean isBackgroundLearner = false;
+
+ public EFHATNode(SplitCriterion splitCriterion,
+ int gracePeriod,
+ Double confidence,
+ Double adaptiveConfidence,
+ boolean useAdaptiveConfidence,
+ String leafPrediction,
+ Integer minSamplesReevaluate,
+ Integer depth,
+ Integer maxDepth,
+ Double tau,
+ boolean binaryOnly,
+ boolean noPrePrune,
+ NominalAttributeClassObserver nominalObserverBlueprint,
+ DoubleVector observedClassDistribution,
+ List usedNominalAttributes,
+ int blockedAttributeIndex,
+ CustomADWINChangeDetector changeDetector) {
+ super(splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence, leafPrediction,
+ minSamplesReevaluate, depth, maxDepth, tau, 0.0, 0.0, binaryOnly, noPrePrune,
+ nominalObserverBlueprint, observedClassDistribution, usedNominalAttributes, blockedAttributeIndex);
+ this.changeDetector = changeDetector == null ? new CustomADWINChangeDetector() : changeDetector;
+ }
+
+ public EFHATNode(SplitCriterion splitCriterion,
+ int gracePeriod,
+ Double confidence,
+ Double adaptiveConfidence,
+ boolean useAdaptiveConfidence,
+ String leafPrediction,
+ Integer minSamplesReevaluate,
+ Integer depth,
+ Integer maxDepth,
+ Double tau,
+ boolean binaryOnly,
+ boolean noPrePrune,
+ NominalAttributeClassObserver nominalObserverBlueprint,
+ DoubleVector observedClassDistribution,
+ List usedNominalAttributes,
+ int blockedAttributeIndex,
+ CustomADWINChangeDetector changeDetector,
+ boolean isBackgroundLearner) {
+ super(splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence, leafPrediction,
+ minSamplesReevaluate, depth, maxDepth, tau, 0.0, 0.0, binaryOnly, noPrePrune,
+ nominalObserverBlueprint, observedClassDistribution, usedNominalAttributes, blockedAttributeIndex);
+ this.changeDetector = changeDetector == null ? new CustomADWINChangeDetector() : changeDetector;
+ this.isBackgroundLearner = isBackgroundLearner;
+ }
+
+ @Override
+ public double[] predict(Instance instance) {
+ double[] pred = super.predict(instance);
+ if (pred.length > 0)
+ predictions.add((double) argmax(pred));
+ if (backgroundLearner != null)
+ backgroundLearner.predict(instance);
+ return pred;
+ }
+
+ @Override
+ public void learnInstance(Instance instance, int totalNumInstances) {
+ seenWeight += instance.weight();
+ nodeTime++;
+ updateStatistics(instance);
+ updateObservers(instance);
+ updateChangeDetector(instance.classValue());
+
+ if (backgroundLearner != null)
+ backgroundLearner.learnInstance(instance, totalNumInstances);
+
+ if (isLeaf() && nodeTime % gracePeriod == 0)
+ attemptInitialSplit(instance);
+
+ if (!isLeaf()
+// && nodeTime % minSamplesReevaluate == 0
+ )
+ hatGrow();
+
+ if (!isLeaf()) //Do NOT! put this in the upper (!isleaf()) block. This is not the same since we might kill the subtree during reevaluation!
+ propagateToSuccessors(instance, totalNumInstances);
+ }
+
+ private void hatGrow() {
+ if (changeDetector.getChange()) {
+ backgroundLearner = newNode(depth, new DoubleVector(), new LinkedList<>(usedNominalAttributes));
+ backgroundLearner.isBackgroundLearner = true;
+ }
+ else if (backgroundLearner != null) {
+ // adopted from HAT implementation
+ if (changeDetector.getWidth() > minSamplesReevaluate && backgroundLearner.changeDetector.getWidth() > minSamplesReevaluate) {
+ double oldErrorRate = changeDetector.getEstimation();
+ double oldWS = changeDetector.getWidth();
+ double altErrorRate = backgroundLearner.changeDetector.getEstimation();
+ double altWS = backgroundLearner.changeDetector.getWidth();
+
+ double fDelta = .05;
+ //if (gNumAlts>0) fDelta=fDelta/gNumAlts;
+// double fN = 1.0 / w2 + 1.0 / w1;
+ double fN = 1.0 / altWS + 1.0 / oldWS;
+ double Bound = (double) Math.sqrt((double) 2.0 * oldErrorRate * (1.0 - oldErrorRate) * Math.log(2.0 / fDelta) * fN);
+
+// double significance = switchSignificance(e1, e2, w1, w2);
+ if (Bound < oldErrorRate - altErrorRate) {
+ performedTreeRevision = true;
+ makeBackgroundLearnerMainLearner();
+ }
+ else if (Bound < altErrorRate - oldErrorRate) {
+ // Erase alternate tree
+ backgroundLearner = null;
+ }
+ }
+ }
+ }
+
+ @Override
+ protected EFHATNode newNode(int depth, DoubleVector classDistribution, List usedNominalAttributes) {
+ return new EFHATNode(
+ splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence,
+ leafPrediction, minSamplesReevaluate, depth, maxDepth,
+ tau, binaryOnly, noPrePrune, nominalObserverBlueprint,
+ classDistribution, new LinkedList<>(),
+ -1, // we don't block attributes in HT
+ (CustomADWINChangeDetector) changeDetector.copy(),
+ isBackgroundLearner
+ );
+ }
+
+ private void makeBackgroundLearnerMainLearner() {
+ splitAttribute = backgroundLearner.splitAttribute;
+ successors = backgroundLearner.successors;
+ observedClassDistribution = backgroundLearner.observedClassDistribution;
+ classDistributionAtTimeOfCreation = backgroundLearner.classDistributionAtTimeOfCreation;
+ attributeObservers = backgroundLearner.attributeObservers;
+ seenWeight = backgroundLearner.seenWeight;
+ nodeTime = backgroundLearner.nodeTime;
+ numSplitAttempts = backgroundLearner.numSplitAttempts;
+ setSplitTest(backgroundLearner.getSplitTest());
+ backgroundLearner = null;
+ }
+
+ private void updateChangeDetector(double label) {
+ if (predictions.size() == 0)
+ return;
+ Double pred = predictions.removeFirst();
+ if (pred == null)
+ return;
+ changeDetector.input(pred == label ? 0.0 : 1.0); // monitoring error rate, not accuracy.
+ }
+
+ private void resetIsBackgroundLearnerInSubtree() {
+ isBackgroundLearner = false;
+ if (isLeaf())
+ return;
+ for (CustomEFDTNode n: successors.getAllSuccessors()) {
+ ((EFHATNode) n).resetIsBackgroundLearnerInSubtree();
+ }
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/MappedTree.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/MappedTree.java
new file mode 100644
index 000000000..7a678f7b0
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/MappedTree.java
@@ -0,0 +1,409 @@
+package moa.classifiers.trees.plastic_util;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+
+import java.util.*;
+
+class MappedTree implements Iterator {
+
+ private LinkedList branchQueue;
+ private final LinkedList finishedBranches = new LinkedList<>();
+
+ private final Attribute splitAttribute;
+ private final int splitAttributeIndex;
+ private final Double splitValue;
+ private final int maxBranchLength;
+
+ public MappedTree(PlasticNode root, Attribute splitAttribute, int splitAttributeIndex, Double splitValue, int maxBranchLength) {
+ branchQueue = disconnectRoot(root);
+
+ this.splitAttribute = splitAttribute;
+ this.splitAttributeIndex = splitAttributeIndex;
+ this.splitValue = splitValue;
+ this.maxBranchLength = maxBranchLength;
+ }
+
+
+ @Override
+ public boolean hasNext() {
+ return !(branchQueue.size() == 0 && finishedBranches.size() == 0);
+ }
+
+ @Override
+ public PlasticBranch next() {
+ if (finishedBranches.size() > 0) {
+ return finishedBranches.removeFirst();
+ }
+ else {
+ while (finishedBranches.size() == 0) {
+ mapBranches(branchQueue, splitAttribute, splitAttributeIndex, splitValue, maxBranchLength);
+ }
+ return finishedBranches.removeFirst();
+ }
+ }
+
+ private void mapBranches(
+ LinkedList branches,
+ Attribute swapAttribute,
+ int swapAttributeIndex,
+ Double splitValue,
+ int maxBranchLength
+ ) {
+ int numBranches = branches.size();
+ for (int i = 0; i < numBranches; i++) {
+ PlasticBranch branch = branches.removeFirst();
+ boolean branchIsFinished = getEndConditionForBranch(branch, swapAttribute, swapAttributeIndex, splitValue, maxBranchLength);
+ if (branchIsFinished) {
+ expandBranch(branch, swapAttribute, swapAttributeIndex, splitValue);
+ List decoupledBranches = decoupleLastNode(branch);
+ decoupledBranches.forEach(b -> modifyBranch(b, swapAttribute));
+ finishedBranches.addAll(decoupledBranches);
+ branchQueue = branches;
+ return;
+ }
+ PlasticTreeElement lastElement = branch.getLast();
+ PlasticBranch branchExtensions = disconnectSuccessors(lastElement, swapAttribute);
+ for (PlasticTreeElement extension: branchExtensions.getBranchRef()) {
+ PlasticBranch extendedBranch = new PlasticBranch((LinkedList) branch.getBranchRef().clone());
+ extendedBranch.getBranchRef().add(extension);
+ branches.add(extendedBranch);
+ }
+ }
+ branchQueue = branches;
+ }
+
+ private boolean getEndConditionForBranch(PlasticBranch branch, Attribute swapAttribute, int swapAttributeIndex, Double splitValue, int maxBranchLength) {
+ CustomEFDTNode lastNodeOfBranch = branch.getLast().getNode();
+ boolean isSwapAttribute = lastNodeOfBranch.getSplitAttribute() == swapAttribute;
+ boolean isLeaf = lastNodeOfBranch.isLeaf();
+ if (isSwapAttribute || isLeaf)
+ return true;
+ return branch.getBranchRef().size() >= maxBranchLength;
+ }
+
+ private PlasticBranch disconnectSuccessors(PlasticTreeElement ancestor, Attribute swapAttribute) {
+ PlasticBranch branchExtensions = new PlasticBranch();
+ PlasticNode ancestorNode = ancestor.getNode();
+ SuccessorIdentifier key = ancestor.getKey();
+ PlasticNode successor = (PlasticNode) ancestorNode.getSuccessors().getSuccessorNode(key);
+
+ boolean endCondition = successor.isLeaf() || successor.getSplitAttribute() == swapAttribute;
+
+ if (endCondition) {
+ PlasticTreeElement element = new PlasticTreeElement(successor, null);
+ branchExtensions.getBranchRef().add(element);
+ }
+ else {
+ for (SuccessorIdentifier successorSuccessorKey: successor.getSuccessors().getKeyset()) {
+ PlasticTreeElement element = new PlasticTreeElement(successor, successorSuccessorKey);
+ branchExtensions.getBranchRef().add(element);
+ }
+ }
+ return branchExtensions;
+ }
+
+ private LinkedList disconnectRoot(PlasticNode root) {
+ Successors successors = root.getSuccessors();
+ if (successors == null) {
+ return null;
+ }
+ if (successors.size() == 0) {
+ return null;
+ }
+ Set keys = successors.getKeyset();
+ LinkedList branches = new LinkedList<>();
+ for (SuccessorIdentifier key: keys) {
+ PlasticTreeElement newElement = new PlasticTreeElement(root, key);
+ PlasticBranch newBranch = new PlasticBranch();
+ newBranch.getBranchRef().add(newElement);
+ branches.add(newBranch);
+ }
+ return branches;
+ }
+
+ private void expandBranch(PlasticBranch branch, Attribute splitAttribute, int splitAttributeIndex, Double splitValue) {
+ if (splitAttribute.isNominal())
+ splitLastNodeIfRequiredCategorical(branch, splitAttribute, splitAttributeIndex, splitValue);
+ else
+ splitLastNodeIfRequiredNumeric(branch, splitAttribute, splitAttributeIndex, splitValue);
+ }
+
+ private LinkedList decoupleLastNode(PlasticBranch branch) {
+ PlasticNode lastNode = branch.getLast().getNode();
+ LinkedList decoupledBranches = new LinkedList<>();
+ Successors lastNodeSuccessors = lastNode.getSuccessors();
+
+ for (SuccessorIdentifier key: lastNodeSuccessors.getKeyset()) {
+ PlasticBranch branchCopy = branch.copy(); //TODO: Doublecheck if this is fine.
+ PlasticTreeElement replacedEndElement = new PlasticTreeElement(branchCopy.getLast().getNode(), key);
+ branchCopy.getBranchRef().removeLast();
+ branchCopy.getBranchRef().add(replacedEndElement);
+ PlasticTreeElement finalElement = new PlasticTreeElement((PlasticNode) lastNodeSuccessors.getSuccessorNode(key), null);
+ branchCopy.getBranchRef().add(finalElement);
+ decoupledBranches.add(branchCopy);
+ }
+
+ return decoupledBranches;
+ }
+
+ private void splitLastNodeIfRequiredCategorical(PlasticBranch branch,
+ Attribute swapAttribute,
+ int swapAttributeIndex,
+ Double splitValue) {
+ PlasticNode lastNode = branch.getLast().getNode();
+
+ boolean shouldBeBinary = splitValue != null;
+ boolean splitAttributesMatch = lastNode.splitAttribute == swapAttribute;
+
+ if (lastNode.isLeaf() || !splitAttributesMatch) { // Option 1: the split attributes don't match
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ shouldBeBinary
+ );
+ if (lastNode.isLeaf()) {
+ System.out.println("Error");
+ }
+ lastNode.successors.getAllSuccessors().forEach(s -> ((PlasticNode) s).setIsArtificial());
+ return;
+ }
+
+ boolean isBinary = lastNode.successors.isBinary();
+
+ if (!isBinary && !shouldBeBinary) // Option 2: the split attributes match and the splits are multiway (this is really the best case possible)
+ // do nothing
+ return;
+
+ if (isBinary && shouldBeBinary) { // Option 3: the split attributes match and also both splits should be binary
+ if (splitValue.equals(lastNode.successors.getReferenceValue()))
+ // do nothing
+ return;
+ Successors lastNodeSuccessors = new Successors(lastNode.getSuccessors(), true);
+
+ // Corresponds to transformation 3 in the paper
+ Attribute lastNodeSplitAttribute = lastNode.getSplitAttribute();
+ int lastNodeSplitAttributeIndex = lastNode.getSplitAttributeIndex();
+ InstanceConditionalTest splitTest = lastNode.getSplitTest();
+ lastNode.successors = null;
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ shouldBeBinary
+ );
+ PlasticNode defaultSuccessor = (PlasticNode) lastNode.getSuccessors().getSuccessorNode(SuccessorIdentifier.DEFAULT_NOMINAL_VALUE);
+ defaultSuccessor.transferSplit(
+ lastNodeSuccessors, lastNodeSplitAttribute, lastNodeSplitAttributeIndex, splitTest
+ );
+ return;
+ }
+
+ if (!isBinary && shouldBeBinary) { // Option 4: The split attributes match and the current split is multiway while the old one was binary. In this case, we do something similar to the numeric splits
+ // Corresponds to transformation 2 in the paper
+ Successors lastNodeSuccessors = new Successors(lastNode.getSuccessors(), true);
+ Attribute lastNodeSplitAttribute = lastNode.getSplitAttribute();
+ int lastNodeSplitAttributeIndex = lastNode.getSplitAttributeIndex();
+ InstanceConditionalTest splitTest = lastNode.getSplitTest();
+ lastNode.successors = null;
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ shouldBeBinary
+ );
+ PlasticNode defaultSuccessor = (PlasticNode) lastNode.getSuccessors().getSuccessorNode(SuccessorIdentifier.DEFAULT_NOMINAL_VALUE);
+// if (lastNodeSuccessors.contains(splitValue)) {
+// SuccessorIdentifier foundKey = null;
+// for (SuccessorIdentifier k: lastNodeSuccessors.getKeyset()) {
+// if (k.getSelectorValue() == splitValue) {
+// foundKey = k;
+// break;
+// }
+// }
+// if (foundKey != null)
+// lastNodeSuccessors.removeSuccessor(foundKey);
+// }
+ defaultSuccessor.transferSplit(
+ lastNodeSuccessors, lastNodeSplitAttribute, lastNodeSplitAttributeIndex, splitTest
+ );
+ return;
+ }
+
+ if (isBinary && !shouldBeBinary) { // Option 5: The split is binary but should be multiway. In this case, we force the split and then use the old subtree of the left branch of the old subtree.
+ // Corresponds to transformation 1 in the paper
+ SuccessorIdentifier keyToPreviousSuccessor = new SuccessorIdentifier(false, splitValue, splitValue, false);
+ PlasticNode previousSuccessor = (PlasticNode) lastNode.getSuccessors().getSuccessorNode(keyToPreviousSuccessor);
+
+ lastNode.successors = null;
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ shouldBeBinary
+ );
+ lastNode.successors.removeSuccessor(keyToPreviousSuccessor);
+ lastNode.successors.addSuccessor(previousSuccessor, keyToPreviousSuccessor);
+ return;
+ }
+
+ else if (lastNode.isLeaf()) {
+ System.out.println("Do nothing");
+ }
+ }
+
+ private void splitLastNodeIfRequiredNumeric(PlasticBranch branch,
+ Attribute swapAttribute,
+ int swapAttributeIndex,
+ Double splitValue) {
+ assert splitValue != null;
+ PlasticNode lastNode = branch.getLast().getNode();
+ boolean forceSplit = lastNode.isLeaf() || lastNode.splitAttribute != swapAttribute;
+
+ if (forceSplit) {
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ true
+ );
+ lastNode.getSuccessors().getAllSuccessors().forEach(s -> ((PlasticNode) s).setIsArtificial());
+ return;
+ }
+
+ Double oldThreshold = lastNode.getSuccessors().getReferenceValue();
+ if (splitValue.equals(oldThreshold))
+ return; // do nothing
+
+ if (lastNode.getSuccessors().size() > 1) {
+ updateThreshold(lastNode, swapAttributeIndex, splitValue);
+ return;
+ }
+
+ lastNode.forceSplit(
+ swapAttribute,
+ swapAttributeIndex,
+ splitValue,
+ true
+ );
+ lastNode.getSuccessors().getAllSuccessors().forEach(s -> ((PlasticNode) s).setIsArtificial());
+ }
+
+ private void updateThreshold(PlasticNode node, int splitAttributeIndex, double splitValue) {
+ Double oldThreshold = node.getSuccessors().getReferenceValue();
+
+ SuccessorIdentifier leftKey = new SuccessorIdentifier(true, oldThreshold, oldThreshold, true);
+ SuccessorIdentifier rightKey = new SuccessorIdentifier(true, oldThreshold, oldThreshold, false);
+ PlasticNode succ1 = (PlasticNode) node.getSuccessors().getSuccessorNode(leftKey);
+ PlasticNode succ2 = (PlasticNode) node.getSuccessors().getSuccessorNode(rightKey);
+ Successors newSuccessors = new Successors(true, true, splitValue);
+ if (succ1 != null)
+ newSuccessors.addSuccessorNumeric(splitValue, succ1, true);
+ if (succ2 != null)
+ newSuccessors.addSuccessorNumeric(splitValue, succ2, false);
+ node.successors = newSuccessors;
+
+ if (node.isLeaf())
+ return;
+
+ for (SuccessorIdentifier key: node.getSuccessors().getKeyset()) {
+ PlasticNode s = (PlasticNode) node.getSuccessors().getSuccessorNode(key);
+ removeUnreachableSubtree(s, splitAttributeIndex, splitValue, key.isLower());
+ }
+ }
+
+ private void removeUnreachableSubtree(PlasticNode node, int splitAttributeIndex, double threshold, boolean isLower) {
+ if (node.isLeaf())
+ return;
+
+ if (node.getSplitAttributeIndex() != splitAttributeIndex) {
+ for (CustomEFDTNode successor: node.getSuccessors().getAllSuccessors()) {
+ removeUnreachableSubtree((PlasticNode) successor, splitAttributeIndex, threshold, isLower);
+ }
+ return;
+ }
+
+ Set keysToRemove = new HashSet<>();
+ for (SuccessorIdentifier key: node.getSuccessors().getKeyset()) {
+ assert key.isNumeric();
+ if (isLower) {
+ if (!key.isLower() && key.getSelectorValue() >= threshold) {
+ keysToRemove.add(key);
+ }
+ }
+ else {
+ if (key.isLower() && key.getSelectorValue() <= threshold) {
+ keysToRemove.add(key);
+ }
+ }
+ }
+ for (SuccessorIdentifier key: keysToRemove) {
+ node.getSuccessors().removeSuccessor(key);
+ }
+
+ if (!node.isLeaf()) {
+ node.getSuccessors().getAllSuccessors().forEach(s -> removeUnreachableSubtree((PlasticNode) s, splitAttributeIndex, threshold, isLower));
+ }
+ }
+
+ private void modifyBranch(PlasticBranch branch, Attribute splitAttribute) {
+ putLastElementToFront(branch, splitAttribute);
+ resetSuccessorsInBranch(branch);
+ setRestructuredFlagInBranch(branch);
+ setDepth(branch);
+ }
+
+ private void putLastElementToFront(PlasticBranch branch, Attribute splitAttribute) {
+ PlasticTreeElement oldFirstBranchElement = branch.getBranchRef().getFirst();
+ PlasticTreeElement newFirstBranchElement = branch.getBranchRef().remove(branch.getBranchRef().size() - 2);
+
+ branch.getBranchRef().addFirst(newFirstBranchElement);
+ if (splitAttribute != newFirstBranchElement.getNode().splitAttribute) {
+ System.out.println(branch.getDescription());
+ }
+
+ PlasticNode oldFirstNode = oldFirstBranchElement.getNode();
+ PlasticNode newFirstNode = newFirstBranchElement.getNode();
+
+ //TODO not sure this is actually required! I think it could be sufficient to just change the successors when building the tree in a later step.
+ newFirstNode.observedClassDistribution = oldFirstNode.observedClassDistribution;
+ newFirstNode.depth = oldFirstNode.depth;
+ newFirstNode.attributeObservers = oldFirstNode.attributeObservers;
+ }
+
+ private void resetSuccessorsInBranch(PlasticBranch branch) {
+ if (branch.getBranchRef().size() == 1)
+ return;
+ int i = 0;
+ for (PlasticTreeElement item: branch.getBranchRef()) {
+ if (i == branch.getBranchRef().size() - 1)
+ break;
+ item.getNode().successors = new Successors(item.getNode().getSuccessors(), false);
+ i++;
+ }
+ }
+
+ private void setRestructuredFlagInBranch(PlasticBranch branch) {
+ if (branch.getBranchRef().size() <= 2)
+ return;
+ int i = 0;
+ for (PlasticTreeElement item: branch.getBranchRef()) {
+ if (i == 0 || i == branch.getBranchRef().size() - 1) {
+ i++;
+ continue;
+ }
+ item.getNode().setRestructuredFlag();
+ i++;
+ }
+ }
+
+ private void setDepth(PlasticBranch branch) {
+ PlasticNode firstNode = branch.getBranchRef().getFirst().getNode();
+ int i = 0;
+ for (PlasticTreeElement item: branch.getBranchRef()) {
+ item.getNode().depth = firstNode.getDepth() + i;
+ i++;
+ }
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/MeasuresNumberOfLeaves.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/MeasuresNumberOfLeaves.java
new file mode 100644
index 000000000..3873c5812
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/MeasuresNumberOfLeaves.java
@@ -0,0 +1,5 @@
+package moa.classifiers.trees.plastic_util;
+
+public interface MeasuresNumberOfLeaves {
+ public int getLeafNumber();
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/PerformsTreeRevision.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/PerformsTreeRevision.java
new file mode 100644
index 000000000..6e87a7986
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/PerformsTreeRevision.java
@@ -0,0 +1,5 @@
+package moa.classifiers.trees.plastic_util;
+
+public interface PerformsTreeRevision {
+ boolean didPerformTreeRevision();
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticBranch.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticBranch.java
new file mode 100644
index 000000000..00dab0ef4
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticBranch.java
@@ -0,0 +1,63 @@
+package moa.classifiers.trees.plastic_util;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+class PlasticBranch implements Comparable {
+ private LinkedList branch = new LinkedList<>();
+
+ public PlasticBranch(){}
+
+ public PlasticBranch(LinkedList branch) {
+ this.branch = branch;
+ }
+
+ public LinkedList getBranchRef() {
+ return branch;
+ }
+
+ public String getDescription() {
+ if (branch == null) {
+ return "Branch is null";
+ }
+ StringBuilder s = new StringBuilder();
+ int i = 0;
+ for (PlasticTreeElement e: branch) {
+ i++;
+ s.append(e.getDescription()).append(i == branch.size() ? "" : " --> ");
+ }
+ return s.toString();
+ }
+
+ public PlasticTreeElement getLast() {
+ if (branch == null)
+ return null;
+ if (branch.size() == 0) {
+ return null;
+ }
+ return branch.getLast();
+ }
+
+ public PlasticBranch copy() {
+ PlasticBranch cpy = new PlasticBranch();
+ for (PlasticTreeElement item: branch) {
+ cpy.getBranchRef().add(item.copy());
+ }
+ return cpy;
+ }
+
+ public ArrayList branchArrayCpy() {
+ return new ArrayList<>(branch);
+ }
+
+ public int compareTo(PlasticBranch other)
+ {
+ int a = branch.getLast().getNode().observedClassDistribution.numValues();
+ int b = other.branch.getLast().getNode().observedClassDistribution.numValues();
+ if (a < b)
+ return -1;
+ if (a == b)
+ return 0;
+ return 1;
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticNode.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticNode.java
new file mode 100644
index 000000000..91b056246
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticNode.java
@@ -0,0 +1,398 @@
+package moa.classifiers.trees.plastic_util;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.Instance;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+
+import java.util.*;
+
+public class PlasticNode extends CustomEFDTNode {
+
+ private Set childrenSplitAttributes;
+ private boolean nodeGotRestructured = false;
+ private boolean isArtificial = false;
+ private final Restructurer restructurer;
+ protected final int maxBranchLength;
+ protected final double acceptedNumericThresholdDeviation;
+ private boolean isDummy = false;
+
+ protected void setRestructuredFlag() {
+ nodeGotRestructured = true;
+ }
+
+ protected void resetRestructuredFlag() {
+ nodeGotRestructured = false;
+ }
+
+ protected boolean getRestructuredFlag() {
+ return nodeGotRestructured;
+ }
+
+ public PlasticNode(
+ SplitCriterion splitCriterion, int gracePeriod, Double confidence, Double adaptiveConfidence,
+ boolean useAdaptiveConfidence, String leafPrediction, Integer minSamplesReevaluate, Integer depth,
+ Integer maxDepth, Double tau, Double tauReevaluate, Double relMinDeltaG, boolean binaryOnly,
+ boolean noPrePrune, NominalAttributeClassObserver nominalObserverBlueprint,
+ DoubleVector observedClassDistribution, List usedNominalAttributes,
+ int maxBranchLength, double acceptedNumericThresholdDeviation, int blockedAttributeIndex
+ ) {
+ super(splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence, leafPrediction,
+ minSamplesReevaluate, depth, maxDepth, tau, tauReevaluate, relMinDeltaG, binaryOnly, noPrePrune,
+ nominalObserverBlueprint, observedClassDistribution, usedNominalAttributes, blockedAttributeIndex);
+ this.maxBranchLength = maxBranchLength;
+ this.acceptedNumericThresholdDeviation = acceptedNumericThresholdDeviation;
+ restructurer = new Restructurer(maxBranchLength, acceptedNumericThresholdDeviation);
+ }
+
+ public PlasticNode(PlasticNode other) {
+ super((SplitCriterion) other.splitCriterion.copy(), other.gracePeriod, other.confidence,
+ other.adaptiveConfidence, other.useAdaptiveConfidence, other.leafPrediction,
+ other.minSamplesReevaluate, other.depth, other.maxDepth, other.tau, other.tauReevaluate,
+ other.relMinDeltaG, other.binaryOnly, other.noPrePrune, other.nominalObserverBlueprint,
+ (DoubleVector) other.observedClassDistribution.copy(), other.usedNominalAttributes,
+ other.blockedAttributeIndex);
+ this.acceptedNumericThresholdDeviation = other.acceptedNumericThresholdDeviation;
+ this.maxBranchLength = other.maxBranchLength;
+ if (other.successors != null)
+ this.successors = new Successors(other.successors, true);
+ if (other.getSplitTest() != null)
+ setSplitTest((InstanceConditionalTest) other.getSplitTest().copy());
+ this.infogainSum = new HashMap<>(infogainSum);
+ this.numSplitAttempts = other.numSplitAttempts;
+ this.classDistributionAtTimeOfCreation = other.classDistributionAtTimeOfCreation;
+ this.nodeTime = other.nodeTime;
+ this.splitAttribute = other.splitAttribute;
+ this.seenWeight = other.seenWeight;
+ this.isArtificial = other.isArtificial;
+ if (other.attributeObservers != null)
+ this.attributeObservers = (AutoExpandVector) other.attributeObservers.copy();
+ restructurer = other.restructurer;
+ blockedAttributeIndex = other.blockedAttributeIndex;
+ }
+
+ /**
+ * In some cases during restructuring, we create dummy nodes that we prune restructuring has finished
+ * @return true if the node is a dummy node
+ */
+ public boolean isDummy() {
+ return isDummy;
+ }
+
+ @Override
+ protected PlasticNode addSuccessor(Instance instance) {
+ List usedNomAttributes = new ArrayList<>(usedNominalAttributes); //deep copy
+ PlasticNode successor = newNode(depth + 1, new DoubleVector(), usedNomAttributes);
+ double value = instance.value(splitAttribute);
+ if (splitAttribute.isNominal()) {
+ if (!successors.isBinary()) {
+ boolean success = successors.addSuccessorNominalMultiway(value, successor);
+ return success ? successor : null;
+ } else {
+ boolean success = successors.addSuccessorNominalBinary(value, successor);
+ if (!success) // this is the case if the split is binary nominal but the "left" successor exists.
+ success = successors.addDefaultSuccessorNominalBinary(successor);
+ return success ? successor : null;
+ }
+ } else {
+ NumericAttributeBinaryTest test = (NumericAttributeBinaryTest) getSplitTest();
+ if (successors.lowerIsMissing()) {
+ boolean success = successors.addSuccessorNumeric(test.getValue(), successor, true);
+ return success ? successor : null;
+ } else if (successors.upperIsMissing()) {
+ boolean success = successors.addSuccessorNumeric(test.getValue(), successor, false);
+ return success ? successor : null;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ protected PlasticNode newNode(int depth, DoubleVector classDistribution, List usedNominalAttributes) {
+ return new PlasticNode(
+ splitCriterion, gracePeriod, confidence, adaptiveConfidence, useAdaptiveConfidence,
+ leafPrediction, minSamplesReevaluate, depth, maxDepth,
+ tau, tauReevaluate, relMinDeltaG, binaryOnly, noPrePrune, nominalObserverBlueprint,
+ classDistribution, usedNominalAttributes, maxBranchLength, acceptedNumericThresholdDeviation, getSplitAttributeIndex()
+ );
+ }
+
+ /**
+ * Collect the split attributes of the children and this node.
+ * For performance reasons, this updates the `childrenSplitAttributes` property at every node.
+ * @return the set of attributes the children and this node split on.
+ */
+ public Set collectChildrenSplitAttributes() {
+ childrenSplitAttributes = new HashSet<>();
+ if (isLeaf()) {
+ // we have no split attribute
+ return childrenSplitAttributes;
+ }
+ // add the split attribute of this node to the set
+ childrenSplitAttributes.add(splitAttribute);
+ for (CustomEFDTNode successor : successors.getAllSuccessors()) {
+ // add the split attributes of the subtree
+ childrenSplitAttributes.addAll(((PlasticNode) successor).collectChildrenSplitAttributes());
+ }
+ return childrenSplitAttributes;
+ }
+
+ /**
+ * Simply returns `childrenSplitAttributes`. In doubt, call `collectChildrenSplitAttributes` before accessing the property.
+ * @return the set of attributes the children and this node split on.
+ */
+ public Set getChildrenSplitAttributes() {
+ return childrenSplitAttributes;
+ }
+
+ /**
+ * Transfers the split from another node to this node
+ * @param successors the sucessors of the other node
+ * @param splitAttribute the split attribute of the other node
+ * @param splitAttributeIndex the split attribute index of the other node
+ * @param splitTest the split test of the other node
+ */
+ public void transferSplit(Successors successors,
+ Attribute splitAttribute,
+ int splitAttributeIndex,
+ InstanceConditionalTest splitTest) {
+ this.successors = successors;
+ this.splitAttribute = splitAttribute;
+ setSplitTest(splitTest);
+ }
+
+ /**
+ * Increases the depth property in all subtree nodes by 1
+ */
+ protected void incrementDepthInSubtree() {
+ depth++;
+ if (isLeaf())
+ return;
+ for (SuccessorIdentifier key : successors.getKeyset()) {
+ PlasticNode successor = (PlasticNode) successors.getSuccessorNode(key);
+ successor.incrementDepthInSubtree();
+ }
+ }
+
+ protected void resetObservers() {
+ AutoExpandVector newObservers = new AutoExpandVector<>();
+ for (AttributeClassObserver observer : attributeObservers) {
+ if (observer.getClass() == nominalObserverBlueprint.getClass())
+ newObservers.add(newNominalClassObserver());
+ else
+ newObservers.add(newNumericClassObserver());
+ }
+ attributeObservers = newObservers;
+ }
+
+ /**
+ * If the node was artificially created during restructuring or if it originated from a 'normal' split
+ * @return true if the node was created artificially
+ */
+ public boolean isArtificial() {
+ return isArtificial;
+ }
+
+ public void setIsArtificial() {
+ isArtificial = true;
+ }
+
+ public void setIsArtificial(boolean val) {
+ isArtificial = val;
+ }
+
+ /**
+ * Forces a split of this node. This is required during restructuring to make sure the branch contains the desired split attribute.
+ * See step 3 of the algorithm
+ * @param splitAttribute the attribute to split on
+ * @param splitAttributeIndex the index of the attribute to split on
+ * @param splitValue the value of the split (e.g., for numerical splits or binary-nominal)
+ * @param isBinary flag if the split is binary or multiway
+ * @return true, if the split was successful
+ */
+ protected boolean forceSplit(Attribute splitAttribute, int splitAttributeIndex, Double splitValue, boolean isBinary) {
+ AttributeClassObserver observer = attributeObservers.get(splitAttributeIndex);
+ if (observer == null) {
+ observer = splitAttribute.isNominal() ? newNominalClassObserver() : newNumericClassObserver();
+ this.attributeObservers.set(splitAttributeIndex, observer);
+ }
+
+ boolean success;
+ if (splitAttribute.isNominal()) {
+ NominalAttributeClassObserver nominalObserver = (NominalAttributeClassObserver) observer;
+ AttributeSplitSuggestion suggestion = nominalObserver.forceSplit(
+ splitCriterion, observedClassDistribution.getArrayCopy(), splitAttributeIndex, isBinary, splitValue
+ );
+ if (suggestion != null) {
+ success = makeSplit(splitAttribute, suggestion);
+ } else
+ success = false;
+
+ if (!success) {
+ successors = new Successors(isBinary, splitAttribute.isNumeric(), splitValue);
+ this.splitAttribute = splitAttribute;
+ setSplitTest(suggestion == null ? null : suggestion.splitTest);
+
+ if (!isBinary) {
+ PlasticNode dummyNode = newNode(depth, new DoubleVector(), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex));
+ SuccessorIdentifier dummyKey = new SuccessorIdentifier(splitAttribute.isNumeric(), 0.0, 0.0, false);
+ success = successors.addSuccessor(dummyNode, dummyKey); // will be pruned later on.
+ dummyNode.isDummy = true;
+ return success;
+ } else {
+ PlasticNode a = newNode(depth + 1, new DoubleVector(), new LinkedList<>(usedNominalAttributes));
+ PlasticNode b = newNode(depth + 1, new DoubleVector(), new LinkedList<>(usedNominalAttributes));
+ SuccessorIdentifier keyA = new SuccessorIdentifier(splitAttribute.isNumeric(), splitValue, splitValue, false);
+ successors.addSuccessor(a, keyA);
+ successors.addDefaultSuccessorNominalBinary(b);
+ return true;
+ }
+ }
+ } else {
+ GaussianNumericAttributeClassObserver numericObserver = (GaussianNumericAttributeClassObserver) observer;
+ AttributeSplitSuggestion suggestion = numericObserver.forceSplit(
+ splitCriterion, observedClassDistribution.getArrayCopy(), splitAttributeIndex, splitValue
+ );
+ if (suggestion != null) {
+ success = makeSplit(splitAttribute, suggestion);
+ } else
+ success = false;
+
+ if (!success) {
+ successors = new Successors(isBinary, splitAttribute.isNumeric(), splitValue);
+ this.splitAttribute = splitAttribute;
+ setSplitTest(suggestion == null ? null : suggestion.splitTest);
+
+ for (int i = 0; i < 1; i++) {
+ PlasticNode dummyNode = newNode(depth, new DoubleVector(), getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex));
+ SuccessorIdentifier dummyKey = new SuccessorIdentifier(splitAttribute.isNumeric(), splitValue, splitValue, i == 0);
+ success = successors.addSuccessor(dummyNode, dummyKey); // will be pruned later on.
+ dummyNode.isDummy = true;
+ if (!success)
+ break;
+ }
+ }
+ }
+
+ return success;
+ }
+
+ /**
+ * Reevaluate the split and restructure if needed
+ * @param instance the current instance
+ */
+ @Override
+ protected void reevaluateSplit(Instance instance) {
+ if (isPure())
+ return;
+
+ numSplitAttempts++;
+
+ AttributeSplitSuggestion[] bestSuggestions = getBestSplitSuggestions(splitCriterion);
+ Arrays.sort(bestSuggestions);
+ if (bestSuggestions.length == 0)
+ return;
+ updateInfogainSum(bestSuggestions);
+
+ AttributeSplitSuggestion[] bestSplitSuggestions = getBestSplitSuggestions(splitCriterion);
+ Arrays.sort(bestSplitSuggestions);
+ AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+ double bestSuggestionAverageMerit = bestSuggestion.splitTest == null ? 0.0 : bestSuggestion.merit;
+ double currentAverageMerit = getCurrentSuggestionAverageMerit(bestSuggestions);
+ double deltaG = bestSuggestionAverageMerit - currentAverageMerit;
+ double eps = computeHoeffdingBound();
+
+ if (deltaG > eps || (eps < tauReevaluate && deltaG > tauReevaluate * relMinDeltaG)) {
+
+ if (bestSuggestion.splitTest == null) {
+ System.out.println("preprune - null wins");
+ killSubtree();
+ resetSplitAttribute();
+ return;
+ }
+
+ Attribute newSplitAttribute = instance.attribute(bestSuggestion.splitTest.getAttsTestDependsOn()[0]);
+ boolean success = false;
+ performedTreeRevision = true;
+ if (maxBranchLength > 1) {
+ success = performReordering(bestSuggestion, newSplitAttribute);
+ if (success)
+ setSplitAttribute(bestSuggestion, newSplitAttribute);
+ }
+ if (!success) {
+ makeSplit(newSplitAttribute, bestSuggestion);
+ }
+ nodeTime = 0;
+ seenWeight = 0.0;
+ }
+ }
+
+ /**
+ * Perform the restructuring and replace the subtree with the restructured subtree
+ * @param xBest the suggestion for the best split
+ * @param splitAttribute the attribute of the best split
+ * @return true if restructuring was successful
+ */
+ private boolean performReordering(AttributeSplitSuggestion xBest, Attribute splitAttribute) {
+ Double splitValue = null;
+ InstanceConditionalTest test = xBest.splitTest;
+ if (test instanceof NominalAttributeBinaryTest)
+ splitValue = ((NominalAttributeBinaryTest) test).getValue();
+ else if (test instanceof NumericAttributeBinaryTest)
+ splitValue = ((NumericAttributeBinaryTest) test).getValue();
+
+ PlasticNode restructuredNode = restructurer.restructure(this, xBest, splitAttribute, splitValue);
+
+ if (restructuredNode != null)
+ successors = restructuredNode.getSuccessors();
+
+ return restructuredNode != null;
+ }
+
+ protected void updateUsedNominalAttributesInSubtree(Attribute splitAttribute, Integer splitAttributeIndex) {
+ if (isLeaf())
+ return;
+ for (CustomEFDTNode successor : successors.getAllSuccessors()) {
+ PlasticNode s = (PlasticNode) successor;
+ s.usedNominalAttributes = getUsedNominalAttributesForSuccessor(splitAttribute, splitAttributeIndex);
+ s.updateUsedNominalAttributesInSubtree(splitAttribute, splitAttributeIndex);
+ }
+ }
+
+ protected Set getMajorityVotesOfLeaves() {
+ Set majorityVotes = new HashSet<>();
+ if (isLeaf()) {
+ if (observedClassDistribution.numValues() == 0)
+ return majorityVotes;
+ majorityVotes.add((double) argmax(observedClassDistribution.getArrayRef()));
+ return majorityVotes;
+ }
+ for (CustomEFDTNode s : getSuccessors().getAllSuccessors()) {
+ majorityVotes.addAll(((PlasticNode) s).getMajorityVotesOfLeaves());
+ }
+ return majorityVotes;
+ }
+
+ protected void setObservedClassDistribution(double[] newDistribution) {
+ observedClassDistribution = new DoubleVector(newDistribution);
+ classDistributionAtTimeOfCreation = new DoubleVector(newDistribution);
+ mcCorrectWeight = 0.0;
+ nbCorrectWeight = 0.0;
+ }
+
+ protected void resetObservedClassDistribution() {
+ observedClassDistribution = new DoubleVector();
+ classDistributionAtTimeOfCreation = new DoubleVector();
+ mcCorrectWeight = 0.0;
+ nbCorrectWeight = 0.0;
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticTreeElement.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticTreeElement.java
new file mode 100644
index 000000000..16eccecef
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/PlasticTreeElement.java
@@ -0,0 +1,40 @@
+package moa.classifiers.trees.plastic_util;
+
+class PlasticTreeElement {
+ private PlasticNode node;
+ private SuccessorIdentifier key;
+
+ public PlasticTreeElement(PlasticNode node, SuccessorIdentifier key) {
+ this.node = node;
+ this.key = key;
+ }
+
+ public PlasticTreeElement(PlasticTreeElement other) {
+ this.node = other.node;
+ this.key = other.key;
+ }
+
+ public PlasticNode getNode() {
+ return node;
+ }
+
+ public SuccessorIdentifier getKey() {
+ return key;
+ }
+
+ public String getDescription() {
+ String blueprint = "%s%s -- %s";
+ return String.format(blueprint,
+ node.splitAttribute != null ? node.splitAttribute.toString() : "L",
+ node.isArtificial() ? "*" : "",
+ key != null ? Double.toString(key.getReferencevalue()) : (node.isLeaf() ? "X" : "...")
+ );
+ }
+
+ public PlasticTreeElement copy() {
+ PlasticNode nodeCpy;
+ nodeCpy = new PlasticNode(node);
+ SuccessorIdentifier keyCpy = key != null ? new SuccessorIdentifier(key) : null;
+ return new PlasticTreeElement(nodeCpy, keyCpy);
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/Restructurer.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/Restructurer.java
new file mode 100644
index 000000000..04f88771b
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/Restructurer.java
@@ -0,0 +1,315 @@
+package moa.classifiers.trees.plastic_util;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import moa.AbstractMOAObject;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
+import moa.core.DoubleVector;
+
+import java.util.*;
+
+class Restructurer extends AbstractMOAObject {
+ private final int maxBranchLength;
+ private final double acceptedThresholdDeviation;
+
+ public Restructurer(int maxBranchLength,
+ double acceptedNumericThresholdDeviation) {
+ this.maxBranchLength = maxBranchLength;
+ acceptedThresholdDeviation = acceptedNumericThresholdDeviation;
+ }
+
+ public PlasticNode restructure(PlasticNode node, AttributeSplitSuggestion suggestion, Attribute splitAttribute, Double splitValue) {
+ boolean isBinary = !(suggestion.splitTest instanceof NominalAttributeMultiwayTest);
+ int splitAttributeIndex = suggestion.splitTest.getAttsTestDependsOn()[0];
+
+ boolean checkSucceeds = checkPreconditions(node, splitAttribute, splitValue, isBinary);
+
+ if (!checkSucceeds)
+ return null;
+
+ if (splitAttribute == node.splitAttribute && isBinary) {
+ assert splitValue != null;
+ Double currentNominalBinarysplitValue = node.getSuccessors().getReferenceValue();
+ if (currentNominalBinarysplitValue.equals(splitValue))
+ return node;
+ }
+
+ if (node.splitAttribute.isNumeric() && splitAttribute.isNumeric()) {
+ assert splitValue != null;
+ Double currentSplitValue = node.getSuccessors().getReferenceValue();
+ if (node.splitAttribute == splitAttribute) {
+ if (!currentSplitValue.equals(splitValue))
+ updateThreshold(node, splitAttributeIndex, splitValue);
+ return node;
+ }
+ }
+
+// node.collectChildrenSplitAttributes();
+ MappedTree mappedTree = new MappedTree(node, splitAttribute, splitAttributeIndex, splitValue, maxBranchLength);
+ PlasticNode newRoot = reassembleTree(mappedTree);
+
+ newRoot.setSplitAttribute(suggestion, splitAttribute);
+ newRoot.updateUsedNominalAttributesInSubtree(splitAttribute, splitAttributeIndex);
+
+ // Reset counters in restructured nodes
+ newRoot.getSuccessors().getAllSuccessors().forEach(s -> cleanupSubtree((PlasticNode) s));
+
+ // Initialize the statistics of the root's direct successors
+ List sortedKeys = new LinkedList<>(newRoot.getSuccessors().getKeyset());
+ Collections.sort(sortedKeys);
+ for (SuccessorIdentifier key: sortedKeys) {
+ PlasticNode successor = (PlasticNode) newRoot.getSuccessors().getSuccessorNode(key);
+ if (splitAttribute.isNominal()) {
+ double selectorValue = key.getSelectorValue();
+ if (selectorValue == SuccessorIdentifier.DEFAULT_NOMINAL_VALUE) {
+ assert isBinary;
+ successor.setObservedClassDistribution(suggestion.resultingClassDistributions[1]);
+ }
+ else if (selectorValue < suggestion.numSplits()) {
+ successor.setObservedClassDistribution(suggestion.resultingClassDistributionFromSplit((int) selectorValue));
+ }
+ else {
+ successor.resetObservedClassDistribution();
+ }
+ }
+ else {
+ if (key.isLower()) {
+ successor.setObservedClassDistribution(suggestion.resultingClassDistributions[0]);
+ }
+ else {
+ successor.setObservedClassDistribution(suggestion.resultingClassDistributions[1]);
+ }
+ }
+ }
+
+ finalProcessing(node);
+ return newRoot;
+ }
+
+ private boolean checkPreconditions(PlasticNode node, Attribute splitAttribute, Double splitValue, boolean isBinary) {
+ if (node.isLeaf())
+ return false;
+ if (splitAttribute.isNominal()) {
+ if (node.getSplitTest() instanceof NominalAttributeBinaryTest && isBinary) {
+ if (
+ ((NominalAttributeBinaryTest) node.getSplitTest()).getValue() == splitValue
+ && splitAttribute == node.splitAttribute
+ ) {
+ System.err.println("This should never be triggered. A binary re-split with the same attribute and split value should never happen");
+ }
+ }
+ else if (node.getSplitTest() instanceof NominalAttributeMultiwayTest) {
+ if (splitAttribute == node.splitAttribute && !isBinary)
+ System.err.println("This should never be triggered. A multiway re-split on the same nominal attribute should never happen");
+ }
+ }
+ return true;
+ }
+
+ private void updateThreshold(PlasticNode node, int splitAttributeIndex, double splitValue) {
+ Double oldThreshold = node.getSuccessors().getReferenceValue();
+
+ SuccessorIdentifier leftKey = new SuccessorIdentifier(true, oldThreshold, oldThreshold, true);
+ SuccessorIdentifier rightKey = new SuccessorIdentifier(true, oldThreshold, oldThreshold, false);
+ PlasticNode succ1 = (PlasticNode) node.getSuccessors().getSuccessorNode(leftKey);
+ PlasticNode succ2 = (PlasticNode) node.getSuccessors().getSuccessorNode(rightKey);
+ Successors newSuccessors = new Successors(true, true, splitValue);
+ if (succ1 != null)
+ newSuccessors.addSuccessorNumeric(splitValue, succ1, true);
+ if (succ2 != null)
+ newSuccessors.addSuccessorNumeric(splitValue, succ2, false);
+ node.successors = newSuccessors;
+
+ if (node.isLeaf())
+ return;
+
+ for (SuccessorIdentifier key: node.getSuccessors().getKeyset()) {
+ PlasticNode s = (PlasticNode) node.getSuccessors().getSuccessorNode(key);
+ removeUnreachableSubtree(s, splitAttributeIndex, splitValue, key.isLower());
+ }
+
+ if (Math.abs(splitValue - oldThreshold) > acceptedThresholdDeviation) {
+ setRestructuredFlagInSubtree(node);
+ }
+ }
+
+ private PlasticNode reassembleTree(LinkedList mappedTree) {
+ if (mappedTree.size() == 0) {
+ System.out.println("MappedTree is empty");
+ }
+
+ PlasticNode root = mappedTree.getFirst().getBranchRef().getFirst().getNode();
+ for (PlasticBranch branch: mappedTree) {
+ PlasticNode currentNode = root;
+
+ int depth = 0;
+ for (PlasticTreeElement thisElement: branch.getBranchRef()) {
+ if (depth == branch.getBranchRef().size() - 1)
+ break;
+
+ PlasticNode thisNode = thisElement.getNode();
+ SuccessorIdentifier thisKey = thisElement.getKey();
+ if (currentNode.getSplitAttribute() == thisNode.getSplitAttribute()) {
+ if (currentNode.getSuccessors().contains(thisKey)) {
+ currentNode = (PlasticNode) currentNode.getSuccessors().getSuccessorNode(thisKey);
+ }
+ else {
+ PlasticNode newSuccessor = branch.getBranchRef().get(depth + 1).getNode();
+ boolean success = currentNode.getSuccessors().addSuccessor(newSuccessor, thisKey);
+ assert success;
+ currentNode = newSuccessor;
+ }
+ }
+ depth++;
+ }
+ }
+ return root;
+ }
+
+ private PlasticNode reassembleTree(MappedTree mappedTree) {
+ if (!mappedTree.hasNext()) {
+ System.out.println("MappedTree is empty");
+ }
+
+ PlasticNode root = null;
+ while (mappedTree.hasNext()) {
+ PlasticBranch branch = mappedTree.next();
+ if (root == null)
+ root = branch.getBranchRef().getFirst().getNode();
+
+ PlasticNode currentNode = root;
+
+ int depth = 0;
+ for (PlasticTreeElement thisElement: branch.getBranchRef()) {
+ if (depth == branch.getBranchRef().size() - 1)
+ break;
+
+ PlasticNode thisNode = thisElement.getNode();
+ SuccessorIdentifier thisKey = thisElement.getKey();
+ if (currentNode.getSplitAttribute() == thisNode.getSplitAttribute()) {
+ if (currentNode.getSuccessors().contains(thisKey)) {
+ currentNode = (PlasticNode) currentNode.getSuccessors().getSuccessorNode(thisKey);
+ }
+ else {
+ PlasticNode newSuccessor = branch.getBranchRef().get(depth + 1).getNode();
+ boolean success = currentNode.getSuccessors().addSuccessor(newSuccessor, thisKey);
+ assert success;
+ currentNode = newSuccessor;
+ }
+ }
+ depth++;
+ }
+ }
+ return root;
+ }
+
+ private void cleanupSubtree(PlasticNode node) {
+ if (!node.getRestructuredFlag())
+ return;
+ if (!node.isLeaf()) {
+ node.resetObservedClassDistribution();
+ }
+ node.resetObservers();
+ node.seenWeight = 0.0;
+ node.nodeTime = 0;
+ node.numSplitAttempts = 0;
+ if (!node.isLeaf())
+ node.successors.getAllSuccessors().forEach(s -> cleanupSubtree((PlasticNode) s));
+ }
+
+ private void finalProcessing(PlasticNode node) {
+ node.setIsArtificial(false);
+ if (node.isLeaf()) {
+ return;
+ }
+
+ Set keys = new HashSet<>(node.getSuccessors().getKeyset());
+ boolean allSuccessorsArePure = true;
+ for (SuccessorIdentifier key : keys) {
+ PlasticNode thisNode = (PlasticNode) node.getSuccessors().getSuccessorNode(key);
+ if (thisNode.isDummy()) {
+ node.getSuccessors().removeSuccessor(key);
+ }
+ if (!thisNode.isPure())
+ allSuccessorsArePure = false;
+ }
+
+ if (node.isLeaf() || node.depth >= node.maxDepth) {
+ node.setObservedClassDistribution(collectStatsFromSuccessors(node).getArrayCopy());
+ node.killSubtree();
+ node.resetSplitAttribute();
+ return;
+ }
+
+ if ((allSuccessorsArePure && node.getMajorityVotesOfLeaves().size() <= 1)) {
+ node.setObservedClassDistribution(collectStatsFromSuccessors(node).getArrayCopy());
+ node.killSubtree();
+ node.resetSplitAttribute();
+ return;
+ }
+
+ for (SuccessorIdentifier key : node.getSuccessors().getKeyset()) {
+ PlasticNode successor = (PlasticNode) node.getSuccessors().getSuccessorNode(key);
+ finalProcessing(successor);
+ }
+ }
+
+ private DoubleVector collectStatsFromSuccessors(CustomEFDTNode node) {
+ if (node.isLeaf()) {
+ return node.observedClassDistribution;
+ }
+ else {
+ DoubleVector stats = new DoubleVector();
+ for (CustomEFDTNode successor : node.getSuccessors().getAllSuccessors()) {
+ DoubleVector fromSuccessor = successor.observedClassDistribution; //collectStatsFromSuccessors(successor);
+ stats.addValues(fromSuccessor);
+ }
+ return stats;
+ }
+ }
+
+ private void removeUnreachableSubtree(PlasticNode node, int splitAttributeIndex, double threshold, boolean isLower) {
+ if (node.isLeaf())
+ return;
+
+ if (node.getSplitAttributeIndex() != splitAttributeIndex) {
+ for (CustomEFDTNode successor: node.getSuccessors().getAllSuccessors()) {
+ removeUnreachableSubtree((PlasticNode) successor, splitAttributeIndex, threshold, isLower);
+ }
+ return;
+ }
+
+ Set keysToRemove = new HashSet<>();
+ for (SuccessorIdentifier key: node.getSuccessors().getKeyset()) {
+ assert key.isNumeric();
+ if (isLower) {
+ if (!key.isLower() && key.getSelectorValue() >= threshold) {
+ keysToRemove.add(key);
+ }
+ }
+ else {
+ if (key.isLower() && key.getSelectorValue() <= threshold) {
+ keysToRemove.add(key);
+ }
+ }
+ }
+ for (SuccessorIdentifier key: keysToRemove) {
+ node.getSuccessors().removeSuccessor(key);
+ }
+
+ if (!node.isLeaf()) {
+ node.getSuccessors().getAllSuccessors().forEach(s -> removeUnreachableSubtree((PlasticNode) s, splitAttributeIndex, threshold, isLower));
+ }
+ }
+
+ private void setRestructuredFlagInSubtree(PlasticNode node) {
+ if (node.isLeaf())
+ return;
+ node.setRestructuredFlag();
+ node.getSuccessors().getAllSuccessors().forEach(s -> setRestructuredFlagInSubtree((PlasticNode) s));
+ }
+
+ @Override
+ public void getDescription(StringBuilder sb, int indent) {}
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/SuccessorIdentifier.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/SuccessorIdentifier.java
new file mode 100644
index 000000000..b4f847665
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/SuccessorIdentifier.java
@@ -0,0 +1,149 @@
+package moa.classifiers.trees.plastic_util;
+
+import moa.AbstractMOAObject;
+
+import java.util.Objects;
+
+class SuccessorIdentifier extends AbstractMOAObject implements Comparable {
+ public static final double DEFAULT_NOMINAL_VALUE = -1.0;
+ private final boolean isNumeric;
+ private final Double selectorValue;
+ private final Double referenceValue;
+ private final boolean isLower;
+ private int hashCode;
+
+ public SuccessorIdentifier(SuccessorIdentifier other) {
+ this.isLower = other.isLower;
+ this.isNumeric = other.isNumeric;
+ this.selectorValue = other.selectorValue;
+ this.referenceValue = other.referenceValue;
+ hashCode = toString().hashCode();
+ }
+
+ public SuccessorIdentifier(boolean isNumeric, Double referenceValue, Double selectorValue, boolean isLower) {
+ this.isNumeric = isNumeric;
+ this.isLower = isLower;
+ this.selectorValue = selectorValue;
+
+ if (referenceValue == null)
+ this.referenceValue = selectorValue;
+ else
+ this.referenceValue = referenceValue;
+
+ hashCode = toString().hashCode();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o)
+ return true;
+ if (o == null)
+ return false;
+ if (getClass() == o.getClass()) {
+ SuccessorIdentifier that = (SuccessorIdentifier) o;
+ boolean equal = isNumeric() == that.isNumeric();
+ equal &= selectorValue.equals(that.getSelectorValue());
+ equal &= referenceValue.equals(that.getReferencevalue());
+ if (isNumeric) {
+ equal &= isLower() == that.isLower();
+ }
+ return equal;
+ }
+ Double that = (Double) o;
+ if (isNumeric)
+ return containsNumericAttribute(that);
+ else {
+ boolean result = Objects.equals(selectorValue, that);
+ if (!result) {
+ // use the default successor if the reference value is not `that` and the selector value is the selectorvalue of the default successor
+ result = Objects.equals(selectorValue, DEFAULT_NOMINAL_VALUE) && !Objects.equals(referenceValue, that);
+ }
+ return result;
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(SuccessorIdentifier other) {
+ if (isNumeric != other.isNumeric)
+ return 0;
+ if (isNumeric) {
+ if (!Objects.equals(referenceValue, other.referenceValue))
+ return 0;
+ if (isLower == other.isLower)
+ return 0;
+ return isLower ? -1 : 1;
+ }
+ else {
+ if (selectorValue == null) // this can only happen in the case of a dummy split (which will be pruned after reordering)
+ return 0;
+ if (selectorValue == DEFAULT_NOMINAL_VALUE || other.selectorValue == DEFAULT_NOMINAL_VALUE)
+ return referenceValue == DEFAULT_NOMINAL_VALUE ? 1 : -1;
+ if (selectorValue.equals(other.selectorValue))
+ return 0;
+ if (selectorValue < other.selectorValue)
+ return -1;
+ return 1;
+ }
+ }
+
+ public Double getSelectorValue() {
+ return selectorValue;
+ }
+
+ public Double getReferencevalue() {
+ return referenceValue;
+ }
+
+ private boolean matchesCategoricalValue(double attValue) {
+ if (isNumeric)
+ return false;
+ return selectorValue == attValue;
+ }
+
+ private boolean containsNumericAttribute(double attValue) {
+ if (!isNumeric)
+ return false;
+ return isLower ? attValue <= selectorValue : attValue > selectorValue;
+ }
+
+ public SuccessorIdentifier getOther() {
+ if (!isNumeric)
+ return null;
+ return new SuccessorIdentifier(isNumeric, selectorValue, selectorValue, !isLower);
+ }
+
+ public boolean isNumeric() {
+ return isNumeric;
+ }
+
+ public boolean isLower() {
+ if (!isNumeric)
+ return false;
+ return isLower;
+ }
+
+ public Double getValue() {
+ return selectorValue;
+ }
+
+ public String toString() {
+ if (isNumeric) {
+ String s = "%b%f%f%b";
+ return String.format(s, true, referenceValue, selectorValue, isLower);
+ }
+ else {
+ String s = "%b%f%f";
+ return String.format(s, false, referenceValue, selectorValue);
+ }
+ }
+
+ @Override
+ public void getDescription(StringBuilder sb, int indent) {
+
+ }
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/plastic_util/Successors.java b/moa/src/main/java/moa/classifiers/trees/plastic_util/Successors.java
new file mode 100644
index 000000000..1f378cda9
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/plastic_util/Successors.java
@@ -0,0 +1,221 @@
+package moa.classifiers.trees.plastic_util;
+
+import moa.AbstractMOAObject;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Set;
+
+class Successors extends AbstractMOAObject {
+ private Double referenceValue;
+ private HashMap successors = new HashMap<>();
+
+ public Successors(Successors other, boolean transferNodes) {
+ isBinarySplit = other.isBinary();
+ isNumericSplit = !other.isNominal();
+ referenceValue = other.getReferenceValue();
+ if (transferNodes) {
+ successors = new HashMap<>(other.successors);
+ }
+ }
+
+ public Successors(boolean isBinarySplit, boolean isNumericSplit, Double splitValue) {
+ this.isBinarySplit = isBinarySplit;
+ this.isNumericSplit = isNumericSplit;
+ this.referenceValue = splitValue;
+ }
+
+ private final boolean isBinarySplit;
+ private final boolean isNumericSplit;
+
+
+ protected boolean addSuccessor(CustomEFDTNode node, SuccessorIdentifier key) {
+ if (node == null)
+ return false;
+ if (isNumericSplit != key.isNumeric())
+ return false;
+ if (successors.size() >= 2 && isBinary()) {
+ return false;
+ }
+ if (successors.containsKey(key)) {
+ return false;
+ }
+ successors.put(key, node);
+ return true;
+ }
+
+
+ public boolean addSuccessorNumeric(Double attValue, CustomEFDTNode n, boolean isLower) {
+ if (n == null)
+ return false;
+ if (!isNumericSplit)
+ return false;
+ if (successors.size() >= 2)
+ return false;
+ if (referenceValue != null && !referenceValue.equals(attValue))
+ return false;
+
+ SuccessorIdentifier id = new SuccessorIdentifier(true, attValue, attValue, isLower);
+ if (successors.containsKey(id))
+ return false;
+
+ referenceValue = attValue;
+ successors.put(id, n);
+ return true;
+ }
+
+
+ public boolean addSuccessorNominalBinary(Double attValue, CustomEFDTNode n) {
+ if (n == null)
+ return false;
+ if (isNumericSplit)
+ return false;
+ if (!isBinarySplit)
+ return false;
+ if (successors.size() >= 2)
+ return false;
+ if (successors.size() == 1) {
+ SuccessorIdentifier key = (SuccessorIdentifier) successors.keySet().toArray()[0]; // get key of existing successor
+ if (key.getValue() == SuccessorIdentifier.DEFAULT_NOMINAL_VALUE) { // check if the key is the default key for nominal values
+ if (!referenceValue.equals(attValue)) // if the key is the default key, only add the successor if the referenceValue of the split matches the provided value
+ return false;
+ }
+ }
+
+ SuccessorIdentifier id = new SuccessorIdentifier(false, attValue, attValue, false);
+ if (successors.containsKey(id))
+ return false;
+
+ referenceValue = attValue;
+ successors.put(id, n);
+ return true;
+ }
+
+ public boolean addDefaultSuccessorNominalBinary(CustomEFDTNode n) {
+ if (n == null)
+ return false;
+ if (isNumericSplit)
+ return false;
+ if (!isBinarySplit)
+ return false;
+ if (successors.size() >= 2)
+ return false;
+
+ SuccessorIdentifier id = new SuccessorIdentifier(false, referenceValue, SuccessorIdentifier.DEFAULT_NOMINAL_VALUE, false);
+ if (successors.containsKey(id))
+ return false;
+
+ successors.put(id, n);
+ return true;
+ }
+
+ public boolean addSuccessorNominalMultiway(Double attValue, CustomEFDTNode n) {
+ if (n == null)
+ return false;
+ if (isNumericSplit)
+ return false;
+ if (isBinarySplit)
+ return false;
+
+ SuccessorIdentifier id = new SuccessorIdentifier(false, attValue, attValue, false);
+ if (successors.containsKey(id))
+ return false;
+
+ successors.put(id, n);
+ return true;
+ }
+
+ public CustomEFDTNode getSuccessorNode(SuccessorIdentifier key) {
+ return successors.get(key);
+ }
+
+ public CustomEFDTNode getSuccessorNode(Double attributeValue) {
+ for (SuccessorIdentifier s : successors.keySet()) {
+ if (s.equals(attributeValue))
+ return successors.get(s);
+ }
+ return null;
+ }
+
+ public SuccessorIdentifier getSuccessorKey(Object key) {
+ //TODO: Looping over a set is probably not the best way to do this.
+ for (SuccessorIdentifier successorKey : successors.keySet()) {
+ if (successorKey.equals(key)) {
+ return successorKey;
+ }
+ }
+ return null;
+ }
+
+ public boolean isNominal() {
+ return !isNumericSplit;
+ }
+
+ public boolean isBinary() {
+ return isBinarySplit;
+ }
+
+ public boolean contains(Object key) {
+ return successors.containsKey((SuccessorIdentifier) key);
+ }
+
+ public Double getReferenceValue() {
+ return referenceValue;
+ }
+
+ public int size() {
+ return successors.size();
+ }
+
+ public SuccessorIdentifier getMissingKey() {
+ if (successors.size() > 1)
+ return null;
+ SuccessorIdentifier someKey = (SuccessorIdentifier) successors.keySet().toArray()[0];
+ return someKey.getOther();
+ }
+
+ public boolean lowerIsMissing() {
+ SuccessorIdentifier key = getMissingKey();
+ if (key == null)
+ return false;
+ return key.isLower();
+ }
+
+ public boolean upperIsMissing() {
+ SuccessorIdentifier key = getMissingKey();
+ if (key == null)
+ return false;
+ return !key.isLower();
+ }
+
+ public void adjustThreshold(double newThreshold) {
+ HashMap newSuccessors = new HashMap<>();
+ for (SuccessorIdentifier oldId: successors.keySet()) {
+ SuccessorIdentifier newId = new SuccessorIdentifier(true, newThreshold, newThreshold, oldId.isLower());
+ newSuccessors.put(newId, successors.get(oldId));
+ }
+ referenceValue = newThreshold;
+ successors = newSuccessors;
+ }
+
+ public Collection getAllSuccessors() {
+ return successors.values();
+ }
+
+ public Set getKeyset() {
+ return successors.keySet();
+ }
+
+ protected void forceSuccessorForKey(SuccessorIdentifier key, CustomEFDTNode node) {
+ successors.put(key, node);
+ }
+
+ protected CustomEFDTNode removeSuccessor(SuccessorIdentifier key) {
+ return successors.remove(key);
+ }
+
+ @Override
+ public void getDescription(StringBuilder sb, int indent) {
+
+ }
+}
diff --git a/moa/src/main/java/moa/clusterers/clustream/Clustream.java b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
index 58e0428bd..93e221c7a 100644
--- a/moa/src/main/java/moa/clusterers/clustream/Clustream.java
+++ b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
@@ -14,8 +14,8 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
- *
+ *
+ *
*/
package moa.clusterers.clustream;
@@ -98,7 +98,9 @@ public void trainOnInstanceImpl(Instance instance) {
// Clustering kmeans_clustering = kMeans(k, buffer);
for ( int i = 0; i < kmeans_clustering.size(); i++ ) {
- kernels[i] = new ClustreamKernel( new DenseInstance(1.0,centers[i].getCenter()), dim, timestamp, t, m );
+ Instance newInstance = new DenseInstance(1.0,centers[i].getCenter());
+ newInstance.setDataset(instance.dataset());
+ kernels[i] = new ClustreamKernel(newInstance, dim, timestamp, t, m );
}
buffer.clear();
@@ -111,7 +113,7 @@ public void trainOnInstanceImpl(Instance instance) {
double minDistance = Double.MAX_VALUE;
for ( int i = 0; i < kernels.length; i++ ) {
//System.out.println(i+" "+kernels[i].getWeight()+" "+kernels[i].getDeviation());
- double distance = distance(instance.toDoubleArray(), kernels[i].getCenter() );
+ double distance = distanceIgnoreNaN(instance.toDoubleArray(), kernels[i].getCenter() );
if ( distance < minDistance ) {
closestKernel = kernels[i];
minDistance = distance;
@@ -213,6 +215,26 @@ private static double distance(double[] pointA, double [] pointB){
return Math.sqrt(distance);
}
+ /***
+ * This function avoids the undesirable situation where the whole distance becomes NaN if one of the attributes
+ * is NaN.
+ * (SSL) This was observed when calculating the distance between an instance without the class label and a center
+ * which was updated using the class label.
+ * @param pointA
+ * @param pointB
+ * @return
+ */
+ public static double distanceIgnoreNaN(double[] pointA, double [] pointB){
+ double distance = 0.0;
+ for (int i = 0; i < pointA.length; i++) {
+ if(!(Double.isNaN(pointA[i]) || Double.isNaN(pointB[i]))) {
+ double d = pointA[i] - pointB[i];
+ distance += d * d;
+ }
+ }
+ return Math.sqrt(distance);
+ }
+
//wrapper... we need to rewrite kmeans to points, not clusters, doesnt make sense anymore
// public static Clustering kMeans( int k, ArrayList points, int dim ) {
// ArrayList cl = new ArrayList();
diff --git a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
index d4f901ba4..609ad8fdb 100644
--- a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
+++ b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
@@ -14,8 +14,8 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
- *
+ *
+ *
*/
package moa.clusterers.clustream;
@@ -25,9 +25,9 @@
import com.yahoo.labs.samoa.instances.Instance;
public class ClustreamKernel extends CFCluster {
- private static final long serialVersionUID = 1L;
+ private static final long serialVersionUID = 1L;
- private final static double EPSILON = 0.00005;
+ private final static double EPSILON = 0.00005;
public static final double MIN_VARIANCE = 1e-50;
protected double LST;
@@ -36,66 +36,111 @@ public class ClustreamKernel extends CFCluster {
int m;
double t;
+ public double[] classObserver;
+
+ public static int ID_GENERATOR = 0;
- public ClustreamKernel( Instance instance, int dimensions, long timestamp , double t, int m) {
+ public ClustreamKernel(Instance instance, int dimensions, long timestamp , double t, int m) {
super(instance, dimensions);
+
+// Avoid situations where the instance header hasn't been defined and runtime errors.
+ if(instance.dataset() != null) {
+ this.classObserver = new double[instance.numClasses()];
+// instance.numAttributes() <= instance.classIndex() -> edge case where the class index is equal the
+// number of attributes (i.e. there is no class value in the attributes array).
+ if (instance.numAttributes() > instance.classIndex() &&
+ !instance.classIsMissing() &&
+ instance.classValue() >= 0 &&
+ instance.classValue() < instance.numClasses()) {
+ this.classObserver[(int) instance.classValue()]++;
+ }
+ }
+ this.setId(ID_GENERATOR++);
this.t = t;
this.m = m;
this.LST = timestamp;
- this.SST = timestamp*timestamp;
+ this.SST = timestamp*timestamp;
}
public ClustreamKernel( ClustreamKernel cluster, double t, int m ) {
super(cluster);
+ this.setId(ID_GENERATOR++);
this.t = t;
this.m = m;
this.LST = cluster.LST;
this.SST = cluster.SST;
+ this.classObserver = cluster.classObserver;
}
public void insert( Instance instance, long timestamp ) {
- N++;
- LST += timestamp;
- SST += timestamp*timestamp;
-
- for ( int i = 0; i < instance.numValues(); i++ ) {
- LS[i] += instance.value(i);
- SS[i] += instance.value(i)*instance.value(i);
- }
+ if(this.classObserver == null)
+ this.classObserver = new double[instance.numClasses()];
+ if(!instance.classIsMissing() &&
+ instance.classValue() >= 0 &&
+ instance.classValue() < instance.numClasses()) {
+ this.classObserver[(int)instance.classValue()]++;
+ }
+ N++;
+ LST += timestamp;
+ SST += timestamp*timestamp;
+
+ for ( int i = 0; i < instance.numValues(); i++ ) {
+ LS[i] += instance.value(i);
+ SS[i] += instance.value(i)*instance.value(i);
+ }
}
@Override
public void add( CFCluster other2 ) {
ClustreamKernel other = (ClustreamKernel) other2;
- assert( other.LS.length == this.LS.length );
- this.N += other.N;
- this.LST += other.LST;
- this.SST += other.SST;
-
- for ( int i = 0; i < LS.length; i++ ) {
- this.LS[i] += other.LS[i];
- this.SS[i] += other.SS[i];
- }
+ assert( other.LS.length == this.LS.length );
+ this.N += other.N;
+ this.LST += other.LST;
+ this.SST += other.SST;
+ this.classObserver = sumClassObservers(other.classObserver, this.classObserver);
+
+ for ( int i = 0; i < LS.length; i++ ) {
+ this.LS[i] += other.LS[i];
+ this.SS[i] += other.SS[i];
+ }
}
+ private double[] sumClassObservers(double[] A, double[] B) {
+ double[] result = null;
+ if (A != null && B != null) {
+ result = new double[A.length];
+ if(A.length == B.length)
+ for(int i = 0 ; i < A.length ; ++i)
+ result[i] += A[i] + B[i];
+ }
+ return result;
+ }
+
+// @Override
+// public void add( CFCluster other2, long timestamp) {
+// this.add(other2);
+// // accumulate the count
+// this.accumulateWeight(other2, timestamp);
+// }
+
public double getRelevanceStamp() {
- if ( N < 2*m )
- return getMuTime();
-
- return getMuTime() + getSigmaTime() * getQuantile( ((double)m)/(2*N) );
+ if ( N < 2*m )
+ return getMuTime();
+
+ return getMuTime() + getSigmaTime() * getQuantile( ((double)m)/(2*N) );
}
private double getMuTime() {
- return LST / N;
+ return LST / N;
}
private double getSigmaTime() {
- return Math.sqrt(SST/N - (LST/N)*(LST/N));
+ return Math.sqrt(SST/N - (LST/N)*(LST/N));
}
private double getQuantile( double z ) {
- assert( z >= 0 && z <= 1 );
- return Math.sqrt( 2 ) * inverseError( 2*z - 1 );
+ assert( z >= 0 && z <= 1 );
+ return Math.sqrt( 2 ) * inverseError( 2*z - 1 );
}
@Override
@@ -187,7 +232,7 @@ private double[] getVarianceVector() {
}
}
else{
-
+
}
}
return res;
@@ -223,7 +268,7 @@ private double calcNormalizedDistance(double[] point) {
return Math.sqrt(res);
}
- /**
+ /**
* Approximates the inverse error function. Clustream needs this.
* @param x
*/
@@ -266,7 +311,7 @@ protected void getClusterSpecificInfo(ArrayList infoTitle, ArrayList windowedResults;
public double[] cumulativeResults;
- public ArrayList targets;
- public ArrayList predictions;
-
+ public ArrayList targets;
+ public ArrayList predictions;
public HashMap otherMeasurements;
- public PrequentialResult(ArrayList windowedResults, double[] cumulativeResults) {
- this.windowedResults = windowedResults;
- this.cumulativeResults = cumulativeResults;
- this.targets = null;
- this.predictions = null;
- }
-
- public PrequentialResult(ArrayList windowedResults, double[] cumulativeResults,
- ArrayList targets, ArrayList predictions) {
+ public PrequentialResult(
+ ArrayList windowedResults,
+ double[] cumulativeResults,
+ ArrayList targets,
+ ArrayList predictions,
+ HashMap otherMeasurements
+ ) {
this.windowedResults = windowedResults;
this.cumulativeResults = cumulativeResults;
this.targets = targets;
this.predictions = predictions;
+ this.otherMeasurements = otherMeasurements;
}
- /***
- * This constructor is useful to store metrics beyond the evaluation metrics available through the evaluators.
- * @param windowedResults
- * @param cumulativeResults
- * @param otherMeasurements
- */
- public PrequentialResult(ArrayList windowedResults, double[] cumulativeResults,
- HashMap otherMeasurements) {
- this(windowedResults, cumulativeResults);
- this.otherMeasurements = otherMeasurements;
+ public PrequentialResult(
+ ArrayList windowedResults,
+ double[] cumulativeResults,
+ ArrayList targets,
+ ArrayList predictions
+ ) {
+ this(windowedResults, cumulativeResults, targets, predictions, null);
+ }
+
+ public PrequentialResult(
+ ArrayList windowedResults,
+ double[] cumulativeResults,
+ HashMap otherMeasurements
+ ) {
+ this(windowedResults, cumulativeResults, null, null, otherMeasurements);
}
}
@@ -93,11 +74,13 @@ public PrequentialResult(ArrayList windowedResults, double[] cumulativ
* @param windowedEvaluator
* @param maxInstances
* @param windowSize
- * @return PrequentialResult is a custom class that holds the respective results from the execution
+ * @param storeY
+ * @param storePredictions
+ * @return the return has to be an ArrayList because we don't know ahead of time how many windows will be produced
*/
public static PrequentialResult PrequentialEvaluation(ExampleStream stream, Learner learner,
- LearningPerformanceEvaluator basicEvaluator,
- LearningPerformanceEvaluator windowedEvaluator,
+ LearningPerformanceEvaluator> basicEvaluator,
+ LearningPerformanceEvaluator> windowedEvaluator,
long maxInstances, long windowSize,
boolean storeY, boolean storePredictions) {
int instancesProcessed = 0;
@@ -106,27 +89,184 @@ public static PrequentialResult PrequentialEvaluation(ExampleStream stream, Lear
stream.restart();
ArrayList windowed_results = new ArrayList<>();
- ArrayList targetValues = new ArrayList<>();
- ArrayList predictions = new ArrayList<>();
+ ArrayList targetValues = new ArrayList<>();
+ ArrayList predictions = new ArrayList<>();
while (stream.hasMoreInstances() &&
(maxInstances == -1 || instancesProcessed < maxInstances)) {
Example instance = stream.nextInstance();
- if (storeY)
- targetValues.add(instance.getData().classValue());
double[] prediction = learner.getVotesForInstance(instance);
+
+ // Update evaluators and store predictions if requested
if (basicEvaluator != null)
basicEvaluator.addResult(instance, prediction);
if (windowedEvaluator != null)
windowedEvaluator.addResult(instance, prediction);
-
if (storePredictions)
- predictions.add(prediction.length == 0? 0 : prediction[0]);
+ predictions.add(Utils.maxIndex(prediction));
+ if (storeY)
+ targetValues.add((int)Math.round(instance.getData().classValue()));
learner.trainOnInstance(instance);
+ instancesProcessed++;
+
+ // Store windowed results if requested
+ if (windowedEvaluator != null)
+ if (instancesProcessed % windowSize == 0) {
+ Measurement[] measurements = windowedEvaluator.getPerformanceMeasurements();
+ double[] values = new double[measurements.length];
+ for (int i = 0; i < values.length; ++i)
+ values[i] = measurements[i].getValue();
+ windowed_results.add(values);
+ }
+ }
+ if (windowedEvaluator != null)
+ if (instancesProcessed % windowSize != 0) {
+ Measurement[] measurements = windowedEvaluator.getPerformanceMeasurements();
+ double[] values = new double[measurements.length];
+ for (int i = 0; i < values.length; ++i)
+ values[i] = measurements[i].getValue();
+ windowed_results.add(values);
+ }
+
+ double[] cumulative_results = null;
+
+ if (basicEvaluator != null) {
+ Measurement[] measurements = basicEvaluator.getPerformanceMeasurements();
+ cumulative_results = new double[measurements.length];
+ for (int i = 0; i < cumulative_results.length; ++i)
+ cumulative_results[i] = measurements[i].getValue();
+ }
+
+ return new PrequentialResult(
+ windowed_results,
+ cumulative_results,
+ targetValues,
+ predictions
+ );
+ }
+
+ public static PrequentialResult PrequentialSSLEvaluation(
+ ExampleStream