Wavelet Structure

[SerializableAttribute]
public struct Wavelet : IKernel, IKernel<double[]>, 
	ICloneable, IKernel<int[]>, IDistance, IDistance<double[]>, 
	IDistance<double[], double[]>, IDistance<int[]>, 
	IDistance<int[], int[]>

<SerializableAttribute>
Public Structure Wavelet
	Implements IKernel, IKernel(Of Double()), 
	ICloneable, IKernel(Of Integer()), IDistance, IDistance(Of Double()), 
	IDistance(Of Double(), Double()), IDistance(Of Integer()), 
	IDistance(Of Integer(), Integer())

// Generate always same random numbers
Accord.Math.Random.Generator.Seed = 0;

// The following is a simple auto association function in which 
// the last column of each input correspond to its own class. This
// problem should be easily solved using a Linear kernel.

// Sample input data
int[][] inputs =
{
    new int[] { 1, 2, 0 },
    new int[] { 6, 2, 3 },
    new int[] { 1, 1, 1 },
    new int[] { 7, 6, 2 },
};

// Output for each of the inputs
int[] outputs = { 0, 3, 1, 2 };

// Create the multi-class learning algorithm for the machine
var teacher = new MulticlassSupportVectorLearning<Wavelet, int[]>()
{
    // Configure the learning algorithm to use SMO to train the
    //  underlying SVMs in each of the binary class subproblems.
    Learner = (param) => new SequentialMinimalOptimization<Wavelet, int[]>()
    {
        // If you would like to use other kernels, simply replace
        // the generic parameter to the desired kernel class, such
        // as for example, Wavelet:

        Kernel = new Wavelet(invariant: true) // use the Wavelet kernel
    }
};

// You can set extra properties to configure the learning if you would like:
teacher.AggregateExceptions = true;
teacher.ParallelOptions.MaxDegreeOfParallelism = 1;

// Estimate the multi-class support vector machine using one-vs-one method
var ovo = teacher.Learn(inputs, outputs);

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

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