nlptoolkit-classification 1.0.7 → 1.0.9

package/source/Model/Parametric/QdaModel.ts

@@ -0,0 +1,83 @@
+import {LdaModel} from "./LdaModel";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {Instance} from "../../Instance/Instance";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
+import {InstanceListOfSameClass} from "../../InstanceList/InstanceListOfSameClass";
+
+export class QdaModel extends LdaModel{
+
+    private W: Map<string, Matrix>
+
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        let size = this.loadPriorDistribution(input)
+        this.loadWandW0(input, size)
+        this.W = new Map<string, Matrix>()
+        for (let i = 0; i < size; i++){
+            let c = input.readLine()
+            let matrix = this.loadMatrix(input)
+            this.W.set(c, matrix)
+        }
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It multiplies Matrix Wi with Vector xi
+     * then calculates the dot product of it with xi. Then, again it finds the dot product of wi and xi and returns the summation with w0i.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The result of Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        let xi = instance.toVector();
+        let Wi = this.W.get(Ci);
+        let wi = this.w.get(Ci);
+        let w0i = this.w0.get(Ci);
+        return Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i;
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * Training algorithm for the quadratic discriminant analysis classifier (Introduction to Machine Learning, Alpaydin, 2015).
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter) {
+        let determinant = 0
+        this.w0 = new Map<string, number>();
+        this.w = new Map<string, Vector>();
+        this.W = new Map<string, Matrix>();
+        let classLists = new Partition(trainSet);
+        this.priorDistribution = trainSet.classDistribution();
+        for (let i = 0; i < classLists.size(); i++) {
+            let Ci = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let classCovariance = classLists.get(i).covariance(averageVector);
+            determinant = classCovariance.determinant();
+            classCovariance.inverse();
+            let Wi = classCovariance.clone();
+            Wi.multiplyWithConstant(-0.5);
+            this.W.set(Ci, Wi);
+            let wi = classCovariance.multiplyWithVectorFromLeft(averageVector);
+            this.w.set(Ci, wi);
+            let w0i = -0.5 * (wi.dotProduct(averageVector) + Math.log(determinant)) + Math.log(this.priorDistribution.getProbability(Ci));
+            this.w0.set(Ci, w0i);
+        }
+    }
+
+    /**
+     * Loads the Qda model from an input file.
+     * @param fileName File name of the Qda model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}

package/source/Model/RandomModel.ts

@@ -3,28 +3,39 @@ import {Instance} from "../Instance/Instance";
 import {CompositeInstance} from "../Instance/CompositeInstance";
 import {Random} from "nlptoolkit-util/dist/Random";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
 
 export class RandomModel extends Model{
 
-    private readonly classLabels: Array<string>
+    private classLabels: Array<string>
     private random: Random
     private seed: number
 
-    constructor(classLabelsOrFileName: Array<string> | string, seed?: number) {
-        super();
-        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())
-            }
+    /**
+     * A constructor that sets the class labels.
+     *
+     * @param classLabels An ArrayList of class labels.
+     * @param seed Seed of the random function.
+     */
+    constructor1(classLabels: Array<string>, seed: number) {
+        this.classLabels = classLabels
+        this.random = new Random(seed)
+        this.seed = seed
+    }
+
+    /**
+     * Loads a random classifier model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        this.seed = parseInt(input.readLine())
+        this.random = new Random(this.seed)
+        let size = parseInt(input.readLine())
+        this.classLabels = new Array<string>()
+        for (let i = 0; i < size; i++){
+            this.classLabels.push(input.readLine())
         }
     }
 
@@ -48,6 +59,11 @@ export class RandomModel extends Model{
         }
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to random model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         let result = new Map<string, number>();
         for (let classLabel of this.classLabels){
@@ -59,4 +75,26 @@ export class RandomModel extends Model{
     saveTxt(fileName: string){
     }
 
+    /**
+     * Training algorithm for random classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let result = new Array<string>()
+        for (let s of trainSet.classDistribution().keys()){
+            result.push(s)
+        }
+        this.constructor1(result, parameters.getSeed());
+    }
+
+    /**
+     * Loads the random classifier model from an input file.
+     * @param fileName File name of the random classifier model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
 }

package/source/Parameter/C45Parameter.ts

@@ -2,8 +2,8 @@ import {Parameter} from "./Parameter";
 
 export class C45Parameter extends Parameter{
 
-    private prune: boolean
-    private crossValidationRatio: number
+    private readonly prune: boolean
+    private readonly crossValidationRatio: number
 
     /**
      * Parameters of the C4.5 univariate decision tree classifier.

package/source/Parameter/DeepNetworkParameter.ts

@@ -2,8 +2,8 @@ import {LinearPerceptronParameter} from "./LinearPerceptronParameter";
 import {ActivationFunction} from "./ActivationFunction";
 
 export class DeepNetworkParameter extends LinearPerceptronParameter{
-    private hiddenLayers: Array<number>
-    private activationFunction: ActivationFunction
+    private readonly hiddenLayers: Array<number>
+    private readonly activationFunction: ActivationFunction
 
     /**
      * Parameters of the deep network classifier.

package/source/Parameter/KnnParameter.ts

@@ -3,7 +3,7 @@ import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
 
 export class KnnParameter extends KMeansParameter{
 
-    private k: number
+    private readonly k: number
 
     /**
      * Parameters of the K-nearest neighbor classifier.

package/source/Parameter/LinearPerceptronParameter.ts

@@ -2,10 +2,10 @@ import {Parameter} from "./Parameter";
 
 export class LinearPerceptronParameter extends Parameter{
 
-    private learningRate: number
-    private etaDecrease: number
-    private crossValidationRatio: number
-    private epoch: number
+    private readonly learningRate: number
+    private readonly etaDecrease: number
+    private readonly crossValidationRatio: number
+    private readonly epoch: number
 
     /**
      * Parameters of the linear perceptron algorithm.

package/source/Parameter/MultiLayerPerceptronParameter.ts

@@ -3,8 +3,8 @@ import {ActivationFunction} from "./ActivationFunction";
 
 export class MultiLayerPerceptronParameter extends LinearPerceptronParameter{
 
-    private hiddenNodes: number
-    private activationFunction: ActivationFunction
+    private readonly hiddenNodes: number
+    private readonly activationFunction: ActivationFunction
 
     /**
      * Parameters of the multi layer perceptron algorithm.

package/source/Parameter/Parameter.ts

@@ -1,6 +1,6 @@
 export class Parameter {
 
-    private seed: number
+    private readonly seed: number
 
     /**
      * Constructor of {@link Parameter} class which assigns given seed value to seed.

package/source/Performance/ConfusionMatrix.ts

@@ -3,7 +3,7 @@ import {CounterHashMap} from "nlptoolkit-datastructure/dist/CounterHashMap";
 export class ConfusionMatrix {
 
     private matrix: Map<string, CounterHashMap<string>> = new Map<string, CounterHashMap<string>>()
-    private classLabels: Array<string>
+    private readonly classLabels: Array<string>
 
     /**
      * Constructor that sets the class labels {@link Array} and creates new {@link Map} matrix

package/source/StatisticalTest/Combined5x2F.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Combined5x2F extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the combined 5x2 cv F test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the combined 5x2 cv F test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         let numerator = 0
@@ -23,6 +29,12 @@ export class Combined5x2F extends PairedTest{
         return numerator / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using combined 5x2 cv F test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom1 = classifier1.numberOfExperiments();

package/source/StatisticalTest/Combined5x2t.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Combined5x2t extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the combined 5x2 cv t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the combined 5x2 cv t test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         for (let i = 0; i < classifier1.numberOfExperiments(); i++){
@@ -24,6 +30,13 @@ export class Combined5x2t extends PairedTest{
         return numerator / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using combined 5x2
+     * cv t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom = classifier1.numberOfExperiments() / 2;

package/source/StatisticalTest/Paired5x2t.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Paired5x2t extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the 5x2 t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the 5x2 t test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         let sum = 0.0;
@@ -23,6 +29,12 @@ export class Paired5x2t extends PairedTest{
         return difference[0] / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using 5x2 t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom = classifier1.numberOfExperiments() / 2;

package/source/StatisticalTest/PairedTest.ts

@@ -6,6 +6,18 @@ export abstract class PairedTest {
 
     abstract compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate). The method first
+     * checks the null hypothesis mu1 < mu2, if the test rejects this null hypothesis with alpha level of confidence, it
+     * decides mu1 > mu2. The algorithm then checks the null hypothesis mu1 > mu2, if the test rejects that null
+     * hypothesis with alpha level of confidence, if decides mu1 < mu2. If none of the two tests are rejected, it can not
+     * make a decision about the performances of algorithms.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @param alpha Alpha level defined for the statistical test.
+     * @return 1 if the performance of the first algorithm is larger than the second algorithm, -1 if the performance of
+     * the second algorithm is larger than the first algorithm, 0 if they have similar performance.
+     */
     compare(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance, alpha: number): number{
         let testResult1 = this.compareClassifiers(classifier1, classifier2);
         let testResult2 = this.compareClassifiers(classifier2, classifier1);

package/source/StatisticalTest/Pairedt.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Pairedt extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the paired t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the paired t test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         let sum = 0.0;
@@ -21,6 +27,12 @@ export class Pairedt extends PairedTest{
         return Math.sqrt(classifier1.numberOfExperiments()) * mean / standardDeviation;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using paired t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom = classifier1.numberOfExperiments() - 1;

package/source/StatisticalTest/Sign.ts

@@ -4,6 +4,11 @@ import {StatisticalTestResult} from "./StatisticalTestResult";
 
 export class Sign extends PairedTest{
 
+    /**
+     * Calculates n!.
+     * @param n n is n!
+     * @return n!.
+     */
     private factorial(n: number): number{
         let result = 1;
         for (let i = 2; i <= n; i++)
@@ -11,6 +16,12 @@ export class Sign extends PairedTest{
         return result;
     }
 
+    /**
+     * Calculates m of n that is C(n, m)
+     * @param m m in C(m, n)
+     * @param n n in C(m, n)
+     * @return C(m, n)
+     */
     private binomial(m: number, n: number): number{
         if (n == 0 || m == n){
             return 1;
@@ -19,6 +30,12 @@ export class Sign extends PairedTest{
         }
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using sign test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let plus = 0, minus = 0;
         for (let i = 0; i < classifier1.numberOfExperiments(); i++){

package/source/StatisticalTest/StatisticalTestResult.ts

@@ -5,11 +5,24 @@ export class StatisticalTestResult {
     private readonly pValue: number
     private readonly onlyTwoTailed: boolean
 
+    /**
+     * Constructor of the StatisticalTestResult. It sets the attribute values.
+     * @param pValue p value of the statistical test result
+     * @param onlyTwoTailed True, if this test applicable only two tailed tests, false otherwise.
+     */
     constructor(pValue: number, onlyTwoTailed: boolean) {
         this.pValue = pValue
         this.onlyTwoTailed = onlyTwoTailed
     }
 
+    /**
+     * Returns reject or failed to reject, depending on the alpha level and p value of the statistical test that checks
+     * one tailed null hypothesis such as mu1 < mu2. If p value is less than the alpha level, the test rejects the null
+     * hypothesis. Otherwise, it fails to reject the null hypothesis.
+     * @param alpha Alpha level of the test
+     * @return If p value is less than the alpha level, the test rejects the null hypothesis. Otherwise, it fails to
+     * reject the null hypothesis.
+     */
     oneTailed(alpha: number): StatisticalTestResultType{
         if (!this.onlyTwoTailed){
             if (this.pValue < alpha){
@@ -20,6 +33,19 @@ export class StatisticalTestResult {
         }
     }
 
+    /**
+     * Returns reject or failed to reject, depending on the alpha level and p value of the statistical test that checks
+     * one tailed null hypothesis such as mu1 < mu2 or two tailed null hypothesis such as mu1 = mu2. If the null
+     * hypothesis is two tailed, and p value is less than the alpha level, the test rejects the null hypothesis.
+     * Otherwise, it fails to reject the null hypothesis. If the null  hypothesis is one tailed, and p value is less
+     * than alpha / 2 or p value is larger than 1 - alpha / 2, the test  rejects the null  hypothesis. Otherwise, it
+     * fails to reject the null hypothesis.
+     * @param alpha Alpha level of the test
+     * @return If the null  hypothesis is two tailed, and p value is less than the alpha level, the test rejects the
+     * null hypothesis.  Otherwise, it fails to reject the null hypothesis. If the null  hypothesis is one tailed, and
+     * p value is less  than alpha / 2 or p value is larger than 1 - alpha / 2, the test  rejects the null  hypothesis.
+     * Otherwise, it  fails to reject the null hypothesis.
+     */
     twoTailed(alpha: number): StatisticalTestResultType{
         if (this.onlyTwoTailed){
             if (this.pValue < alpha){
@@ -36,6 +62,10 @@ export class StatisticalTestResult {
         }
     }
 
+    /**
+     * Accessor for the p value of the statistical test result.
+     * @return p value of the statistical test result
+     */
     getPValue(): number{
         return this.pValue
     }

package/source/index.ts

@@ -0,0 +1,88 @@
+export * from "./Attribute/Attribute"
+export * from "./Attribute/AttributeType"
+export * from "./Attribute/BinaryAttribute"
+export * from "./Attribute/ContinuousAttribute"
+export * from "./Attribute/DiscreteAttribute"
+export * from "./Attribute/DiscreteIndexedAttribute"
+export * from "./DataSet/DataDefinition"
+export * from "./DataSet/DataSet"
+export * from "./DistanceMetric/DistanceMetric"
+export * from "./DistanceMetric/EuclidianDistance"
+export * from "./DistanceMetric/MahalanobisDistance"
+export * from "./Experiment/BootstrapRun"
+export * from "./Experiment/Experiment"
+export * from "./Experiment/KFoldRun"
+export * from "./Experiment/KFoldRunSeparateTest"
+export * from "./Experiment/MultipleRun"
+export * from "./Experiment/MxKFoldRun"
+export * from "./Experiment/MxKFoldRunSeparateTest"
+export * from "./Experiment/SingleRun"
+export * from "./Experiment/SingleRunWithK"
+export * from "./Experiment/StratifiedKFoldRun"
+export * from "./Experiment/StratifiedKFoldRunSeparateTest"
+export * from "./Experiment/StratifiedMxKFoldRun"
+export * from "./Experiment/StratifiedMxKFoldRunSeparateTest"
+export * from "./Experiment/StratifiedSingleRunWithK"
+export * from "./FeatureSelection/BackwardSelection"
+export * from "./FeatureSelection/FeatureSubSet"
+export * from "./FeatureSelection/FloatingSelection"
+export * from "./FeatureSelection/ForwardSelection"
+export * from "./FeatureSelection/SubSetSelection"
+export * from "./Filter/DiscreteToContinuous"
+export * from "./Filter/DiscreteToIndexed"
+export * from "./Filter/FeatureFilter"
+export * from "./Filter/LaryFilter"
+export * from "./Filter/LaryToBinary"
+export * from "./Filter/Normalize"
+export * from "./Filter/Pca"
+export * from "./Filter/TrainedFeatureFilter"
+export * from "./Instance/CompositeInstance"
+export * from "./Instance/Instance"
+export * from "./InstanceList/InstanceList"
+export * from "./InstanceList/InstanceListOfSameClass"
+export * from "./InstanceList/Partition"
+export * from "./Model/DecisionTree/DecisionCondition"
+export * from "./Model/DecisionTree/DecisionNode"
+export * from "./Model/DecisionTree/DecisionTree"
+export * from "./Model/DecisionTree/DecisionStump"
+export * from "./Model/Ensemble/BaggingModel"
+export * from "./Model/NeuralNetwork/DeepNetworkModel"
+export * from "./Model/DummyModel"
+export * from "./Model/Parametric/GaussianModel"
+export * from "./Model/Parametric/KMeansModel"
+export * from "./Model/Parametric/LdaModel"
+export * from "./Model/Parametric/QdaModel"
+export * from "./Model/Parametric/NaiveBayesModel"
+export * from "./Model/NonParametric/KnnInstance"
+export * from "./Model/NonParametric/KnnModel"
+export * from "./Model/NeuralNetwork/LinearPerceptronModel"
+export * from "./Model/Model"
+export * from "./Model/NeuralNetwork/MultiLayerPerceptronModel"
+export * from "./Model/NeuralNetwork/NeuralNetworkModel"
+export * from "./Model/RandomModel"
+export * from "./Model/Ensemble/RandomForestModel"
+export * from "./Model/Ensemble/TreeEnsembleModel"
+export * from "./Model/ValidatedModel"
+export * from "./Parameter/ActivationFunction"
+export * from "./Parameter/BaggingParameter"
+export * from "./Parameter/C45Parameter"
+export * from "./Parameter/DeepNetworkParameter"
+export * from "./Parameter/KMeansParameter"
+export * from "./Parameter/KnnParameter"
+export * from "./Parameter/LinearPerceptronParameter"
+export * from "./Parameter/MultiLayerPerceptronParameter"
+export * from "./Parameter/Parameter"
+export * from "./Parameter/RandomForestParameter"
+export * from "./Performance/ClassificationPerformance"
+export * from "./Performance/ConfusionMatrix"
+export * from "./Performance/DetailedClassificationPerformance"
+export * from "./Performance/ExperimentPerformance"
+export * from "./Performance/Performance"
+export * from "./StatisticalTest/Combined5x2F"
+export * from "./StatisticalTest/Combined5x2t"
+export * from "./StatisticalTest/Paired5x2t"
+export * from "./StatisticalTest/Pairedt"
+export * from "./StatisticalTest/PairedTest"
+export * from "./StatisticalTest/Sign"
+export * from "./StatisticalTest/StatisticalTestResult"
+export * from "./StatisticalTest/StatisticalTestResultType"

package/tests/Classifier/C45Test.ts

@@ -1,13 +1,13 @@
 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";
+import {DecisionTree} from "../../dist/Model/DecisionTree/DecisionTree";
 
 describe('C45Test', function() {
     describe('C45Test', function() {
-        let c45 = new C45()
+        let c45 = new DecisionTree()
         let c45Parameter = new C45Parameter(1, true, 0.2)
         let attributeTypes = new Array<AttributeType>();
         for (let i = 0; i < 4; i++){

package/tests/Classifier/DeepNetworkTest.ts

@@ -2,15 +2,13 @@ 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";
+import {DeepNetworkModel} from "../../dist/Model/NeuralNetwork/DeepNetworkModel";
 
 describe('DeepNetworkTest', function() {
     describe('DeepNetworkTest', function() {
-        let deepNetwork = new DeepNetwork()
+        let deepNetwork = new DeepNetworkModel()
         let attributeTypes = new Array<AttributeType>();
         for (let i = 0; i < 4; i++){
             attributeTypes.push(AttributeType.CONTINUOUS)
@@ -38,7 +36,7 @@ describe('DeepNetworkTest', function() {
             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);
+            assert.ok(Math.abs(1.37 -  100 * deepNetwork.test(dermatology.getInstanceList()).getErrorRate()) <= 0.01);
         });
         it('testLoad', function() {
             deepNetwork.loadModel("models/deepNetwork-iris.txt");

package/tests/Classifier/DummyTest.ts

@@ -2,11 +2,11 @@ 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";
+import {DummyModel} from "../../dist/Model/DummyModel";
 
 describe('DummyTest', function() {
     describe('DummyTest', function() {
-        let dummy = new Dummy()
+        let dummy = new DummyModel()
         let attributeTypes = new Array<AttributeType>();
         for (let i = 0; i < 4; i++){
             attributeTypes.push(AttributeType.CONTINUOUS)

package/tests/Classifier/KMeansTest.ts

@@ -2,12 +2,12 @@ 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";
+import {KMeansModel} from "../../dist/Model/Parametric/KMeansModel";
 
 describe('KMeansTest', function() {
     describe('KMeansTest', function() {
-        let kMeans = new KMeans()
+        let kMeans = new KMeansModel()
         let kMeansParameter = new KMeansParameter(1)
         let attributeTypes = new Array<AttributeType>();
         for (let i = 0; i < 4; i++){