nlptoolkit-classification 1.0.0

package/source/Attribute/AttributeType.ts

@@ -0,0 +1,18 @@
+export enum AttributeType {
+    /**
+     * Continuous Attribute
+     */
+    CONTINUOUS,
+    /**
+     * Discrete Attribute
+     */
+    DISCRETE,
+    /**
+     * Binary Attribute
+     */
+    BINARY,
+    /**
+     * Discrete Indexed Attribute is used to store the indices.
+     */
+    DISCRETE_INDEXED
+}

package/source/Attribute/BinaryAttribute.ts

@@ -0,0 +1,14 @@
+import {DiscreteAttribute} from "./DiscreteAttribute";
+
+export class BinaryAttribute extends DiscreteAttribute{
+
+    /**
+     * Constructor for a binary discrete attribute. The attribute can take only two values "True" or "False".
+     *
+     * @param value Value of the attribute. Can be true or false.
+     */
+    constructor(value: boolean) {
+        super(value == true ? "1" : "0");
+    }
+
+}

package/source/Attribute/ContinuousAttribute.ts

@@ -0,0 +1,53 @@
+import {Attribute} from "./Attribute";
+
+export class ContinuousAttribute extends Attribute{
+
+    private value: number
+
+    /**
+     * Constructor for a continuous attribute.
+     *
+     * @param value Value of the attribute.
+     */
+    constructor(value: number) {
+        super();
+        this.value = value
+    }
+
+    /**
+     * Accessor method for value.
+     *
+     * @return value
+     */
+    getValue(): number{
+        return this.value
+    }
+
+    /**
+     * Mutator method for value
+     *
+     * @param value New value of value.
+     */
+    setValue(value: number){
+        this.value = value
+    }
+
+    /**
+     * Converts value to {@link String}.
+     *
+     * @return String representation of value.
+     */
+    toString(): string{
+        return this.value.toString()
+    }
+
+    continuousAttributeSize(): number {
+        return 1;
+    }
+
+    continuousAttributes(): Array<number> {
+        let result = new Array<number>();
+        result.push(this.value)
+        return result
+    }
+}

package/source/Attribute/DiscreteAttribute.ts

@@ -0,0 +1,46 @@
+import {Attribute} from "./Attribute";
+
+export class DiscreteAttribute extends Attribute{
+
+    private value: string = "NULL"
+
+    /**
+     * Constructor for a discrete attribute.
+     *
+     * @param value Value of the attribute.
+     */
+    constructor(value: string) {
+        super();
+        this.value = value
+    }
+
+    /**
+     * Accessor method for value.
+     *
+     * @return value
+     */
+    getValue(): string{
+        return this.value
+    }
+
+    /**
+     * Converts value to {@link String}.
+     *
+     * @return String representation of value.
+     */
+    toString(): string{
+        if (this.value == ","){
+            return "comma";
+        }
+        return this.value;
+    }
+
+    continuousAttributeSize(): number {
+        return 0;
+    }
+
+    continuousAttributes(): Array<number> {
+        return new Array<number>();
+    }
+
+}

package/source/Attribute/DiscreteIndexedAttribute.ts

@@ -0,0 +1,54 @@
+import {DiscreteAttribute} from "./DiscreteAttribute";
+
+export class DiscreteIndexedAttribute extends DiscreteAttribute{
+
+    private index: number
+    private maxIndex: number
+
+    /**
+     * Constructor for a discrete attribute.
+     *
+     * @param value Value of the attribute.
+     * @param index Index of the attribute.
+     * @param maxIndex Maximum index of the attribute.
+     */
+    constructor(value: string, index: number, maxIndex: number) {
+        super(value);
+        this.index = index
+        this.maxIndex = maxIndex
+    }
+
+    /**
+     * Accessor method for index.
+     *
+     * @return index.
+     */
+    getIndex(): number{
+        return this.index
+    }
+
+    /**
+     * Accessor method for maxIndex.
+     *
+     * @return maxIndex.
+     */
+    getMaxIndex(): number{
+        return this.maxIndex
+    }
+
+    continuousAttributeSize(): number {
+        return this.maxIndex
+    }
+
+    continuousAttributes(): Array<number> {
+        let result = new Array<number>()
+        for (let i = 0; i < this.maxIndex; i++) {
+            if (i != this.index) {
+                result.push(0.0);
+            } else {
+                result.push(1.0);
+            }
+        }
+        return result
+    }
+}

