nlptoolkit-classification 1.0.3 → 1.0.5

package/tests/Classifier/C45Test.ts

@@ -0,0 +1,98 @@
+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>();
+        let attributeValueList = new Array<Array<String>>()
+        attributeValueList.push(["vhigh", "high", "low", "med"])
+        attributeValueList.push(["vhigh", "high", "low", "med"])
+        attributeValueList.push(["2", "3", "4", "5more"])
+        attributeValueList.push(["2", "4", "more"])
+        attributeValueList.push(["big", "med", "small"])
+        attributeValueList.push(["high", "low", "med"])
+        for (let i = 0; i < 6; i++){
+            attributeTypes.push(AttributeType.DISCRETE_INDEXED)
+        }
+        dataDefinition = new DataDefinition(attributeTypes, attributeValueList)
+        let carIndexed = 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")
+        attributeTypes = new Array<AttributeType>();
+        attributeValueList = new Array<Array<String>>()
+        for (let i = 0; i < 9; i++){
+            attributeTypes.push(AttributeType.DISCRETE_INDEXED)
+            attributeValueList.push(["b", "o", "x"])
+        }
+        dataDefinition = new DataDefinition(attributeTypes, attributeValueList)
+        let tictactoeIndexed = 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);
+            c45.train(carIndexed.getInstanceList(), c45Parameter);
+            let a = 100 * c45.test(carIndexed.getInstanceList()).getErrorRate()
+            assert.ok(Math.abs(10.76 - 100 * c45.test(carIndexed.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.train(tictactoeIndexed.getInstanceList(), c45Parameter);
+            a = 100 * c45.test(tictactoeIndexed.getInstanceList()).getErrorRate()
+            assert.ok(Math.abs(16.08 - 100 * c45.test(tictactoeIndexed.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);
+            c45.loadModel("models/c45-carIndexed.txt");
+            assert.ok(Math.abs(3.36 - 100 * c45.test(carIndexed.getInstanceList()).getErrorRate()) <= 0.01);
+            c45.loadModel("models/c45-tictactoeIndexed.txt");
+            assert.ok(Math.abs(4.49 - 100 * c45.test(tictactoeIndexed.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);
+        });
+    });
+});

package/tests/Classifier/DummyTest.ts

@@ -0,0 +1,89 @@
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import * as assert from "assert";
+import {Dummy} from "../../dist/Classifier/Dummy";
+
+describe('DummyTest', function() {
+    describe('DummyTest', function() {
+        let dummy = new Dummy()
+        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")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 8; i++){
+            attributeTypes.push(AttributeType.DISCRETE)
+        }
+        dataDefinition = new DataDefinition(attributeTypes);
+        let nursery = new DataSet(dataDefinition, ",", "datasets/nursery.data")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 6; i++){
+            if (i % 2 == 0){
+                attributeTypes.push(AttributeType.DISCRETE)
+            } else {
+                attributeTypes.push(AttributeType.CONTINUOUS)
+            }
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let chess = new DataSet(dataDefinition, ",", "datasets/chess.data")
+        it('testTrain', function() {
+            dummy.train(iris.getInstanceList(), null);
+            assert.ok(Math.abs(66.67 - 100 * dummy.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(bupa.getInstanceList(), null);
+            assert.ok(Math.abs(42.03 -  100 * dummy.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(dermatology.getInstanceList(), null);
+            assert.ok(Math.abs(69.40 -  100 * dummy.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(car.getInstanceList(), null);
+            assert.ok(Math.abs(29.98 - 100 * dummy.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(tictactoe.getInstanceList(), null);
+            assert.ok(Math.abs(34.66 - 100 * dummy.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(nursery.getInstanceList(), null);
+            assert.ok(Math.abs(66.67 - 100 * dummy.test(nursery.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.train(chess.getInstanceList(), null);
+            assert.ok(Math.abs(83.77 - 100 * dummy.test(chess.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            dummy.loadModel("models/dummy-iris.txt");
+            assert.ok(Math.abs(66.67 - 100 * dummy.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-bupa.txt");
+            assert.ok(Math.abs(42.03 -  100 * dummy.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-dermatology.txt");
+            assert.ok(Math.abs(69.40 -  100 * dummy.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-car.txt");
+            assert.ok(Math.abs(29.98 - 100 * dummy.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-tictactoe.txt");
+            assert.ok(Math.abs(34.66 - 100 * dummy.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-nursery.txt");
+            assert.ok(Math.abs(66.67 - 100 * dummy.test(nursery.getInstanceList()).getErrorRate()) <= 0.01);
+            dummy.loadModel("models/dummy-chess.txt");
+            assert.ok(Math.abs(83.77 - 100 * dummy.test(chess.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/KMeansTest.ts

@@ -0,0 +1,89 @@
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import * as assert from "assert";
+import {KMeans} from "../../dist/Classifier/KMeans";
+import {KMeansParameter} from "../../dist/Parameter/KMeansParameter";
+
+describe('KMeansTest', function() {
+    describe('KMeansTest', function() {
+        let kMeans = new KMeans()
+        let kMeansParameter = new KMeansParameter(1)
+        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")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 8; i++){
+            attributeTypes.push(AttributeType.DISCRETE)
+        }
+        dataDefinition = new DataDefinition(attributeTypes);
+        let nursery = new DataSet(dataDefinition, ",", "datasets/nursery.data")
+        attributeTypes = new Array<AttributeType>()
+        for (let i = 0; i < 6; i++){
+            if (i % 2 == 0){
+                attributeTypes.push(AttributeType.DISCRETE)
+            } else {
+                attributeTypes.push(AttributeType.CONTINUOUS)
+            }
+        }
+        dataDefinition = new DataDefinition(attributeTypes)
+        let chess = new DataSet(dataDefinition, ",", "datasets/chess.data")
+        it('testTrain', function() {
+            kMeans.train(iris.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(7.33 - 100 * kMeans.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(bupa.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(43.77 -  100 * kMeans.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(dermatology.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(45.08 -  100 * kMeans.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(car.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(47.98 - 100 * kMeans.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(tictactoe.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(38.94 - 100 * kMeans.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(nursery.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(53.60 - 100 * kMeans.test(nursery.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.train(chess.getInstanceList(), kMeansParameter);
+            assert.ok(Math.abs(83.25 - 100 * kMeans.test(chess.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            kMeans.loadModel("models/kMeans-iris.txt");
+            assert.ok(Math.abs(7.33 - 100 * kMeans.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.loadModel("models/kMeans-bupa.txt");
+            assert.ok(Math.abs(43.77 -  100 * kMeans.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.loadModel("models/kMeans-dermatology.txt");
+            assert.ok(Math.abs(45.08 -  100 * kMeans.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.loadModel("models/kMeans-car.txt");
+            assert.ok(Math.abs(29.98 - 100 * kMeans.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.loadModel("models/kMeans-tictactoe.txt");
+            assert.ok(Math.abs(34.66 - 100 * kMeans.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+            kMeans.loadModel("models/kMeans-chess.txt");
+            assert.ok(Math.abs(85.83 - 100 * kMeans.test(chess.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/KnnTest.ts

@@ -0,0 +1,68 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {Knn} from "../../dist/Classifier/Knn";
+import {KnnParameter} from "../../dist/Parameter/KnnParameter";
+import {EuclidianDistance} from "../../dist/DistanceMetric/EuclidianDistance";
+
+describe('KnnTest', function() {
+    describe('KnnTest', function() {
+        let knn = new Knn()
+        let knnParameter = new KnnParameter(1, 3, new EuclidianDistance())
+        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() {
+            knn.train(iris.getInstanceList(), knnParameter);
+            assert.ok(Math.abs(4.00 - 100 * knn.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.train(bupa.getInstanceList(), knnParameter);
+            assert.ok(Math.abs(19.42 -  100 * knn.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.train(dermatology.getInstanceList(), knnParameter);
+            assert.ok(Math.abs(3.00 -  100 * knn.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.train(car.getInstanceList(), knnParameter);
+            assert.ok(Math.abs(20.31 - 100 * knn.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.train(tictactoe.getInstanceList(), knnParameter);
+            assert.ok(Math.abs(32.57 - 100 * knn.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            knn.loadModel("models/knn-iris.txt");
+            assert.ok(Math.abs(4.00 - 100 * knn.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.loadModel("models/knn-bupa.txt");
+            assert.ok(Math.abs(19.42 -  100 * knn.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.loadModel("models/knn-dermatology.txt");
+            assert.ok(Math.abs(3.00 -  100 * knn.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.loadModel("models/knn-car.txt");
+            assert.ok(Math.abs(29.98 - 100 * knn.test(car.getInstanceList()).getErrorRate()) <= 0.01);
+            knn.loadModel("models/knn-tictactoe.txt");
+            assert.ok(Math.abs(34.66 - 100 * knn.test(tictactoe.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/LdaTest.ts

@@ -0,0 +1,45 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {Lda} from "../../dist/Classifier/Lda";
+
+describe('LdaTest', function() {
+    describe('LdaTest', function() {
+        let lda = new Lda()
+        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() {
+            lda.train(iris.getInstanceList(), null);
+            assert.ok(Math.abs(2.00 - 100 * lda.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            lda.train(bupa.getInstanceList(), null);
+            assert.ok(Math.abs(29.57 -  100 * lda.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            lda.train(dermatology.getInstanceList(), null);
+            assert.ok(Math.abs(1.91 -  100 * lda.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            lda.loadModel("models/lda-iris.txt");
+            assert.ok(Math.abs(2.00 - 100 * lda.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            lda.loadModel("models/lda-bupa.txt");
+            assert.ok(Math.abs(29.57 -  100 * lda.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            lda.loadModel("models/lda-dermatology.txt");
+            assert.ok(Math.abs(1.91 -  100 * lda.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/LinearPerceptronTest.ts

@@ -0,0 +1,49 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {LinearPerceptron} from "../../dist/Classifier/LinearPerceptron";
+import {LinearPerceptronParameter} from "../../dist/Parameter/LinearPerceptronParameter";
+
+describe('LinearPerceptronTest', function() {
+    describe('LinearPerceptronTest', function() {
+        let linearPerceptron = new LinearPerceptron()
+        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 linearPerceptronParameter = new LinearPerceptronParameter(1, 0.1, 0.99, 0.2, 100)
+            linearPerceptron.train(iris.getInstanceList(), linearPerceptronParameter);
+            assert.ok(Math.abs(3.33 - 100 * linearPerceptron.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            linearPerceptronParameter = new LinearPerceptronParameter(1, 0.001, 0.99, 0.2, 100)
+            linearPerceptron.train(bupa.getInstanceList(), linearPerceptronParameter);
+            assert.ok(Math.abs(33.33 -  100 * linearPerceptron.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            linearPerceptronParameter = new LinearPerceptronParameter(1, 0.1, 0.99, 0.2, 100)
+            linearPerceptron.train(dermatology.getInstanceList(), linearPerceptronParameter);
+            assert.ok(Math.abs(1.36 -  100 * linearPerceptron.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            linearPerceptron.loadModel("models/linearPerceptron-iris.txt");
+            assert.ok(Math.abs(3.33 - 100 * linearPerceptron.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            linearPerceptron.loadModel("models/linearPerceptron-bupa.txt");
+            assert.ok(Math.abs(31.88 -  100 * linearPerceptron.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            linearPerceptron.loadModel("models/linearPerceptron-dermatology.txt");
+            assert.ok(Math.abs(0.82 -  100 * linearPerceptron.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/MultiLayerPerceptronTest.ts

@@ -0,0 +1,51 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {LinearPerceptronParameter} from "../../dist/Parameter/LinearPerceptronParameter";
+import {MultiLayerPerceptron} from "../../dist/Classifier/MultiLayerPerceptron";
+import {MultiLayerPerceptronParameter} from "../../dist/Parameter/MultiLayerPerceptronParameter";
+import {ActivationFunction} from "../../dist/Parameter/ActivationFunction";
+
+describe('MultiLayerPerceptronTest', function() {
+    describe('MultiLayerPerceptronTest', function() {
+        let multiLayerPerceptron = new MultiLayerPerceptron()
+        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 multiLayerPerceptronParameter = new MultiLayerPerceptronParameter(1, 0.1, 0.99, 0.2, 100, 3, ActivationFunction.SIGMOID)
+            multiLayerPerceptron.train(iris.getInstanceList(), multiLayerPerceptronParameter);
+            assert.ok(Math.abs(7.33 - 100 * multiLayerPerceptron.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            multiLayerPerceptronParameter = new MultiLayerPerceptronParameter(1, 0.01, 0.99, 0.2, 100, 30, ActivationFunction.SIGMOID)
+            multiLayerPerceptron.train(bupa.getInstanceList(), multiLayerPerceptronParameter);
+            assert.ok(Math.abs(29.57 -  100 * multiLayerPerceptron.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            multiLayerPerceptronParameter = new MultiLayerPerceptronParameter(1, 0.01, 0.99, 0.2, 100, 20, ActivationFunction.SIGMOID)
+            multiLayerPerceptron.train(dermatology.getInstanceList(), multiLayerPerceptronParameter);
+            assert.ok(Math.abs(2.19 -  100 * multiLayerPerceptron.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            multiLayerPerceptron.loadModel("models/multiLayerPerceptron-iris.txt");
+            assert.ok(Math.abs(2.67 - 100 * multiLayerPerceptron.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            multiLayerPerceptron.loadModel("models/multiLayerPerceptron-bupa.txt");
+            assert.ok(Math.abs(27.54 -  100 * multiLayerPerceptron.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            multiLayerPerceptron.loadModel("models/multiLayerPerceptron-dermatology.txt");
+            assert.ok(Math.abs(1.09 -  100 * multiLayerPerceptron.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/NaiveBayesTest.ts

@@ -0,0 +1,45 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {NaiveBayes} from "../../dist/Classifier/NaiveBayes";
+
+describe('NaiveBayesTest', function() {
+    describe('NaiveBayesTest', function() {
+        let naiveBayes = new NaiveBayes()
+        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() {
+            naiveBayes.train(iris.getInstanceList(), null);
+            assert.ok(Math.abs(5.33 - 100 * naiveBayes.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            naiveBayes.train(bupa.getInstanceList(), null);
+            assert.ok(Math.abs(38.55 -  100 * naiveBayes.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            naiveBayes.train(dermatology.getInstanceList(), null);
+            assert.ok(Math.abs(9.56 -  100 * naiveBayes.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            naiveBayes.loadModel("models/naiveBayes-iris.txt");
+            assert.ok(Math.abs(5.33 - 100 * naiveBayes.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            naiveBayes.loadModel("models/naiveBayes-bupa.txt");
+            assert.ok(Math.abs(38.55 -  100 * naiveBayes.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+            naiveBayes.loadModel("models/naiveBayes-dermatology.txt");
+            assert.ok(Math.abs(9.56 -  100 * naiveBayes.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});

package/tests/Classifier/QdaTest.ts

@@ -0,0 +1,35 @@
+import * as assert from "assert";
+import {AttributeType} from "../../dist/Attribute/AttributeType";
+import {DataDefinition} from "../../dist/DataSet/DataDefinition";
+import {DataSet} from "../../dist/DataSet/DataSet";
+import {Qda} from "../../dist/Classifier/Qda";
+
+describe('QdaTest', function() {
+    describe('QdaTest', function() {
+        let qda = new Qda()
+        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")
+        it('testTrain', function() {
+            qda.train(iris.getInstanceList(), null);
+            assert.ok(Math.abs(2.00 - 100 * qda.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            qda.train(bupa.getInstanceList(), null);
+            assert.ok(Math.abs(36.52 -  100 * qda.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+        it('testLoad', function() {
+            qda.loadModel("models/qda-iris.txt");
+            assert.ok(Math.abs(2.00 - 100 * qda.test(iris.getInstanceList()).getErrorRate()) <= 0.01);
+            qda.loadModel("models/qda-bupa.txt");
+            assert.ok(Math.abs(36.52 -  100 * qda.test(bupa.getInstanceList()).getErrorRate()) <= 0.01);
+        });
+    });
+});