nlptoolkit-classification 1.0.0

package/source/Experiment/MultipleRun.ts

@@ -0,0 +1,7 @@
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+
+export interface MultipleRun {
+
+    execute(experiment: Experiment): ExperimentPerformance
+}

package/source/Experiment/MxKFoldRun.ts

@@ -0,0 +1,37 @@
+import {KFoldRun} from "./KFoldRun";
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+
+export class MxKFoldRun extends KFoldRun{
+
+    protected M: number
+
+    /**
+     * Constructor for MxKFoldRun class. Basically sets K parameter of the K-fold cross-validation and M for the number of times.
+     *
+     * @param M number of cross-validation times.
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(M: number, K: number) {
+        super(K);
+        this.M = M
+    }
+
+    /**
+     * Execute the MxKFold run with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        for (let j = 0; j < this.M; j++) {
+            let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K, experiment.getParameter().getSeed());
+            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        }
+        return result;
+    }
+
+}

package/source/Experiment/MxKFoldRunSeparateTest.ts

@@ -0,0 +1,40 @@
+import {KFoldRunSeparateTest} from "./KFoldRunSeparateTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {Experiment} from "./Experiment";
+import {Partition} from "../InstanceList/Partition";
+import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+
+export class MxKFoldRunSeparateTest extends KFoldRunSeparateTest{
+
+    protected M: number
+
+    /**
+     * Constructor for KFoldRunSeparateTest class. Basically sets K parameter of the K-fold cross-validation and M for
+     * the number of times.
+     *
+     * @param M number of cross-validation times.
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(M: number, K: number) {
+        super(K);
+        this.M = M
+    }
+
+    /**
+     * Execute the MxKFold run with separate test set with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        let instanceList = experiment.getDataSet().getInstanceList();
+        let partition = new Partition(instanceList, 0.25, true);
+        for (let j = 0; j < this.M; j++) {
+            let crossValidation = new KFoldCrossValidation<Instance>(partition.get(1).getInstances(), this.K, experiment.getParameter().getSeed());
+            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        }
+        return result;
+    }
+}

package/source/Experiment/SingleRun.ts

@@ -0,0 +1,7 @@
+import {Performance} from "../Performance/Performance";
+import {Experiment} from "./Experiment";
+
+export interface SingleRun {
+
+    execute(experiment: Experiment): Performance
+}

package/source/Experiment/SingleRunWithK.ts

@@ -0,0 +1,39 @@
+import {SingleRun} from "./SingleRun";
+import {Experiment} from "./Experiment";
+import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+import {Performance} from "../Performance/Performance";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Classifier} from "../Classifier/Classifier";
+import {Parameter} from "../Parameter/Parameter";
+import {CrossValidation} from "nlptoolkit-sampling/dist/CrossValidation";
+
+export class SingleRunWithK implements SingleRun{
+
+    private K: number
+
+    constructor(K: number) {
+        this.K = K
+    }
+
+    runExperiment(classifier: Classifier,
+                  parameter: Parameter,
+                  crossValidation: CrossValidation<Instance>){
+        let trainSet = new InstanceList(crossValidation.getTrainFold(0));
+        let testSet = new InstanceList(crossValidation.getTestFold(0));
+        return classifier.singleRun(parameter, trainSet, testSet);
+    }
+
+    /**
+     * Execute Single K-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return A Performance instance
+     */
+    execute(experiment: Experiment): Performance {
+        let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K,
+            experiment.getParameter().getSeed());
+        return this.runExperiment(experiment.getClassifier(), experiment.getParameter(), crossValidation);
+    }
+
+}

package/source/Experiment/StratifiedKFoldRun.ts

