nlptoolkit-classification 1.0.0

package/dist/Model/NeuralNetworkModel.d.ts

@@ -0,0 +1,99 @@
+import { ValidatedModel } from "./ValidatedModel";
+import { Vector } from "nlptoolkit-math/dist/Vector";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Matrix } from "nlptoolkit-math/dist/Matrix";
+import { Instance } from "../Instance/Instance";
+import { ActivationFunction } from "../Parameter/ActivationFunction";
+export declare abstract class NeuralNetworkModel extends ValidatedModel {
+    protected classLabels: Array<string>;
+    protected K: number;
+    protected d: number;
+    protected x: Vector;
+    protected y: Vector;
+    protected r: Vector;
+    protected abstract calculateOutput(): void;
+    /**
+     * Constructor that sets the class labels, their sizes as K and the size of the continuous attributes as d.
+     *
+     * @param trainSet {@link InstanceList} to use as train set.
+     */
+    protected constructor(trainSet: InstanceList);
+    /**
+     * The allocateLayerWeights method returns a new {@link Matrix} with random weights.
+     *
+     * @param row    Number of rows.
+     * @param column Number of columns.
+     * @return Matrix with random weights.
+     */
+    protected allocateLayerWeights(row: number, column: number): Matrix;
+    /**
+     * The normalizeOutput method takes an input {@link Vector} o, gets the result for e^o of each element of o,
+     * then sums them up. At the end, divides each e^o by the summation.
+     *
+     * @param o Vector to normalize.
+     * @return Normalized vector.
+     */
+    protected normalizeOutput(o: Vector): Vector;
+    /**
+     * The createInputVector method takes an {@link Instance} as an input. It converts given Instance to the {@link Vector}
+     * and insert 1.0 to the first element.
+     *
+     * @param instance Instance to insert 1.0.
+     */
+    protected createInputVector(instance: Instance): void;
+    /**
+     * The calculateHidden method takes a {@link Vector} input and {@link Matrix} weights, It multiplies the weights
+     * Matrix with given input Vector than applies the sigmoid function and returns the result.
+     *
+     * @param input   Vector to multiply weights.
+     * @param weights Matrix is multiplied with input Vector.
+     * @param activationFunction Activation function.
+     * @return Result of sigmoid function.
+     */
+    protected calculateHidden(input: Vector, weights: Matrix, activationFunction: ActivationFunction): Vector;
+    /**
+     * The calculateOneMinusHidden method takes a {@link Vector} as input. It creates a Vector of ones and
+     * returns the difference between given Vector.
+     *
+     * @param hidden Vector to find difference.
+     * @return Returns the difference between one's Vector and input Vector.
+     */
+    protected calculateOneMinusHidden(hidden: Vector): Vector;
+    /**
+     * The calculateForwardSingleHiddenLayer method takes two matrices W and V. First it multiplies W with x, then
+     * multiplies V with the result of the previous multiplication.
+     *
+     * @param W Matrix to multiply with x.
+     * @param V Matrix to multiply.
+     * @param activationFunction Activation function.
+     */
+    protected calculateForwardSingleHiddenLayer(W: Matrix, V: Matrix, activationFunction: ActivationFunction): void;
+    /**
+     * The calculateRMinusY method creates a new {@link Vector} with given Instance, then it multiplies given
+     * input Vector with given weights Matrix. After normalizing the output, it returns the difference between the newly created
+     * Vector and normalized output.
+     *
+     * @param instance Instance is used to get class labels.
+     * @param input    Vector to multiply weights.
+     * @param weights  Matrix of weights/
+     * @return Difference between newly created Vector and normalized output.
+     */
+    protected calculateRMinusY(instance: Instance, input: Vector, weights: Matrix): Vector;
+    /**
+     * The predictWithCompositeInstance method takes an ArrayList possibleClassLabels. It returns the class label
+     * which has the maximum value of y.
+     *
+     * @param possibleClassLabels ArrayList that has the class labels.
+     * @return The class label which has the maximum value of y.
+     */
+    protected predictWithCompositeInstance(possibleClassLabels: Array<string>): string;
+    /**
+     * The predict method takes an {@link Instance} as an input, converts it to a Vector and calculates the {@link Matrix} y by
+     * multiplying Matrix W with {@link Vector} x. Then it returns the class label which has the maximum y value.
+     *
+     * @param instance Instance to predict.
+     * @return The class label which has the maximum y.
+     */
+    predict(instance: Instance): string;
+    predictProbability(instance: Instance): Map<string, number>;
+}

