nlptoolkit-classification 1.0.0

package/source/Model/QdaModel.ts

@@ -0,0 +1,39 @@
+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 class QdaModel extends LdaModel{
+
+    private W: Map<string, Matrix>
+
+    /**
+     * 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>) {
+        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: Instance, Ci: string): number {
+        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;
+    }
+}

package/source/Model/RandomModel.ts

@@ -0,0 +1,44 @@
+import {Model} from "./Model";
+import {Instance} from "../Instance/Instance";
+import {CompositeInstance} from "../Instance/CompositeInstance";
+
+export class RandomModel extends Model{
+
+    private classLabels: Array<string>
+    private seed: number
+
+    constructor(classLabels: Array<string>, seed: number) {
+        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: Instance): string {
+        if ((instance instanceof CompositeInstance)) {
+            let possibleClassLabels = (<CompositeInstance> 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: Instance): Map<string, number> {
+        let result = new Map<string, number>();
+        for (let classLabel of this.classLabels){
+            result.set(classLabel, 1.0 / this.classLabels.length);
+        }
+        return result;
+    }
+
+}

package/source/Model/TreeEnsembleModel.ts

@@ -0,0 +1,43 @@
+import {Model} from "./Model";
+import {Instance} from "../Instance/Instance";
+import {DecisionTree} from "./DecisionTree/DecisionTree";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+
+export class TreeEnsembleModel extends Model{
+
+    private forest: Array<DecisionTree>
+
+    /**
+     * 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>) {
+        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: Instance): string {
+        let distribution = new DiscreteDistribution();
+        for (let tree of this.forest) {
+            distribution.addItem(tree.predict(instance));
+        }
+        return distribution.getMaxItem();
+    }
+
+    predictProbability(instance: Instance): Map<string, number> {
+        let distribution = new DiscreteDistribution();
+        for (let tree of this.forest) {
+            distribution.addItem(tree.predict(instance));
+        }
+        return distribution.getProbabilityDistribution();
+    }
+
+}

package/source/Model/ValidatedModel.ts

@@ -0,0 +1,23 @@
+import {Model} from "./Model";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
+
+export 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{
+        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(count / total);
+    }
+}

package/source/Parameter/ActivationFunction.ts

@@ -0,0 +1,3 @@
+export enum ActivationFunction {
+    SIGMOID, TANH, RELU
+}

package/source/Parameter/BaggingParameter.ts

@@ -0,0 +1,26 @@
+import {Parameter} from "./Parameter";
+
+export 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) {
+        super(seed);
+        this.ensembleSize = ensembleSize
+    }
+
+    /**
+     * Accessor for the ensemble size.
+     *
+     * @return The ensemble size.
+     */
+    getEnsembleSize(): number{
+        return this.ensembleSize
+    }
+}

package/source/Parameter/C45Parameter.ts

@@ -0,0 +1,38 @@
+import {Parameter} from "./Parameter";
+
+export class C45Parameter extends Parameter{
+
+    private prune: boolean
+    private crossValidationRatio: number
+
+    /**
+     * Parameters of the C4.5 univariate decision tree classifier.
+     *
+     * @param seed                 Seed is used for random number generation.
+     * @param prune                Boolean value for prune.
+     * @param crossValidationRatio Double value for cross crossValidationRatio ratio.
+     */
+    constructor(seed: number, prune: boolean, crossValidationRatio: number) {
+        super(seed);
+        this.prune = prune
+        this.crossValidationRatio = crossValidationRatio
+    }
+
+    /**
+     * Accessor for the prune.
+     *
+     * @return Prune.
+     */
+    isPrune(): boolean{
+        return this.prune
+    }
+
+    /**
+     * Accessor for the crossValidationRatio.
+     *
+     * @return crossValidationRatio.
+     */
+    getCrossValidationRatio(): number{
+        return this.crossValidationRatio
+    }
+}

package/source/Parameter/DeepNetworkParameter.ts

