LinearDualCoordinateDescent Class

public class LinearDualCoordinateDescent : BaseLinearDualCoordinateDescent<SupportVectorMachine, Linear, double[]>, 
	ILinearSupportVectorMachineLearning, ISupervisedLearning<SupportVectorMachine, double[], double>, 
	ISupervisedLearning<SupportVectorMachine, double[], int>, ISupervisedLearning<SupportVectorMachine, double[], bool>, 
	ISupportVectorMachineLearning, ISupportVectorMachineLearning<double[]>, ISupervisedBinaryLearning<ISupportVectorMachine<double[]>, double[]>, 
	ISupervisedMulticlassLearning<ISupportVectorMachine<double[]>, double[]>, ISupervisedMultilabelLearning<ISupportVectorMachine<double[]>, double[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], int[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], bool[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], int>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], bool>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], double>

Public Class LinearDualCoordinateDescent
	Inherits BaseLinearDualCoordinateDescent(Of SupportVectorMachine, Linear, Double())
	Implements ILinearSupportVectorMachineLearning, ISupervisedLearning(Of SupportVectorMachine, Double(), Double), 
	ISupervisedLearning(Of SupportVectorMachine, Double(), Integer), ISupervisedLearning(Of SupportVectorMachine, Double(), Boolean), 
	ISupportVectorMachineLearning, ISupportVectorMachineLearning(Of Double()), ISupervisedBinaryLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedMulticlassLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedMultilabelLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Integer()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Boolean()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Integer), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Boolean), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Double)

min_\alpha  0.5(\alpha^T (Q + D)\alpha) - e^T \alpha,
  s.t.      0 <= \alpha_i <= upper_bound_i,

upper_bound_i = Cp if y_i = 1
upper_bound_i = Cn if y_i = -1
D_ii = 0

upper_bound_i = INF
D_ii = 1/(2*Cp)    if y_i = 1
D_ii = 1/(2*Cn)    if y_i = -1

// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
// 
double[][] inputs =
{
    //               input         output
    new double[] { 0, 1, 1, 0 }, //  0 
    new double[] { 0, 1, 0, 0 }, //  0
    new double[] { 0, 0, 1, 0 }, //  0
    new double[] { 0, 1, 1, 0 }, //  0
    new double[] { 0, 1, 0, 0 }, //  0
    new double[] { 1, 0, 0, 0 }, //  1
    new double[] { 1, 0, 0, 0 }, //  1
    new double[] { 1, 0, 0, 1 }, //  1
    new double[] { 0, 0, 0, 1 }, //  1
    new double[] { 0, 0, 0, 1 }, //  1
    new double[] { 1, 1, 1, 1 }, //  2
    new double[] { 1, 0, 1, 1 }, //  2
    new double[] { 1, 1, 0, 1 }, //  2
    new double[] { 0, 1, 1, 1 }, //  2
    new double[] { 1, 1, 1, 1 }, //  2
};

int[] outputs = // those are the class labels
{
    0, 0, 0, 0, 0,
    1, 1, 1, 1, 1,
    2, 2, 2, 2, 2,
};

// Create a one-vs-one multi-class SVM learning algorithm 
var teacher = new MulticlassSupportVectorLearning<Linear>()
{
    // using LIBLINEAR's L2-loss SVC dual for each SVM
    Learner = (p) => new LinearDualCoordinateDescent()
    {
        Loss = Loss.L2
    }
};

// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)

// Learn a machine
var machine = teacher.Learn(inputs, outputs);

// Obtain class predictions for each sample
int[] predicted = machine.Decide(inputs);

// Compute classification error
double error = new ZeroOneLoss(outputs).Loss(predicted);

// Declare some training data. This is exactly the same
// data used in the MultipleLinearRegression documentation page

// We will try to model a plane as an equation in the form
// "ax + by + c = z". We have two input variables (x and y)
// and we will be trying to find two parameters a and b and 
// an intercept term c.

// Create the linear-SVM learning algorithm
var teacher = new LinearDualCoordinateDescent()
{
    Tolerance = 1e-10,
    Complexity = 1e+10, // learn a hard-margin model
};

// Now suppose you have some points
double[][] inputs =
{
    new double[] { 1, 1 },
    new double[] { 0, 1 },
    new double[] { 1, 0 },
    new double[] { 0, 0 },
};

// located in the same Z (z = 1)
double[] outputs = { 1, 1, 1, 1 };

// Learn the support vector machine
var svm = teacher.Learn(inputs, outputs);

// Convert the svm to logistic regression
var regression = (MultipleLinearRegression)svm;

// As result, we will be given the following:
double a = regression.Weights[0]; // a = 0
double b = regression.Weights[1]; // b = 0
double c = regression.Intercept;  // c = 1

// This is the plane described by the equation
// ax + by + c = z => 0x + 0y + 1 = z => 1 = z.

// We can compute the predicted points using
double[] predicted = regression.Transform(inputs);

// And the squared error loss using 
double error = new SquareLoss(outputs).Loss(predicted);