nlptoolkit-classification 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nlptoolkit-classification",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Classification Library",
   "main": "index.js",
   "types": "index.js",
@@ -25,8 +25,8 @@
   },
   "dependencies": {
     "nlptoolkit-datastructure": "^1.0.4",
-    "nlptoolkit-math": "^1.0.2",
+    "nlptoolkit-math": "^1.0.3",
     "nlptoolkit-sampling": "^1.0.2",
-    "nlptoolkit-util": "^1.0.5"
+    "nlptoolkit-util": "^1.0.8"
   }
 }

package/source/Classifier/Bagging.ts

@@ -29,4 +29,7 @@ export class Bagging extends Classifier{
         this.model = new TreeEnsembleModel(forest);
     }
 
+    loadModel(fileName: string): void{
+        this.model = new TreeEnsembleModel(fileName)
+    }
 }

package/source/Classifier/C45.ts

@@ -27,4 +27,8 @@ export class C45 extends Classifier{
         this.model = tree;
     }
 
+    loadModel(fileName: string): void{
+        this.model = new DecisionTree(fileName)
+    }
+
 }

package/source/Classifier/C45Stump.ts

@@ -16,4 +16,8 @@ export class C45Stump extends Classifier{
         this.model = new DecisionTree(new DecisionNode(trainSet, undefined, undefined, true));
     }
 
+    loadModel(fileName: string): void{
+        this.model = new DecisionTree(fileName)
+    }
+
 }

package/source/Classifier/Classifier.ts

@@ -13,6 +13,7 @@ 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.

package/source/Classifier/DeepNetwork.ts

@@ -19,4 +19,8 @@ export class DeepNetwork extends Classifier{
         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

@@ -16,4 +16,8 @@ export class Dummy extends Classifier{
         this.model = new DummyModel(trainSet);
     }
 
+    loadModel(fileName: string): void{
+        this.model = new DummyModel(fileName)
+    }
+
 }

package/source/Classifier/KMeans.ts

@@ -23,4 +23,8 @@ export class KMeans extends Classifier{
         this.model = new KMeansModel(priorDistribution, classMeans, (<KMeansParameter> parameters).getDistanceMetric());
     }
 
+    loadModel(fileName: string): void{
+        this.model = new KMeansModel(fileName)
+    }
+
 }

package/source/Classifier/Knn.ts

@@ -17,5 +17,9 @@ export class Knn extends Classifier{
     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

@@ -40,4 +40,8 @@ export class Lda extends Classifier{
         this.model = new LdaModel(priorDistribution, w, w0);
     }
 
+    loadModel(fileName: string): void{
+        this.model = new LdaModel(fileName)
+    }
+
 }

package/source/Classifier/LinearPerceptron.ts

@@ -20,4 +20,8 @@ export class LinearPerceptron extends Classifier{
         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

@@ -20,4 +20,8 @@ export class MultiLayerPerceptron extends Classifier{
         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

@@ -59,4 +59,8 @@ export class NaiveBayes extends Classifier{
         }
     }
 
+    loadModel(fileName: string): void{
+        this.model = new NaiveBayesModel(fileName)
+    }
+
 }

package/source/Classifier/Qda.ts

@@ -39,4 +39,8 @@ export class Qda extends Classifier{
         this.model = new QdaModel(priorDistribution, W, w, w0);
     }
 
+    loadModel(fileName: string): void{
+        this.model = new QdaModel(fileName)
+    }
+
 }

package/source/Classifier/RandomClassifier.ts

@@ -19,4 +19,8 @@ export class RandomClassifier extends Classifier{
         this.model = new RandomModel(result, parameters.getSeed());
     }
 
+    loadModel(fileName: string): void{
+        this.model = new RandomModel(fileName)
+    }
+
 }

package/source/Classifier/RandomForest.ts

@@ -26,4 +26,8 @@ export class RandomForest extends Classifier{
         this.model = new TreeEnsembleModel(forest);
     }
 
+    loadModel(fileName: string): void{
+        this.model = new TreeEnsembleModel(fileName)
+    }
+
 }

