nlptoolkit-classification 1.0.6 → 1.0.8

package/source/Model/Model.ts

@@ -3,12 +3,21 @@ import {CounterHashMap} from "nlptoolkit-datastructure/dist/CounterHashMap";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
 import {InstanceList} from "../InstanceList/InstanceList";
 import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {Parameter} from "../Parameter/Parameter";
+import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+import {DiscreteIndexedAttribute} from "../Attribute/DiscreteIndexedAttribute";
+import {Performance} from "../Performance/Performance";
+import {ConfusionMatrix} from "../Performance/ConfusionMatrix";
+import {DetailedClassificationPerformance} from "../Performance/DetailedClassificationPerformance";
 
 export abstract class Model {
 
     abstract predict(instance: Instance): string
     abstract predictProbability(instance: Instance): Map<string, number>
     abstract saveTxt(fileName: String): void
+    abstract train(trainSet: InstanceList, parameters: Parameter):void
+    abstract loadModel(fileName: string): void
 
     /**
      * Given an array of class labels, returns the maximum occurred one.
@@ -24,6 +33,13 @@ export abstract class Model {
         return frequencies.max();
     }
 
+    /**
+     * Loads a single instance from a single line.
+     * @param line Line containing the instance.
+     * @param attributeTypes Type of the attributes of the instance. If th attribute is discrete, it is "DISCRETE",
+     *                       otherwise it is "CONTINUOUS".
+     * @return Instance read from the line.
+     */
     loadInstance(line: string, attributeTypes: string[]): Instance{
         let items = line.split(",")
         let instance = new Instance(items[items.length - 1])
@@ -40,6 +56,30 @@ export abstract class Model {
         return instance
     }
 
+    /**
+     * Loads a discrete distribution from an input model file
+     * @param input Input model file.
+     * @return Discrete distribution read from an input model file.
+     */
+    static loadDiscreteDistribution(input: FileContents): DiscreteDistribution{
+        let distribution = new DiscreteDistribution()
+        let size = parseInt(input.readLine())
+        for (let i = 0; i < size; i++){
+            let line = input.readLine()
+            let items = line.split(" ")
+            let count = parseInt(items[1])
+            for (let j = 0; j < count; j++){
+                distribution.addItem(items[0])
+            }
+        }
+        return distribution
+    }
+
+    /**
+     * Loads an instance list from an input model file.
+     * @param input Input model file.
+     * @return Instance list read from an input model file.
+     */
     loadInstanceList(input: FileContents): InstanceList{
         let types = input.readLine().split(" ")
         let instanceCount = parseInt(input.readLine())
@@ -50,6 +90,11 @@ export abstract class Model {
         return instanceList;
     }
 
+    /**
+     * Loads a matrix from an input model file.
+     * @param input Input model file.
+     * @return Matrix read from the input model file.
+     */
     loadMatrix(input: FileContents): Matrix{
         let items = input.readLine().split(" ")
         let matrix = new Matrix(parseInt(items[0]), parseInt(items[1]))
@@ -62,4 +107,51 @@ export abstract class Model {
         }
         return matrix
     }
+
+    /**
+     * 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.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);
+    }
+
 }

package/source/Model/{DeepNetworkModel.ts → NeuralNetwork/DeepNetworkModel.ts}

@@ -1,12 +1,14 @@
 import {NeuralNetworkModel} from "./NeuralNetworkModel";
 import {Matrix} from "nlptoolkit-math/dist/Matrix";
-import {ActivationFunction} from "../Parameter/ActivationFunction";
-import {DeepNetworkParameter} from "../Parameter/DeepNetworkParameter";
-import {InstanceList} from "../InstanceList/InstanceList";
+import {ActivationFunction} from "../../Parameter/ActivationFunction";
+import {DeepNetworkParameter} from "../../Parameter/DeepNetworkParameter";
+import {InstanceList} from "../../InstanceList/InstanceList";
 import {Vector} from "nlptoolkit-math/dist/Vector";
-import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
+import {ClassificationPerformance} from "../../Performance/ClassificationPerformance";
 import {Random} from "nlptoolkit-util/dist/Random";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
 
 export class DeepNetworkModel extends NeuralNetworkModel{
 
@@ -45,7 +47,55 @@ export class DeepNetworkModel extends NeuralNetworkModel{
         return bestWeights;
     }
 
-    constructor1(trainSet: InstanceList, validationSet: InstanceList, parameters: DeepNetworkParameter){
+    /**
+     * Loads a deep network model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string){
+        let input = new FileContents(fileName)
+        this.loadClassLabels(input)
+        this.hiddenLayerSize = parseInt(input.readLine())
+        this.weights = new Array<Matrix>()
+        for (let i = 0; i < this.hiddenLayerSize + 1; i++){
+            this.weights.push(this.loadMatrix(input))
+        }
+        this.activationFunction = this.loadActivationFunction(input)
+    }
+
+    /**
+     * The calculateOutput method loops size of the weights times and calculate one hidden layer at a time and adds bias term.
+     * At the end it updates the output y value.
+     */
+    protected calculateOutput(): void {
+        let hiddenBiased
+        for (let i = 0; i < this.weights.length - 1; i++) {
+            let hidden
+            if (i == 0) {
+                hidden = this.calculateHidden(this.x, this.weights[i], this.activationFunction);
+            } else {
+                hidden = this.calculateHidden(hiddenBiased, this.weights[i], this.activationFunction);
+            }
+            hiddenBiased = hidden.biased();
+        }
+        this.y = this.weights[this.weights.length - 1].multiplyWithVectorFromRight(hiddenBiased);
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * Training algorithm for deep network classifier.
+     *
+     * @param train  Training data given to the algorithm.
+     * @param params Parameters of the deep network algorithm. crossValidationRatio and seed are used as parameters.
+     * @throws DiscreteFeaturesNotAllowed Exception for discrete features.
+     */
+    train(train: InstanceList, params: Parameter): void {
+        this.initialize(train)
+        let parameters = <DeepNetworkParameter> params
+        let partition = new Partition(train, parameters.getCrossValidationRatio(), true);
+        let trainSet = partition.get(1)
+        let validationSet = partition.get(0)
         let tmpHidden = new Vector(0, 0);
         let deltaWeights = new Array<Matrix>();
         let hidden = new Array<Vector>();
@@ -123,59 +173,12 @@ export class DeepNetworkModel extends NeuralNetworkModel{
         }
     }
 
-    constructor2(fileName: string){
-        let input = new FileContents(fileName)
-        this.loadClassLabels(input)
-        this.hiddenLayerSize = parseInt(input.readLine())
-        this.weights = new Array<Matrix>()
-        for (let i = 0; i < this.hiddenLayerSize + 1; i++){
-            this.weights.push(this.loadMatrix(input))
-        }
-        this.activationFunction = this.loadActivationFunction(input)
-    }
-
     /**
-     * Constructor that takes two {@link InstanceList} train set and validation set and {@link DeepNetworkParameter} as inputs.
-     * First it sets the class labels, their sizes as K and the size of the continuous attributes as d of given train set and
-     * allocates weights and sets the best weights. At each epoch, it shuffles the train set and loops through the each item of that train set,
-     * it multiplies the weights Matrix with input Vector than applies the sigmoid function and stores the result as hidden and add bias.
-     * Then updates weights and at the end it compares the performance of these weights with validation set. It updates the bestClassificationPerformance and
-     * bestWeights according to the current situation. At the end it updates the learning rate via etaDecrease value and finishes
-     * with clearing the weights.
-     *
-     * @param trainSetOrFileName      {@link InstanceList} to be used as trainSet.
-     * @param validationSet {@link InstanceList} to be used as validationSet.
-     * @param parameters    {@link DeepNetworkParameter} input.
+     * Loads the deep network model from an input file.
+     * @param fileName File name of the deep network model.
      */
-    constructor(trainSetOrFileName: InstanceList | string, validationSet?: InstanceList, parameters?: DeepNetworkParameter) {
-        if (trainSetOrFileName instanceof InstanceList){
-            super(trainSetOrFileName)
-            this.constructor1(trainSetOrFileName, validationSet, parameters)
-        } else {
-            super()
-            this.constructor2(trainSetOrFileName)
-        }
-    }
-
-    /**
-     * The calculateOutput method loops size of the weights times and calculate one hidden layer at a time and adds bias term.
-     * At the end it updates the output y value.
-     */
-    protected calculateOutput(): void {
-        let hiddenBiased
-        for (let i = 0; i < this.weights.length - 1; i++) {
-            let hidden
-            if (i == 0) {
-                hidden = this.calculateHidden(this.x, this.weights[i], this.activationFunction);
-            } else {
-                hidden = this.calculateHidden(hiddenBiased, this.weights[i], this.activationFunction);
-            }
-            hiddenBiased = hidden.biased();
-        }
-        this.y = this.weights[this.weights.length - 1].multiplyWithVectorFromRight(hiddenBiased);
-    }
-
-    saveTxt(fileName: string){
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
     }
 
 }

package/source/Model/NeuralNetwork/LinearPerceptronModel.ts

@@ -0,0 +1,81 @@
+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";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
+
+export class LinearPerceptronModel extends NeuralNetworkModel{
+
+    protected W: Matrix
+
+    /**
+     * Loads a linear perceptron model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string){
+        let input = new FileContents(fileName)
+        this.loadClassLabels(input)
+        this.W = this.loadMatrix(input)
+    }
+
+    /**
+     * 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){
+    }
+
+    /**
+     * 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 train   Training data given to the algorithm
+     * @param params Parameters of the linear perceptron.
+     */
+    train(train: InstanceList, params: Parameter): void {
+        this.initialize(train)
+        let parameters = <LinearPerceptronParameter> params
+        let partition = new Partition(train, parameters.getCrossValidationRatio(), true);
+        let trainSet = partition.get(1)
+        let validationSet = partition.get(0)
+        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
+    }
+
+    /**
+     * Loads the linear perceptron model from an input file.
+     * @param fileName File name of the linear perceptron model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}

package/source/Model/{MultiLayerPerceptronModel.ts → NeuralNetwork/MultiLayerPerceptronModel.ts}

@@ -1,12 +1,14 @@
 import {LinearPerceptronModel} from "./LinearPerceptronModel";
 import {Matrix} from "nlptoolkit-math/dist/Matrix";
-import {ActivationFunction} from "../Parameter/ActivationFunction";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {MultiLayerPerceptronParameter} from "../Parameter/MultiLayerPerceptronParameter";
-import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
+import {ActivationFunction} from "../../Parameter/ActivationFunction";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {MultiLayerPerceptronParameter} from "../../Parameter/MultiLayerPerceptronParameter";
+import {ClassificationPerformance} from "../../Performance/ClassificationPerformance";
 import {Vector} from "nlptoolkit-math/dist/Vector";
 import {Random} from "nlptoolkit-util/dist/Random";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
 
 export class MultiLayerPerceptronModel extends LinearPerceptronModel{
 
@@ -24,7 +26,42 @@ export class MultiLayerPerceptronModel extends LinearPerceptronModel{
         this.V = this.allocateLayerWeights(this.K, H + 1, random);
     }
 
-    constructor1(trainSet: InstanceList, validationSet?: InstanceList, parameters?: MultiLayerPerceptronParameter){
+    /**
+     * Loads a multi-layer perceptron model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string){
+        let input = new FileContents(fileName)
+        this.loadClassLabels(input)
+        this.W = this.loadMatrix(input)
+        this.V = this.loadMatrix(input)
+        this.activationFunction = this.loadActivationFunction(input)
+    }
+
+    /**
+     * The calculateOutput method calculates the forward single hidden layer by using Matrices W and V.
+     */
+    protected calculateOutput() {
+        this.calculateForwardSingleHiddenLayer(this.W, this.V, this.activationFunction);
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * 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 train   Training data given to the algorithm
+     * @param params Parameters of the multilayer perceptron.
+     */
+    train(train: InstanceList, params: Parameter): void {
+        this.initialize(train)
+        let parameters = (<MultiLayerPerceptronParameter> params)
+        let partition = new Partition(train, parameters.getCrossValidationRatio(), true);
+        let trainSet = partition.get(1)
+        let validationSet = partition.get(1)
         this.activationFunction = parameters.getActivationFunction();
         this.allocateWeights(parameters.getHiddenNodes(), new Random(parameters.getSeed()));
         let bestW = this.W.clone();
@@ -78,42 +115,12 @@ export class MultiLayerPerceptronModel extends LinearPerceptronModel{
         this.V = bestV;
     }
 
-    constructor2(fileName: string){
-        let input = new FileContents(fileName)
-        this.loadClassLabels(input)
-        this.W = this.loadMatrix(input)
-        this.V = this.loadMatrix(input)
-        this.activationFunction = this.loadActivationFunction(input)
-    }
-
     /**
-     * A constructor that takes {@link InstanceList}s as trainsSet and validationSet. It  sets the {@link NeuralNetworkModel}
-     * nodes with given {@link InstanceList} then creates an input vector by using given trainSet and finds error.
-     * Via the validationSet it finds the classification performance and reassigns the allocated weight Matrix with the matrix
-     * that has the best accuracy and the Matrix V with the best Vector input.
-     *
-     * @param trainSetOrFileName      InstanceList that is used to train.
-     * @param validationSet InstanceList that is used to validate.
-     * @param parameters    Multi layer perceptron parameters; seed, learningRate, etaDecrease, crossValidationRatio, epoch, hiddenNodes.
+     * Loads the multi-layer perceptron model from an input file.
+     * @param fileName File name of the multi-layer perceptron model.
      */
-    constructor(trainSetOrFileName: InstanceList | string, validationSet?: InstanceList, parameters?: MultiLayerPerceptronParameter) {
-        if (trainSetOrFileName instanceof InstanceList){
-            super(trainSetOrFileName)
-            this.constructor1(trainSetOrFileName, validationSet, parameters)
-        } else {
-            super()
-            this.constructor2(trainSetOrFileName)
-        }
-    }
-
-    /**
-     * The calculateOutput method calculates the forward single hidden layer by using Matrices W and V.
-     */
-    protected calculateOutput() {
-        this.calculateForwardSingleHiddenLayer(this.W, this.V, this.activationFunction);
-    }
-
-    saveTxt(fileName: string){
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
     }
 
 }

package/source/Model/{NeuralNetworkModel.ts → NeuralNetwork/NeuralNetworkModel.ts}

@@ -1,10 +1,10 @@
-import {ValidatedModel} from "./ValidatedModel";
+import {ValidatedModel} from "../ValidatedModel";
 import {Vector} from "nlptoolkit-math/dist/Vector";
-import {InstanceList} from "../InstanceList/InstanceList";
+import {InstanceList} from "../../InstanceList/InstanceList";
 import {Matrix} from "nlptoolkit-math/dist/Matrix";
-import {Instance} from "../Instance/Instance";
-import {ActivationFunction} from "../Parameter/ActivationFunction";
-import {CompositeInstance} from "../Instance/CompositeInstance";
+import {Instance} from "../../Instance/Instance";
+import {ActivationFunction} from "../../Parameter/ActivationFunction";
+import {CompositeInstance} from "../../Instance/CompositeInstance";
 import {Random} from "nlptoolkit-util/dist/Random";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
@@ -24,8 +24,7 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
      *
      * @param trainSet {@link InstanceList} to use as train set.
      */
-    protected constructor(trainSet?: InstanceList) {
-        super();
+    protected initialize(trainSet: InstanceList) {
         if (trainSet != undefined){
             this.classLabels = trainSet.getDistinctClassLabels()
             this.K = this.classLabels.length
@@ -180,6 +179,11 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
         }
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to neural network model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         this.createInputVector(instance);
         this.calculateOutput();
@@ -190,6 +194,10 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
         return result;
     }
 
+    /**
+     * Loads the class labels from input model file.
+     * @param input Input model file.
+     */
     loadClassLabels(input: FileContents){
         let items = input.readLine().split(" ")
         this.K = parseInt(items[0])
@@ -200,6 +208,11 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
         }
     }
 
+    /**
+     * Loads the activation function from an input model file.
+     * @param input Input model file.
+     * @return Activation function read.
+     */
     loadActivationFunction(input: FileContents): ActivationFunction{
         switch (input.readLine()){
             case "TANH":

package/source/Model/{KnnInstance.ts → NonParametric/KnnInstance.ts}

@@ -1,4 +1,4 @@
-import {Instance} from "../Instance/Instance";
+import {Instance} from "../../Instance/Instance";
 
 export class KnnInstance {
 

package/source/Model/{KnnModel.ts → NonParametric/KnnModel.ts}

@@ -1,11 +1,13 @@
-import {Model} from "./Model";
-import {InstanceList} from "../InstanceList/InstanceList";
-import {Instance} from "../Instance/Instance";
-import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
-import {CompositeInstance} from "../Instance/CompositeInstance";
+import {Model} from "../Model";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Instance} from "../../Instance/Instance";
+import {DistanceMetric} from "../../DistanceMetric/DistanceMetric";
+import {CompositeInstance} from "../../Instance/CompositeInstance";
 import {KnnInstance} from "./KnnInstance";
-import {EuclidianDistance} from "../DistanceMetric/EuclidianDistance";
+import {EuclidianDistance} from "../../DistanceMetric/EuclidianDistance";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Parameter} from "../../Parameter/Parameter";
+import {KnnParameter} from "../../Parameter/KnnParameter";
 
 export class KnnModel extends Model{
 
@@ -16,22 +18,25 @@ export class KnnModel extends Model{
     /**
      * Constructor that sets the data {@link InstanceList}, k value and the {@link DistanceMetric}.
      *
-     * @param dataOrFileName           {@link InstanceList} input.
+     * @param data           {@link InstanceList} input.
      * @param k              K value.
      * @param distanceMetric {@link DistanceMetric} input.
      */
-    constructor(dataOrFileName: InstanceList | string, k?: number, distanceMetric?: DistanceMetric) {
-        super()
-        if (dataOrFileName instanceof InstanceList){
-            this.data = dataOrFileName
-            this.k = k
-            this.distanceMetric = distanceMetric
-        } else {
-            this.distanceMetric = new EuclidianDistance()
-            let input = new FileContents(dataOrFileName)
-            this.k = parseInt(input.readLine())
-            this.data = this.loadInstanceList(input)
-        }
+    constructor1(data: InstanceList, k: number, distanceMetric: DistanceMetric) {
+        this.data = data
+        this.k = k
+        this.distanceMetric = distanceMetric
+    }
+
+    /**
+     * Loads a K-nearest neighbor model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        this.distanceMetric = new EuclidianDistance()
+        let input = new FileContents(fileName)
+        this.k = parseInt(input.readLine())
+        this.data = this.loadInstanceList(input)
     }
 
     /**
@@ -52,6 +57,11 @@ export class KnnModel extends Model{
         return predictedClass;
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to K-means model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         let nearestNeighbors = this.nearestNeighbors(instance);
         return nearestNeighbors.classDistribution().getProbabilityDistribution();
@@ -88,4 +98,23 @@ export class KnnModel extends Model{
     saveTxt(fileName: string){
     }
 
+    /**
+     * 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.constructor1(trainSet, (<KnnParameter> parameters).getK(), (<KnnParameter> parameters).getDistanceMetric());
+    }
+
+    /**
+     * Loads the K-nearest neighbor model from an input file.
+     * @param fileName File name of the K-nearest neighbor model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
 }

package/source/Model/{GaussianModel.ts → Parametric/GaussianModel.ts}

@@ -1,7 +1,7 @@
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
-import {Instance} from "../Instance/Instance";
-import {ValidatedModel} from "./ValidatedModel";
-import {CompositeInstance} from "../Instance/CompositeInstance";
+import {Instance} from "../../Instance/Instance";
+import {ValidatedModel} from "../ValidatedModel";
+import {CompositeInstance} from "../../Instance/CompositeInstance";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
 import {Vector} from "nlptoolkit-math/dist/Vector";
 
@@ -54,6 +54,12 @@ export abstract class GaussianModel extends ValidatedModel{
         return predictedClass;
     }
 
+    /**
+     * Loads the prior probability distribution from an input model file.
+     * @param input Input model file.
+     * @return Prior probability distribution.
+     * @throws IOException If the input file can not be read, the method throws IOException.
+     */
     loadPriorDistribution(input: FileContents): number{
         let size = parseInt(input.readLine())
         this.priorDistribution = new DiscreteDistribution()
@@ -67,6 +73,13 @@ export abstract class GaussianModel extends ValidatedModel{
         return size
     }
 
+    /**
+     * Loads hash map of vectors from input model file.
+     * @param input Input model file.
+     * @param size Number of vectors to be read from input model file.
+     * @return Hash map of vectors.
+     * @throws IOException If the input file can not be read, the method throws IOException.
+     */
     loadVectors(input: FileContents, size: number): Map<string, Vector>{
         let map = new Map<string, Vector>()
         for (let i = 0; i < size; i++){
@@ -81,6 +94,11 @@ export abstract class GaussianModel extends ValidatedModel{
         return map
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to Gaussian model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         return undefined;
     }