nlptoolkit-classification 1.0.0

package/source/Filter/DiscreteToIndexed.ts

@@ -0,0 +1,48 @@
+import {LaryFilter} from "./LaryFilter";
+import {Instance} from "../Instance/Instance";
+import {DataSet} from "../DataSet/DataSet";
+import {DiscreteIndexedAttribute} from "../Attribute/DiscreteIndexedAttribute";
+import {AttributeType} from "../Attribute/AttributeType";
+
+export class DiscreteToIndexed extends LaryFilter{
+
+    /**
+     * Converts the data definition with discrete attributes, to data definition with DISCRETE_INDEXED attributes.
+     */
+    convertDataDefinition(): void {
+        let dataDefinition = this.dataSet.getDataDefinition();
+        let size = dataDefinition.attributeCount();
+        for (let i = 0; i < size; i++) {
+            if (this.attributeDistributions[i].size > 0) {
+                dataDefinition.addAttribute(AttributeType.DISCRETE_INDEXED);
+            }
+        }
+        this.removeDiscreteAttributesFromDataDefinition(size);
+    }
+
+    /**
+     * Converts discrete attributes of a single instance to indexed version.
+     *
+     * @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());
+                instance.addAttribute(new DiscreteIndexedAttribute(instance.getAttribute(i).toString(), index,
+                    this.attributeDistributions[i].size));
+            }
+        }
+        this.removeDiscreteAttributesFromInstance(instance, size);
+    }
+
+    /**
+     * Constructor for discrete to indexed filter.
+     *
+     * @param dataSet The dataSet whose instances whose discrete attributes will be converted to indexed attributes
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+    }
+}

package/source/Filter/FeatureFilter.ts

@@ -0,0 +1,31 @@
+import {DataSet} from "../DataSet/DataSet";
+import {Instance} from "../Instance/Instance";
+
+export abstract class FeatureFilter {
+
+    protected dataSet: DataSet
+
+    abstract convertInstance(instance: Instance): void
+    abstract convertDataDefinition(): void
+
+    /**
+     * Constructor that sets the dataSet.
+     *
+     * @param dataSet DataSet that will bu used.
+     */
+    constructor(dataSet: DataSet) {
+        this.dataSet = dataSet
+    }
+
+    /**
+     * Feature converter for a list of instances. Using the abstract method convertInstance, each instance in the
+     * instance list will be converted.
+     */
+    convert(){
+        let instances = this.dataSet.getInstances();
+        for (let instance of instances) {
+            this.convertInstance(instance);
+        }
+        this.convertDataDefinition();
+    }
+}

package/source/Filter/LaryFilter.ts

@@ -0,0 +1,54 @@
+import {FeatureFilter} from "./FeatureFilter";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {DataSet} from "../DataSet/DataSet";
+import {Instance} from "../Instance/Instance";
+
+export abstract class LaryFilter extends FeatureFilter{
+
+    protected attributeDistributions: Array<DiscreteDistribution>
+
+    /**
+     * Constructor that sets the dataSet and all the attributes distributions.
+     *
+     * @param dataSet DataSet that will bu used.
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+        this.attributeDistributions = dataSet.getInstanceList().allAttributesDistribution()
+    }
+
+    /**
+     * The removeDiscreteAttributes method takes an {@link Instance} as an input, and removes the discrete attributes from
+     * given instance.
+     *
+     * @param instance Instance to removes attributes from.
+     * @param size     Size of the given instance.
+     */
+    protected removeDiscreteAttributesFromInstance(instance: Instance, size: number){
+        let k = 0;
+        for (let i = 0; i < size; i++) {
+            if (this.attributeDistributions[i].size > 0) {
+                instance.removeAttribute(k);
+            } else {
+                k++;
+            }
+        }
+    }
+
+    /**
+     * The removeDiscreteAttributes method removes the discrete attributes from dataDefinition.
+     *
+     * @param size Size of item that attributes will be removed.
+     */
+    protected removeDiscreteAttributesFromDataDefinition(size: number){
+        let dataDefinition = this.dataSet.getDataDefinition();
+        let k = 0;
+        for (let i = 0; i < size; i++) {
+            if (this.attributeDistributions[i].size > 0) {
+                dataDefinition.removeAttribute(k);
+            } else {
+                k++;
+            }
+        }
+    }
+}

package/source/Filter/LaryToBinary.ts

