nlptoolkit-classification 1.0.0

package/source/Model/KMeansModel.ts

@@ -0,0 +1,44 @@
+import {GaussianModel} from "./GaussianModel";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
+import {Instance} from "../Instance/Instance";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+
+export class KMeansModel extends GaussianModel{
+
+    private classMeans: InstanceList
+    private distanceMetric: DistanceMetric
+
+    /**
+     * The constructor that sets the classMeans, priorDistribution and distanceMetric according to given inputs.
+     *
+     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param classMeans        {@link InstanceList} of class means.
+     * @param distanceMetric    {@link DistanceMetric} input.
+     */
+    constructor(priorDistribution: DiscreteDistribution, classMeans: InstanceList, distanceMetric: DistanceMetric) {
+        super();
+        this.classMeans = classMeans;
+        this.priorDistribution = priorDistribution;
+        this.distanceMetric = distanceMetric;
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It loops through the class means, if
+     * the corresponding class label is same as the given String it returns the negated distance between given instance and the
+     * current item of class means. Otherwise it returns the smallest negative number.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The negated distance between given instance and the current item of class means.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        for (let i = 0; i < this.classMeans.size(); i++) {
+            if (this.classMeans.get(i).getClassLabel() == Ci) {
+                return -this.distanceMetric.distance(instance, this.classMeans.get(i));
+            }
+        }
+        return Number.NEGATIVE_INFINITY;
+    }
+
+}

package/source/Model/KnnInstance.ts

@@ -0,0 +1,27 @@
+import {Instance} from "../Instance/Instance";
+
+export class KnnInstance {
+
+    private readonly distance: number
+    private readonly instance: Instance
+
+    /**
+     * The constructor that sets the instance and distance value.
+     *
+     * @param instance {@link Instance} input.
+     * @param distance Double distance value.
+     */
+    constructor(instance: Instance, distance: number) {
+        this.instance = instance;
+        this.distance = distance;
+    }
+
+    getInstance(): Instance{
+        return this.instance
+    }
+
+    getDistance(): number{
+        return this.distance
+    }
+
+}

package/source/Model/KnnModel.ts

@@ -0,0 +1,78 @@
+import {Model} from "./Model";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Instance} from "../Instance/Instance";
+import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
+import {CompositeInstance} from "../Instance/CompositeInstance";
+import {KnnInstance} from "./KnnInstance";
+
+export class KnnModel extends Model{
+
+    private data: InstanceList
+    private k: number
+    private distanceMetric: DistanceMetric
+
+    /**
+     * Constructor that sets the data {@link InstanceList}, k value and the {@link DistanceMetric}.
+     *
+     * @param data           {@link InstanceList} input.
+     * @param k              K value.
+     * @param distanceMetric {@link DistanceMetric} input.
+     */
+    constructor(data: InstanceList, k: number, distanceMetric: DistanceMetric) {
+        super();
+        this.data = data
+        this.k = k
+        this.distanceMetric = distanceMetric
+    }
+
+    /**
+     * The predict method takes an {@link Instance} as an input and finds the nearest neighbors of given instance. Then
+     * it returns the first possible class label as the predicted class.
+     *
+     * @param instance {@link Instance} to make prediction.
+     * @return The first possible class label as the predicted class.
+     */
+    predict(instance: Instance): string {
+        let nearestNeighbors = this.nearestNeighbors(instance);
+        let predictedClass
+        if (instance instanceof CompositeInstance && nearestNeighbors.size() == 0) {
+            predictedClass = (<CompositeInstance> instance).getPossibleClassLabels()[0];
+        } else {
+            predictedClass = Model.getMaximum(nearestNeighbors.getClassLabels());
+        }
+        return predictedClass;
+    }
+
+    predictProbability(instance: Instance): Map<string, number> {
+        let nearestNeighbors = this.nearestNeighbors(instance);
+        return nearestNeighbors.classDistribution().getProbabilityDistribution();
+    }
+
+    /**
+     * The nearestNeighbors method takes an {@link Instance} as an input. First it gets the possible class labels, then loops
+     * through the data {@link InstanceList} and creates new {@link Array} of {@link KnnInstance}s and adds the corresponding data with
+     * the distance between data and given instance. After sorting this newly created ArrayList, it loops k times and
+     * returns the first k instances as an {@link InstanceList}.
+     *
+     * @param instance {@link Instance} to find nearest neighbors/
+     * @return The first k instances which are nearest to the given instance as an {@link InstanceList}.
+     */
+    nearestNeighbors(instance: Instance): InstanceList{
+        let result = new InstanceList();
+        let instances = new Array<KnnInstance>();
+        let possibleClassLabels = undefined;
+        if (instance instanceof CompositeInstance) {
+            possibleClassLabels = (<CompositeInstance> instance).getPossibleClassLabels();
+        }
+        for (let i = 0; i < this.data.size(); i++) {
+            if (!(instance instanceof CompositeInstance) || possibleClassLabels.includes(this.data.get(i).getClassLabel())) {
+                instances.push(new KnnInstance(this.data.get(i), this.distanceMetric.distance(this.data.get(i), instance)));
+            }
+        }
+        instances.sort((a: KnnInstance, b: KnnInstance) => a.getDistance() < b.getDistance() ? -1 : a.getDistance() > b.getDistance() ? 1: 0);
+        for (let i = 0; i < Math.min(this.k, instances.length); i++) {
+            result.add(instances[i].getInstance());
+        }
+        return result;
+    }
+}

