SVM non-sequential 0 to n class outputs causes index out of bounds

[stigvoss]

The following code seems to cause array index out of bounds if the outputs array isn't sequential from zero such as [0, 1, 2, ...] but instead e.g. [13, 15, 17, ...] or like.

double[][] inputs = ...
int[] outputs = ...
            
 var teacher = new MulticlassSupportVectorLearning<Gaussian>()
{
    Learner = (param) => new SequentialMinimalOptimization<Gaussian>()
    {
        ...
    }
};

[cesarsouza]

Hi there,

Every .Learn() method in the framework expects the class labels to be contiguous and zero-indexed, meaning that if you have a classification problem with n classes, all class labels must be numbers ranging from 0 to n-1.

If you have class labels that are not contiguous, or that do not start at zero, you might have to pre-process them so they fit in the required format. A easy way to do this is to use the framework Codification class. I will add an example on how it can be done soon.

Regards,
Cesar

[cesarsouza]

An example can be seen in the last code section of the Codification documentation page:

// 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
};

// Now, suppose that our class labels are not contiguous. We
// have 3 classes, but they have the class labels 5, 1, and 8
// respectively. In this case, we can use a Codification filter
// to obtain a contiguous zero-indexed labeling before learning
int[] output_labels = 
{
    5, 5, 5, 5, 5,
    1, 1, 1, 1, 1,
    8, 8, 8, 8, 8,
};

// Create a codification object to obtain a output mapping
var codebook = new Codification<int>().Learn(output_labels);

// Transform the original labels using the codebook
int[] outputs = codebook.Transform(output_labels);

// Create the multi-class learning algorithm for the machine
var teacher = new MulticlassSupportVectorLearning<Gaussian>()
{
    // Configure the learning algorithm to use SMO to train the
    //  underlying SVMs in each of the binary class subproblems.
    Learner = (param) => new SequentialMinimalOptimization<Gaussian>()
    {
        // Estimate a suitable guess for the Gaussian kernel's parameters.
        // This estimate can serve as a starting point for a grid search.
        UseKernelEstimation = true
    }
};

// Configure parallel execution options
teacher.ParallelOptions.MaxDegreeOfParallelism = 1;

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

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

// Translate the integers back to the original lagbels
int[] predicted_labels = codebook.Revert(predicted);

Hope it helps!

Regards,
Cesar