@@ -0,0 +1,57 @@
+import {LaryFilter} from "./LaryFilter";
+import {Instance} from "../Instance/Instance";
+import {DataSet} from "../DataSet/DataSet";
+import {BinaryAttribute} from "../Attribute/BinaryAttribute";
+import {AttributeType} from "../Attribute/AttributeType";
+
+export class LaryToBinary extends LaryFilter{
+
+    /**
+     * Converts the data definition with L-ary discrete attributes, to data definition with binary discrete attributes.
+     */
+    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.BINARY);
+                }
+            }
+        }
+        this.removeDiscreteAttributesFromDataDefinition(size);
+    }
+
+    /**
+     * Converts discrete attributes of a single instance to binary discrete version using 1-of-L encoding. For example, if
+     * an attribute has values red, green, blue; this attribute will be converted to 3 binary attributes where
+     * red will have the value true false false, green will have the value false true false, and blue will have the value false false true.
+     *
+     * @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 BinaryAttribute(false));
+                    } else {
+                        instance.addAttribute(new BinaryAttribute(true));
+                    }
+                }
+            }
+        }
+        this.removeDiscreteAttributesFromInstance(instance, size);
+    }
+
+    /**
+     * Constructor for L-ary discrete to binary discrete filter.
+     *
+     * @param dataSet The instances whose L-ary discrete attributes will be converted to binary discrete attributes.
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+    }
+}

package/source/Filter/Normalize.ts

@@ -0,0 +1,42 @@
+import {FeatureFilter} from "./FeatureFilter";
+import {Instance} from "../Instance/Instance";
+import {DataSet} from "../DataSet/DataSet";
+import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
+
+export class Normalize extends FeatureFilter{
+
+    private averageInstance: Instance
+    private standardDeviationInstance: Instance
+
+    /**
+     * Constructor for normalize feature filter. It calculates and stores the mean (m) and standard deviation (s) of
+     * the sample.
+     *
+     * @param dataSet Instances whose continuous attribute values will be normalized.
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+        this.averageInstance = dataSet.getInstanceList().average();
+        this.standardDeviationInstance = dataSet.getInstanceList().standardDeviation();
+    }
+
+    convertDataDefinition(): void {
+    }
+
+    /**
+     * Normalizes the continuous attributes of a single instance. For all i, new x_i = (x_i - m_i) / s_i.
+     *
+     * @param instance Instance whose attributes will be normalized.
+     */
+    convertInstance(instance: Instance): void {
+        for (let i = 0; i < instance.attributeSize(); i++) {
+            if (instance.getAttribute(i) instanceof ContinuousAttribute) {
+                let xi = <ContinuousAttribute> instance.getAttribute(i);
+                let mi = <ContinuousAttribute> this.averageInstance.getAttribute(i);
+                let si = <ContinuousAttribute> this.standardDeviationInstance.getAttribute(i);
+                xi.setValue((xi.getValue() - mi.getValue()) / si.getValue());
+            }
+        }
+    }
+
+}

package/source/Filter/Pca.ts