package/dist/Model/NeuralNetworkModel.js

@@ -0,0 +1,180 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./ValidatedModel", "nlptoolkit-math/dist/Vector", "nlptoolkit-math/dist/Matrix", "../Parameter/ActivationFunction", "../Instance/CompositeInstance"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NeuralNetworkModel = void 0;
+    const ValidatedModel_1 = require("./ValidatedModel");
+    const Vector_1 = require("nlptoolkit-math/dist/Vector");
+    const Matrix_1 = require("nlptoolkit-math/dist/Matrix");
+    const ActivationFunction_1 = require("../Parameter/ActivationFunction");
+    const CompositeInstance_1 = require("../Instance/CompositeInstance");
+    class NeuralNetworkModel extends ValidatedModel_1.ValidatedModel {
+        /**
+         * Constructor that sets the class labels, their sizes as K and the size of the continuous attributes as d.
+         *
+         * @param trainSet {@link InstanceList} to use as train set.
+         */
+        constructor(trainSet) {
+            super();
+            this.classLabels = trainSet.getDistinctClassLabels();
+            this.K = this.classLabels.length;
+            this.d = trainSet.get(0).continuousAttributeSize();
+        }
+        /**
+         * The allocateLayerWeights method returns a new {@link Matrix} with random weights.
+         *
+         * @param row    Number of rows.
+         * @param column Number of columns.
+         * @return Matrix with random weights.
+         */
+        allocateLayerWeights(row, column) {
+            return new Matrix_1.Matrix(row, column, -0.01, +0.01);
+        }
+        /**
+         * The normalizeOutput method takes an input {@link Vector} o, gets the result for e^o of each element of o,
+         * then sums them up. At the end, divides each e^o by the summation.
+         *
+         * @param o Vector to normalize.
+         * @return Normalized vector.
+         */
+        normalizeOutput(o) {
+            let sum = 0.0;
+            let values = new Array();
+            for (let i = 0; i < values.length; i++) {
+                sum += Math.exp(o.getValue(i));
+            }
+            for (let i = 0; i < values.length; i++) {
+                values.push(Math.exp(o.getValue(i)) / sum);
+            }
+            return new Vector_1.Vector(values);
+        }
+        /**
+         * The createInputVector method takes an {@link Instance} as an input. It converts given Instance to the {@link Vector}
+         * and insert 1.0 to the first element.
+         *
+         * @param instance Instance to insert 1.0.
+         */
+        createInputVector(instance) {
+            this.x = instance.toVector();
+            this.x.insert(0, 1.0);
+        }
+        /**
+         * The calculateHidden method takes a {@link Vector} input and {@link Matrix} weights, It multiplies the weights
+         * Matrix with given input Vector than applies the sigmoid function and returns the result.
+         *
+         * @param input   Vector to multiply weights.
+         * @param weights Matrix is multiplied with input Vector.
+         * @param activationFunction Activation function.
+         * @return Result of sigmoid function.
+         */
+        calculateHidden(input, weights, activationFunction) {
+            let z = weights.multiplyWithVectorFromRight(input);
+            switch (activationFunction) {
+                case ActivationFunction_1.ActivationFunction.SIGMOID:
+                default:
+                    z.sigmoid();
+                    break;
+                case ActivationFunction_1.ActivationFunction.TANH:
+                    z.tanh();
+                    break;
+                case ActivationFunction_1.ActivationFunction.RELU:
+                    z.relu();
+                    break;
+            }
+            return z;
+        }
+        /**
+         * The calculateOneMinusHidden method takes a {@link Vector} as input. It creates a Vector of ones and
+         * returns the difference between given Vector.
+         *
+         * @param hidden Vector to find difference.
+         * @return Returns the difference between one's Vector and input Vector.
+         */
+        calculateOneMinusHidden(hidden) {
+            let one = new Vector_1.Vector(hidden.size(), 1.0);
+            return one.difference(hidden);
+        }
+        /**
+         * The calculateForwardSingleHiddenLayer method takes two matrices W and V. First it multiplies W with x, then
+         * multiplies V with the result of the previous multiplication.
+         *
+         * @param W Matrix to multiply with x.
+         * @param V Matrix to multiply.
+         * @param activationFunction Activation function.
+         */
+        calculateForwardSingleHiddenLayer(W, V, activationFunction) {
+            let hidden = this.calculateHidden(this.x, W, activationFunction);
+            let hiddenBiased = hidden.biased();
+            this.y = V.multiplyWithVectorFromRight(hiddenBiased);
+        }
+        /**
+         * The calculateRMinusY method creates a new {@link Vector} with given Instance, then it multiplies given
+         * input Vector with given weights Matrix. After normalizing the output, it returns the difference between the newly created
+         * Vector and normalized output.
+         *
+         * @param instance Instance is used to get class labels.
+         * @param input    Vector to multiply weights.
+         * @param weights  Matrix of weights/
+         * @return Difference between newly created Vector and normalized output.
+         */
+        calculateRMinusY(instance, input, weights) {
+            this.r = new Vector_1.Vector(this.K, this.classLabels.indexOf(instance.getClassLabel()), 1.0);
+            let o = weights.multiplyWithVectorFromRight(input);
+            this.y = this.normalizeOutput(o);
+            return this.r.difference(this.y);
+        }
+        /**
+         * The predictWithCompositeInstance method takes an ArrayList possibleClassLabels. It returns the class label
+         * which has the maximum value of y.
+         *
+         * @param possibleClassLabels ArrayList that has the class labels.
+         * @return The class label which has the maximum value of y.
+         */
+        predictWithCompositeInstance(possibleClassLabels) {
+            let predictedClass = possibleClassLabels[0];
+            let maxY = Number.NEGATIVE_INFINITY;
+            for (let i = 0; i < this.classLabels.length; i++) {
+                if (possibleClassLabels.includes(this.classLabels[i]) && this.y.getValue(i) > maxY) {
+                    maxY = this.y.getValue(i);
+                    predictedClass = this.classLabels[i];
+                }
+            }
+            return predictedClass;
+        }
+        /**
+         * The predict method takes an {@link Instance} as an input, converts it to a Vector and calculates the {@link Matrix} y by
+         * multiplying Matrix W with {@link Vector} x. Then it returns the class label which has the maximum y value.
+         *
+         * @param instance Instance to predict.
+         * @return The class label which has the maximum y.
+         */
+        predict(instance) {
+            this.createInputVector(instance);
+            this.calculateOutput();
+            if (instance instanceof CompositeInstance_1.CompositeInstance) {
+                return this.predictWithCompositeInstance(instance.getPossibleClassLabels());
+            }
+            else {
+                return this.classLabels[this.y.maxIndex()];
+            }
+        }
+        predictProbability(instance) {
+            this.createInputVector(instance);
+            this.calculateOutput();
+            let result = new Map();
+            for (let i = 0; i < this.classLabels.length; i++) {
+                result.set(this.classLabels[i], this.y.getValue(i));
+            }
+            return result;
+        }
+    }
+    exports.NeuralNetworkModel = NeuralNetworkModel;
+});
+//# sourceMappingURL=NeuralNetworkModel.js.map