@@ -0,0 +1,30 @@
+import {KFoldRun} from "./KFoldRun";
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StratifiedKFoldCrossValidation} from "nlptoolkit-sampling/dist/StratifiedKFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+
+export class StratifiedKFoldRun extends KFoldRun{
+
+    /**
+     * Constructor for KFoldRun class. Basically sets K parameter of the K-fold cross-validation.
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(K: number) {
+        super(K);
+    }
+
+    /**
+     * Execute Stratified K-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(), this.K, experiment.getParameter().getSeed());
+        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        return result;
+    }
+
+}

package/source/Experiment/StratifiedKFoldRunSeparateTest.ts

@@ -0,0 +1,33 @@
+import {KFoldRunSeparateTest} from "./KFoldRunSeparateTest";
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {Partition} from "../InstanceList/Partition";
+import {StratifiedKFoldCrossValidation} from "nlptoolkit-sampling/dist/StratifiedKFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+
+export class StratifiedKFoldRunSeparateTest extends KFoldRunSeparateTest{
+
+    /**
+     * Constructor for StratifiedKFoldRunSeparateTest class. Basically sets K parameter of the K-fold cross-validation.
+     *
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(K: number) {
+        super(K);
+    }
+
+    /**
+     * Execute Stratified K-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        let instanceList = experiment.getDataSet().getInstanceList();
+        let partition = new Partition(instanceList, 0.25, true);
+        let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(), this.K, experiment.getParameter().getSeed());
+        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        return result;
+    }
+}

package/source/Experiment/StratifiedMxKFoldRun.ts

@@ -0,0 +1,34 @@
+import {MxKFoldRun} from "./MxKFoldRun";
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StratifiedKFoldCrossValidation} from "nlptoolkit-sampling/dist/StratifiedKFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+
+export class StratifiedMxKFoldRun extends MxKFoldRun{
+
+    /**
+     * Constructor for StratifiedMxKFoldRun class. Basically sets K parameter of the K-fold cross-validation and M for the number of times.
+     *
+     * @param M number of cross-validation times.
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(M: number, K: number) {
+        super(M, K);
+    }
+
+    /**
+     * Execute the Stratified MxK-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        for (let j = 0; j < this.M; j++) {
+            let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(),
+                this.K, experiment.getParameter().getSeed());
+            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        }
+        return result;
+    }
+}

package/source/Experiment/StratifiedMxKFoldRunSeparateTest.ts

@@ -0,0 +1,40 @@
+import {StratifiedKFoldRunSeparateTest} from "./StratifiedKFoldRunSeparateTest";
+import {Experiment} from "./Experiment";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {Partition} from "../InstanceList/Partition";
+import {Instance} from "../Instance/Instance";
+import {StratifiedKFoldCrossValidation} from "nlptoolkit-sampling/dist/StratifiedKFoldCrossValidation";
+
+export class StratifiedMxKFoldRunSeparateTest extends StratifiedKFoldRunSeparateTest{
+
+    protected M: number
+
+    /**
+     * Constructor for StratifiedMxKFoldRunSeparateTest class. Basically sets K parameter of the K-fold cross-validation and M for the number of times.
+     *
+     * @param M number of cross-validation times.
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(M: number, K: number) {
+        super(K);
+        this.M = M
+    }
+
+    /**
+     * Execute the Stratified MxK-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return An ExperimentPerformance instance.
+     */
+    execute(experiment: Experiment): ExperimentPerformance {
+        let result = new ExperimentPerformance();
+        for (let j = 0; j < this.M; j++) {
+            let instanceList = experiment.getDataSet().getInstanceList();
+            let partition = new Partition(instanceList, 0.25, true);
+            let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(),
+                this.K, experiment.getParameter().getSeed());
+            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        }
+        return result;
+    }
+}

package/source/Experiment/StratifiedSingleRunWithK.ts