@@ -0,0 +1,104 @@
+import {TrainedFeatureFilter} from "./TrainedFeatureFilter";
+import {Eigenvector} from "nlptoolkit-math/dist/Eigenvector";
+import {Instance} from "../Instance/Instance";
+import {DataSet} from "../DataSet/DataSet";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {AttributeType} from "../Attribute/AttributeType";
+
+export class Pca extends TrainedFeatureFilter{
+
+    private readonly covarianceExplained: number = 0.99
+    private eigenvectors: Array<Eigenvector> = new Array<Eigenvector>()
+    private readonly numberOfDimensions : number = -1
+
+    /**
+     * The convertDataDefinition method gets the data definitions of the dataSet and removes all the attributes. Then adds
+     * new attributes as CONTINUOUS.
+     */
+    convertDataDefinition(): void {
+        let dataDefinition = this.dataSet.getDataDefinition();
+        dataDefinition.removeAllAttributes();
+        for (let i = 0; i < this.eigenvectors.length; i++) {
+            dataDefinition.addAttribute(AttributeType.CONTINUOUS);
+        }
+    }
+
+    /**
+     * The convertInstance method takes an {@link Instance} as an input and creates a {@link Vector} attributes from continuousAttributes.
+     * After removing all attributes of given instance, it then adds new {@link ContinuousAttribute} by using the dot
+     * product of attribute Vector and the eigenvectors.
+     *
+     * @param instance Instance that will be converted to {@link ContinuousAttribute} by using eigenvectors.
+     */
+    convertInstance(instance: Instance): void {
+        let attributes : Vector = new Vector(instance.continuousAttributes());
+        instance.removeAllAttributes();
+        for (let eigenvector of this.eigenvectors) {
+            instance.addAttribute(new ContinuousAttribute(attributes.dotProduct(eigenvector)));
+        }
+    }
+
+    /**
+     * The train method creates an averageVector from continuousAttributeAverage and a covariance {@link Matrix} from that averageVector.
+     * Then finds the eigenvectors of that covariance matrix and removes its unnecessary eigenvectors.
+     */
+    protected train(): void {
+        let averageVector : Vector = new Vector(this.dataSet.getInstanceList().continuousAttributeAverage());
+        let covariance : Matrix = this.dataSet.getInstanceList().covariance(averageVector);
+        this.eigenvectors = covariance.characteristics();
+        if (this.numberOfDimensions != -1) {
+            this.removeAllEigenvectorsExceptTheMostImportantK();
+        } else {
+            this.removeUnnecessaryEigenvectors();
+        }
+    }
+
+    /**
+     * Constructor that sets the dataSet and dimension. Then calls train method.
+     *
+     * @param dataSet            DataSet that will be used.
+     * @param numberOfDimensionsOrCovarianceExplained Dimension number.
+     */
+    constructor(dataSet: DataSet, numberOfDimensionsOrCovarianceExplained?: number) {
+        super(dataSet);
+        if (numberOfDimensionsOrCovarianceExplained != undefined){
+            if (Number.isInteger(numberOfDimensionsOrCovarianceExplained)){
+                this.numberOfDimensions = numberOfDimensionsOrCovarianceExplained
+            } else {
+                this.covarianceExplained = numberOfDimensionsOrCovarianceExplained
+            }
+        }
+        this.train()
+    }
+
+    /**
+     * The removeUnnecessaryEigenvectors methods takes an ArrayList of Eigenvectors. It first calculates the summation
+     * of eigenValues. Then it finds the eigenvectors which have lesser summation than covarianceExplained and removes these
+     * eigenvectors.
+     */
+    private removeUnnecessaryEigenvectors(){
+        let sum = 0.0, currentSum = 0.0;
+        for (let eigenvector of this.eigenvectors) {
+            sum += eigenvector.getEigenValue();
+        }
+        for (let i = 0; i < this.eigenvectors.length; i++) {
+            if (currentSum / sum < this.covarianceExplained) {
+                currentSum += this.eigenvectors[i].getEigenValue();
+            } else {
+                this.eigenvectors.splice(i, 1);
+                i--;
+            }
+        }
+    }
+
+    /**
+     * The removeAllEigenvectorsExceptTheMostImportantK method takes an {@link Array} of {@link Eigenvector}s and removes the
+     * surplus eigenvectors when the number of eigenvectors is greater than the dimension.
+     */
+    private removeAllEigenvectorsExceptTheMostImportantK(){
+        this.eigenvectors.splice(this.numberOfDimensions, this.eigenvectors.length - this.numberOfDimensions)
+    }
+
+}

package/source/Filter/TrainedFeatureFilter.ts

@@ -0,0 +1,17 @@
+import {FeatureFilter} from "./FeatureFilter";
+import {DataSet} from "../DataSet/DataSet";
+
+export abstract class TrainedFeatureFilter extends FeatureFilter{
+
+    protected abstract train(): void;
+
+    /**
+     * Constructor that sets the dataSet.
+     *
+     * @param dataSet DataSet that will bu used.
+     */
+    constructor(dataSet: DataSet) {
+        super(dataSet);
+    }
+
+}

package/source/Instance/CompositeInstance.ts

@@ -0,0 +1,53 @@
+import {Instance} from "./Instance";
+import {Attribute} from "../Attribute/Attribute";
+
+export class CompositeInstance extends Instance{
+
+    private possibleClassLabels: Array<string> = new Array<string>()
+
+    /**
+     * Constructor of {@link CompositeInstance} class which takes a class label, attributes and an {@link ArrayList} of
+     * possible labels as inputs. It generates a new composite instance with given labels, attributes and possible labels.
+     *
+     * @param classLabel          Class label of the composite instance.
+     * @param attributes          Attributes of the composite instance.
+     * @param possibleClassLabels Possible labels of the composite instance.
+     */
+    constructor(classLabel: string, attributes?: Array<Attribute>, possibleClassLabels?: Array<string>) {
+        super(classLabel, attributes);
+        if (possibleClassLabels != undefined){
+            this.possibleClassLabels = possibleClassLabels
+        }
+    }
+
+    /**
+     * Accessor for the possible class labels.
+     *
+     * @return Possible class labels of the composite instance.
+     */
+    getPossibleClassLabels(): Array<string>{
+        return this.possibleClassLabels
+    }
+
+    /**
+     * Mutator method for possible class labels.
+     *
+     * @param possibleClassLabels Ner value of possible class labels.
+     */
+    setPossibleClassLabels(possibleClassLabels: Array<string>){
+        this.possibleClassLabels = possibleClassLabels
+    }
+
+    /**
+     * Converts composite instance to {@link String}.
+     *
+     * @return String representation of composite instance.
+     */
+    toString(): string{
+        let result = super.toString();
+        for (let possibleClassLabel of this.possibleClassLabels) {
+            result += ";" + possibleClassLabel;
+        }
+        return result.toString();
+    }
+}

package/source/Instance/Instance.ts

