nlptoolkit-classification 1.0.0

package/dist/Instance/Instance.js

@@ -0,0 +1,170 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../Attribute/Attribute", "../Attribute/ContinuousAttribute", "../Attribute/DiscreteAttribute", "nlptoolkit-math/dist/Vector"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Instance = void 0;
+    const Attribute_1 = require("../Attribute/Attribute");
+    const ContinuousAttribute_1 = require("../Attribute/ContinuousAttribute");
+    const DiscreteAttribute_1 = require("../Attribute/DiscreteAttribute");
+    const Vector_1 = require("nlptoolkit-math/dist/Vector");
+    class Instance {
+        /**
+         * 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, attributes) {
+            this.attributes = new Array();
+            this.classLabel = classLabel;
+            if (attributes != undefined) {
+                this.attributes = attributes;
+            }
+        }
+        /**
+         * Adds a new attribute.
+         *
+         * @param value Attribute to be added.
+         */
+        addAttribute(value) {
+            if (value instanceof Attribute_1.Attribute) {
+                this.attributes.push(value);
+            }
+            else {
+                if (!Number.isNaN(value)) {
+                    this.attributes.push(new ContinuousAttribute_1.ContinuousAttribute(value));
+                }
+                else {
+                    this.attributes.push(new DiscreteAttribute_1.DiscreteAttribute(value));
+                }
+            }
+        }
+        /**
+         * Adds a {@link Vector} of continuous attributes.
+         *
+         * @param vector {@link Vector} that has the continuous attributes.
+         */
+        addVectorAttribute(vector) {
+            for (let i = 0; i < vector.size(); i++) {
+                this.attributes.push(new ContinuousAttribute_1.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) {
+            this.attributes.splice(index, 1);
+        }
+        /**
+         * Removes all the attributes from the attributes list.
+         */
+        removeAllAttributes() {
+            this.attributes = new Array();
+        }
+        /**
+         * Accessor for a single attribute.
+         *
+         * @param index Index of the attribute to be accessed.
+         * @return Attribute with index 'index'.
+         */
+        getAttribute(index) {
+            return this.attributes[index];
+        }
+        /**
+         * Returns the number of attributes in the attributes list.
+         *
+         * @return Number of attributes in the attributes list.
+         */
+        attributeSize() {
+            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() {
+            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() {
+            let result = new Array();
+            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() {
+            return this.classLabel;
+        }
+        /**
+         * Converts instance to a {@link String}.
+         *
+         * @return A string of attributes separated with comma character.
+         */
+        toString() {
+            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) {
+            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() {
+            let values = new Array();
+            for (let attribute of this.attributes) {
+                for (let continuousAttribute of attribute.continuousAttributes()) {
+                    values.push(continuousAttribute);
+                }
+            }
+            return new Vector_1.Vector(values);
+        }
+    }
+    exports.Instance = Instance;
+});
+//# sourceMappingURL=Instance.js.map

package/dist/Instance/Instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.js","sourceRoot":"","sources":["../../source/Instance/Instance.ts"],"names":[],"mappings":"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"}

package/dist/InstanceList/InstanceList.d.ts

@@ -0,0 +1,188 @@
+import { Instance } from "../Instance/Instance";
+import { Bootstrap } from "nlptoolkit-sampling/dist/Bootstrap";
+import { DiscreteDistribution } from "nlptoolkit-math/dist/DiscreteDistribution";
+import { Vector } from "nlptoolkit-math/dist/Vector";
+import { Matrix } from "nlptoolkit-math/dist/Matrix";
+export declare class InstanceList {
+    protected list: Array<Instance>;
+    /**
+     * Constructor for an instance list with a given data definition, data file and a separator character. Each instance
+     * must be stored in a separate line separated with the character separator. The last item must be the class label.
+     * The function reads the file line by line and for each line; depending on the data definition, that is, type of
+     * the attributes, adds discrete and continuous attributes to a new instance. For example, given the data set file
+     * <p>
+     * red;1;0.4;true
+     * green;-1;0.8;true
+     * blue;3;1.3;false
+     * <p>
+     * where the first attribute is a discrete attribute, second and third attributes are continuous attributes, the
+     * fourth item is the class label.
+     *
+     * @param definition Data definition of the data set.
+     * @param separator  Separator character which separates the attribute values in the data file.
+     * @param fileName   Name of the data set file.
+     */
+    constructor(definition?: any, separator?: string, fileName?: string);
+    /**
+     * Adds instance to the instance list.
+     *
+     * @param instance Instance to be added.
+     */
+    add(instance: Instance): void;
+    /**
+     * Adds a list of instances to the current instance list.
+     *
+     * @param instanceList List of instances to be added.
+     */
+    addAll(instanceList: Array<Instance>): void;
+    /**
+     * Returns size of the instance list.
+     *
+     * @return Size of the instance list.
+     */
+    size(): number;
+    /**
+     * Accessor for a single instance with the given index.
+     *
+     * @param index Index of the instance.
+     * @return Instance with index 'index'.
+     */
+    get(index: number): Instance;
+    /**
+     * Sorts instance list according to the attribute with index 'attributeIndex'.
+     *
+     * @param attributeIndex index of the attribute.
+     */
+    sort(attributeIndex?: number): void;
+    /**
+     * Shuffles the instance list.
+     * @param seed Seed is used for random number generation.
+     */
+    shuffle(seed: number): void;
+    /**
+     * Creates a bootstrap sample from the current instance list.
+     *
+     * @param seed To create a different bootstrap sample, we need a new seed for each sample.
+     * @return Bootstrap sample.
+     */
+    bootstrap(seed: number): Bootstrap<Instance>;
+    /**
+     * Extracts the class labels of each instance in the instance list and returns them in an array of {@link String}.
+     *
+     * @return An array list of class labels.
+     */
+    getClassLabels(): Array<string>;
+    /**
+     * Extracts the class labels of each instance in the instance list and returns them as a set.
+     *
+     * @return An {@link Array} of distinct class labels.
+     */
+    getDistinctClassLabels(): Array<string>;
+    /**
+     * Extracts the possible class labels of each instance in the instance list and returns them as a set.
+     *
+     * @return An {@link Array} of distinct class labels.
+     */
+    getUnionOfPossibleClassLabels(): Array<string>;
+    /**
+     * Extracts distinct discrete values of a given attribute as an array of strings.
+     *
+     * @param attributeIndex Index of the discrete attribute.
+     * @return An array of distinct values of a discrete attribute.
+     */
+    getAttributeValueList(attributeIndex: number): Array<string>;
+    /**
+     * Calculates the mean of a single attribute for this instance list (m_i). If the attribute is discrete, the maximum
+     * occurring value for that attribute is returned. If the attribute is continuous, the mean value of the values of
+     * all instances are returned.
+     *
+     * @param index Index of the attribute.
+     * @return The mean value of the instances as an attribute.
+     */
+    private attributeAverage;
+    /**
+     * Calculates the mean of a single attribute for this instance list (m_i).
+     *
+     * @param index Index of the attribute.
+     * @return The mean value of the instances as an attribute.
+     */
+    continuousAttributeAverage(index?: number): Array<number>;
+    /**
+     * Calculates the standard deviation of a single attribute for this instance list (m_i). If the attribute is discrete,
+     * null returned. If the attribute is continuous, the standard deviation  of the values all instances are returned.
+     *
+     * @param index Index of the attribute.
+     * @return The standard deviation of the instances as an attribute.
+     */
+    private attributeStandardDeviation;
+    /**
+     * Calculates the standard deviation of a single continuous attribute for this instance list (m_i).
+     *
+     * @param index Index of the attribute.
+     * @return The standard deviation of the instances as an attribute.
+     */
+    private continuousAttributeStandardDeviation;
+    /**
+     * The attributeDistribution method takes an index as an input and if the attribute of the instance at given index is
+     * discrete, it returns the distribution of the attributes of that instance.
+     *
+     * @param index Index of the attribute.
+     * @return Distribution of the attribute.
+     */
+    attributeDistribution(index: number): DiscreteDistribution;
+    /**
+     * The attributeClassDistribution method takes an attribute index as an input. It loops through the instances, gets
+     * the corresponding value of given attribute index and adds the class label of that instance to the discrete distributions list.
+     *
+     * @param attributeIndex Index of the attribute.
+     * @return Distribution of the class labels.
+     */
+    attributeClassDistribution(attributeIndex: number): Array<DiscreteDistribution>;
+    /**
+     * The discreteIndexedAttributeClassDistribution method takes an attribute index and an attribute value as inputs.
+     * It loops through the instances, gets the corresponding value of given attribute index and given attribute value.
+     * Then, adds the class label of that instance to the discrete indexed distributions list.
+     *
+     * @param attributeIndex Index of the attribute.
+     * @param attributeValue Value of the attribute.
+     * @return Distribution of the class labels.
+     */
+    discreteIndexedAttributeClassDistribution(attributeIndex: number, attributeValue: number): DiscreteDistribution;
+    /**
+     * The classDistribution method returns the distribution of all the class labels of instances.
+     *
+     * @return Distribution of the class labels.
+     */
+    classDistribution(): DiscreteDistribution;
+    /**
+     * The allAttributesDistribution method returns the distributions of all the attributes of instances.
+     *
+     * @return Distributions of all the attributes of instances.
+     */
+    allAttributesDistribution(): Array<DiscreteDistribution>;
+    /**
+     * Returns the mean of all the attributes for instances in the list.
+     *
+     * @return Mean of all the attributes for instances in the list.
+     */
+    average(): Instance;
+    /**
+     * Returns the standard deviation of attributes for instances.
+     *
+     * @return Standard deviation of attributes for instances.
+     */
+    standardDeviation(): Instance;
+    /**
+     * Calculates a covariance {@link Matrix} by using an average {@link Vector}.
+     *
+     * @param average Vector input.
+     * @return Covariance {@link Matrix}.
+     */
+    covariance(average: Vector): Matrix;
+    /**
+     * Accessor for the instances.
+     *
+     * @return Instances.
+     */
+    getInstances(): Array<Instance>;
+}