LinearDualCoordinateDescentTKernel Class

public class LinearDualCoordinateDescent<TKernel> : BaseLinearDualCoordinateDescent<SupportVectorMachine<TKernel>, TKernel, double[]>
where TKernel : struct, new(), ILinear

Public Class LinearDualCoordinateDescent(Of TKernel As {Structure, New, ILinear})
	Inherits BaseLinearDualCoordinateDescent(Of SupportVectorMachine(Of TKernel), TKernel, 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);