@@ -0,0 +1,170 @@
+import {Attribute} from "../Attribute/Attribute";
+import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
+import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {FeatureSubSet} from "../FeatureSelection/FeatureSubSet";
+
+export class Instance {
+
+    private readonly classLabel: string
+    private attributes: Array<Attribute> = new Array<Attribute>()
+
+    /**
+     * Constructor for a single instance. Given the attributes and class label, it generates a new instance.
+     *
+     * @param classLabel Class label of the instance.
+     * @param attributes Attributes of the instance.
+     */
+    constructor(classLabel: string, attributes?: Array<Attribute>) {
+        this.classLabel = classLabel
+        if (attributes != undefined){
+            this.attributes = attributes
+        }
+    }
+
+    /**
+     * Adds a new attribute.
+     *
+     * @param value Attribute to be added.
+     */
+    addAttribute(value: any){
+        if (value instanceof Attribute){
+            this.attributes.push(value)
+        } else {
+            if (!Number.isNaN(value)){
+                this.attributes.push(new ContinuousAttribute(value))
+            } else {
+                this.attributes.push(new DiscreteAttribute(value))
+            }
+        }
+    }
+
+    /**
+     * Adds a {@link Vector} of continuous attributes.
+     *
+     * @param vector {@link Vector} that has the continuous attributes.
+     */
+    addVectorAttribute(vector: Vector){
+        for (let i = 0; i < vector.size(); i++){
+            this.attributes.push(new ContinuousAttribute(vector.getValue(i)))
+        }
+    }
+
+    /**
+     * Removes attribute with the given index from the attributes list.
+     *
+     * @param index Index of the attribute to be removed.
+     */
+    removeAttribute(index: number){
+        this.attributes.splice(index, 1)
+    }
+
+    /**
+     * Removes all the attributes from the attributes list.
+     */
+    removeAllAttributes(){
+        this.attributes = new Array<Attribute>()
+    }
+
+    /**
+     * Accessor for a single attribute.
+     *
+     * @param index Index of the attribute to be accessed.
+     * @return Attribute with index 'index'.
+     */
+    getAttribute(index: number): Attribute{
+        return this.attributes[index]
+    }
+
+    /**
+     * Returns the number of attributes in the attributes list.
+     *
+     * @return Number of attributes in the attributes list.
+     */
+    attributeSize(): number{
+        return this.attributes.length
+    }
+
+    /**
+     * Returns the number of continuous and discrete indexed attributes in the attributes list.
+     *
+     * @return Number of continuous and discrete indexed attributes in the attributes list.
+     */
+    continuousAttributeSize(): number{
+        let size = 0;
+        for (let attribute of this.attributes) {
+            size += attribute.continuousAttributeSize();
+        }
+        return size;
+    }
+
+    /**
+     * The continuousAttributes method creates a new {@link Array} result and it adds the continuous attributes of the
+     * attributes list and also it adds 1 for the discrete indexed attributes
+     * .
+     *
+     * @return result {@link Array} that has continuous and discrete indexed attributes.
+     */
+    continuousAttributes(): Array<number>{
+        let result = new Array<number>();
+        for (let attribute of this.attributes) {
+            for (let continuousAttribute of attribute.continuousAttributes()){
+                result.push(continuousAttribute);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Accessor for the class label.
+     *
+     * @return Class label of the instance.
+     */
+    getClassLabel(): string{
+        return this.classLabel
+    }
+
+    /**
+     * Converts instance to a {@link String}.
+     *
+     * @return A string of attributes separated with comma character.
+     */
+    toString(): string{
+        let result = "";
+        for (let attribute of this.attributes) {
+            result = result + attribute.toString() + ",";
+        }
+        result = result + this.classLabel;
+        return result;
+    }
+
+    /**
+     * The getSubSetOfFeatures method takes a {@link FeatureSubSet} as an input. First it creates a result {@link Instance}
+     * with the class label, and adds the attributes of the given featureSubSet to it.
+     *
+     * @param featureSubSet {@link FeatureSubSet} an {@link Array} of indices.
+     * @return result Instance.
+     */
+    getSubSetOfFeatures(featureSubSet: FeatureSubSet): Instance{
+        let result = new Instance(this.classLabel);
+        for (let i = 0; i < featureSubSet.size(); i++) {
+            result.addAttribute(this.attributes[featureSubSet.get(i)]);
+        }
+        return result;
+    }
+
+    /**
+     * The toVector method returns a {@link Vector} of continuous attributes and discrete indexed attributes.
+     *
+     * @return {@link Vector} of continuous attributes and discrete indexed attributes.
+     */
+    toVector(): Vector{
+        let values = new Array<number>();
+        for (let attribute of this.attributes) {
+            for (let continuousAttribute of attribute.continuousAttributes()){
+                values.push(continuousAttribute);
+            }
+        }
+        return new Vector(values);
+    }
+}