package/source/Classifier/Bagging.ts

@@ -0,0 +1,32 @@
+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";
+
+export class Bagging extends Classifier{
+
+    /**
+     * Bagging bootstrap ensemble method that creates individuals for its ensemble by training each classifier on a random
+     * redistribution of the training set.
+     * This training method is for a bagged decision tree classifier. 20 percent of the instances are left aside for pruning of the trees
+     * 80 percent of the instances are used for training the trees. The number of trees (forestSize) is a parameter, and basically
+     * the method will learn an ensemble of trees as a model.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters Parameters of the bagging trees algorithm. ensembleSize returns the number of trees in the bagged forest.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let forestSize = (<BaggingParameter> parameters).getEnsembleSize();
+        let 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.model = new TreeEnsembleModel(forest);
+    }
+
+}

package/source/Classifier/C45.ts

@@ -0,0 +1,30 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {C45Parameter} from "../Parameter/C45Parameter";
+import {Partition} from "../InstanceList/Partition";
+import {DecisionTree} from "../Model/DecisionTree/DecisionTree";
+import {DecisionNode} from "../Model/DecisionTree/DecisionNode";
+
+export class C45 extends Classifier{
+
+    /**
+     * 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 {
+        let tree: DecisionTree
+        if ((<C45Parameter> parameters).isPrune()) {
+            let partition = new Partition(trainSet, (<C45Parameter> parameters).getCrossValidationRatio(), true);
+            tree = new DecisionTree(new DecisionNode(partition.get(1), undefined, undefined, false));
+            tree.prune(partition.get(0));
+        } else {
+            tree = new DecisionTree(new DecisionNode(trainSet, undefined, undefined, false));
+        }
+        this.model = tree;
+    }
+
+}

package/source/Classifier/C45Stump.ts

@@ -0,0 +1,19 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {DecisionTree} from "../Model/DecisionTree/DecisionTree";
+import {DecisionNode} from "../Model/DecisionTree/DecisionNode";
+
+export class C45Stump extends Classifier{
+
+    /**
+     * 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.model = new DecisionTree(new DecisionNode(trainSet, undefined, undefined, true));
+    }
+
+}

package/source/Classifier/Classifier.ts

@@ -0,0 +1,71 @@
+import {Model} from "../Model/Model";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Instance} from "../Instance/Instance";
+import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+import {DiscreteIndexedAttribute} from "../Attribute/DiscreteIndexedAttribute";
+import {ConfusionMatrix} from "../Performance/ConfusionMatrix";
+import {Performance} from "../Performance/Performance";
+import {DetailedClassificationPerformance} from "../Performance/DetailedClassificationPerformance";
+
+export abstract class Classifier {
+
+    protected model: Model
+
+    abstract train(trainSet: InstanceList, parameters: Parameter):void
+
+    /**
+     * Checks given instance's attribute and returns true if it is a discrete indexed attribute, false otherwise.
+     *
+     * @param instance Instance to check.
+     * @return True if instance is a discrete indexed attribute, false otherwise.
+     */
+    discreteCheck(instance: Instance): boolean{
+        for (let i = 0; i < instance.attributeSize(); i++) {
+            if (instance.getAttribute(i) instanceof DiscreteAttribute &&
+                !(instance.getAttribute(i) instanceof DiscreteIndexedAttribute)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * TestClassification an instance list with the current model.
+     *
+     * @param testSet Test data (list of instances) to be tested.
+     * @return The accuracy (and error) of the model as an instance of Performance class.
+     */
+    test(testSet: InstanceList): Performance{
+        let classLabels = testSet.getUnionOfPossibleClassLabels();
+        let confusion = new ConfusionMatrix(classLabels);
+        for (let i = 0; i < testSet.size(); i++) {
+            let instance = testSet.get(i);
+            confusion.classify(instance.getClassLabel(), this.model.predict(instance));
+        }
+        return new DetailedClassificationPerformance(confusion);
+    }
+
+    /**
+     * Runs current classifier with the given train and test data.
+     *
+     * @param parameter Parameter of the classifier to be trained.
+     * @param trainSet  Training data to be used in training the classifier.
+     * @param testSet   Test data to be tested after training the model.
+     * @return The accuracy (and error) of the trained model as an instance of Performance class.
+     * @throws DiscreteFeaturesNotAllowed Exception for discrete features.
+     */
+    singleRun(parameter: Parameter, trainSet: InstanceList, testSet: InstanceList): Performance{
+        this.train(trainSet, parameter);
+        return this.test(testSet);
+    }
+
+    /**
+     * Accessor for the model.
+     *
+     * @return Model.
+     */
+    getModel(): Model{
+        return this.model
+    }
+}

package/source/Classifier/DeepNetwork.ts

@@ -0,0 +1,22 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Partition} from "../InstanceList/Partition";
+import {DeepNetworkParameter} from "../Parameter/DeepNetworkParameter";
+import {DeepNetworkModel} from "../Model/DeepNetworkModel";
+
+export class DeepNetwork extends Classifier{
+
+    /**
+     * Training algorithm for deep network classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters Parameters of the deep network algorithm. crossValidationRatio and seed are used as parameters.
+     * @throws DiscreteFeaturesNotAllowed Exception for discrete features.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let partition = new Partition(trainSet, (<DeepNetworkParameter> parameters).getCrossValidationRatio(), true);
+        this.model = new DeepNetworkModel(partition.get(1), partition.get(0), <DeepNetworkParameter> parameters);
+    }
+
+}

package/source/Classifier/Dummy.ts

@@ -0,0 +1,19 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {DummyModel} from "../Model/DummyModel";
+
+export class Dummy extends Classifier{
+
+    /**
+     * 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.model = new DummyModel(trainSet);
+    }
+
+}

package/source/Classifier/KMeans.ts

@@ -0,0 +1,26 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Partition} from "../InstanceList/Partition";
+import {KMeansModel} from "../Model/KMeansModel";
+import {KMeansParameter} from "../Parameter/KMeansParameter";
+
+export class KMeans extends Classifier{
+
+    /**
+     * Training algorithm for K-Means classifier. K-Means finds the mean of each class for training.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters distanceMetric: distance metric used to calculate the distance between two instances.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let priorDistribution = trainSet.classDistribution();
+        let classMeans = new InstanceList();
+        let classLists = new Partition(trainSet);
+        for (let i = 0; i < classLists.size(); i++) {
+            classMeans.add(classLists.get(i).average());
+        }
+        this.model = new KMeansModel(priorDistribution, classMeans, (<KMeansParameter> parameters).getDistanceMetric());
+    }
+
+}

package/source/Classifier/Knn.ts

@@ -0,0 +1,21 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {KnnModel} from "../Model/KnnModel";
+import {KnnParameter} from "../Parameter/KnnParameter";
+
+export class Knn extends Classifier{
+
+
+    /**
+     * Training algorithm for K-nearest neighbor classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters K: k parameter of the K-nearest neighbor algorithm
+     *                   distanceMetric: distance metric used to calculate the distance between two instances.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.model = new KnnModel(trainSet, (<KnnParameter> parameters).getK(), (<KnnParameter> parameters).getDistanceMetric());
+    }
+    
+}

package/source/Classifier/Lda.ts

@@ -0,0 +1,43 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {Partition} from "../InstanceList/Partition";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {InstanceListOfSameClass} from "../InstanceList/InstanceListOfSameClass";
+import {LdaModel} from "../Model/LdaModel";
+
+export class Lda extends Classifier{
+
+    /**
+     * Training algorithm for the linear discriminant analysis classifier (Introduction to Machine Learning, Alpaydin, 2015).
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let w0 = new Map<string, number>();
+        let w = new Map<string, Vector>();
+        let priorDistribution = trainSet.classDistribution();
+        let classLists = new Partition(trainSet);
+        let covariance = new Matrix(trainSet.get(0).continuousAttributeSize(), trainSet.get(0).continuousAttributeSize());
+        for (let i = 0; i < classLists.size(); i++) {
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let classCovariance = classLists.get(i).covariance(averageVector);
+            classCovariance.multiplyWithConstant(classLists.get(i).size() - 1);
+            covariance.add(classCovariance);
+        }
+        covariance.divideByConstant(trainSet.size() - classLists.size());
+        covariance.inverse();
+        for (let i = 0; i < classLists.size(); i++) {
+            let Ci = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let wi = covariance.multiplyWithVectorFromRight(averageVector);
+            w.set(Ci, wi);
+            let w0i = -0.5 * wi.dotProduct(averageVector) + Math.log(priorDistribution.getProbability(Ci));
+            w0.set(Ci, w0i);
+        }
+        this.model = new LdaModel(priorDistribution, w, w0);
+    }
+
+}

package/source/Classifier/LinearPerceptron.ts

@@ -0,0 +1,23 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Partition} from "../InstanceList/Partition";
+import {LinearPerceptronParameter} from "../Parameter/LinearPerceptronParameter";
+import {LinearPerceptronModel} from "../Model/LinearPerceptronModel";
+
+export class LinearPerceptron extends Classifier{
+
+    /**
+     * Training algorithm for the linear perceptron algorithm. 20 percent of the data is separated as cross-validation
+     * data used for selecting the best weights. 80 percent of the data is used for training the linear perceptron with
+     * gradient descent.
+     *
+     * @param trainSet   Training data given to the algorithm
+     * @param parameters Parameters of the linear perceptron.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let partition = new Partition(trainSet, (<LinearPerceptronParameter> parameters).getCrossValidationRatio(), true);
+        this.model = new LinearPerceptronModel(partition.get(1), partition.get(0), <LinearPerceptronParameter> parameters);
+    }
+
+}

package/source/Classifier/MultiLayerPerceptron.ts

@@ -0,0 +1,23 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {Partition} from "../InstanceList/Partition";
+import {MultiLayerPerceptronParameter} from "../Parameter/MultiLayerPerceptronParameter";
+import {MultiLayerPerceptronModel} from "../Model/MultiLayerPerceptronModel";
+
+export class MultiLayerPerceptron extends Classifier{
+
+    /**
+     * Training algorithm for the multilayer perceptron algorithm. 20 percent of the data is separated as cross-validation
+     * data used for selecting the best weights. 80 percent of the data is used for training the multilayer perceptron with
+     * gradient descent.
+     *
+     * @param trainSet   Training data given to the algorithm
+     * @param parameters Parameters of the multilayer perceptron.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let partition = new Partition(trainSet, (<MultiLayerPerceptronParameter> parameters).getCrossValidationRatio(), true);
+        this.model = new MultiLayerPerceptronModel(partition.get(1), partition.get(0), <MultiLayerPerceptronParameter> parameters);
+    }
+
+}

package/source/Classifier/NaiveBayes.ts

@@ -0,0 +1,62 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {Partition} from "../InstanceList/Partition";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {InstanceListOfSameClass} from "../InstanceList/InstanceListOfSameClass";
+import {NaiveBayesModel} from "../Model/NaiveBayesModel";
+import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+
+export class NaiveBayes extends Classifier{
+
+    /**
+     * Training algorithm for Naive Bayes algorithm with a continuous data set.
+     *
+     * @param priorDistribution Probability distribution of classes P(C_i)
+     * @param classLists        Instances are divided into K lists, where each list contains only instances from a single class
+     */
+    private trainContinuousVersion(priorDistribution: DiscreteDistribution, classLists: Partition){
+        let classMeans = new Map<string, Vector>();
+        let classDeviations = new Map<string, Vector>();
+        for (let i = 0; i < classLists.size(); i++){
+            let classLabel = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = classLists.get(i).average().toVector();
+            classMeans.set(classLabel, averageVector);
+            let standardDeviationVector = classLists.get(i).standardDeviation().toVector();
+            classDeviations.set(classLabel, standardDeviationVector);
+        }
+        this.model = new NaiveBayesModel(priorDistribution, classMeans, classDeviations);
+    }
+
+    /**
+     * Training algorithm for Naive Bayes algorithm with a discrete data set.
+     * @param priorDistribution Probability distribution of classes P(C_i)
+     * @param classLists Instances are divided into K lists, where each list contains only instances from a single class
+     */
+    private trainDiscreteVersion(priorDistribution: DiscreteDistribution, classLists: Partition){
+        let classAttributeDistributions = new Map<String, Array<DiscreteDistribution>>();
+        for (let i = 0; i < classLists.size(); i++){
+            classAttributeDistributions.set((<InstanceListOfSameClass> classLists.get(i)).getClassLabel(),
+                classLists.get(i).allAttributesDistribution());
+        }
+        this.model = new NaiveBayesModel(priorDistribution, classAttributeDistributions);
+    }
+
+    /**
+     * Training algorithm for Naive Bayes algorithm. It basically calls trainContinuousVersion for continuous data sets,
+     * trainDiscreteVersion for discrete data sets.
+     * @param trainSet Training data given to the algorithm
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let priorDistribution = trainSet.classDistribution();
+        let classLists = new Partition(trainSet);
+        if (classLists.get(0).get(0).getAttribute(0) instanceof DiscreteAttribute){
+            this.trainDiscreteVersion(priorDistribution, classLists);
+        } else {
+            this.trainContinuousVersion(priorDistribution, classLists);
+        }
+    }
+
+}

package/source/Classifier/Qda.ts

@@ -0,0 +1,42 @@
+import {Classifier} from "./Classifier";
+import {Parameter} from "../Parameter/Parameter";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {Partition} from "../InstanceList/Partition";
+import {InstanceListOfSameClass} from "../InstanceList/InstanceListOfSameClass";
+import {QdaModel} from "../Model/QdaModel";
+
+export class Qda extends Classifier{
+
+    /**
+     * Training algorithm for the quadratic discriminant analysis classifier (Introduction to Machine Learning, Alpaydin, 2015).
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter) {
+        let determinant = 0
+        let w0 = new Map<string, number>();
+        let w = new Map<string, Vector>();
+        let W = new Map<string, Matrix>();
+        let classLists = new Partition(trainSet);
+        let priorDistribution = trainSet.classDistribution();
+        for (let i = 0; i < classLists.size(); i++) {
+            let Ci = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let classCovariance = classLists.get(i).covariance(averageVector);
+            determinant = classCovariance.determinant();
+            classCovariance.inverse();
+            let Wi = classCovariance.clone();
+            Wi.multiplyWithConstant(-0.5);
+            W.set(Ci, Wi);
+            let wi = classCovariance.multiplyWithVectorFromLeft(averageVector);
+            w.set(Ci, wi);
+            let w0i = -0.5 * (wi.dotProduct(averageVector) + Math.log(determinant)) + Math.log(priorDistribution.getProbability(Ci));
+            w0.set(Ci, w0i);
+        }
+        this.model = new QdaModel(priorDistribution, W, w, w0);
+    }
+
+}

package/source/Classifier/RandomClassifier.ts

@@ -0,0 +1,22 @@
+import {Classifier} from "./Classifier";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
+import {RandomModel} from "../Model/RandomModel";
+
+export class RandomClassifier extends Classifier{
+
+    /**
+     * Training algorithm for random classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let result = new Array<string>()
+        for (let s of trainSet.classDistribution().keys()){
+            result.push(s)
+        }
+        this.model = new RandomModel(result, parameters.getSeed());
+    }
+
+}