nlptoolkit-classification 1.0.6 → 1.0.8

package/source/Model/DecisionTree/DecisionNode.ts

@@ -16,19 +16,46 @@ 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.classLabel = Model.getMaximum(data.getClassLabels());
+        this.classLabelsDistribution = new DiscreteDistribution()
+        let labels = data.getClassLabels()
+        for (let label of labels){
+            this.classLabelsDistribution.addItem(label)
+        }
+        this.classLabel = Model.getMaximum(labels)
         this.leaf = true;
         let classLabels = data.getDistinctClassLabels();
         if (classLabels.length == 1) {
@@ -69,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;
@@ -106,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"){
@@ -144,6 +175,7 @@ export class DecisionNode {
         } else {
             this.leaf = true
             this.classLabel = contents.readLine()
+            this.classLabelsDistribution = Model.loadDiscreteDistribution(contents);
         }
     }
 
@@ -184,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;
     }
@@ -200,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));
@@ -233,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));
@@ -255,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;
@@ -286,16 +322,23 @@ 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.data.classDistribution().getProbabilityDistribution();
+            return this.classLabelsDistribution.getProbabilityDistribution();
         } else {
             for (let node of this.children) {
                 if (node.condition.satisfy(instance)) {
                     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)
+    }
+
+}

package/source/Model/DecisionTree/DecisionTree.ts

@@ -4,29 +4,27 @@ import {Instance} from "../../Instance/Instance";
 import {CompositeInstance} from "../../Instance/CompositeInstance";
 import {InstanceList} from "../../InstanceList/InstanceList";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Parameter} from "../../Parameter/Parameter";
