nlptoolkit-classification 1.0.3 → 1.0.4

package/source/Model/LdaModel.ts

@@ -2,6 +2,7 @@ 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{
 
@@ -11,15 +12,23 @@ export class LdaModel extends GaussianModel{
     /**
      * A constructor which sets the priorDistribution, w and w0 according to given inputs.
      *
-     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param priorDistributionOrFileName {@link DiscreteDistribution} input.
      * @param w                 {@link HashMap} of String and Vectors.
      * @param w0                {@link HashMap} of String and Double.
      */
-    constructor(priorDistribution: DiscreteDistribution, w: Map<string, Vector>, w0: Map<string, number>) {
-        super();
-        this.priorDistribution = priorDistribution;
-        this.w = w;
-        this.w0 = w0;
+    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)
+            }
+        }
     }
 
     /**
@@ -36,4 +45,18 @@ export class LdaModel extends GaussianModel{
         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

@@ -4,45 +4,69 @@ 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
 
-    /**
-     * 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 trainSet      InstanceList that is used to train.
-     * @param validationSet InstanceList that is used to validate.
-     * @param parameters    Linear perceptron parameters; learningRate, etaDecrease, crossValidationRatio, epoch.
-     */
-    constructor(trainSet: InstanceList, validationSet?: InstanceList, parameters?: LinearPerceptronParameter) {
-        super(trainSet);
+    constructor1(trainSet: InstanceList, validationSet?: InstanceList, parameters?: LinearPerceptronParameter){
         if (validationSet != undefined){
-            let W = this.allocateLayerWeights(this.K, this.d + 1, new Random(parameters.getSeed()));
-            let bestW = W.clone();
-            let bestClassificationPerformance = new ClassificationPerformance(0.0);
-            let epoch = parameters.getEpoch();
-            let learningRate = parameters.getLearningRate();
+            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()));
+                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, W);
+                    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);
-                    W.add(deltaW);
+                    this.W.add(deltaW)
                 }
-                let currentClassificationPerformance = this.testClassifier(validationSet);
+                let currentClassificationPerformance = this.testClassifier(validationSet)
                 if (currentClassificationPerformance.getAccuracy() > bestClassificationPerformance.getAccuracy()) {
-                    bestClassificationPerformance = currentClassificationPerformance;
-                    bestW = W.clone();
+                    bestClassificationPerformance = currentClassificationPerformance
+                    bestW = this.W.clone()
                 }
-                learningRate *= parameters.getEtaDecrease();
+                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()
             }
-            W = bestW;
         }
     }
 
@@ -53,4 +77,7 @@ export class LinearPerceptronModel extends NeuralNetworkModel{
         this.y = this.W.multiplyWithVectorFromRight(this.x);
     }
 
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/Model.ts

