nlptoolkit-classification 1.0.7 → 1.0.9

package/source/Experiment/MxKFoldRunSeparateTest.ts

@@ -33,7 +33,7 @@ export class MxKFoldRunSeparateTest extends KFoldRunSeparateTest{
         let partition = new Partition(instanceList, 0.25, true);
         for (let j = 0; j < this.M; j++) {
             let crossValidation = new KFoldCrossValidation<Instance>(partition.get(1).getInstances(), this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         }
         return result;
     }

package/source/Experiment/SingleRunWithK.ts

@@ -4,24 +4,39 @@ import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidatio
 import {Instance} from "../Instance/Instance";
 import {Performance} from "../Performance/Performance";
 import {InstanceList} from "../InstanceList/InstanceList";
-import {Classifier} from "../Classifier/Classifier";
 import {Parameter} from "../Parameter/Parameter";
 import {CrossValidation} from "nlptoolkit-sampling/dist/CrossValidation";
+import {Model} from "../Model/Model";
 
 export class SingleRunWithK implements SingleRun{
 
-    private K: number
+    private readonly K: number
 
+    /**
+     * Constructor for SingleRunWithK class. Basically sets K parameter of the K-fold cross-validation.
+     *
+     * @param K K of the K-fold cross-validation.
+     */
     constructor(K: number) {
         this.K = K
     }
 
-    runExperiment(classifier: Classifier,
+    /**
+     * Runs first fold of a K fold cross-validated experiment for the given classifier with the given parameters.
+     * The experiment result will be returned.
+     * @param model Classifier for the experiment
+     * @param parameter Hyperparameters of the classifier of the experiment
+     * @param crossValidation K-fold crossvalidated dataset.
+     * @return The experiment result of the first fold of the K-fold cross-validated experiment.
+     * @throws DiscreteFeaturesNotAllowed If the classifier does not allow discrete features and the dataset contains
+     * discrete features, DiscreteFeaturesNotAllowed will be thrown.
+     */
+    runExperiment(model: Model,
                   parameter: Parameter,
                   crossValidation: CrossValidation<Instance>){
         let trainSet = new InstanceList(crossValidation.getTrainFold(0));
         let testSet = new InstanceList(crossValidation.getTestFold(0));
-        return classifier.singleRun(parameter, trainSet, testSet);
+        return model.singleRun(parameter, trainSet, testSet);
     }
 
     /**
@@ -33,7 +48,7 @@ export class SingleRunWithK implements SingleRun{
     execute(experiment: Experiment): Performance {
         let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K,
             experiment.getParameter().getSeed());
-        return this.runExperiment(experiment.getClassifier(), experiment.getParameter(), crossValidation);
+        return this.runExperiment(experiment.getmodel(), experiment.getParameter(), crossValidation);
     }
 
 }

package/source/Experiment/StratifiedKFoldRun.ts

@@ -23,7 +23,7 @@ export class StratifiedKFoldRun extends KFoldRun{
     execute(experiment: Experiment): ExperimentPerformance {
         let result = new ExperimentPerformance();
         let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         return result;
     }
 

package/source/Experiment/StratifiedKFoldRunSeparateTest.ts

@@ -27,7 +27,7 @@ export class StratifiedKFoldRunSeparateTest extends KFoldRunSeparateTest{
         let instanceList = experiment.getDataSet().getInstanceList();
         let partition = new Partition(instanceList, 0.25, true);
         let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         return result;
     }
 }

package/source/Experiment/StratifiedMxKFoldRun.ts

@@ -27,7 +27,7 @@ export class StratifiedMxKFoldRun extends MxKFoldRun{
         for (let j = 0; j < this.M; j++) {
             let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(),
                 this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         }
         return result;
     }

package/source/Experiment/StratifiedMxKFoldRunSeparateTest.ts

@@ -28,12 +28,12 @@ export class StratifiedMxKFoldRunSeparateTest extends StratifiedKFoldRunSeparate
      */
     execute(experiment: Experiment): ExperimentPerformance {
         let result = new ExperimentPerformance();
+        let instanceList = experiment.getDataSet().getInstanceList();
+        let partition = new Partition(instanceList, 0.25, true);
         for (let j = 0; j < this.M; j++) {
-            let instanceList = experiment.getDataSet().getInstanceList();
-            let partition = new Partition(instanceList, 0.25, true);
             let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(),
                 this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         }
         return result;
     }

package/source/Experiment/StratifiedSingleRunWithK.ts

@@ -28,6 +28,6 @@ export class StratifiedSingleRunWithK {
             this.K, experiment.getParameter().getSeed());
         let trainSet = new InstanceList(crossValidation.getTrainFold(0));
         let testSet = new InstanceList(crossValidation.getTestFold(0));
-        return experiment.getClassifier().singleRun(experiment.getParameter(), trainSet, testSet);
+        return experiment.getmodel().singleRun(experiment.getParameter(), trainSet, testSet);
     }
 }

package/source/Filter/LaryFilter.ts

@@ -10,7 +10,7 @@ export abstract class LaryFilter extends FeatureFilter{
     /**
      * Constructor that sets the dataSet and all the attributes distributions.
      *
-     * @param dataSet DataSet that will bu used.
+     * @param dataSet DataSet that will be used.
      */
     constructor(dataSet: DataSet) {
         super(dataSet);

package/source/Filter/TrainedFeatureFilter.ts

@@ -8,7 +8,7 @@ export abstract class TrainedFeatureFilter extends FeatureFilter{
     /**
      * Constructor that sets the dataSet.
      *
-     * @param dataSet DataSet that will bu used.
+     * @param dataSet DataSet that will be used.
      */
     constructor(dataSet: DataSet) {
         super(dataSet);

package/source/InstanceList/Partition.ts

@@ -10,81 +10,141 @@ export class Partition {
 
     private multiList: Array<InstanceList> = new Array<InstanceList>()
 
+    /**
+     * Divides the instances in the instance list into partitions so that all instances of a class are grouped in a
+     * single partition.
+     * @param instanceList Instance list for which partition will be created.
+     */
+    constructor1(instanceList: InstanceList){
+        let classLabels = instanceList.getDistinctClassLabels();
+        for (let classLabel of classLabels){
+            this.add(new InstanceListOfSameClass(classLabel));
+        }
+        for (let instance of instanceList.getInstances()) {
+            this.get(classLabels.indexOf(instance.getClassLabel())).add(instance);
+        }
+    }
+
+    /**
+     * Creates a partition depending on the distinct values of a discrete attribute. If the discrete attribute has 4
+     * distinct values, the resulting partition will have 4 groups, where each group contain instance whose
+     * values of that discrete attribute are the same.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the discrete attribute.
+     */
+    constructor2(instanceList: InstanceList, attributeIndex: number){
+        let valueList = instanceList.getAttributeValueList(attributeIndex);
+        for (let value of valueList) {
+            this.add(new InstanceList());
+        }
+        for (let instance of instanceList.getInstances()) {
+            this.get(valueList.indexOf((<DiscreteAttribute> instance.getAttribute(attributeIndex)).getValue())).add(instance);
+        }
+    }
+
+    /**
+     * Creates a stratified partition of the current instance list. In a stratified partition, the percentage of each
+     * class is preserved. For example, let's say there are three classes in the instance list, and let the percentages of
+     * these classes be %20, %30, and %50; then the percentages of these classes in the stratified partitions are the
+     * same, that is, %20, %30, and %50.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param ratio Ratio of the stratified partition. Ratio is between 0 and 1. If the ratio is 0.2, then 20 percent
+     *              of the instances are put in the first group, 80 percent of the instances are put in the second group.
+     * @param random random is used as a random number.
+     * @param stratified If true, stratified partition is obtained.
+     */
+    constructor3(instanceList: InstanceList, ratio: number, random: Random, stratified: boolean){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        if (stratified){
+            let distribution = instanceList.classDistribution();
+            let counts = new Array<number>(distribution.size).fill(0)
+            let randomArray = new Array<number>()
+            for (let i = 0; i < instanceList.size(); i++){
+                randomArray.push(i);
+            }
+            if (random != undefined){
+                random.shuffle(randomArray)
+            }
+            for (let i = 0; i < instanceList.size(); i++) {
+                let instance = instanceList.get(randomArray[i]);
+                let classIndex = distribution.getIndex(instance.getClassLabel());
+                if (counts[classIndex] < instanceList.size() * ratio * distribution.getProbability(instance.getClassLabel())) {
+                    this.get(0).add(instance);
+                } else {
+                    this.get(1).add(instance);
+                }
+                counts[classIndex]++;
+            }
+        } else {
+            instanceList.shuffle(random)
+            for (let i = 0; i < instanceList.size(); i++) {
+                let instance = instanceList.get(i);
+                if (i < instanceList.size() * ratio) {
+                    this.get(0).add(instance);
+                } else {
+                    this.get(1).add(instance);
+                }
+            }
+        }
+    }
+
+    /**
+     * Creates a partition depending on the distinct values of a discrete indexed attribute.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the discrete indexed attribute.
+     * @param attributeValue Value of the attribute.
+     */
+    constructor4(instanceList: InstanceList, attributeIndex: number, attributeValue: number){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        for (let instance of instanceList.getInstances()) {
+            if ((<DiscreteIndexedAttribute> instance.getAttribute(attributeIndex)).getIndex() == attributeValue) {
+                this.get(0).add(instance);
+            } else {
+                this.get(1).add(instance);
+            }
+        }
+    }
+
+    /**
+     * Creates a two group partition depending on the values of a continuous attribute. If the value of the attribute is
+     * less than splitValue, the instance is forwarded to the first group, else it is forwarded to the second group.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the continuous attribute
+     * @param splitValue     Threshold to divide instances
+     */
+    constructor5(instanceList: InstanceList, attributeIndex: number, splitValue: number){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        for (let instance of instanceList.getInstances()) {
+            if ((<ContinuousAttribute> instance.getAttribute(attributeIndex)).getValue() <= splitValue) {
+                this.get(0).add(instance);
+            } else {
+                this.get(1).add(instance);
+            }
+        }
+    }
+
     constructor(instanceList?: InstanceList, attributeIndex?: number, stratifiedOrValue?: any, random?: Random) {
         if (instanceList != undefined){
             if (attributeIndex == undefined){
-                let classLabels = instanceList.getDistinctClassLabels();
-                for (let classLabel of classLabels){
-                    this.add(new InstanceListOfSameClass(classLabel));
-                }
-                for (let instance of instanceList.getInstances()) {
-                    this.get(classLabels.indexOf(instance.getClassLabel())).add(instance);
-                }
+                this.constructor1(instanceList);
             } else {
                 if (stratifiedOrValue == undefined){
-                    let valueList = instanceList.getAttributeValueList(attributeIndex);
-                    for (let value of valueList) {
-                        this.add(new InstanceList());
-                    }
-                    for (let instance of instanceList.getInstances()) {
-                        this.get(valueList.indexOf((<DiscreteAttribute> instance.getAttribute(attributeIndex)).getValue())).add(instance);
-                    }
+                    this.constructor2(instanceList, attributeIndex)
                 } else {
                     if (typeof stratifiedOrValue == "boolean"){
-                        this.add(new InstanceList());
-                        this.add(new InstanceList());
-                        if (stratifiedOrValue){
-                            let distribution = instanceList.classDistribution();
-                            let counts = new Array<number>(distribution.size).fill(0)
-                            let randomArray = new Array<number>()
-                            for (let i = 0; i < instanceList.size(); i++){
-                                randomArray.push(i);
-                            }
-                            if (random != undefined){
-                                random.shuffle(randomArray)
-                            }
-                            for (let i = 0; i < instanceList.size(); i++) {
-                                let instance = instanceList.get(randomArray[i]);
-                                let classIndex = distribution.getIndex(instance.getClassLabel());
-                                let ratio = attributeIndex
-                                if (counts[classIndex] < instanceList.size() * ratio * distribution.getProbability(instance.getClassLabel())) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                                counts[classIndex]++;
-                            }
-                        } else {
-                            instanceList.shuffle(random)
-                            for (let i = 0; i < instanceList.size(); i++) {
-                                let instance = instanceList.get(i);
-                                let ratio = attributeIndex
-                                if (i < instanceList.size() * ratio) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
-                        }
+                        this.constructor3(instanceList, attributeIndex, random, stratifiedOrValue)
                     } else {
-                        this.add(new InstanceList());
-                        this.add(new InstanceList());
                         if (Number.isInteger(stratifiedOrValue)){
-                            for (let instance of instanceList.getInstances()) {
-                                if ((<DiscreteIndexedAttribute> instance.getAttribute(attributeIndex)).getIndex() == stratifiedOrValue) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
+                            this.constructor4(instanceList, attributeIndex, stratifiedOrValue);
                         } else {
-                            for (let instance of instanceList.getInstances()) {
-                                if ((<ContinuousAttribute> instance.getAttribute(attributeIndex)).getValue() <= stratifiedOrValue) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
+                            this.constructor5(instanceList, attributeIndex, stratifiedOrValue);
                         }
                     }
                 }

package/source/Model/DecisionTree/DecisionCondition.ts

@@ -23,10 +23,18 @@ export class DecisionCondition {
         this.value = value;
     }
 
+    /**
+     * Accessor for the attribute index.
+     * @return Attribute index.
+     */
     getAttributeIndex(): number{
         return this.attributeIndex
     }
 
+    /**
+     * Accessor for the value.
+     * @return Value.
+     */
     getValue(): Attribute{
         return this.value
     }

package/source/Model/DecisionTree/DecisionNode.ts

@@ -16,19 +16,40 @@ export class DecisionNode {
 
     children: Array<DecisionNode> = undefined
     private EPSILON: number = 0.0000000001;
-    private data : InstanceList = undefined
     private classLabel : string = undefined
     leaf: boolean = false
     private condition: DecisionCondition = undefined
     private classLabelsDistribution: DiscreteDistribution
 
+    /**
+     * The DecisionNode method takes {@link InstanceList} data as input and then it sets the class label parameter by finding
+     * the most occurred class label of given data, it then gets distinct class labels as class labels ArrayList. Later, it adds ordered
+     * indices to the indexList and shuffles them randomly. Then, it gets the class distribution of given data and finds the best entropy value
+     * of these class distribution.
+     * <p>
+     * If an attribute of given data is {@link DiscreteIndexedAttribute}, it creates a Distribution according to discrete indexed attribute class distribution
+     * and finds the entropy. If it is better than the last best entropy it reassigns the best entropy, best attribute and best split value according to
+     * the newly founded best entropy's index. At the end, it also add new distribution to the class distribution .
+     * <p>
+     * If an attribute of given data is {@link DiscreteAttribute}, it directly finds the entropy. If it is better than the last best entropy it
+     * reassigns the best entropy, best attribute and best split value according to the newly founded best entropy's index.
+     * <p>
+     * If an attribute of given data is {@link ContinuousAttribute}, it creates two distributions; left and right according to class distribution
+     * and discrete distribution respectively, and finds the entropy. If it is better than the last best entropy it reassigns the best entropy,
+     * best attribute and best split value according to the newly founded best entropy's index. At the end, it also add new distribution to
+     * the right distribution and removes from left distribution .
+     *
+     * @param data      {@link InstanceList} input.
+     * @param condition {@link DecisionCondition} to check.
+     * @param parameter RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
+     * @param isStump   Refers to decision trees with only 1 splitting rule.
+     */
     constructor1(data: InstanceList, condition?: DecisionCondition | number, parameter?: RandomForestParameter, isStump?: boolean){
         let bestAttribute = -1
         let bestSplitValue = 0
         if (condition instanceof DecisionCondition){
             this.condition = condition;
         }
-        this.data = data
         this.classLabelsDistribution = new DiscreteDistribution()
         let labels = data.getClassLabels()
         for (let label of labels){
@@ -75,7 +96,7 @@ export class DecisionNode {
                 }
             } else {
                 if (data.get(0).getAttribute(index) instanceof DiscreteAttribute) {
-                    let entropy = this.entropyForDiscreteAttribute(index);
+                    let entropy = this.entropyForDiscreteAttribute(data, index);
                     if (entropy + this.EPSILON < bestEntropy) {
                         bestEntropy = entropy;
                         bestAttribute = index;
@@ -112,19 +133,23 @@ export class DecisionNode {
         if (bestAttribute != -1) {
             this.leaf = false;
             if (data.get(0).getAttribute(bestAttribute) instanceof DiscreteIndexedAttribute) {
-                this.createChildrenForDiscreteIndexed(bestAttribute, bestSplitValue, parameter, isStump);
+                this.createChildrenForDiscreteIndexed(data, bestAttribute, bestSplitValue, parameter, isStump);
             } else {
                 if (data.get(0).getAttribute(bestAttribute) instanceof DiscreteAttribute) {
-                    this.createChildrenForDiscrete(bestAttribute, parameter, isStump);
+                    this.createChildrenForDiscrete(data, bestAttribute, parameter, isStump);
                 } else {
                     if (data.get(0).getAttribute(bestAttribute) instanceof ContinuousAttribute) {
-                        this.createChildrenForContinuous(bestAttribute, bestSplitValue, parameter, isStump);
+                        this.createChildrenForContinuous(data, bestAttribute, bestSplitValue, parameter, isStump);
                     }
                 }
             }
         }
     }
 
+    /**
+     * Reads the decision node model (as one line) from model file.
+     * @param contents Model file
+     */
     constructor2(contents: FileContents){
         let items = contents.readLine().split(" ")
         if (items[0] != "-1"){
@@ -191,14 +216,15 @@ export class DecisionNode {
      * The entropyForDiscreteAttribute method takes an attributeIndex and creates an ArrayList of DiscreteDistribution.
      * Then loops through the distributions and calculates the total entropy.
      *
+     * @param data Instance list.
      * @param attributeIndex Index of the attribute.
      * @return Total entropy for the discrete attribute.
      */
-    private entropyForDiscreteAttribute(attributeIndex: number): number{
+    private entropyForDiscreteAttribute(data: InstanceList, attributeIndex: number): number{
         let sum = 0.0;
-        let distributions = this.data.attributeClassDistribution(attributeIndex);
+        let distributions = data.attributeClassDistribution(attributeIndex);
         for (let distribution of distributions) {
-            sum += (distribution.getSum() / this.data.size()) * distribution.entropy();
+            sum += (distribution.getSum() / data.size()) * distribution.entropy();
         }
         return sum;
     }
@@ -207,29 +233,31 @@ export class DecisionNode {
      * The createChildrenForDiscreteIndexed method creates an ArrayList of DecisionNodes as children and a partition with respect to
      * indexed attribute.
      *
+     * @param data Instance list.
      * @param attributeIndex Index of the attribute.
      * @param attributeValue Value of the attribute.
      * @param parameter      RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
      * @param isStump        Refers to decision trees with only 1 splitting rule.
      */
-    private createChildrenForDiscreteIndexed(attributeIndex: number, attributeValue: number, parameter: RandomForestParameter, isStump: boolean){
-        let childrenData = new Partition(this.data, attributeIndex, attributeValue);
+    private createChildrenForDiscreteIndexed(data: InstanceList, attributeIndex: number, attributeValue: number, parameter: RandomForestParameter, isStump: boolean){
+        let childrenData = new Partition(data, attributeIndex, attributeValue);
         this.children = new Array<DecisionNode>();
-        this.children.push(new DecisionNode(childrenData.get(0), new DecisionCondition(attributeIndex, new DiscreteIndexedAttribute("", attributeValue, (<DiscreteIndexedAttribute> this.data.get(0).getAttribute(attributeIndex)).getMaxIndex())), parameter, isStump));
-        this.children.push(new DecisionNode(childrenData.get(1), new DecisionCondition(attributeIndex, new DiscreteIndexedAttribute("", -1, (<DiscreteIndexedAttribute> this.data.get(0).getAttribute(attributeIndex)).getMaxIndex())), parameter, isStump));
+        this.children.push(new DecisionNode(childrenData.get(0), new DecisionCondition(attributeIndex, new DiscreteIndexedAttribute("", attributeValue, (<DiscreteIndexedAttribute> data.get(0).getAttribute(attributeIndex)).getMaxIndex())), parameter, isStump));
+        this.children.push(new DecisionNode(childrenData.get(1), new DecisionCondition(attributeIndex, new DiscreteIndexedAttribute("", -1, (<DiscreteIndexedAttribute> data.get(0).getAttribute(attributeIndex)).getMaxIndex())), parameter, isStump));
     }
 
     /**
      * The createChildrenForDiscrete method creates an ArrayList of values, a partition with respect to attributes and an ArrayList
      * of DecisionNodes as children.
      *
+     * @param data Instance list.
      * @param attributeIndex Index of the attribute.
      * @param parameter      RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
      * @param isStump        Refers to decision trees with only 1 splitting rule.
      */
-    private createChildrenForDiscrete(attributeIndex: number, parameter: RandomForestParameter, isStump: boolean){
-        let valueList = this.data.getAttributeValueList(attributeIndex);
-        let childrenData = new Partition(this.data, attributeIndex);
+    private createChildrenForDiscrete(data: InstanceList, attributeIndex: number, parameter: RandomForestParameter, isStump: boolean){
+        let valueList = data.getAttributeValueList(attributeIndex);
+        let childrenData = new Partition(data, attributeIndex);
         this.children = new Array<DecisionNode>();
         for (let i = 0; i < valueList.length; i++) {
             this.children.push(new DecisionNode(childrenData.get(i), new DecisionCondition(attributeIndex, new DiscreteAttribute(valueList[i])), parameter, isStump));
@@ -240,13 +268,14 @@ export class DecisionNode {
      * The createChildrenForContinuous method creates an ArrayList of DecisionNodes as children and a partition with respect to
      * continuous attribute and the given split value.
      *
+     * @param data Instance list.
      * @param attributeIndex Index of the attribute.
      * @param parameter      RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
      * @param isStump        Refers to decision trees with only 1 splitting rule.
      * @param splitValue     Split value is used for partitioning.
      */
-    private createChildrenForContinuous(attributeIndex: number, splitValue: number, parameter: RandomForestParameter, isStump: boolean){
-        let childrenData = new Partition(this.data, attributeIndex, splitValue + 0.0000001);
+    private createChildrenForContinuous(data: InstanceList, attributeIndex: number, splitValue: number, parameter: RandomForestParameter, isStump: boolean){
+        let childrenData = new Partition(data, attributeIndex, splitValue + 0.0000001);
         this.children = new Array<DecisionNode>();
         this.children.push(new DecisionNode(childrenData.get(0), new DecisionCondition(attributeIndex, new ContinuousAttribute(splitValue), "<"), parameter, isStump));
         this.children.push(new DecisionNode(childrenData.get(1), new DecisionCondition(attributeIndex, new ContinuousAttribute(splitValue), ">"), parameter, isStump));
@@ -262,7 +291,7 @@ export class DecisionNode {
     predict(instance: Instance): string{
         if (instance instanceof CompositeInstance) {
             let possibleClassLabels = (<CompositeInstance> instance).getPossibleClassLabels();
-            let distribution = this.data.classDistribution();
+            let distribution = this.classLabelsDistribution;
             let predictedClass = distribution.getMaxItem(possibleClassLabels);
             if (this.leaf) {
                 return predictedClass;
@@ -293,6 +322,13 @@ export class DecisionNode {
         }
     }
 
+    /**
+     * Recursive method that returns the posterior probability distribution of a given instance. If the node is a leaf
+     * node, it returns the class label distribution, otherwise it checks in which direction (child node) this instance
+     * is forwarded.
+     * @param instance Instance for which the posterior probability distribution is calculated.
+     * @return Posterior probability distribution for this instance.
+     */
     predictProbabilityDistribution(instance: Instance): Map<string, number>{
         if (this.leaf) {
             return this.classLabelsDistribution.getProbabilityDistribution();
@@ -302,7 +338,7 @@ export class DecisionNode {
                     return node.predictProbabilityDistribution(instance);
                 }
             }
-            return this.data.classDistribution().getProbabilityDistribution();
+            return this.classLabelsDistribution.getProbabilityDistribution();
         }
     }
 }

package/source/Model/DecisionTree/DecisionStump.ts

@@ -0,0 +1,26 @@
+import {DecisionTree} from "./DecisionTree";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {DecisionNode} from "./DecisionNode";
+
+export class DecisionStump extends DecisionTree {
+
+    /**
+     * Training algorithm for C4.5 Stump univariate decision tree classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.root = new DecisionNode(trainSet, undefined, undefined, true);
+    }
+
+    /**
+     * Loads the decision tree model from an input file.
+     * @param fileName File name of the decision tree model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}