@@ -0,0 +1,59 @@
+import {LinearPerceptronParameter} from "./LinearPerceptronParameter";
+import {ActivationFunction} from "./ActivationFunction";
+
+export class DeepNetworkParameter extends LinearPerceptronParameter{
+    private hiddenLayers: Array<number>
+    private activationFunction: ActivationFunction
+
+    /**
+     * Parameters of the deep network classifier.
+     *
+     * @param seed                 Seed is used for random number generation.
+     * @param learningRate         Double value for learning rate of the algorithm.
+     * @param etaDecrease          Double value for decrease in eta of the algorithm.
+     * @param crossValidationRatio Double value for cross validation ratio of the algorithm.
+     * @param epoch                Integer value for epoch number of the algorithm.
+     * @param hiddenLayers         An integer {@link Array} for hidden layers of the algorithm.
+     * @param activationFunction   Activation function
+     */
+    constructor(seed: number,
+                learningRate: number,
+                etaDecrease: number,
+                crossValidationRatio: number,
+                epoch: number,
+                hiddenLayers: Array<number>,
+                activationFunction: ActivationFunction) {
+        super(seed, learningRate, etaDecrease, crossValidationRatio, epoch);
+        this.hiddenLayers = hiddenLayers
+        this.activationFunction = activationFunction
+    }
+
+    /**
+     * The layerSize method returns the size of the hiddenLayers {@link Array}.
+     *
+     * @return The size of the hiddenLayers {@link Array}.
+     */
+    layerSize(): number{
+        return this.hiddenLayers.length
+    }
+
+    /**
+     * The getHiddenNodes method takes a layer index as an input and returns the element at the given index of hiddenLayers
+     * {@link Array}.
+     *
+     * @param layerIndex Index of the layer.
+     * @return The element at the layerIndex of hiddenLayers {@link Array}.
+     */
+    getHiddenNodes(layerIndex: number): number{
+        return this.hiddenLayers[layerIndex]
+    }
+
+    /**
+     * Accessor for the activation function.
+     *
+     * @return The activation function.
+     */
+    getActivationFunction(): ActivationFunction{
+        return this.activationFunction
+    }
+}

package/source/Parameter/KMeansParameter.ts

@@ -0,0 +1,33 @@
+import {Parameter} from "./Parameter";
+import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
+import {EuclidianDistance} from "../DistanceMetric/EuclidianDistance";
+
+export class KMeansParameter extends Parameter{
+
+    protected distanceMetric: DistanceMetric
+
+    /**
+     * * Parameters of the K Means classifier.
+     *
+     * @param seed           Seed is used for random number generation.
+     * @param distanceMetric distance metric used to calculate the distance between two instances.
+     */
+    constructor(seed: number, distanceMetric?: DistanceMetric) {
+        super(seed);
+        if (distanceMetric == undefined){
+            this.distanceMetric = new EuclidianDistance()
+        } else {
+            this.distanceMetric = distanceMetric
+        }
+    }
+
+    /**
+     * Accessor for the distanceMetric.
+     *
+     * @return The distanceMetric.
+     */
+    getDistanceMetric(): DistanceMetric{
+        return this.distanceMetric
+    }
+
+}

package/source/Parameter/KnnParameter.ts

@@ -0,0 +1,28 @@
+import {KMeansParameter} from "./KMeansParameter";
+import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
+
+export class KnnParameter extends KMeansParameter{
+
+    private k: number
+
+    /**
+     * Parameters of the K-nearest neighbor classifier.
+     *
+     * @param seed           Seed is used for random number generation.
+     * @param k              Parameter of the K-nearest neighbor algorithm.
+     * @param distanceMetric Used to calculate the distance between two instances.
+     */
+    constructor(seed: number, k: number, distanceMetric?: DistanceMetric) {
+        super(seed, distanceMetric);
+        this.k = k
+    }
+
+    /**
+     * Accessor for the k.
+     *
+     * @return Value of the k.
+     */
+    getK(): number{
+        return this.k
+    }
+}

package/source/Parameter/LinearPerceptronParameter.ts

@@ -0,0 +1,66 @@
+import {Parameter} from "./Parameter";
+
+export class LinearPerceptronParameter extends Parameter{
+
+    private learningRate: number
+    private etaDecrease: number
+    private crossValidationRatio: number
+    private epoch: number
+
+    /**
+     * Parameters of the linear perceptron algorithm.
+     *
+     * @param seed                 Seed is used for random number generation.
+     * @param learningRate         Double value for learning rate of the algorithm.
+     * @param etaDecrease          Double value for decrease in eta of the algorithm.
+     * @param crossValidationRatio Double value for cross validation ratio of the algorithm.
+     * @param epoch                Integer value for epoch number of the algorithm.
+     */
+    constructor(seed: number,
+                learningRate: number,
+                etaDecrease: number,
+                crossValidationRatio: number,
+                epoch: number) {
+        super(seed);
+        this.learningRate = learningRate
+        this.etaDecrease = etaDecrease
+        this.crossValidationRatio = crossValidationRatio
+        this.epoch = epoch
+    }
+
+    /**
+     * Accessor for the learningRate.
+     *
+     * @return The learningRate.
+     */
+    getLearningRate(): number{
+        return this.learningRate
+    }
+
+    /**
+     * Accessor for the etaDecrease.
+     *
+     * @return The etaDecrease.
+     */
+    getEtaDecrease(): number{
+        return this.etaDecrease
+    }
+
+    /**
+     * Accessor for the crossValidationRatio.
+     *
+     * @return The crossValidationRatio.
+     */
+    getCrossValidationRatio(): number{
+        return this.crossValidationRatio
+    }
+
+    /**
+     * Accessor for the epoch.
+     *
+     * @return The epoch.
+     */
+    getEpoch(): number{
+        return this.epoch
+    }
+}