@@ -1,10 +1,14 @@
 import {Instance} from "../Instance/Instance";
 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";
 
 export abstract class Model {
 
     abstract predict(instance: Instance): string
     abstract predictProbability(instance: Instance): Map<string, number>
+    abstract saveTxt(fileName: String): void
 
     /**
      * Given an array of class labels, returns the maximum occurred one.
@@ -19,4 +23,43 @@ export abstract class Model {
         }
         return frequencies.max();
     }
+
+    loadInstance(line: string, attributeTypes: string[]): Instance{
+        let items = line.split(",")
+        let instance = new Instance(items[items.length - 1])
+        for (let i = 0; i < items.length - 1; i++){
+            switch (attributeTypes[i]){
+                case "DISCRETE":
+                    instance.addAttribute(items[i])
+                    break
+                case "CONTINUOUS":
+                    instance.addAttribute(parseFloat(items[i]))
+                    break
+            }
+        }
+        return instance
+    }
+
+    loadInstanceList(input: FileContents): InstanceList{
+        let types = input.readLine().split(" ")
+        let instanceCount = parseInt(input.readLine())
+        let instanceList = new InstanceList()
+        for (let i = 0; i < instanceCount; i++){
+            instanceList.add(this.loadInstance(input.readLine(), types))
+        }
+        return instanceList;
+    }
+
+    loadMatrix(input: FileContents): Matrix{
+        let items = input.readLine().split(" ")
+        let matrix = new Matrix(parseInt(items[0]), parseInt(items[1]))
+        for (let j = 0; j < matrix.getRow(); j++){
+            let line = input.readLine()
+            items = line.split(" ")
+            for (let k = 0; k < matrix.getColumn(); k++){
+                matrix.setValue(j, k, parseFloat(items[k]))
+            }
+        }
+        return matrix
+    }
 }

package/source/Model/MultiLayerPerceptronModel.ts

@@ -6,6 +6,7 @@ import {MultiLayerPerceptronParameter} from "../Parameter/MultiLayerPerceptronPa
 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";
 
 export class MultiLayerPerceptronModel extends LinearPerceptronModel{
 
@@ -23,18 +24,7 @@ export class MultiLayerPerceptronModel extends LinearPerceptronModel{
         this.V = this.allocateLayerWeights(this.K, H + 1, random);
     }
 
-    /**
-     * 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 trainSet      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.
-     */
-    constructor(trainSet: InstanceList, validationSet: InstanceList, parameters: MultiLayerPerceptronParameter) {
-        super(trainSet);
+    constructor1(trainSet: InstanceList, validationSet?: InstanceList, parameters?: MultiLayerPerceptronParameter){
         this.activationFunction = parameters.getActivationFunction();
         this.allocateWeights(parameters.getHiddenNodes(), new Random(parameters.getSeed()));
         let bestW = this.W.clone();
@@ -88,10 +78,42 @@ export class MultiLayerPerceptronModel extends LinearPerceptronModel{
         this.V = bestV;
     }
 
+    constructor2(fileName: string){
+        let input = new FileContents(fileName)
+        this.activationFunction = this.loadActivationFunction(input)
+        this.loadClassLabels(input)
+        this.W = this.loadMatrix(input)
+        this.V = this.loadMatrix(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.
+     */
+    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){
+    }
+
 }

package/source/Model/NaiveBayesModel.ts

@@ -4,6 +4,7 @@ import {Vector} from "nlptoolkit-math/dist/Vector";
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
 import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
 import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class NaiveBayesModel extends GaussianModel{
 
@@ -18,14 +19,21 @@ export class NaiveBayesModel extends GaussianModel{
      * @param classMeans        A {@link Map} of String and {@link Vector}.
      * @param classDeviations   A {@link Map} of String and {@link Vector}.
      */
-    constructor(priorDistribution: DiscreteDistribution, classMeans: any, classDeviations?: Map<string, Vector>) {
-        super();
-        this.priorDistribution = priorDistribution
-        if (classDeviations != undefined){
-            this.classMeans = classMeans
-            this.classDeviations = classDeviations
+    constructor(priorDistribution: DiscreteDistribution | string, classMeans?: any, classDeviations?: Map<string, Vector>) {
+        super()
+        if (priorDistribution instanceof DiscreteDistribution){
+            this.priorDistribution = priorDistribution
+            if (classDeviations != undefined){
+                this.classMeans = classMeans
+                this.classDeviations = classDeviations
+            } else {
+                this.classAttributeDistributions = classMeans
+            }
         } else {
-            this.classAttributeDistributions = classMeans
+            let input = new FileContents(priorDistribution)
+            let size = this.loadPriorDistribution(input)
+            this.classMeans = this.loadVectors(input, size)
+            this.classDeviations = this.loadVectors(input, size)
         }
     }
 
@@ -86,4 +94,8 @@ export class NaiveBayesModel extends GaussianModel{
         }
         return logLikelihood;
     }
+
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/NeuralNetworkModel.ts

@@ -6,6 +6,7 @@ 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";
 
 export abstract class NeuralNetworkModel extends ValidatedModel{
 
@@ -23,11 +24,13 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
      *
      * @param trainSet {@link InstanceList} to use as train set.
      */
-    protected constructor(trainSet: InstanceList) {
+    protected constructor(trainSet?: InstanceList) {
         super();
-        this.classLabels = trainSet.getDistinctClassLabels()
-        this.K = this.classLabels.length
-        this.d = trainSet.get(0).continuousAttributeSize()
+        if (trainSet != undefined){
+            this.classLabels = trainSet.getDistinctClassLabels()
+            this.K = this.classLabels.length
+            this.d = trainSet.get(0).continuousAttributeSize()
+        }
     }
 
     /**
@@ -52,10 +55,10 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
     protected normalizeOutput(o: Vector): Vector{
         let sum = 0.0;
         let values = new Array<number>()
-        for (let i = 0; i < values.length; i++){
+        for (let i = 0; i < o.size(); i++){
             sum += Math.exp(o.getValue(i));
         }
-        for (let i = 0; i < values.length; i++){
+        for (let i = 0; i < o.size(); i++){
             values.push(Math.exp(o.getValue(i)) / sum);
         }
         return new Vector(values);
@@ -135,7 +138,7 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
      * @return Difference between newly created Vector and normalized output.
      */
     protected calculateRMinusY(instance: Instance, input: Vector, weights: Matrix): Vector{
-        this.r = new Vector(this.K, this.classLabels.indexOf(instance.getClassLabel()), 1.0);
+        this.r = new Vector(this.K, 1.0, this.classLabels.indexOf(instance.getClassLabel()));
         let o = weights.multiplyWithVectorFromRight(input);
         this.y = this.normalizeOutput(o);
         return this.r.difference(this.y);
@@ -186,4 +189,25 @@ export abstract class NeuralNetworkModel extends ValidatedModel{
         }
         return result;
     }
+
+    loadClassLabels(input: FileContents){
+        let items = input.readLine().split(" ")
+        this.K = parseInt(items[0])
+        this.d = parseInt(items[1])
+        this.classLabels = new Array<string>()
+        for (let i = 0; i < this.K; i++){
+            this.classLabels.push(input.readLine())
+        }
+    }
+
+    loadActivationFunction(input: FileContents): ActivationFunction{
+        switch (input.readLine()){
+            case "TANH":
+                return ActivationFunction.TANH
+            case "RELU":
+                return ActivationFunction.RELU
+            default:
+                return ActivationFunction.SIGMOID
+        }
+    }
 }

package/source/Model/QdaModel.ts

@@ -3,6 +3,7 @@ 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{
 
@@ -11,14 +12,27 @@ export class QdaModel extends LdaModel{
     /**
      * The constructor which sets the priorDistribution, w w1 and HashMap of String Matrix.
      *
-     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @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(priorDistribution: DiscreteDistribution, W: Map<string, Matrix>, w: Map<string, Vector>, w0: Map<string, number>) {
-        super(priorDistribution, w, w0);
-        this.W = W
+    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)
+            }
+        }
     }
 
     /**
@@ -36,4 +50,8 @@ export class QdaModel extends LdaModel{
         let w0i = this.w0.get(Ci);
         return Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i;
     }
+
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/RandomModel.ts

@@ -2,16 +2,30 @@ import {Model} from "./Model";
 import {Instance} from "../Instance/Instance";
 import {CompositeInstance} from "../Instance/CompositeInstance";
 import {Random} from "nlptoolkit-util/dist/Random";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
 
 export class RandomModel extends Model{
 
-    private classLabels: Array<string>
+    private readonly classLabels: Array<string>
     private random: Random
+    private seed: number
 
-    constructor(classLabels: Array<string>, seed: number) {
+    constructor(classLabelsOrFileName: Array<string> | string, seed?: number) {
         super();
-        this.classLabels = classLabels
-        this.random = new Random(seed)
+        if (classLabelsOrFileName instanceof Array){
+            this.classLabels = classLabelsOrFileName
+            this.random = new Random(seed)
+            this.seed = seed
+        } else {
+            let input = new FileContents(classLabelsOrFileName)
+            seed = parseInt(input.readLine())
+            this.random = new Random(seed)
+            let size = parseInt(input.readLine())
+            this.classLabels = new Array<string>()
+            for (let i = 0; i < size; i++){
+                this.classLabels.push(input.readLine())
+            }
+        }
     }
 
     /**
@@ -42,4 +56,7 @@ export class RandomModel extends Model{
         return result;
     }
 
+    saveTxt(fileName: string){
+    }
+
 }

package/source/Model/TreeEnsembleModel.ts

@@ -2,6 +2,8 @@ import {Model} from "./Model";
 import {Instance} from "../Instance/Instance";
 import {DecisionTree} from "./DecisionTree/DecisionTree";
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {DecisionNode} from "./DecisionTree/DecisionNode";
 
 export class TreeEnsembleModel extends Model{
 
@@ -10,11 +12,20 @@ export class TreeEnsembleModel extends Model{
     /**
      * A constructor which sets the {@link Array} of {@link DecisionTree} with given input.
      *
-     * @param forest An {@link Array} of {@link DecisionTree}.
+     * @param forestOrFileName An {@link Array} of {@link DecisionTree}.
      */
-    constructor(forest: Array<DecisionTree>) {
+    constructor(forestOrFileName: Array<DecisionTree> | string) {
         super();
-        this.forest = forest
+        if (forestOrFileName instanceof Array){
+            this.forest = forestOrFileName
+        } else {
+            let input = new FileContents(forestOrFileName)
+            let numberOfTrees = parseInt(input.readLine())
+            this.forest = new Array<DecisionTree>()
+            for (let i = 0; i < numberOfTrees; i++){
+                this.forest.push(new DecisionTree(new DecisionNode(input)))
+            }
+        }
     }
 
     /**
@@ -40,4 +51,7 @@ export class TreeEnsembleModel extends Model{
         return distribution.getProbabilityDistribution();
     }
 
+    saveTxt(fileName: string){
+    }
+
 }

package/tests/Classifier/C45Test.ts

@@ -0,0 +1,67 @@
+import * as assert from "assert";
+import {C45} from "../../dist/Classifier/C45";
+import {C45Parameter} from "../../dist/Parameter/C45Parameter";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+
+describe('C45Test', function() {
+    describe('C45Test', function() {
+        let c45 = new C45()
+        let c45Parameter = new C45Parameter(1, true, 0.2)
+        let attributeTypes = new Array<AttributeType>();
+        for (let i = 0; i < 4; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        let dataDefinition = new DataDefinition(attributeTypes)
+        let iris = new DataSet(dataDefinition, ",", "datasets/iris.data")
+        attributeTypes = new Array<AttributeType>();
+        for (let i = 0; i < 6; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let bupa = new DataSet(dataDefinition, ",", "datasets/bupa.data")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 34; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let dermatology = new DataSet(dataDefinition, ",", "datasets/dermatology.data")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 6; i++){
+            attributeTypes.push(AttributeType.DISCRETE)
+        }
+        dataDefinition = new DataDefinition(attributeTypes);
+        let car = new DataSet(dataDefinition, ",", "datasets/car.data");
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 9; i++){
+            attributeTypes.push(AttributeType.DISCRETE)
+        }
+        dataDefinition = new DataDefinition(attributeTypes);
+        let tictactoe = new DataSet(dataDefinition, ",", "datasets/tictactoe.data")
+        it('testTrain', function() {
+            c45.train(iris.getInstanceList(), c45Parameter);
+            assert.ok(Math.abs(4.00 - 100 * c45.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.train(bupa.getInstanceList(), c45Parameter);
+            assert.ok(Math.abs(28.41 -  100 * c45.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.train(dermatology.getInstanceList(), c45Parameter);
+            assert.ok(Math.abs(2.46 -  100 * c45.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.train(car.getInstanceList(), c45Parameter);
+            assert.ok(Math.abs(21.35 - 100 * c45.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.train(tictactoe.getInstanceList(), c45Parameter);
+            assert.ok(Math.abs(19.94 - 100 * c45.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            c45.loadModel("models/c45-iris.txt");
+            assert.ok(Math.abs(4.00 - 100 * c45.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.loadModel("models/c45-bupa.txt");
+            assert.ok(Math.abs(42.03 -  100 * c45.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.loadModel("models/c45-dermatology.txt");
+            assert.ok(Math.abs(2.19 -  100 * c45.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.loadModel("models/c45-car.txt");
+            assert.ok(Math.abs(8.16 - 100 * c45.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.loadModel("models/c45-tictactoe.txt");
+            assert.ok(Math.abs(14.61 - 100 * c45.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/DeepNetworkTest.ts

@@ -0,0 +1,52 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {MultiLayerPerceptron} from "../../dist/Classifier/MultiLayerPerceptron";
+import {MultiLayerPerceptronParameter} from "../../dist/Parameter/MultiLayerPerceptronParameter";
+import {ActivationFunction} from "../../dist/Parameter/ActivationFunction";
+import {DeepNetwork} from "../../dist/Classifier/DeepNetwork";
+import {DeepNetworkParameter} from "../../dist/Parameter/DeepNetworkParameter";
+
+describe('DeepNetworkTest', function() {
+    describe('DeepNetworkTest', function() {
+        let deepNetwork = new DeepNetwork()
+        let attributeTypes = new Array<AttributeType>();
+        for (let i = 0; i < 4; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        let dataDefinition = new DataDefinition(attributeTypes)
+        let iris = new DataSet(dataDefinition, ",", "datasets/iris.data")
+        attributeTypes = new Array<AttributeType>();
+        for (let i = 0; i < 6; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let bupa = new DataSet(dataDefinition, ",", "datasets/bupa.data")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 34; i++){
+            attributeTypes.push(AttributeType.CONTINUOUS)
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let dermatology = new DataSet(dataDefinition, ",", "datasets/dermatology.data")
+        it('testTrain', function() {
+            let deepNetworkParameter = new DeepNetworkParameter(1, 0.1, 0.99, 0.2, 100, [5, 5], ActivationFunction.SIGMOID)
+            deepNetwork.train(iris.getInstanceList(), deepNetworkParameter);
+            assert.ok(Math.abs(2.67 - 100 * deepNetwork.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            deepNetworkParameter = new DeepNetworkParameter(1, 0.01, 0.99, 0.2, 100, [15, 15], ActivationFunction.SIGMOID)
+            deepNetwork.train(bupa.getInstanceList(), deepNetworkParameter);
+            assert.ok(Math.abs(28.70 -  100 * deepNetwork.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            deepNetworkParameter = new DeepNetworkParameter(1, 0.01, 0.99, 0.2, 100, [20], ActivationFunction.SIGMOID)
+            deepNetwork.train(dermatology.getInstanceList(), deepNetworkParameter);
+            assert.ok(Math.abs(2.73 -  100 * deepNetwork.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            deepNetwork.loadModel("models/deepNetwork-iris.txt");
+            assert.ok(Math.abs(1.33 - 100 * deepNetwork.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            deepNetwork.loadModel("models/deepNetwork-bupa.txt");
+            assert.ok(Math.abs(28.99 -  100 * deepNetwork.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            deepNetwork.loadModel("models/deepNetwork-dermatology.txt");
+            assert.ok(Math.abs(1.09 -  100 * deepNetwork.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});