nlptoolkit-classification 1.0.7 → 1.0.9

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){
-    }
-
-}

package/source/Model/LdaModel.ts

@@ -1,62 +0,0 @@
-import {GaussianModel} from "./GaussianModel";
-import {Vector} from "nlptoolkit-math/dist/Vector";
-import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
-import {Instance} from "../Instance/Instance";
-import {FileContents} from "nlptoolkit-util/dist/FileContents";
-
-export class LdaModel extends GaussianModel{
-
-    protected w0: Map<string, number>
-    protected w: Map<string, Vector>
-
-    /**
-     * A constructor which sets the priorDistribution, w and w0 according to given inputs.
-     *
-     * @param priorDistributionOrFileName {@link DiscreteDistribution} input.
-     * @param w                 {@link HashMap} of String and Vectors.
-     * @param w0                {@link HashMap} of String and Double.
-     */
-    constructor(priorDistributionOrFileName?: DiscreteDistribution | string, w?: Map<string, Vector>, w0?: Map<string, number>) {
-        super()
-        if (priorDistributionOrFileName instanceof DiscreteDistribution){
-            this.priorDistribution = priorDistributionOrFileName
-            this.w = w
-            this.w0 = w0
-        } else {
-            if (priorDistributionOrFileName != undefined){
-                let input = new FileContents(priorDistributionOrFileName)
-                let size = this.loadPriorDistribution(input)
-                this.loadWandW0(input, size)
-            }
-        }
-    }
-
-    /**
-     * The calculateMetric method takes an {@link Instance} and a String as inputs. It returns the dot product of given Instance
-     * and wi plus w0i.
-     *
-     * @param instance {@link Instance} input.
-     * @param Ci       String input.
-     * @return The dot product of given Instance and wi plus w0i.
-     */
-    calculateMetric(instance: Instance, Ci: string): number {
-        let xi = instance.toVector();
-        let wi = this.w.get(Ci);
-        let w0i = this.w0.get(Ci);
-        return wi.dotProduct(xi) + w0i;
-    }
-
-    loadWandW0(input: FileContents, size: number){
-        this.w0 = new Map<string, number>()
-        for (let i = 0; i < size; i++){
-            let line = input.readLine()
-            let items = line.split(" ")
-            this.w0.set(items[0], parseFloat(items[1]))
-        }
-        this.w = this.loadVectors(input, size)
-    }
-
-    saveTxt(fileName: string){
-    }
-
-}

package/source/Model/LinearPerceptronModel.ts

@@ -1,83 +0,0 @@
-import {NeuralNetworkModel} from "./NeuralNetworkModel";
-import {Matrix} from "nlptoolkit-math/dist/Matrix";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {LinearPerceptronParameter} from "../Parameter/LinearPerceptronParameter";
-import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
-import {Random} from "nlptoolkit-util/dist/Random";
-import {FileContents} from "nlptoolkit-util/dist/FileContents";
-
-export class LinearPerceptronModel extends NeuralNetworkModel{
-
-    protected W: Matrix
-
-    constructor1(trainSet: InstanceList, validationSet?: InstanceList, parameters?: LinearPerceptronParameter){
-        if (validationSet != undefined){
-            this.W = this.allocateLayerWeights(this.K, this.d + 1, new Random(parameters.getSeed()));
-            let bestW = this.W.clone();
-            let bestClassificationPerformance = new ClassificationPerformance(0.0)
-            let epoch = parameters.getEpoch()
-            let learningRate = parameters.getLearningRate()
-            for (let i = 0; i < epoch; i++) {
-                trainSet.shuffle(new Random(parameters.getSeed()))
-                for (let j = 0; j < trainSet.size(); j++) {
-                    this.createInputVector(trainSet.get(j))
-                    let rMinusY = this.calculateRMinusY(trainSet.get(j), this.x, this.W)
-                    let deltaW = new Matrix(rMinusY, this.x);
-                    deltaW.multiplyWithConstant(learningRate);
-                    this.W.add(deltaW)
-                }
-                let currentClassificationPerformance = this.testClassifier(validationSet)
-                if (currentClassificationPerformance.getAccuracy() > bestClassificationPerformance.getAccuracy()) {
-                    bestClassificationPerformance = currentClassificationPerformance
-                    bestW = this.W.clone()
-                }
-                learningRate *= parameters.getEtaDecrease()
-            }
-            this.W = bestW
-        }
-    }
-
-    constructor2(fileName: string){
-        let input = new FileContents(fileName)
-        this.loadClassLabels(input)
-        this.W = this.loadMatrix(input)
-    }
-
-    /**
-     * Constructor that takes {@link InstanceList}s as trainsSet and validationSet. Initially it allocates layer weights,
-     * then creates an input vector by using given trainSet and finds error. Via the validationSet it finds the classification
-     * performance and at the end it reassigns the allocated weight Matrix with the matrix that has the best accuracy.
-     *
-     * @param trainSetOrFileName      InstanceList that is used to train.
-     * @param validationSet InstanceList that is used to validate.
-     * @param parameters    Linear perceptron parameters; learningRate, etaDecrease, crossValidationRatio, epoch.
-     */
-    constructor(trainSetOrFileName?: InstanceList | string, validationSet?: InstanceList, parameters?: LinearPerceptronParameter) {
-        if (trainSetOrFileName instanceof InstanceList){
-            if (validationSet != undefined){
-                super(trainSetOrFileName)
-                this.constructor1(trainSetOrFileName, validationSet, parameters)
-            } else {
-                super(trainSetOrFileName)
-            }
-        } else {
-            if (trainSetOrFileName != undefined){
-                super()
-                this.constructor2(trainSetOrFileName)
-            } else {
-                super()
-            }
-        }
-    }
-
-    /**
-     * The calculateOutput method calculates the {@link Matrix} y by multiplying Matrix W with {@link Vector} x.
-     */
-    protected calculateOutput(): void {
-        this.y = this.W.multiplyWithVectorFromRight(this.x);
-    }
-
-    saveTxt(fileName: string){
-    }
-
-}

package/source/Model/QdaModel.ts

@@ -1,57 +0,0 @@
-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";
-import {FileContents} from "nlptoolkit-util/dist/FileContents";
-
-export class QdaModel extends LdaModel{
-
-    private W: Map<string, Matrix>
-
-    /**
-     * The constructor which sets the priorDistribution, w w1 and HashMap of String Matrix.
-     *
-     * @param priorDistributionOrFileName {@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(priorDistributionOrFileName: DiscreteDistribution | string, W?: Map<string, Matrix>, w?: Map<string, Vector>, w0?: Map<string, number>) {
-        if (priorDistributionOrFileName instanceof DiscreteDistribution){
-            super(priorDistributionOrFileName, w, w0);
-            this.W = W
-        } else {
-            super()
-            let input = new FileContents(priorDistributionOrFileName)
-            let size = this.loadPriorDistribution(input)
-            this.loadWandW0(input, size)
-            this.W = new Map<string, Matrix>()
-            for (let i = 0; i < size; i++){
-                let c = input.readLine()
-                let matrix = this.loadMatrix(input)
-                this.W.set(c, matrix)
-            }
-        }
-    }
-
-    /**
-     * 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;
-    }
-
-    saveTxt(fileName: string){
-    }
-
-}

package/source/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "../dist",
-    "module": "umd",
-    "target": "es6",
-    "sourceMap": true,
-    "noImplicitAny": true,
-    "strictNullChecks": false,
-    "removeComments": false,
-    "moduleResolution": "node",
-    "declaration": true
-  }
-}