package/source/Model/LdaModel.ts

@@ -0,0 +1,39 @@
+import {GaussianModel} from "./GaussianModel";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {Instance} from "../Instance/Instance";
+
+export class LdaModel extends GaussianModel{
+
+    protected w0: Map<string, number>
+    protected w: Map<string, Vector>
+
+    /**
+     * A constructor which sets the priorDistribution, w and w0 according to given inputs.
+     *
+     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param w                 {@link HashMap} of String and Vectors.
+     * @param w0                {@link HashMap} of String and Double.
+     */
+    constructor(priorDistribution: DiscreteDistribution, w: Map<string, Vector>, w0: Map<string, number>) {
+        super();
+        this.priorDistribution = priorDistribution;
+        this.w = w;
+        this.w0 = w0;
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It returns the dot product of given Instance
+     * and wi plus w0i.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The dot product of given Instance and wi plus w0i.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        let xi = instance.toVector();
+        let wi = this.w.get(Ci);
+        let w0i = this.w0.get(Ci);
+        return wi.dotProduct(xi) + w0i;
+    }
+}

package/source/Model/LinearPerceptronModel.ts

@@ -0,0 +1,55 @@
+import {NeuralNetworkModel} from "./NeuralNetworkModel";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {LinearPerceptronParameter} from "../Parameter/LinearPerceptronParameter";
+import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
+
+export class LinearPerceptronModel extends NeuralNetworkModel{
+
+    protected W: Matrix
+
+    /**
+     * Constructor that takes {@link InstanceList}s as trainsSet and validationSet. Initially it allocates layer weights,
+     * then creates an input vector by using given trainSet and finds error. Via the validationSet it finds the classification
+     * performance and at the end it reassigns the allocated weight Matrix with the matrix that has the best accuracy.
+     *
+     * @param trainSet      InstanceList that is used to train.
+     * @param validationSet InstanceList that is used to validate.
+     * @param parameters    Linear perceptron parameters; learningRate, etaDecrease, crossValidationRatio, epoch.
+     */
+    constructor(trainSet: InstanceList, validationSet?: InstanceList, parameters?: LinearPerceptronParameter) {
+        super(trainSet);
+        if (validationSet != undefined){
+            let W = this.allocateLayerWeights(this.K, this.d + 1);
+            let bestW = W.clone();
+            let bestClassificationPerformance = new ClassificationPerformance(0.0);
+            let epoch = parameters.getEpoch();
+            let learningRate = parameters.getLearningRate();
+            for (let i = 0; i < epoch; i++) {
+                trainSet.shuffle(parameters.getSeed());
+                for (let j = 0; j < trainSet.size(); j++) {
+                    this.createInputVector(trainSet.get(j));
+                    let rMinusY = this.calculateRMinusY(trainSet.get(j), this.x, W);
+                    let deltaW = new Matrix(rMinusY, this.x);
+                    deltaW.multiplyWithConstant(learningRate);
+                    W.add(deltaW);
+                }
+                let currentClassificationPerformance = this.testClassifier(validationSet);
+                if (currentClassificationPerformance.getAccuracy() > bestClassificationPerformance.getAccuracy()) {
+                    bestClassificationPerformance = currentClassificationPerformance;
+                    bestW = W.clone();
+                }
+                learningRate *= parameters.getEtaDecrease();
+            }
+            W = bestW;
+        }
+    }
+
+    /**
+     * The calculateOutput method calculates the {@link Matrix} y by multiplying Matrix W with {@link Vector} x.
+     */
+    protected calculateOutput(): void {
+        this.y = this.W.multiplyWithVectorFromRight(this.x);
+    }
+
+}