@@ -0,0 +1,33 @@
+import {Experiment} from "./Experiment";
+import {Performance} from "../Performance/Performance";
+import {StratifiedKFoldCrossValidation} from "nlptoolkit-sampling/dist/StratifiedKFoldCrossValidation";
+import {Instance} from "../Instance/Instance";
+import {InstanceList} from "../InstanceList/InstanceList";
+
+export class StratifiedSingleRunWithK {
+
+    private readonly K: number
+
+    /**
+     * Constructor for StratifiedSingleRunWithK class. Basically sets K parameter of the K-fold cross-validation.
+     *
+     * @param K K of the K-fold cross-validation.
+     */
+    constructor(K: number) {
+        this.K = K
+    }
+
+    /**
+     * Execute Stratified Single K-fold cross-validation with the given classifier on the given data set using the given parameters.
+     *
+     * @param experiment Experiment to be run.
+     * @return A Performance instance.
+     */
+    execute(experiment: Experiment): Performance{
+        let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(),
+            this.K, experiment.getParameter().getSeed());
+        let trainSet = new InstanceList(crossValidation.getTrainFold(0));
+        let testSet = new InstanceList(crossValidation.getTestFold(0));
+        return experiment.getClassifier().singleRun(experiment.getParameter(), trainSet, testSet);
+    }
+}

package/source/FeatureSelection/BackwardSelection.ts

@@ -0,0 +1,28 @@
+import {SubSetSelection} from "./SubSetSelection";
+import {FeatureSubSet} from "./FeatureSubSet";
+
+export class BackwardSelection extends SubSetSelection{
+
+    /**
+     * Constructor that creates a new {@link FeatureSubSet} and initializes indexList with given number of features.
+     *
+     * @param numberOfFeatures Indicates the indices of indexList.
+     */
+    constructor(numberOfFeatures: number) {
+        super(new FeatureSubSet(numberOfFeatures));
+    }
+
+    /**
+     * The operator method calls backward method which starts with all the features and removes the least significant feature at each iteration.
+     *
+     * @param current          FeatureSubset that will be added to new ArrayList.
+     * @param numberOfFeatures Indicates the indices of indexList.
+     * @return ArrayList of FeatureSubSets created from backward.
+     */
+    protected operator(current: FeatureSubSet, numberOfFeatures: number): Array<FeatureSubSet> {
+        let result = new Array<FeatureSubSet>();
+        this.backward(result, current);
+        return result;
+    }
+    
+}

package/source/FeatureSelection/FeatureSubSet.ts

@@ -0,0 +1,82 @@
+export class FeatureSubSet {
+
+    private readonly indexList: Array<number> = new Array<number>()
+
+    /**
+     * A constructor that takes number of features as input and initializes indexList with these numbers.
+     *
+     * @param numberOfFeaturesOrList Indicates the indices of indexList.
+     */
+    constructor(numberOfFeaturesOrList?: any) {
+        if (numberOfFeaturesOrList != undefined){
+            if (typeof numberOfFeaturesOrList == "number"){
+                for (let i = 0; i < numberOfFeaturesOrList; i++) {
+                    this.indexList.push(i);
+                }
+            } else {
+                this.indexList = numberOfFeaturesOrList
+            }
+        }
+    }
+
+    /**
+     * The clone method creates a new ArrayList with the elements of indexList and returns it as a new FeatureSubSet.
+     *
+     * @return A new ArrayList with the elements of indexList and returns it as a new FeatureSubSet.
+     */
+    clone(): FeatureSubSet{
+        let result = new FeatureSubSet(this.indexList.length)
+        for (let i = 0; i < this.indexList.length; i++){
+            result.add(this.indexList[i])
+        }
+        return result
+    }
+
+    /**
+     * The size method returns the size of the indexList.
+     *
+     * @return The size of the indexList.
+     */
+    size(): number{
+        return this.indexList.length
+    }
+
+    /**
+     * The get method returns the item of indexList at given index.
+     *
+     * @param index Index of the indexList to be accessed.
+     * @return The item of indexList at given index.
+     */
+    get(index: number): number{
+        return this.indexList[index]
+    }
+
+    /**
+     * The contains method returns True, if indexList contains given input number and False otherwise.
+     *
+     * @param featureNo Feature number that will be checked.
+     * @return True, if indexList contains given input number.
+     */
+    contains(featureNo: number){
+        return this.indexList.includes(featureNo)
+    }
+
+    /**
+     * The add method adds given Integer to the indexList.
+     *
+     * @param featureNo Integer that will be added to indexList.
+     */
+    add(featureNo: number){
+        this.indexList.push(featureNo)
+    }
+
+    /**
+     * The remove method removes the item of indexList at the given index.
+     *
+     * @param index Index of the item that will be removed.
+     */
+    remove(index: number){
+        this.indexList.splice(index, 1)
+    }
+
+}