package/source/Parameter/MultiLayerPerceptronParameter.ts

@@ -0,0 +1,49 @@
+import {LinearPerceptronParameter} from "./LinearPerceptronParameter";
+import {ActivationFunction} from "./ActivationFunction";
+
+export class MultiLayerPerceptronParameter extends LinearPerceptronParameter{
+
+    private hiddenNodes: number
+    private activationFunction: ActivationFunction
+
+    /**
+     * Parameters of the multi layer perceptron algorithm.
+     *
+     * @param seed                 Seed is used for random number generation.
+     * @param learningRate         Double value for learning rate of the algorithm.
+     * @param etaDecrease          Double value for decrease in eta of the algorithm.
+     * @param crossValidationRatio Double value for cross validation ratio of the algorithm.
+     * @param epoch                Integer value for epoch number of the algorithm.
+     * @param hiddenNodes          Integer value for the number of hidden nodes.
+     * @param activationFunction   Activation function
+     */
+    constructor(seed: number,
+                learningRate: number,
+                etaDecrease: number,
+                crossValidationRatio: number,
+                epoch: number,
+                hiddenNodes: number,
+                activationFunction: ActivationFunction) {
+        super(seed, learningRate, etaDecrease, crossValidationRatio, epoch);
+        this.hiddenNodes = hiddenNodes
+        this.activationFunction = activationFunction
+    }
+
+    /**
+     * Accessor for the hiddenNodes.
+     *
+     * @return The hiddenNodes.
+     */
+    getHiddenNodes(): number{
+        return this.hiddenNodes
+    }
+
+    /**
+     * Accessor for the activation function.
+     *
+     * @return The activation function.
+     */
+    getActivationFunction(): ActivationFunction{
+        return this.activationFunction
+    }
+}

package/source/Parameter/Parameter.ts

@@ -0,0 +1,22 @@
+export class Parameter {
+
+    private seed: number
+
+    /**
+     * Constructor of {@link Parameter} class which assigns given seed value to seed.
+     *
+     * @param seed Seed is used for random number generation.
+     */
+    constructor(seed: number) {
+        this.seed = seed
+    }
+
+    /**
+     * Accessor for the seed.
+     *
+     * @return The seed.
+     */
+    getSeed(): number{
+        return this.seed
+    }
+}

package/source/Parameter/RandomForestParameter.ts

@@ -0,0 +1,27 @@
+import {BaggingParameter} from "./BaggingParameter";
+
+export class RandomForestParameter extends BaggingParameter{
+
+    attributeSubsetSize: number
+
+    /**
+     * Parameters of the random forest classifier.
+     *
+     * @param seed                Seed is used for random number generation.
+     * @param ensembleSize        The number of trees in the bagged forest.
+     * @param attributeSubsetSize Integer value for the size of attribute subset.
+     */
+    constructor(seed: number, ensembleSize: number, attributeSubsetSize: number) {
+        super(seed, ensembleSize);
+        this.attributeSubsetSize = attributeSubsetSize
+    }
+
+    /**
+     * Accessor for the attributeSubsetSize.
+     *
+     * @return The attributeSubsetSize.
+     */
+    getAttributeSubsetSize(): number{
+        return this.attributeSubsetSize
+    }
+}

package/source/Performance/ClassificationPerformance.ts

@@ -0,0 +1,26 @@
+import {Performance} from "./Performance";
+
+export class ClassificationPerformance extends Performance{
+
+    private readonly accuracy: number
+
+    /**
+     * A constructor that sets the accuracy and errorRate via given input.
+     *
+     * @param accuracy  Double value input.
+     * @param errorRate Double value input.
+     */
+    constructor(accuracy: number, errorRate?: number) {
+        super(errorRate == undefined ? 1 - accuracy : errorRate);
+        this.accuracy = accuracy
+    }
+
+    /**
+     * Accessor for the accuracy.
+     *
+     * @return Accuracy value.
+     */
+    getAccuracy(): number{
+        return this.accuracy
+    }
+}