package/source/Model/Model.ts

@@ -0,0 +1,22 @@
+import {Instance} from "../Instance/Instance";
+import {CounterHashMap} from "nlptoolkit-datastructure/dist/CounterHashMap";
+
+export abstract class Model {
+
+    abstract predict(instance: Instance): string
+    abstract predictProbability(instance: Instance): Map<string, number>
+
+    /**
+     * Given an array of class labels, returns the maximum occurred one.
+     *
+     * @param classLabels An array of class labels.
+     * @return The class label that occurs most in the array of class labels (mod of class label list).
+     */
+    static getMaximum(classLabels: Array<string>): string{
+        let frequencies = new CounterHashMap<string>();
+        for (let label of classLabels) {
+            frequencies.put(label);
+        }
+        return frequencies.max();
+    }
+}

package/source/Model/MultiLayerPerceptronModel.ts

@@ -0,0 +1,95 @@
+import {LinearPerceptronModel} from "./LinearPerceptronModel";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {ActivationFunction} from "../Parameter/ActivationFunction";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {MultiLayerPerceptronParameter} from "../Parameter/MultiLayerPerceptronParameter";
+import {ClassificationPerformance} from "../Performance/ClassificationPerformance";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+
+export class MultiLayerPerceptronModel extends LinearPerceptronModel{
+
+    private V: Matrix
+    protected activationFunction: ActivationFunction
+
+    /**
+     * The allocateWeights method allocates layers' weights of Matrix W and V.
+     *
+     * @param H Integer value for weights.
+     */
+    private allocateWeights(H: number){
+        this.W = this.allocateLayerWeights(H, this.d + 1);
+        this.V = this.allocateLayerWeights(this.K, H + 1);
+    }
+
+    /**
+     * A constructor that takes {@link InstanceList}s as trainsSet and validationSet. It  sets the {@link NeuralNetworkModel}
+     * nodes with given {@link InstanceList} then creates an input vector by using given trainSet and finds error.
+     * Via the validationSet it finds the classification performance and reassigns the allocated weight Matrix with the matrix
+     * that has the best accuracy and the Matrix V with the best Vector input.
+     *
+     * @param trainSet      InstanceList that is used to train.
+     * @param validationSet InstanceList that is used to validate.
+     * @param parameters    Multi layer perceptron parameters; seed, learningRate, etaDecrease, crossValidationRatio, epoch, hiddenNodes.
+     */
+    constructor(trainSet: InstanceList, validationSet: InstanceList, parameters: MultiLayerPerceptronParameter) {
+        super(trainSet);
+        this.activationFunction = parameters.getActivationFunction();
+        this.allocateWeights(parameters.getHiddenNodes());
+        let bestW = this.W.clone();
+        let bestV = this.V.clone();
+        let bestClassificationPerformance = new ClassificationPerformance(0.0);
+        let epoch = parameters.getEpoch();
+        let learningRate = parameters.getLearningRate();
+        for (let i = 0; i < epoch; i++) {
+            trainSet.shuffle(parameters.getSeed());
+            for (let j = 0; j < trainSet.size(); j++) {
+                this.createInputVector(trainSet.get(j));
+                let hidden = this.calculateHidden(this.x, this.W, this.activationFunction);
+                let hiddenBiased = hidden.biased();
+                let rMinusY = this.calculateRMinusY(trainSet.get(j), hiddenBiased, this.V);
+                let deltaV = new Matrix(rMinusY, hiddenBiased);
+                let tmph = this.V.multiplyWithVectorFromLeft(rMinusY);
+                tmph.remove(0);
+                let activationDerivative
+                switch (this.activationFunction){
+                    case ActivationFunction.SIGMOID:
+                    default:
+                        let oneMinusHidden = this.calculateOneMinusHidden(hidden);
+                        activationDerivative = oneMinusHidden.elementProduct(hidden);
+                        break;
+                    case ActivationFunction.TANH:
+                        let one = new Vector(hidden.size(), 1.0);
+                        hidden.tanh();
+                        activationDerivative = one.difference(hidden.elementProduct(hidden));
+                        break;
+                    case ActivationFunction.RELU:
+                        hidden.reluDerivative();
+                        activationDerivative = hidden;
+                        break;
+                }
+                let tmpHidden = tmph.elementProduct(activationDerivative);
+                let deltaW = new Matrix(tmpHidden, this.x);
+                deltaV.multiplyWithConstant(learningRate);
+                this.V.add(deltaV);
+                deltaW.multiplyWithConstant(learningRate);
+                this.W.add(deltaW);
+            }
+            let currentClassificationPerformance = this.testClassifier(validationSet);
+            if (currentClassificationPerformance.getAccuracy() > bestClassificationPerformance.getAccuracy()) {
+                bestClassificationPerformance = currentClassificationPerformance;
+                bestW = this.W.clone();
+                bestV = this.V.clone();
+            }
+            learningRate *= parameters.getEtaDecrease();
+        }
+        this.W = bestW;
+        this.V = bestV;
+    }
+
+    /**
+     * The calculateOutput method calculates the forward single hidden layer by using Matrices W and V.
+     */
+    protected calculateOutput() {
+        this.calculateForwardSingleHiddenLayer(this.W, this.V, this.activationFunction);
+    }
+}