package/dist/Model/NeuralNetworkModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NeuralNetworkModel.js","sourceRoot":"","sources":["../../source/Model/NeuralNetworkModel.ts"],"names":[],"mappings":"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"}

package/dist/Model/QdaModel.d.ts

@@ -0,0 +1,26 @@
+import { LdaModel } from "./LdaModel";
+import { Matrix } from "nlptoolkit-math/dist/Matrix";
+import { DiscreteDistribution } from "nlptoolkit-math/dist/DiscreteDistribution";
+import { Vector } from "nlptoolkit-math/dist/Vector";
+import { Instance } from "../Instance/Instance";
+export declare class QdaModel extends LdaModel {
+    private W;
+    /**
+     * The constructor which sets the priorDistribution, w w1 and HashMap of String Matrix.
+     *
+     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param W                 {@link HashMap} of String and Matrix.
+     * @param w                 {@link HashMap} of String and Vectors.
+     * @param w0                {@link HashMap} of String and Double.
+     */
+    constructor(priorDistribution: DiscreteDistribution, W: Map<string, Matrix>, w: Map<string, Vector>, w0: Map<string, number>);
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It multiplies Matrix Wi with Vector xi
+     * then calculates the dot product of it with xi. Then, again it finds the dot product of wi and xi and returns the summation with w0i.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The result of Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i.
+     */
+    calculateMetric(instance: Instance, Ci: string): number;
+}

