nlptoolkit-classification 1.0.6 → 1.0.8

package/index.js

@@ -1,100 +0,0 @@
-export * from "./dist/Attribute/Attribute"
-export * from "./dist/Attribute/AttributeType"
-export * from "./dist/Attribute/BinaryAttribute"
-export * from "./dist/Attribute/ContinuousAttribute"
-export * from "./dist/Attribute/DiscreteAttribute"
-export * from "./dist/Attribute/DiscreteIndexedAttribute"
-export * from "./dist/Classifier/Bagging"
-export * from "./dist/Classifier/C45"
-export * from "./dist/Classifier/C45Stump"
-export * from "./dist/Classifier/Classifier"
-export * from "./dist/Classifier/DeepNetwork"
-export * from "./dist/Classifier/Dummy"
-export * from "./dist/Classifier/KMeans"
-export * from "./dist/Classifier/Knn"
-export * from "./dist/Classifier/Lda"
-export * from "./dist/Classifier/LinearPerceptron"
-export * from "./dist/Classifier/MultiLayerPerceptron"
-export * from "./dist/Classifier/NaiveBayes"
-export * from "./dist/Classifier/Qda"
-export * from "./dist/Classifier/RandomClassifier"
-export * from "./dist/Classifier/RandomForest"
-export * from "./dist/DataSet/DataDefinition"
-export * from "./dist/DataSet/DataSet"
-export * from "./dist/DistanceMetric/DistanceMetric"
-export * from "./dist/DistanceMetric/EuclidianDistance"
-export * from "./dist/DistanceMetric/MahalanobisDistance"
-export * from "./dist/Experiment/BootstrapRun"
-export * from "./dist/Experiment/Experiment"
-export * from "./dist/Experiment/KFoldRun"
-export * from "./dist/Experiment/KFoldRunSeparateTest"
-export * from "./dist/Experiment/MultipleRun"
-export * from "./dist/Experiment/MxKFoldRun"
-export * from "./dist/Experiment/MxKFoldRunSeparateTest"
-export * from "./dist/Experiment/SingleRun"
-export * from "./dist/Experiment/SingleRunWithK"
-export * from "./dist/Experiment/StratifiedKFoldRun"
-export * from "./dist/Experiment/StratifiedKFoldRunSeparateTest"
-export * from "./dist/Experiment/StratifiedMxKFoldRun"
-export * from "./dist/Experiment/StratifiedMxKFoldRunSeparateTest"
-export * from "./dist/Experiment/StratifiedSingleRunWithK"
-export * from "./dist/FeatureSelection/BackwardSelection"
-export * from "./dist/FeatureSelection/FeatureSubSet"
-export * from "./dist/FeatureSelection/FloatingSelection"
-export * from "./dist/FeatureSelection/ForwardSelection"
-export * from "./dist/FeatureSelection/SubSetSelection"
-export * from "./dist/Filter/DiscreteToContinuous"
-export * from "./dist/Filter/DiscreteToIndexed"
-export * from "./dist/Filter/FeatureFilter"
-export * from "./dist/Filter/LaryFilter"
-export * from "./dist/Filter/LaryToBinary"
-export * from "./dist/Filter/Normalize"
-export * from "./dist/Filter/Pca"
-export * from "./dist/Filter/TrainedFeatureFilter"
-export * from "./dist/Instance/CompositeInstance"
-export * from "./dist/Instance/Instance"
-export * from "./dist/InstanceList/InstanceList"
-export * from "./dist/InstanceList/InstanceListOfSameClass"
-export * from "./dist/InstanceList/Partition"
-export * from "./dist/Model/DecisionTree/DecisionCondition"
-export * from "./dist/Model/DecisionTree/DecisionNode"
-export * from "./dist/Model/DecisionTree/DecisionTree"
-export * from "./dist/Model/DeepNetworkModel"
-export * from "./dist/Model/DummyModel"
-export * from "./dist/Model/GaussianModel"
-export * from "./dist/Model/KMeansModel"
-export * from "./dist/Model/KnnInstance"
-export * from "./dist/Model/KnnModel"
-export * from "./dist/Model/LdaModel"
-export * from "./dist/Model/LinearPerceptronModel"
-export * from "./dist/Model/Model"
-export * from "./dist/Model/MultiLayerPerceptronModel"
-export * from "./dist/Model/NaiveBayesModel"
-export * from "./dist/Model/NeuralNetworkModel"
-export * from "./dist/Model/QdaModel"
-export * from "./dist/Model/RandomModel"
-export * from "./dist/Model/TreeEnsembleModel"
-export * from "./dist/Model/ValidatedModel"
-export * from "./dist/Parameter/ActivationFunction"
-export * from "./dist/Parameter/BaggingParameter"
-export * from "./dist/Parameter/C45Parameter"
-export * from "./dist/Parameter/DeepNetworkParameter"
-export * from "./dist/Parameter/KMeansParameter"
-export * from "./dist/Parameter/KnnParameter"
-export * from "./dist/Parameter/LinearPerceptronParameter"
-export * from "./dist/Parameter/MultiLayerPerceptronParameter"
-export * from "./dist/Parameter/Parameter"
-export * from "./dist/Parameter/RandomForestParameter"
-export * from "./dist/Performance/ClassificationPerformance"
-export * from "./dist/Performance/ConfusionMatrix"
-export * from "./dist/Performance/DetailedClassificationPerformance"
-export * from "./dist/Performance/ExperimentPerformance"
-export * from "./dist/Performance/Performance"
-export * from "./dist/StatisticalTest/Combined5x2F"
-export * from "./dist/StatisticalTest/Combined5x2t"
-export * from "./dist/StatisticalTest/Paired5x2t"
-export * from "./dist/StatisticalTest/Pairedt"
-export * from "./dist/StatisticalTest/PairedTest"
-export * from "./dist/StatisticalTest/Sign"
-export * from "./dist/StatisticalTest/StatisticalTestResult"
-export * from "./dist/StatisticalTest/StatisticalTestResultType"