package/source/Model/NaiveBayesModel.ts

@@ -0,0 +1,89 @@
+import {GaussianModel} from "./GaussianModel";
+import {Instance} from "../Instance/Instance";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
+import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
+import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+
+export class NaiveBayesModel extends GaussianModel{
+
+    private classMeans: Map<string, Vector> = undefined
+    private classDeviations: Map<string, Vector> = undefined
+    private readonly classAttributeDistributions: Map<string, Array<DiscreteDistribution>> = undefined
+
+    /**
+     * A constructor that sets the priorDistribution, classMeans and classDeviations.
+     *
+     * @param priorDistribution {@link DiscreteDistribution} input.
+     * @param classMeans        A {@link Map} of String and {@link Vector}.
+     * @param classDeviations   A {@link Map} of String and {@link Vector}.
+     */
+    constructor(priorDistribution: DiscreteDistribution, classMeans: any, classDeviations?: Map<string, Vector>) {
+        super();
+        this.priorDistribution = priorDistribution
+        if (classDeviations != undefined){
+            this.classMeans = classMeans
+            this.classDeviations = classDeviations
+        } else {
+            this.classAttributeDistributions = classMeans
+        }
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs, and it returns the log likelihood of
+     * these inputs.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The log likelihood of inputs.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        if (this.classAttributeDistributions == undefined) {
+            return this.logLikelihoodContinuous(Ci, instance);
+        } else {
+            return this.logLikelihoodDiscrete(Ci, instance);
+        }
+    }
+
+    /**
+     * The logLikelihoodContinuous method takes an {@link Instance} and a class label as inputs. First it gets the logarithm
+     * of given class label's probability via prior distribution as logLikelihood. Then it loops times of given instance attribute size, and accumulates the
+     * logLikelihood by calculating -0.5 * ((xi - mi) / si )** 2).
+     *
+     * @param classLabel String input class label.
+     * @param instance   {@link Instance} input.
+     * @return The log likelihood of given class label and {@link Instance}.
+     */
+    private logLikelihoodContinuous(classLabel: string, instance: Instance): number{
+        let logLikelihood = Math.log(this.priorDistribution.getProbability(classLabel));
+        for (let i = 0; i < instance.attributeSize(); i++) {
+            let xi = (<ContinuousAttribute> instance.getAttribute(i)).getValue();
+            let mi = this.classMeans.get(classLabel).getValue(i);
+            let si = this.classDeviations.get(classLabel).getValue(i);
+            if (si != 0){
+                logLikelihood += -0.5 * Math.pow((xi - mi) / si, 2);
+            }
+        }
+        return logLikelihood;
+    }
+
+    /**
+     * The logLikelihoodDiscrete method takes an {@link Instance} and a class label as inputs. First it gets the logarithm
+     * of given class label's probability via prior distribution as logLikelihood and gets the class attribute distribution of given class label.
+     * Then it loops times of given instance attribute size, and accumulates the logLikelihood by calculating the logarithm of
+     * corresponding attribute distribution's smoothed probability by using laplace smoothing on xi.
+     *
+     * @param classLabel String input class label.
+     * @param instance   {@link Instance} input.
+     * @return The log likelihood of given class label and {@link Instance}.
+     */
+    private logLikelihoodDiscrete(classLabel: string, instance: Instance): number{
+        let logLikelihood = Math.log(this.priorDistribution.getProbability(classLabel));
+        let attributeDistributions = this.classAttributeDistributions.get(classLabel);
+        for (let i = 0; i < instance.attributeSize(); i++) {
+            let xi = (<DiscreteAttribute> instance.getAttribute(i)).getValue();
+            logLikelihood += Math.log(attributeDistributions[i].getProbabilityLaplaceSmoothing(xi));
+        }
+        return logLikelihood;
+    }
+}