package/source/DataSet/DataDefinition.ts

@@ -4,16 +4,34 @@ import {FeatureSubSet} from "../FeatureSelection/FeatureSubSet";
 export class DataDefinition {
 
     private attributeTypes: Array<AttributeType>
+    private readonly attributeValueList: Array<Array<String>>
 
     /**
      * Constructor for creating a new {@link DataDefinition} with given attribute types.
      *
      * @param attributeTypes Attribute types of the data definition.
+     * @param attributeValueList Array of array of strings to represent all possible values of discrete features.
      */
-    constructor(attributeTypes?: Array<AttributeType>) {
+    constructor(attributeTypes?: Array<AttributeType>, attributeValueList?: Array<Array<String>>) {
         if (attributeTypes != undefined){
             this.attributeTypes = attributeTypes
+            if (attributeValueList != undefined){
+                this.attributeValueList = attributeValueList;
+            }
+        }
+    }
+
+    numberOfValues(attributeIndex: number): number{
+        return this.attributeValueList[attributeIndex].length
+    }
+
+    featureValueIndex(attributeIndex: number, value: String): number{
+        for (let i = 0; i < this.attributeValueList[attributeIndex].length; i++){
+            if (this.attributeValueList[attributeIndex][i] == value){
+                return i
+            }
         }
+        return -1
     }
 
     /**

package/source/DataSet/DataSet.ts

@@ -25,7 +25,7 @@ export class DataSet {
      */
     constructor(definition?: any, separator?: string, fileName?: string) {
         if (definition != undefined){
-            if (definition instanceof DataDefinition){
+            if (definition instanceof DataDefinition && fileName == undefined){
                 this.definition = definition
             } else {
                 if (separator == undefined){

package/source/InstanceList/InstanceList.ts

@@ -50,6 +50,11 @@ export class InstanceList {
                                 case AttributeType.DISCRETE:
                                     current.addAttribute(new DiscreteAttribute(attributeList[i]));
                                     break;
+                                case AttributeType.DISCRETE_INDEXED:
+                                    current.addAttribute(new DiscreteIndexedAttribute(attributeList[i],
+                                        definition.featureValueIndex(i, attributeList[i]),
+                                        definition.numberOfValues(i)))
+                                    break;
                                 case AttributeType.BINARY:
                                     if (attributeList[i].toLowerCase() == "yes" || attributeList[i] == "1"){
                                         current.addAttribute(new BinaryAttribute(true));

package/source/Model/DecisionTree/DecisionNode.ts

@@ -9,45 +9,24 @@ import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 import {Partition} from "../../InstanceList/Partition";
 import {Instance} from "../../Instance/Instance";
 import {CompositeInstance} from "../../Instance/CompositeInstance";
-import {Random} from "nlptoolkit-util/dist/Random";
 import {RandomArray} from "nlptoolkit-util/dist/RandomArray";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class DecisionNode {
 
     children: Array<DecisionNode> = undefined
     private EPSILON: number = 0.0000000001;
-    private readonly data : InstanceList = undefined
-    private readonly classLabel : string = undefined
+    private data : InstanceList = undefined
+    private classLabel : string = undefined
     leaf: boolean = false
     private condition: DecisionCondition = undefined
 
-    /**
-     * The DecisionNode method takes {@link InstanceList} data as input, and then it sets the class label parameter by finding
-     * the most occurred class label of given data, it then gets distinct class labels as class labels ArrayList. Later, it adds ordered
-     * indices to the indexList and shuffles them randomly. Then, it gets the class distribution of given data and finds the best entropy value
-     * of these class distribution.
-     * <p>
-     * If an attribute of given data is {@link DiscreteIndexedAttribute}, it creates a Distribution according to discrete indexed attribute class distribution
-     * and finds the entropy. If it is better than the last best entropy it reassigns the best entropy, best attribute and best split value according to
-     * the newly founded best entropy's index. At the end, it also adds new distribution to the class distribution .
-     * <p>
-     * If an attribute of given data is {@link DiscreteAttribute}, it directly finds the entropy. If it is better than the last best entropy it
-     * reassigns the best entropy, best attribute and best split value according to the newly founded best entropy's index.
-     * <p>
-     * If an attribute of given data is {@link ContinuousAttribute}, it creates two distributions; left and right according to class distribution
-     * and discrete distribution respectively, and finds the entropy. If it is better than the last best entropy it reassigns the best entropy,
-     * best attribute and best split value according to the newly founded best entropy's index. At the end, it also adds new distribution to
-     * the right distribution and removes from left distribution .
-     *
-     * @param data      {@link InstanceList} input.
-     * @param condition {@link DecisionCondition} to check.
-     * @param parameter RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
-     * @param isStump   Refers to decision trees with only 1 splitting rule.
-     */
-    constructor(data: InstanceList, condition: DecisionCondition, parameter: RandomForestParameter, isStump: boolean) {
+    constructor1(data: InstanceList, condition?: DecisionCondition | number, parameter?: RandomForestParameter, isStump?: boolean){
         let bestAttribute = -1
         let bestSplitValue = 0
-        this.condition = condition;
+        if (condition instanceof DecisionCondition){
+            this.condition = condition;
+        }
         this.data = data;
         this.classLabel = Model.getMaximum(data.getClassLabels());
         this.leaf = true;
@@ -140,6 +119,67 @@ export class DecisionNode {
         }
     }
 
+    constructor2(contents: FileContents){
+        let items = contents.readLine().split(" ")
+        if (items[0] != "-1"){
+            if (items[1][0] == '='){
+                this.condition = new DecisionCondition(parseInt(items[0]), new DiscreteAttribute(items[2]), items[1][0])
+            } else {
+                if (items[1][0] == ':'){
+                    this.condition = new DecisionCondition(parseInt(items[0]), new DiscreteIndexedAttribute("", parseInt(items[2]), parseInt(items[3])), '=')
+                } else {
+                    this.condition = new DecisionCondition(parseInt(items[0]), new ContinuousAttribute(parseFloat(items[2])), items[1][0])
+                }
+            }
+        } else {
+            this.condition = null
+        }
+        let numberOfChildren = parseInt(contents.readLine())
+        if (numberOfChildren != 0){
+            this.leaf = false
+            this.children = new Array<DecisionNode>()
+            for (let i = 0; i < numberOfChildren; i++){
+                this.children.push(new DecisionNode(contents))
+            }
+        } else {
+            this.leaf = true
+            this.classLabel = contents.readLine()
+        }
+    }
+
+    /**
+     * The DecisionNode method takes {@link InstanceList} data as input, and then it sets the class label parameter by finding
+     * the most occurred class label of given data, it then gets distinct class labels as class labels ArrayList. Later, it adds ordered
+     * indices to the indexList and shuffles them randomly. Then, it gets the class distribution of given data and finds the best entropy value
+     * of these class distribution.
+     * <p>
+     * If an attribute of given data is {@link DiscreteIndexedAttribute}, it creates a Distribution according to discrete indexed attribute class distribution
+     * and finds the entropy. If it is better than the last best entropy it reassigns the best entropy, best attribute and best split value according to
+     * the newly founded best entropy's index. At the end, it also adds new distribution to the class distribution .
+     * <p>
+     * If an attribute of given data is {@link DiscreteAttribute}, it directly finds the entropy. If it is better than the last best entropy it
+     * reassigns the best entropy, best attribute and best split value according to the newly founded best entropy's index.
+     * <p>
+     * If an attribute of given data is {@link ContinuousAttribute}, it creates two distributions; left and right according to class distribution
+     * and discrete distribution respectively, and finds the entropy. If it is better than the last best entropy it reassigns the best entropy,
+     * best attribute and best split value according to the newly founded best entropy's index. At the end, it also adds new distribution to
+     * the right distribution and removes from left distribution .
+     *
+     * @param data      {@link InstanceList} input.
+     * @param condition {@link DecisionCondition} to check.
+     * @param parameter RandomForestParameter like seed, ensembleSize, attributeSubsetSize.
+     * @param isStump   Refers to decision trees with only 1 splitting rule.
+     */
+    constructor(data: InstanceList | FileContents, condition?: DecisionCondition, parameter?: RandomForestParameter, isStump?: boolean) {
+        if (data instanceof InstanceList && (condition instanceof DecisionCondition || condition == undefined)){
+            this.constructor1(data, condition, parameter, isStump)
+        } else {
+            if (data instanceof FileContents){
+                this.constructor2(data)
+            }
+        }
+    }
+
     /**
      * The entropyForDiscreteAttribute method takes an attributeIndex and creates an ArrayList of DiscreteDistribution.
      * Then loops through the distributions and calculates the total entropy.
@@ -199,7 +239,7 @@ export class DecisionNode {
      * @param splitValue     Split value is used for partitioning.
      */
     private createChildrenForContinuous(attributeIndex: number, splitValue: number, parameter: RandomForestParameter, isStump: boolean){
-        let childrenData = new Partition(this.data, attributeIndex, splitValue);
+        let childrenData = new Partition(this.data, attributeIndex, splitValue + 0.0000001);
         this.children = new Array<DecisionNode>();
         this.children.push(new DecisionNode(childrenData.get(0), new DecisionCondition(attributeIndex, new ContinuousAttribute(splitValue), "<"), parameter, isStump));
         this.children.push(new DecisionNode(childrenData.get(1), new DecisionCondition(attributeIndex, new ContinuousAttribute(splitValue), ">"), parameter, isStump));

package/source/Model/DecisionTree/DecisionTree.ts

@@ -3,19 +3,26 @@ import {DecisionNode} from "./DecisionNode";
 import {Instance} from "../../Instance/Instance";
 import {CompositeInstance} from "../../Instance/CompositeInstance";
 import {InstanceList} from "../../InstanceList/InstanceList";
+import * as fs from "fs";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class DecisionTree extends ValidatedModel{
 
-    private root: DecisionNode
+    private readonly root: DecisionNode
 
     /**
      * Constructor that sets root node of the decision tree.
      *
-     * @param root DecisionNode type input.
+     * @param rootOrFileName DecisionNode type input or fileName
      */
-    constructor(root: DecisionNode) {
+    constructor(rootOrFileName: DecisionNode | string) {
         super();
-        this.root = root
+        if (rootOrFileName instanceof DecisionNode){
+            this.root = rootOrFileName
+        } else {
+            let contents = new FileContents(rootOrFileName)
+            this.root = new DecisionNode(contents)
+        }
     }
 
     /**
@@ -37,6 +44,9 @@ export class DecisionTree extends ValidatedModel{
         return this.root.predictProbabilityDistribution(instance)
     }
 
+    saveTxt(fileName: string){
+    }
+
     /**
      * The prune method takes a {@link DecisionNode} and an {@link InstanceList} as inputs. It checks the classification performance
      * of given InstanceList before pruning, i.e making a node leaf, and after pruning. If the after performance is better than the

package/source/Model/DeepNetworkModel.ts

@@ -6,12 +6,13 @@ import {InstanceList} from "../InstanceList/InstanceList";
 import {Vector} from "nlptoolkit-math/dist/Vector";
 import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
 import {Random} from "nlptoolkit-util/dist/Random";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class DeepNetworkModel extends NeuralNetworkModel{
 
     private weights: Array<Matrix>
     private hiddenLayerSize: number
-    private readonly activationFunction: ActivationFunction
+    private activationFunction: ActivationFunction
 
     /**
      * The allocateWeights method takes {@link DeepNetworkParameter}s as an input. First it adds random weights to the {@link Array}
@@ -44,21 +45,7 @@ export class DeepNetworkModel extends NeuralNetworkModel{
         return bestWeights;
     }
 
-    /**
-     * 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 trainSet      {@link InstanceList} to be used as trainSet.
-     * @param validationSet {@link InstanceList} to be used as validationSet.
-     * @param parameters    {@link DeepNetworkParameter} input.
-     */
-    constructor(trainSet: InstanceList, validationSet: InstanceList, parameters: DeepNetworkParameter) {
-        super(trainSet);
+    constructor1(trainSet: InstanceList, validationSet: InstanceList, parameters: DeepNetworkParameter){
         let tmpHidden = new Vector(0, 0);
         let deltaWeights = new Array<Matrix>();
         let hidden = new Array<Vector>();
@@ -136,6 +123,40 @@ export class DeepNetworkModel extends NeuralNetworkModel{
         }
     }
 
+    constructor2(fileName: string){
+        let input = new FileContents(fileName)
+        this.activationFunction = this.loadActivationFunction(input)
+        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))
+        }
+    }
+
+    /**
+     * 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.
+     */
+    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.
@@ -154,4 +175,7 @@ export class DeepNetworkModel extends NeuralNetworkModel{
         this.y = this.weights[this.weights.length - 1].multiplyWithVectorFromRight(hiddenBiased);
     }
 
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/DummyModel.ts

@@ -3,6 +3,7 @@ import {Instance} from "../Instance/Instance";
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 import {InstanceList} from "../InstanceList/InstanceList";
 import {CompositeInstance} from "../Instance/CompositeInstance";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class DummyModel extends Model{
 
@@ -13,9 +14,23 @@ export class DummyModel extends Model{
      *
      * @param trainSet {@link InstanceList} which is used to get the class distribution.
      */
-    constructor(trainSet: InstanceList) {
+    constructor(trainSet: InstanceList | string) {
         super();
-        this.distribution = trainSet.classDistribution();
+        if (trainSet instanceof InstanceList){
+            this.distribution = trainSet.classDistribution();
+        } else {
+            let input = new FileContents(trainSet)
+            this.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++){
+                    this.distribution.addItem(items[0])
+                }
+            }
+        }
     }
 
     /**
@@ -37,4 +52,7 @@ export class DummyModel extends Model{
         return this.distribution.getProbabilityDistribution();
     }
 
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/GaussianModel.ts

@@ -2,6 +2,8 @@ import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 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";
 
 export abstract class GaussianModel extends ValidatedModel{
 
@@ -52,6 +54,33 @@ export abstract class GaussianModel extends ValidatedModel{
         return predictedClass;
     }
 
+    loadPriorDistribution(input: FileContents): number{
+        let size = parseInt(input.readLine())
+        this.priorDistribution = new DiscreteDistribution()
+        for (let i = 0; i < size; i++){
+            let line = input.readLine()
+            let items = line.split(" ");
+            for (let j = 0; j < parseInt(items[1]); j++){
+                this.priorDistribution.addItem(items[0])
+            }
+        }
+        return size
+    }
+
+    loadVectors(input: FileContents, size: number): Map<string, Vector>{
+        let map = new Map<string, Vector>()
+        for (let i = 0; i < size; i++){
+            let line = input.readLine()
+            let items = line.split(" ")
+            let vector = new Vector(parseInt(items[1]), 0)
+            for (let j = 2; j < items.length; j++){
+                vector.setValue(j - 2, parseFloat(items[j]))
+            }
+            map.set(items[0], vector)
+        }
+        return map
+    }
+
     predictProbability(instance: Instance): Map<string, number> {
         return undefined;
     }

package/source/Model/KMeansModel.ts

@@ -3,6 +3,8 @@ 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{
 
@@ -12,15 +14,22 @@ export class KMeansModel extends GaussianModel{
     /**
      * The constructor that sets the classMeans, priorDistribution and distanceMetric according to given inputs.
      *
-     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param priorDistributionOrFileName {@link DiscreteDistribution} input.
      * @param classMeans        {@link InstanceList} of class means.
      * @param distanceMetric    {@link DistanceMetric} input.
      */
-    constructor(priorDistribution: DiscreteDistribution, classMeans: InstanceList, distanceMetric: DistanceMetric) {
-        super();
-        this.classMeans = classMeans;
-        this.priorDistribution = priorDistribution;
-        this.distanceMetric = distanceMetric;
+    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)
+        }
     }
 
     /**
@@ -41,4 +50,7 @@ export class KMeansModel extends GaussianModel{
         return Number.NEGATIVE_INFINITY;
     }
 
+    saveTxt(fileName: string){
+    }
+
 }