package/source/Classifier/C45.ts

@@ -1,34 +0,0 @@
-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;
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new DecisionTree(fileName)
-    }
-
-}

package/source/Classifier/C45Stump.ts

@@ -1,23 +0,0 @@
-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));
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new DecisionTree(fileName)
-    }
-
-}

package/source/Classifier/Classifier.ts

@@ -1,72 +0,0 @@
-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
-    abstract loadModel(fileName: string): 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

@@ -1,26 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new DeepNetworkModel(fileName)
-    }
-
-}

package/source/Classifier/Dummy.ts

@@ -1,23 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new DummyModel(fileName)
-    }
-
-}

package/source/Classifier/KMeans.ts

@@ -1,30 +0,0 @@
-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());
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new KMeansModel(fileName)
-    }
-
-}

package/source/Classifier/Knn.ts

@@ -1,25 +0,0 @@
-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());
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new KnnModel(fileName)
-    }
-
-}

package/source/Classifier/Lda.ts

@@ -1,47 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new LdaModel(fileName)
-    }
-
-}

package/source/Classifier/LinearPerceptron.ts

@@ -1,27 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new LinearPerceptronModel(fileName)
-    }
-
-}

package/source/Classifier/MultiLayerPerceptron.ts

@@ -1,27 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new MultiLayerPerceptronModel(fileName)
-    }
-
-}

package/source/Classifier/NaiveBayes.ts

@@ -1,66 +0,0 @@
-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);
-        }
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new NaiveBayesModel(fileName)
-    }
-
-}

package/source/Classifier/Qda.ts

@@ -1,46 +0,0 @@
-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);
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new QdaModel(fileName)
-    }
-
-}

package/source/Classifier/RandomClassifier.ts

@@ -1,26 +0,0 @@
-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());
-    }
-
-    loadModel(fileName: string): void{
-        this.model = new RandomModel(fileName)
-    }
-
-}

package/source/Model/KMeansModel.ts

@@ -1,56 +0,0 @@
-import {GaussianModel} from "./GaussianModel";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
-import {Instance} from "../Instance/Instance";
-import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
-import {FileContents} from "nlptoolkit-util/dist/FileContents";
-import {EuclidianDistance} from "../DistanceMetric/EuclidianDistance";
-
-export class KMeansModel extends GaussianModel{
-
-    private classMeans: InstanceList
-    private distanceMetric: DistanceMetric
-
-    /**
-     * The constructor that sets the classMeans, priorDistribution and distanceMetric according to given inputs.
-     *
-     * @param priorDistributionOrFileName {@link DiscreteDistribution} input.
-     * @param classMeans        {@link InstanceList} of class means.
-     * @param distanceMetric    {@link DistanceMetric} input.
-     */
-    constructor(priorDistributionOrFileName: DiscreteDistribution | string, classMeans?: InstanceList, distanceMetric?: DistanceMetric) {
-        super()
-        if (priorDistributionOrFileName instanceof DiscreteDistribution){
-            this.classMeans = classMeans
-            this.priorDistribution = priorDistributionOrFileName
-            this.distanceMetric = distanceMetric
-        } else {
-            this.distanceMetric = new EuclidianDistance()
-            let input = new FileContents(priorDistributionOrFileName)
-            this.loadPriorDistribution(input)
-            this.classMeans = this.loadInstanceList(input)
-        }
-    }
-
-    /**
-     * The calculateMetric method takes an {@link Instance} and a String as inputs. It loops through the class means, if
-     * the corresponding class label is same as the given String it returns the negated distance between given instance and the
-     * current item of class means. Otherwise it returns the smallest negative number.
-     *
-     * @param instance {@link Instance} input.
-     * @param Ci       String input.
-     * @return The negated distance between given instance and the current item of class means.
-     */
-    calculateMetric(instance: Instance, Ci: string): number {
-        for (let i = 0; i < this.classMeans.size(); i++) {
-            if (this.classMeans.get(i).getClassLabel() == Ci) {
-                return -this.distanceMetric.distance(instance, this.classMeans.get(i));
-            }
-        }
-        return Number.NEGATIVE_INFINITY;
-    }
-
-    saveTxt(fileName: string){
-    }
-
-}