DynamicTimeWarping Structure

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

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

// Suppose you have sequences of univariate observations, 
// and that those sequences could be of arbitrary length.
// In this example, we have sequences binary numbers:

double[][] inputs =
{
    // Class -1
    new double[] { 0,1,1,0 },
    new double[] { 0,0,1,0 },
    new double[] { 0,1,1,1,0 },
    new double[] { 0,1,0 },    

    // Class +1
    new double[] { 1,0,0,1 },
    new double[] { 1,1,0,1 },
    new double[] { 1,0,0,0,1 },
    new double[] { 1,0,1 },
    new double[] { 1,0,0,0,1,1 }
};

int[] outputs =
{
        0, 0, 0, 0,  // First four sequences are of class 0
        1, 1, 1, 1, 1 // Last five sequences are of class 1
};

// Create the Sequential Minimal Optimization learning algorithm
var smo = new SequentialMinimalOptimization<DynamicTimeWarping>()
{
    Complexity = 1.5,

    // Set the parameters of the kernel
    Kernel = new DynamicTimeWarping(alpha: 1, degree: 1)
};

// And use it to learn a machine!
var svm = smo.Learn(inputs, outputs);

// Now we can compute predicted values
bool[] predicted = svm.Decide(inputs);

// And check how far we are from the expected values
double error = new ZeroOneLoss(outputs).Loss(predicted); // error will be 0.0

// Suppose you have sequences of multivariate observations, and that
// those sequences could be of arbitrary length. On the other hand, 
// each observation have a fixed, delimited number of dimensions.

// In this example, we have sequences of 3-dimensional observations. 
// Each sequence can have an arbitrary length, but each observation
// will always have length 3:

double[][][] sequences =
{
    new double[][] // first sequence
    {
        new double[] { 1, 1, 1 }, // first observation of the first sequence
        new double[] { 1, 2, 1 }, // second observation of the first sequence
        new double[] { 1, 4, 2 }, // third observation of the first sequence
        new double[] { 2, 2, 2 }, // fourth observation of the first sequence
    },

    new double[][] // second sequence (note that this sequence has a different length)
    {
        new double[] { 1, 1, 1 }, // first observation of the second sequence
        new double[] { 1, 5, 6 }, // second observation of the second sequence
        new double[] { 2, 7, 1 }, // third observation of the second sequence
    },

    new double[][] // third sequence 
    {
        new double[] { 8, 2, 1 }, // first observation of the third sequence
    },

    new double[][] // fourth sequence 
    {
        new double[] { 8, 2, 5 }, // first observation of the fourth sequence
        new double[] { 1, 5, 4 }, // second observation of the fourth sequence
    }
};

// Now, we will also have different class labels associated which each 
// sequence. We will assign -1 to sequences whose observations start 
// with { 1, 1, 1 } and +1 to those that do not:

int[] outputs =
{
        0, 0,  // First two sequences are of class 0 (those start with {1,1,1})
        1, 1,  // Last two sequences are of class  1 (don't start with {1,1,1})
};

// Now we can create the Sequential Minimal Optimization learning algorithm
var smo = new SequentialMinimalOptimization<DynamicTimeWarping, double[][]>()
{
    Complexity = 1.5,

    // Set the parameters of the kernel
    Kernel = new DynamicTimeWarping(alpha: 1, degree: 1)
};

// And use it to learn a machine!
var svm = smo.Learn(sequences, outputs);

// Now we can compute predicted values
bool[] predicted = svm.Decide(sequences);

// And check how far we are from the expected values
double error = new ZeroOneLoss(outputs).Loss(predicted); // error will be 0.0


// At this point, we should have obtained an useful machine. Let's
// see if it can understand a few examples it hasn't seem before:

double[][] a =
{
    new double[] { 1, 1, 1 },
    new double[] { 7, 2, 5 },
    new double[] { 2, 5, 1 },
};

double[][] b =
{
    new double[] { 8, 5, 2 },
    new double[] { 4, 2, 5 },
};

// Following the aforementioned logic, sequence (a) should be
// classified as -1, and sequence (b) should be classified as +1.

bool resultA = svm.Decide(a); // false
bool resultB = svm.Decide(b); // true