package/dist/Model/QdaModel.js

@@ -0,0 +1,45 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./LdaModel"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.QdaModel = void 0;
+    const LdaModel_1 = require("./LdaModel");
+    class QdaModel extends LdaModel_1.LdaModel {
+        /**
+         * The constructor which sets the priorDistribution, w w1 and HashMap of String Matrix.
+         *
+         * @param priorDistribution {@link DiscreteDistribution} input.
+         * @param W                 {@link HashMap} of String and Matrix.
+         * @param w                 {@link HashMap} of String and Vectors.
+         * @param w0                {@link HashMap} of String and Double.
+         */
+        constructor(priorDistribution, W, w, w0) {
+            super(priorDistribution, w, w0);
+            this.W = W;
+        }
+        /**
+         * The calculateMetric method takes an {@link Instance} and a String as inputs. It multiplies Matrix Wi with Vector xi
+         * then calculates the dot product of it with xi. Then, again it finds the dot product of wi and xi and returns the summation with w0i.
+         *
+         * @param instance {@link Instance} input.
+         * @param Ci       String input.
+         * @return The result of Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i.
+         */
+        calculateMetric(instance, Ci) {
+            let xi = instance.toVector();
+            let Wi = this.W.get(Ci);
+            let wi = this.w.get(Ci);
+            let w0i = this.w0.get(Ci);
+            return Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i;
+        }
+    }
+    exports.QdaModel = QdaModel;
+});
+//# sourceMappingURL=QdaModel.js.map

package/dist/Model/QdaModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QdaModel.js","sourceRoot":"","sources":["../../source/Model/QdaModel.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,yCAAoC;IAMpC,MAAa,QAAS,SAAQ,mBAAQ;QAIlC;;;;;;;WAOG;QACH,YAAY,iBAAuC,EAAE,CAAsB,EAAE,CAAsB,EAAE,EAAuB;YACxH,KAAK,CAAC,iBAAiB,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;YAChC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QACd,CAAC;QAED;;;;;;;WAOG;QACH,eAAe,CAAC,QAAkB,EAAE,EAAU;YAC1C,IAAI,EAAE,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAC7B,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACxB,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACxB,IAAI,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC1B,OAAO,EAAE,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QACtF,CAAC;KACJ;IAhCD,4BAgCC"}

package/dist/Model/RandomModel.d.ts

@@ -0,0 +1,16 @@
+import { Model } from "./Model";
+import { Instance } from "../Instance/Instance";
+export declare class RandomModel extends Model {
+    private classLabels;
+    private seed;
+    constructor(classLabels: Array<string>, seed: number);
+    /**
+     * The predict method gets an Instance as an input and retrieves the possible class labels as an ArrayList. Then selects a
+     * random number as an index and returns the class label at this selected index.
+     *
+     * @param instance {@link Instance} to make prediction.
+     * @return The class label at the randomly selected index.
+     */
+    predict(instance: Instance): string;
+    predictProbability(instance: Instance): Map<string, number>;
+}