+import {C45Parameter} from "../../Parameter/C45Parameter";
+import {Partition} from "../../InstanceList/Partition";
 
 export class DecisionTree extends ValidatedModel{
 
-    private readonly root: DecisionNode
+    protected root: DecisionNode
 
-    /**
-     * Constructor that sets root node of the decision tree.
-     *
-     * @param rootOrFileName DecisionNode type input or fileName
-     */
-    constructor(rootOrFileName: DecisionNode | string) {
+    constructor2(fileName: string) {
+        let contents = new FileContents(fileName)
+        this.root = new DecisionNode(contents)
+    }
+
+    constructor(root?: DecisionNode) {
         super();
-        if (rootOrFileName instanceof DecisionNode){
-            this.root = rootOrFileName
-        } else {
-            let contents = new FileContents(rootOrFileName)
-            this.root = new DecisionNode(contents)
-        }
+        this.root = root;
     }
 
     /**
-     * The predict method  performs prediction on the root node of given instance, and if it is null, it returns the possible class labels.
-     * Otherwise it returns the returned class labels.
+     * The predict method  performs prediction on the root node of given instance, and if it is null, it returns the
+     * possible class labels. Otherwise, it returns the returned class labels.
      *
      * @param instance Instance make prediction.
      * @return Possible class labels.
@@ -39,6 +37,11 @@ export class DecisionTree extends ValidatedModel{
         return predictedClass;
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to Decision tree model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         return this.root.predictProbabilityDistribution(instance)
     }
@@ -77,4 +80,30 @@ export class DecisionTree extends ValidatedModel{
     prune(pruneSet: InstanceList){
         this.pruneNode(this.root, pruneSet)
     }
+
+    /**
+     * Training algorithm for C4.5 univariate decision tree classifier. 20 percent of the data are left aside for pruning
+     * 80 percent of the data is used for constructing the tree.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        if ((<C45Parameter> parameters).isPrune()) {
+            let partition = new Partition(trainSet, (<C45Parameter> parameters).getCrossValidationRatio(), true);
+            this.root = new DecisionNode(partition.get(1), undefined, undefined, false);
+            this.prune(partition.get(0));
+        } else {
+            this.root = new DecisionNode(trainSet, undefined, undefined, false);
+        }
+    }
+
+    /**
+     * 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)
+    }
+
 }

package/source/Model/DummyModel.ts

@@ -4,33 +4,29 @@ import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 import {InstanceList} from "../InstanceList/InstanceList";
 import {CompositeInstance} from "../Instance/CompositeInstance";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Parameter} from "../Parameter/Parameter";
 
 export class DummyModel extends Model{
 
     private distribution: DiscreteDistribution
 
     /**
-     * Constructor which sets the distribution using the given {@link InstanceList}.
+     * Training algorithm for the dummy classifier. Actually dummy classifier returns the maximum occurring class in
+     * the training data, there is no training. Sets the distribution using the given {@link InstanceList}.
      *
-     * @param trainSet {@link InstanceList} which is used to get the class distribution.
+     * @param trainSet   Training data given to the algorithm.
      */
-    constructor(trainSet: InstanceList | string) {
-        super();
-        if (trainSet instanceof InstanceList){
-            this.distribution = trainSet.classDistribution();
-        } else {
-            let input = new FileContents(trainSet)
-            this.distribution = new DiscreteDistribution()
-            let size = parseInt(input.readLine())
-            for (let i = 0; i < size; i++){
-                let line = input.readLine()
-                let items = line.split(" ")
-                let count = parseInt(items[1])
-                for (let j = 0; j < count; j++){
-                    this.distribution.addItem(items[0])
-                }
-            }
-        }
+    constructor1(trainSet: InstanceList){
+        this.distribution = trainSet.classDistribution()
+    }
+
+    /**
+     * Loads the dummy model from an input file.
+     * @param fileName File name of the dummy model.
+     */
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        this.distribution = Model.loadDiscreteDistribution(input)
     }
 
     /**
@@ -48,6 +44,11 @@ export class DummyModel extends Model{
         }
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to dummy model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         return this.distribution.getProbabilityDistribution();
     }
@@ -55,4 +56,24 @@ export class DummyModel extends Model{
     saveTxt(fileName: string){
     }
 
+    /**
+     * Training algorithm for the dummy classifier. Actually dummy classifier returns the maximum occurring class in
+     * the training data, there is no training.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.constructor1(trainSet)
+    }
+
+    /**
+     * Loads the dummy model from an input file.
+     * @param fileName File name of the dummy model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+
 }

package/source/{Classifier/Bagging.ts → Model/Ensemble/BaggingModel.ts}

@@ -1,12 +1,11 @@
-import {Classifier} from "./Classifier";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {Parameter} from "../Parameter/Parameter";
-import {BaggingParameter} from "../Parameter/BaggingParameter";
-import {DecisionTree} from "../Model/DecisionTree/DecisionTree";
-import {DecisionNode} from "../Model/DecisionTree/DecisionNode";
-import {TreeEnsembleModel} from "../Model/TreeEnsembleModel";
+import {TreeEnsembleModel} from "./TreeEnsembleModel";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {BaggingParameter} from "../../Parameter/BaggingParameter";
+import {DecisionTree} from "../DecisionTree/DecisionTree";
+import {DecisionNode} from "../DecisionTree/DecisionNode";
 
-export class Bagging extends Classifier{
+export class BaggingModel extends TreeEnsembleModel{
 
     /**
      * Bagging bootstrap ensemble method that creates individuals for its ensemble by training each classifier on a random
@@ -20,16 +19,20 @@ export class Bagging extends Classifier{
      */
     train(trainSet: InstanceList, parameters: Parameter): void {
         let forestSize = (<BaggingParameter> parameters).getEnsembleSize();
-        let forest = new Array<DecisionTree>();
+        this.forest = new Array<DecisionTree>();
         for (let i = 0; i < forestSize; i++) {
             let bootstrap = trainSet.bootstrap(i);
             let tree = new DecisionTree(new DecisionNode(new InstanceList(bootstrap.getSample()), undefined, undefined, false));
-            forest.push(tree);
+            this.forest.push(tree);
         }
-        this.model = new TreeEnsembleModel(forest);
     }
 
+    /**
+     * Loads the Bagging ensemble model from an input file.
+     * @param fileName File name of the decision tree model.
+     */
     loadModel(fileName: string): void{
-        this.model = new TreeEnsembleModel(fileName)
+        this.constructor2(fileName)
     }
+
 }

package/source/{Classifier/RandomForest.ts → Model/Ensemble/RandomForestModel.ts}

@@ -1,12 +1,11 @@
-import {Classifier} from "./Classifier";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {Parameter} from "../Parameter/Parameter";
-import {RandomForestParameter} from "../Parameter/RandomForestParameter";
-import {DecisionTree} from "../Model/DecisionTree/DecisionTree";
-import {DecisionNode} from "../Model/DecisionTree/DecisionNode";
-import {TreeEnsembleModel} from "../Model/TreeEnsembleModel";
+import {TreeEnsembleModel} from "./TreeEnsembleModel";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {RandomForestParameter} from "../../Parameter/RandomForestParameter";
+import {DecisionTree} from "../DecisionTree/DecisionTree";
+import {DecisionNode} from "../DecisionTree/DecisionNode";
 
-export class RandomForest extends Classifier{
+export class RandomForestModel extends TreeEnsembleModel{
 
     /**
      * Training algorithm for random forest classifier. Basically the algorithm creates K distinct decision trees from
@@ -17,17 +16,20 @@ export class RandomForest extends Classifier{
      */
     train(trainSet: InstanceList, parameters: Parameter): void {
         let forestSize = (<RandomForestParameter> parameters).getEnsembleSize();
-        let forest = new Array<DecisionTree>();
+        this.forest = new Array<DecisionTree>();
         for (let i = 0; i < forestSize; i++){
             let bootstrap = trainSet.bootstrap(i);
             let tree = new DecisionTree(new DecisionNode(new InstanceList(bootstrap.getSample()), undefined, <RandomForestParameter> parameters, false));
-            forest.push(tree);
+            this.forest.push(tree);
         }
-        this.model = new TreeEnsembleModel(forest);
     }
 
+    /**
+     * Loads the random forest model from an input file.
+     * @param fileName File name of the random forest model.
+     */
     loadModel(fileName: string): void{
-        this.model = new TreeEnsembleModel(fileName)
+        this.constructor2(fileName)
     }
 
 }

package/source/Model/{TreeEnsembleModel.ts → Ensemble/TreeEnsembleModel.ts}

@@ -1,30 +1,33 @@
-import {Model} from "./Model";
-import {Instance} from "../Instance/Instance";
-import {DecisionTree} from "./DecisionTree/DecisionTree";
+import {Model} from "../Model";
+import {Instance} from "../../Instance/Instance";
+import {DecisionTree} from "../DecisionTree/DecisionTree";
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
-import {DecisionNode} from "./DecisionTree/DecisionNode";
+import {DecisionNode} from "../DecisionTree/DecisionNode";
 
-export class TreeEnsembleModel extends Model{
+export abstract class TreeEnsembleModel extends Model{
 
-    private forest: Array<DecisionTree>
+    protected forest: Array<DecisionTree>
 
     /**
      * A constructor which sets the {@link Array} of {@link DecisionTree} with given input.
      *
-     * @param forestOrFileName An {@link Array} of {@link DecisionTree}.
+     * @param forest An {@link Array} of {@link DecisionTree}.
      */
-    constructor(forestOrFileName: Array<DecisionTree> | string) {
-        super();
-        if (forestOrFileName instanceof Array){
-            this.forest = forestOrFileName
-        } else {
-            let input = new FileContents(forestOrFileName)
-            let numberOfTrees = parseInt(input.readLine())
-            this.forest = new Array<DecisionTree>()
-            for (let i = 0; i < numberOfTrees; i++){
-                this.forest.push(new DecisionTree(new DecisionNode(input)))
-            }
+    constructor1(forest: Array<DecisionTree>) {
+        this.forest = forest
+    }
+
+    /**
+     * Loads a tree ensemble model such as Random Forest model or Bagging model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        let numberOfTrees = parseInt(input.readLine())
+        this.forest = new Array<DecisionTree>()
+        for (let i = 0; i < numberOfTrees; i++){
+            this.forest.push(new DecisionTree(new DecisionNode(input)))
         }
     }
 
@@ -43,6 +46,11 @@ export class TreeEnsembleModel extends Model{
         return distribution.getMaxItem();
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to ensemble tree model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         let distribution = new DiscreteDistribution();
         for (let tree of this.forest) {