package/source/FeatureSelection/FloatingSelection.ts

@@ -0,0 +1,27 @@
+import {SubSetSelection} from "./SubSetSelection";
+import {FeatureSubSet} from "./FeatureSubSet";
+
+export class FloatingSelection extends SubSetSelection{
+
+    /**
+     * Constructor that creates a new {@link FeatureSubSet}.
+     */
+    constructor() {
+        super(new FeatureSubSet());
+    }
+
+    /**
+     * The operator method calls forward and backward methods.
+     *
+     * @param current          {@link FeatureSubSet} input.
+     * @param numberOfFeatures Indicates the indices of indexList.
+     * @return ArrayList of FeatureSubSet.
+     */
+    protected operator(current: FeatureSubSet, numberOfFeatures: number): Array<FeatureSubSet> {
+        let result = new Array<FeatureSubSet>();
+        this.forward(result, current, numberOfFeatures);
+        this.backward(result, current);
+        return result;
+    }
+
+}

package/source/FeatureSelection/ForwardSelection.ts

@@ -0,0 +1,27 @@
+import {SubSetSelection} from "./SubSetSelection";
+import {FeatureSubSet} from "./FeatureSubSet";
+
+export class ForwardSelection extends SubSetSelection{
+
+    /**
+     * Constructor that creates a new {@link FeatureSubSet}.
+     */
+    constructor() {
+        super(new FeatureSubSet());
+    }
+
+    /**
+     * The operator method calls forward method which starts with having no feature in the model. In each iteration,
+     * it keeps adding the features that are not currently listed.
+     *
+     * @param current          FeatureSubset that will be added to new ArrayList.
+     * @param numberOfFeatures Indicates the indices of indexList.
+     * @return ArrayList of FeatureSubSets created from forward.
+     */
+    protected operator(current: FeatureSubSet, numberOfFeatures: number): Array<FeatureSubSet> {
+        let result = new Array<FeatureSubSet>();
+        this.forward(result, current, numberOfFeatures);
+        return result;
+    }
+
+}

package/source/FeatureSelection/SubSetSelection.ts

@@ -0,0 +1,88 @@
+import {FeatureSubSet} from "./FeatureSubSet";
+import {MultipleRun} from "../Experiment/MultipleRun";
+import {Experiment} from "../Experiment/Experiment";
+
+export abstract class SubSetSelection {
+
+    protected initialSubSet: FeatureSubSet
+
+    protected abstract operator(current: FeatureSubSet, numberOfFeatures: number): Array<FeatureSubSet>
+
+    /**
+     * A constructor that sets the initial subset with given input.
+     *
+     * @param initialSubSet {@link FeatureSubSet} input.
+     */
+    protected constructor(initialSubSet: FeatureSubSet) {
+        this.initialSubSet = initialSubSet
+    }
+
+    /**
+     * The forward method starts with having no feature in the model. In each iteration, it keeps adding the features that are not currently listed.
+     *
+     * @param currentSubSetList ArrayList to add the FeatureSubsets.
+     * @param current           FeatureSubset that will be added to currentSubSetList.
+     * @param numberOfFeatures  The number of features to add the subset.
+     */
+    protected forward(currentSubSetList: Array<FeatureSubSet>, current: FeatureSubSet, numberOfFeatures: number){
+        for (let i = 0; i < numberOfFeatures; i++) {
+            if (!current.contains(i)) {
+                let candidate = current.clone();
+                candidate.add(i);
+                currentSubSetList.push(candidate);
+            }
+        }
+    }
+
+    /**
+     * The backward method starts with all the features and removes the least significant feature at each iteration.
+     *
+     * @param currentSubSetList ArrayList to add the FeatureSubsets.
+     * @param current           FeatureSubset that will be added to currentSubSetList
+     */
+    protected backward(currentSubSetList: Array<FeatureSubSet>, current: FeatureSubSet){
+        for (let i = 0; i < current.size(); i++) {
+            let candidate = current.clone();
+            candidate.remove(i);
+            currentSubSetList.push(candidate);
+        }
+    }
+
+    /**
+     * The execute method takes an {@link Experiment} and a {@link MultipleRun} as inputs. By selecting a candidateList from given
+     * Experiment it tries to find a FeatureSubSet that gives best performance.
+     *
+     * @param multipleRun {@link MultipleRun} type input.
+     * @param experiment  {@link Experiment} type input.
+     * @return FeatureSubSet that gives best performance.
+     */
+    execute(multipleRun: MultipleRun, experiment: Experiment): FeatureSubSet{
+        let processed = new Set<FeatureSubSet>();
+        let best = this.initialSubSet;
+        processed.add(best);
+        let betterFound = true;
+        let bestPerformance = undefined, currentPerformance;
+        if (best.size() > 0){
+            bestPerformance = multipleRun.execute(experiment.featureSelectedExperiment(best));
+        }
+        while (betterFound) {
+            betterFound = false;
+            let candidateList = this.operator(best, experiment.getDataSet().getDataDefinition().attributeCount());
+            for (let candidateSubSet of candidateList) {
+                if (!processed.has(candidateSubSet)) {
+                    if (candidateSubSet.size() > 0){
+                        currentPerformance = multipleRun.execute(experiment.featureSelectedExperiment(candidateSubSet));
+                        if (bestPerformance == null || currentPerformance.isBetter(bestPerformance)) {
+                            best = candidateSubSet;
+                            bestPerformance = currentPerformance;
+                            betterFound = true;
+                        }
+                    }
+                    processed.add(candidateSubSet);
+                }
+            }
+        }
+        return best;
+    }
+
+}