package/dist/Model/RandomModel.js

@@ -0,0 +1,51 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Model", "../Instance/CompositeInstance"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RandomModel = void 0;
+    const Model_1 = require("./Model");
+    const CompositeInstance_1 = require("../Instance/CompositeInstance");
+    class RandomModel extends Model_1.Model {
+        constructor(classLabels, seed) {
+            super();
+            this.classLabels = classLabels;
+            this.seed = seed;
+        }
+        /**
+         * The predict method gets an Instance as an input and retrieves the possible class labels as an ArrayList. Then selects a
+         * random number as an index and returns the class label at this selected index.
+         *
+         * @param instance {@link Instance} to make prediction.
+         * @return The class label at the randomly selected index.
+         */
+        predict(instance) {
+            if ((instance instanceof CompositeInstance_1.CompositeInstance)) {
+                let possibleClassLabels = instance.getPossibleClassLabels();
+                let size = possibleClassLabels.length;
+                let index = Math.floor(Math.random() * size);
+                return possibleClassLabels[index];
+            }
+            else {
+                let size = this.classLabels.length;
+                let index = Math.floor(Math.random() * size);
+                return this.classLabels[index];
+            }
+        }
+        predictProbability(instance) {
+            let result = new Map();
+            for (let classLabel of this.classLabels) {
+                result.set(classLabel, 1.0 / this.classLabels.length);
+            }
+            return result;
+        }
+    }
+    exports.RandomModel = RandomModel;
+});
+//# sourceMappingURL=RandomModel.js.map

package/dist/Model/RandomModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RandomModel.js","sourceRoot":"","sources":["../../source/Model/RandomModel.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,mCAA8B;IAE9B,qEAAgE;IAEhE,MAAa,WAAY,SAAQ,aAAK;QAKlC,YAAY,WAA0B,EAAE,IAAY;YAChD,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;YAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACpB,CAAC;QAED;;;;;;WAMG;QACH,OAAO,CAAC,QAAkB;YACtB,IAAI,CAAC,QAAQ,YAAY,qCAAiB,CAAC,EAAE;gBACzC,IAAI,mBAAmB,GAAwB,QAAS,CAAC,sBAAsB,EAAE,CAAC;gBAClF,IAAI,IAAI,GAAG,mBAAmB,CAAC,MAAM,CAAC;gBACtC,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;gBAC7C,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;aACrC;iBAAM;gBACH,IAAI,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;gBACnC,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;gBAC7C,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;aAClC;QACL,CAAC;QAED,kBAAkB,CAAC,QAAkB;YACjC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;YACvC,KAAK,IAAI,UAAU,IAAI,IAAI,CAAC,WAAW,EAAC;gBACpC,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;aACzD;YACD,OAAO,MAAM,CAAC;QAClB,CAAC;KAEJ;IAvCD,kCAuCC"}

package/dist/Model/TreeEnsembleModel.d.ts

@@ -0,0 +1,21 @@
+import { Model } from "./Model";
+import { Instance } from "../Instance/Instance";
+import { DecisionTree } from "./DecisionTree/DecisionTree";
+export declare class TreeEnsembleModel extends Model {
+    private forest;
+    /**
+     * A constructor which sets the {@link Array} of {@link DecisionTree} with given input.
+     *
+     * @param forest An {@link Array} of {@link DecisionTree}.
+     */
+    constructor(forest: Array<DecisionTree>);
+    /**
+     * The predict method takes an {@link Instance} as an input and loops through the {@link ArrayList} of {@link DecisionTree}s.
+     * Makes prediction for the items of that ArrayList and returns the maximum item of that ArrayList.
+     *
+     * @param instance Instance to make prediction.
+     * @return The maximum prediction of a given Instance.
+     */
+    predict(instance: Instance): string;
+    predictProbability(instance: Instance): Map<string, number>;
+}