package/source/Model/NeuralNetworkModel.ts

@@ -0,0 +1,187 @@
+import {ValidatedModel} from "./ValidatedModel";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {Instance} from "../Instance/Instance";
+import {ActivationFunction} from "../Parameter/ActivationFunction";
+import {CompositeInstance} from "../Instance/CompositeInstance";
+
+export abstract class NeuralNetworkModel extends ValidatedModel{
+
+    protected classLabels: Array<string>
+    protected K: number
+    protected d: number
+    protected x: Vector
+    protected y: Vector
+    protected r: Vector
+
+    protected abstract calculateOutput(): void
+
+    /**
+     * Constructor that sets the class labels, their sizes as K and the size of the continuous attributes as d.
+     *
+     * @param trainSet {@link InstanceList} to use as train set.
+     */
+    protected constructor(trainSet: InstanceList) {
+        super();
+        this.classLabels = trainSet.getDistinctClassLabels()
+        this.K = this.classLabels.length
+        this.d = trainSet.get(0).continuousAttributeSize()
+    }
+
+    /**
+     * The allocateLayerWeights method returns a new {@link Matrix} with random weights.
+     *
+     * @param row    Number of rows.
+     * @param column Number of columns.
+     * @return Matrix with random weights.
+     */
+    protected allocateLayerWeights(row: number, column: number): Matrix{
+        return new Matrix(row, column, -0.01, +0.01);
+    }
+
+    /**
+     * The normalizeOutput method takes an input {@link Vector} o, gets the result for e^o of each element of o,
+     * then sums them up. At the end, divides each e^o by the summation.
+     *
+     * @param o Vector to normalize.
+     * @return Normalized vector.
+     */
+    protected normalizeOutput(o: Vector): Vector{
+        let sum = 0.0;
+        let values = new Array<number>()
+        for (let i = 0; i < values.length; i++){
+            sum += Math.exp(o.getValue(i));
+        }
+        for (let i = 0; i < values.length; i++){
+            values.push(Math.exp(o.getValue(i)) / sum);
+        }
+        return new Vector(values);
+    }
+
+    /**
+     * The createInputVector method takes an {@link Instance} as an input. It converts given Instance to the {@link Vector}
+     * and insert 1.0 to the first element.
+     *
+     * @param instance Instance to insert 1.0.
+     */
+    protected createInputVector(instance: Instance){
+        this.x = instance.toVector();
+        this.x.insert(0, 1.0);
+    }
+
+    /**
+     * The calculateHidden method takes a {@link Vector} input and {@link Matrix} weights, It multiplies the weights
+     * Matrix with given input Vector than applies the sigmoid function and returns the result.
+     *
+     * @param input   Vector to multiply weights.
+     * @param weights Matrix is multiplied with input Vector.
+     * @param activationFunction Activation function.
+     * @return Result of sigmoid function.
+     */
+    protected calculateHidden(input: Vector, weights: Matrix, activationFunction: ActivationFunction): Vector{
+        let z = weights.multiplyWithVectorFromRight(input);
+        switch (activationFunction){
+            case ActivationFunction.SIGMOID:
+            default:
+                z.sigmoid();
+                break;
+            case ActivationFunction.TANH:
+                z.tanh();
+                break;
+            case ActivationFunction.RELU:
+                z.relu();
+                break;
+        }
+        return z;
+    }
+
+    /**
+     * The calculateOneMinusHidden method takes a {@link Vector} as input. It creates a Vector of ones and
+     * returns the difference between given Vector.
+     *
+     * @param hidden Vector to find difference.
+     * @return Returns the difference between one's Vector and input Vector.
+     */
+    protected calculateOneMinusHidden(hidden: Vector): Vector{
+        let one = new Vector(hidden.size(), 1.0);
+        return one.difference(hidden);
+    }
+
+    /**
+     * The calculateForwardSingleHiddenLayer method takes two matrices W and V. First it multiplies W with x, then
+     * multiplies V with the result of the previous multiplication.
+     *
+     * @param W Matrix to multiply with x.
+     * @param V Matrix to multiply.
+     * @param activationFunction Activation function.
+     */
+    protected calculateForwardSingleHiddenLayer(W: Matrix, V: Matrix, activationFunction: ActivationFunction){
+        let hidden = this.calculateHidden(this.x, W, activationFunction);
+        let hiddenBiased = hidden.biased();
+        this.y = V.multiplyWithVectorFromRight(hiddenBiased);
+    }
+
+    /**
+     * The calculateRMinusY method creates a new {@link Vector} with given Instance, then it multiplies given
+     * input Vector with given weights Matrix. After normalizing the output, it returns the difference between the newly created
+     * Vector and normalized output.
+     *
+     * @param instance Instance is used to get class labels.
+     * @param input    Vector to multiply weights.
+     * @param weights  Matrix of weights/
+     * @return Difference between newly created Vector and normalized output.
+     */
+    protected calculateRMinusY(instance: Instance, input: Vector, weights: Matrix): Vector{
+        this.r = new Vector(this.K, this.classLabels.indexOf(instance.getClassLabel()), 1.0);
+        let o = weights.multiplyWithVectorFromRight(input);
+        this.y = this.normalizeOutput(o);
+        return this.r.difference(this.y);
+    }
+
+    /**
+     * The predictWithCompositeInstance method takes an ArrayList possibleClassLabels. It returns the class label
+     * which has the maximum value of y.
+     *
+     * @param possibleClassLabels ArrayList that has the class labels.
+     * @return The class label which has the maximum value of y.
+     */
+    protected predictWithCompositeInstance(possibleClassLabels: Array<string>){
+        let predictedClass = possibleClassLabels[0];
+        let maxY = Number.NEGATIVE_INFINITY
+        for (let i = 0; i < this.classLabels.length; i++) {
+            if (possibleClassLabels.includes(this.classLabels[i]) && this.y.getValue(i) > maxY) {
+                maxY = this.y.getValue(i);
+                predictedClass = this.classLabels[i];
+            }
+        }
+        return predictedClass;
+    }
+
+    /**
+     * The predict method takes an {@link Instance} as an input, converts it to a Vector and calculates the {@link Matrix} y by
+     * multiplying Matrix W with {@link Vector} x. Then it returns the class label which has the maximum y value.
+     *
+     * @param instance Instance to predict.
+     * @return The class label which has the maximum y.
+     */
+    predict(instance: Instance): string {
+        this.createInputVector(instance);
+        this.calculateOutput();
+        if (instance instanceof CompositeInstance) {
+            return this.predictWithCompositeInstance((<CompositeInstance> instance).getPossibleClassLabels());
+        } else {
+            return this.classLabels[this.y.maxIndex()];
+        }
+    }
+
+    predictProbability(instance: Instance): Map<string, number> {
+        this.createInputVector(instance);
+        this.calculateOutput();
+        let result = new Map<string, number>();
+        for (let i = 0; i < this.classLabels.length; i++){
+            result.set(this.classLabels[i], this.y.getValue(i));
+        }
+        return result;
+    }
+}