package/source/Filter/DiscreteToContinuous.ts

@@ -0,0 +1,59 @@
+import {LaryFilter} from "./LaryFilter";
+import {Instance} from "../Instance/Instance";
+import {DataSet} from "../DataSet/DataSet";
+import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
+import {AttributeType} from "../Attribute/AttributeType";
+
+export class DiscreteToContinuous extends LaryFilter{
+
+    /**
+     * Converts the data definition with discrete attributes, to data definition with continuous attributes. Basically,
+     * for each discrete attribute with L possible values, L more continuous attributes will be added.
+     */
+    convertDataDefinition(): void {
+        let dataDefinition = this.dataSet.getDataDefinition();
+        let size = dataDefinition.attributeCount();
+        for (let i = 0; i < size; i++) {
+            if (this.attributeDistributions[i].size > 0) {
+                for (let j = 0; j < this.attributeDistributions[i].size; j++) {
+                    dataDefinition.addAttribute(AttributeType.CONTINUOUS);
+                }
+            }
+        }
+        this.removeDiscreteAttributesFromDataDefinition(size);
+    }
+
+    /**
+     * Converts discrete attributes of a single instance to continuous version using 1-of-L encoding. For example, if
+     * an attribute has values red, green, blue; this attribute will be converted to 3 continuous attributes where
+     * red will have the value 100, green will have the value 010, and blue will have the value 001.
+     *
+     * @param instance The instance to be converted.
+     */
+    convertInstance(instance: Instance): void {
+        let size = instance.attributeSize();
+        for (let i = 0; i < size; i++) {
+            if (this.attributeDistributions[i].size > 0) {
+                let index = this.attributeDistributions[i].getIndex(instance.getAttribute(i).toString());
+                for (let j = 0; j < this.attributeDistributions[i].size; j++) {
+                    if (j != index) {
+                        instance.addAttribute(new ContinuousAttribute(0));
+                    } else {
+                        instance.addAttribute(new ContinuousAttribute(1));
+                    }
+                }
+            }
+        }
+        this.removeDiscreteAttributesFromInstance(instance, size);
+    }
+
+    /**
+     * Constructor for discrete to continuous filter.
+     *
+     * @param dataSet The dataSet whose instances whose discrete attributes will be converted to continuous attributes using
+     *                1-of-L encoding.
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+    }
+}