package/dist/Model/TreeEnsembleModel.js

@@ -0,0 +1,49 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Model", "nlptoolkit-math/dist/DiscreteDistribution"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TreeEnsembleModel = void 0;
+    const Model_1 = require("./Model");
+    const DiscreteDistribution_1 = require("nlptoolkit-math/dist/DiscreteDistribution");
+    class TreeEnsembleModel extends Model_1.Model {
+        /**
+         * A constructor which sets the {@link Array} of {@link DecisionTree} with given input.
+         *
+         * @param forest An {@link Array} of {@link DecisionTree}.
+         */
+        constructor(forest) {
+            super();
+            this.forest = forest;
+        }
+        /**
+         * The predict method takes an {@link Instance} as an input and loops through the {@link ArrayList} of {@link DecisionTree}s.
+         * Makes prediction for the items of that ArrayList and returns the maximum item of that ArrayList.
+         *
+         * @param instance Instance to make prediction.
+         * @return The maximum prediction of a given Instance.
+         */
+        predict(instance) {
+            let distribution = new DiscreteDistribution_1.DiscreteDistribution();
+            for (let tree of this.forest) {
+                distribution.addItem(tree.predict(instance));
+            }
+            return distribution.getMaxItem();
+        }
+        predictProbability(instance) {
+            let distribution = new DiscreteDistribution_1.DiscreteDistribution();
+            for (let tree of this.forest) {
+                distribution.addItem(tree.predict(instance));
+            }
+            return distribution.getProbabilityDistribution();
+        }
+    }
+    exports.TreeEnsembleModel = TreeEnsembleModel;
+});
+//# sourceMappingURL=TreeEnsembleModel.js.map

package/dist/Model/TreeEnsembleModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeEnsembleModel.js","sourceRoot":"","sources":["../../source/Model/TreeEnsembleModel.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,mCAA8B;IAG9B,oFAA+E;IAE/E,MAAa,iBAAkB,SAAQ,aAAK;QAIxC;;;;WAIG;QACH,YAAY,MAA2B;YACnC,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACxB,CAAC;QAED;;;;;;WAMG;QACH,OAAO,CAAC,QAAkB;YACtB,IAAI,YAAY,GAAG,IAAI,2CAAoB,EAAE,CAAC;YAC9C,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE;gBAC1B,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;aAChD;YACD,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;QACrC,CAAC;QAED,kBAAkB,CAAC,QAAkB;YACjC,IAAI,YAAY,GAAG,IAAI,2CAAoB,EAAE,CAAC;YAC9C,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE;gBAC1B,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;aAChD;YACD,OAAO,YAAY,CAAC,0BAA0B,EAAE,CAAC;QACrD,CAAC;KAEJ;IArCD,8CAqCC"}

package/dist/Model/ValidatedModel.d.ts

@@ -0,0 +1,12 @@
+import { Model } from "./Model";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { ClassificationPerformance } from "../Performance/ClassificationPerformance";
+export declare abstract class ValidatedModel extends Model {
+    /**
+     * The testClassifier method takes an {@link InstanceList} as an input and returns an accuracy value as {@link ClassificationPerformance}.
+     *
+     * @param data {@link InstanceList} to test.
+     * @return Accuracy value as {@link ClassificationPerformance}.
+     */
+    testClassifier(data: InstanceList): ClassificationPerformance;
+}

package/dist/Model/ValidatedModel.js

@@ -0,0 +1,35 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Model", "../Performance/ClassificationPerformance"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValidatedModel = void 0;
+    const Model_1 = require("./Model");
+    const ClassificationPerformance_1 = require("../Performance/ClassificationPerformance");
+    class ValidatedModel extends Model_1.Model {
+        /**
+         * The testClassifier method takes an {@link InstanceList} as an input and returns an accuracy value as {@link ClassificationPerformance}.
+         *
+         * @param data {@link InstanceList} to test.
+         * @return Accuracy value as {@link ClassificationPerformance}.
+         */
+        testClassifier(data) {
+            let total = data.size();
+            let count = 0;
+            for (let i = 0; i < data.size(); i++) {
+                if (data.get(i).getClassLabel().toLowerCase() == this.predict(data.get(i)).toLowerCase()) {
+                    count++;
+                }
+            }
+            return new ClassificationPerformance_1.ClassificationPerformance(count / total);
+        }
+    }
+    exports.ValidatedModel = ValidatedModel;
+});
+//# sourceMappingURL=ValidatedModel.js.map

package/dist/Model/ValidatedModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidatedModel.js","sourceRoot":"","sources":["../../source/Model/ValidatedModel.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,mCAA8B;IAE9B,wFAAmF;IAEnF,MAAsB,cAAe,SAAQ,aAAK;QAE9C;;;;;WAKG;QACH,cAAc,CAAC,IAAkB;YAC7B,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;YACxB,IAAI,KAAK,GAAG,CAAC,CAAC;YACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE;gBAClC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE;oBACtF,KAAK,EAAE,CAAC;iBACX;aACJ;YACD,OAAO,IAAI,qDAAyB,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;QACxD,CAAC;KACJ;IAlBD,wCAkBC"}

package/dist/Parameter/ActivationFunction.d.ts

@@ -0,0 +1,5 @@
+export declare enum ActivationFunction {
+    SIGMOID = 0,
+    TANH = 1,
+    RELU = 2
+}

package/dist/Parameter/ActivationFunction.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ActivationFunction = void 0;
+    var ActivationFunction;
+    (function (ActivationFunction) {
+        ActivationFunction[ActivationFunction["SIGMOID"] = 0] = "SIGMOID";
+        ActivationFunction[ActivationFunction["TANH"] = 1] = "TANH";
+        ActivationFunction[ActivationFunction["RELU"] = 2] = "RELU";
+    })(ActivationFunction = exports.ActivationFunction || (exports.ActivationFunction = {}));
+});
+//# sourceMappingURL=ActivationFunction.js.map

package/dist/Parameter/ActivationFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivationFunction.js","sourceRoot":"","sources":["../../source/Parameter/ActivationFunction.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,IAAY,kBAEX;IAFD,WAAY,kBAAkB;QAC1B,iEAAO,CAAA;QAAE,2DAAI,CAAA;QAAE,2DAAI,CAAA;IACvB,CAAC,EAFW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAE7B"}

package/dist/Parameter/BaggingParameter.d.ts

@@ -0,0 +1,17 @@
+import { Parameter } from "./Parameter";
+export declare class BaggingParameter extends Parameter {
+    protected ensembleSize: number;
+    /**
+     * Parameters of the bagging trees algorithm.
+     *
+     * @param seed         Seed is used for random number generation.
+     * @param ensembleSize The number of trees in the bagged forest.
+     */
+    constructor(seed: number, ensembleSize: number);
+    /**
+     * Accessor for the ensemble size.
+     *
+     * @return The ensemble size.
+     */
+    getEnsembleSize(): number;
+}

package/dist/Parameter/BaggingParameter.js

@@ -0,0 +1,36 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Parameter"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaggingParameter = void 0;
+    const Parameter_1 = require("./Parameter");
+    class BaggingParameter extends Parameter_1.Parameter {
+        /**
+         * Parameters of the bagging trees algorithm.
+         *
+         * @param seed         Seed is used for random number generation.
+         * @param ensembleSize The number of trees in the bagged forest.
+         */
+        constructor(seed, ensembleSize) {
+            super(seed);
+            this.ensembleSize = ensembleSize;
+        }
+        /**
+         * Accessor for the ensemble size.
+         *
+         * @return The ensemble size.
+         */
+        getEnsembleSize() {
+            return this.ensembleSize;
+        }
+    }
+    exports.BaggingParameter = BaggingParameter;
+});
+//# sourceMappingURL=BaggingParameter.js.map