Click or drag to resize
Accord.NET (logo)

SequentialMinimalOptimization Class

Sequential Minimal Optimization (SMO) Algorithm
Inheritance Hierarchy
SystemObject
  Accord.MachineLearningBinaryLearningBaseISupportVectorMachineDouble, Double
    Accord.MachineLearning.VectorMachines.LearningBaseSupportVectorClassificationISupportVectorMachineDouble, IKernelDouble, Double
      Accord.MachineLearning.VectorMachines.LearningBaseSequentialMinimalOptimizationISupportVectorMachineDouble, IKernelDouble, Double
        Accord.MachineLearning.VectorMachines.LearningSequentialMinimalOptimization

Namespace:  Accord.MachineLearning.VectorMachines.Learning
Assembly:  Accord.MachineLearning (in Accord.MachineLearning.dll) Version: 3.5.0
Syntax
public class SequentialMinimalOptimization : BaseSequentialMinimalOptimization<ISupportVectorMachine<double[]>, IKernel<double[]>, double[]>, 
	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>
Request Example View Source

The SequentialMinimalOptimization type exposes the following members.

Constructors
Properties
  NameDescription
Public propertyActiveExamples
Gets the indices of the active examples (examples which have the corresponding Lagrange multiplier different than zero).
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyBoundedExamples
Gets the indices of the examples at the boundary (examples which have the corresponding Lagrange multipliers equal to C).
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Protected propertyC
Gets or sets the cost values associated with each input vector.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyCacheSize
Gets or sets the cache size to partially stored the kernel matrix. Default is the same number of input vectors. If set to zero, the cache will be disabled and all operations will be computed as needed.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyCompact Obsolete.
Gets or sets whether to produce compact models. Compact formulation is currently limited to linear models.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyComplexity
Complexity (cost) parameter C. Increasing the value of C forces the creation of a more accurate model that may not generalize well. If this value is not set and UseComplexityHeuristic is set to true, the framework will automatically guess a value for C. If this value is manually set to something else, then UseComplexityHeuristic will be automatically disabled and the given value will be used instead.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyEpsilon
Epsilon for round-off errors. Default value is 1e-12.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Protected propertyInputs
Gets or sets the input vectors for training.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyKernel
Gets or sets the kernel function use to create a kernel Support Vector Machine. If this property is set, UseKernelEstimation will be set to false.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyLagrange
Gets the value for the Lagrange multipliers (alpha) for every observation vector.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyModel
Gets or sets the classifier being learned.
(Inherited from BinaryLearningBaseTModel, TInput.)
Public propertyNegativeWeight
Gets or sets the negative class weight. This should be a value higher than 0 indicating how much of the Complexity parameter C should be applied to instances carrying the negative label.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyNonBoundExamples
Gets the indices of the non-bounded examples (examples which have the corresponding Lagrange multipliers between 0 and C).
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Protected propertyOutputs
Gets or sets the output labels for each training vector.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyPositiveWeight
Gets or sets the positive class weight. This should be a value higher than 0 indicating how much of the Complexity parameter C should be applied to instances carrying the positive label.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyShrinking
Gets or sets a value indicating whether shrinking heuristics should be used. Note: this property can only be used when Strategy is set to SecondOrder.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyStrategy
Gets or sets the pair selection strategy to be used during optimization.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyToken
Gets or sets a cancellation token that can be used to stop the learning algorithm while it is running.
(Inherited from BinaryLearningBaseTModel, TInput.)
Public propertyTolerance
Convergence tolerance. Default value is 1e-2.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public propertyUseClassProportions
Gets or sets a value indicating whether the weight ratio to be used between Complexity values for negative and positive instances should be computed automatically from the data proportions. Default is false.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyUseComplexityHeuristic
Gets or sets a value indicating whether the Complexity parameter C should be computed automatically by employing an heuristic rule. Default is true.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyUseKernelEstimation
Gets or sets whether initial values for some kernel parameters should be estimated from the data, if possible. Default is true.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public propertyWeightRatio
Gets or sets the weight ratio between positive and negative class weights. This ratio controls how much of the Complexity parameter C should be applied to the positive class.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Top
Methods
  NameDescription
Public methodComputeError Obsolete.
Computes the error rate for a given set of input and outputs.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Protected methodCreate
Creates an instance of the model to be learned. Inheritors of this abstract class must define this method so new models can be created from the training data.
(Overrides BaseSupportVectorClassificationTModel, TKernel, TInputCreate(Int32, TKernel).)
Public methodEquals
Determines whether the specified object is equal to the current object.
(Inherited from Object.)
Protected methodFinalize
Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.
(Inherited from Object.)
Public methodGetHashCode
Serves as the default hash function.
(Inherited from Object.)
Public methodGetType
Gets the Type of the current instance.
(Inherited from Object.)
Protected methodInnerRun
Runs the learning algorithm.
(Inherited from BaseSequentialMinimalOptimizationTModel, TKernel, TInput.)
Public methodLearn(Double, Boolean, Double)
Learns a model that can map the given inputs to the given outputs.
Public methodLearn(Double, Boolean, Double)
Learns a model that can map the given inputs to the given outputs.
Public methodLearn(Double, Double, Double)
Learns a model that can map the given inputs to the given outputs.
Public methodLearn(Double, Int32, Double)
Learns a model that can map the given inputs to the given outputs.
Public methodLearn(Double, Int32, Double)
Learns a model that can map the given inputs to the given outputs.
Protected methodMemberwiseClone
Creates a shallow copy of the current Object.
(Inherited from Object.)
Public methodRun Obsolete.
Obsolete.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public methodRun(Boolean) Obsolete.
Obsolete.
(Inherited from BaseSupportVectorClassificationTModel, TKernel, TInput.)
Public methodToString
Returns a string that represents the current object.
(Inherited from Object.)
Top
Extension Methods
  NameDescription
Public Extension MethodHasMethod
Checks whether an object implements a method with the given name.
(Defined by ExtensionMethods.)
Public Extension MethodIsEqual
Compares two objects for equality, performing an elementwise comparison if the elements are vectors or matrices.
(Defined by Matrix.)
Public Extension MethodToTOverloaded.
Converts an object into another type, irrespective of whether the conversion can be done at compile time or not. This can be used to convert generic types to numeric types during runtime.
(Defined by ExtensionMethods.)
Public Extension MethodToTOverloaded.
Converts an object into another type, irrespective of whether the conversion can be done at compile time or not. This can be used to convert generic types to numeric types during runtime.
(Defined by Matrix.)
Top
Remarks

The SMO algorithm is an algorithm for solving large quadratic programming (QP) optimization problems, widely used for the training of support vector machines. First developed by John C. Platt in 1998, SMO breaks up large QP problems into a series of smallest possible QP problems, which are then solved analytically.

This class follows the original algorithm by Platt with additional modifications by Keerthi et al.

This class can also be used in combination with MulticlassSupportVectorLearning or MultilabelSupportVectorLearning to learn MulticlassSupportVectorMachines using the one-vs-one or one-vs-all multi-class decision strategies, respectively.

References:

Examples

The following example shows how to use a SVM to learn a simple XOR function.

// As an example, we will try to learn a decision machine 
// that can replicate the "exclusive-or" logical function:

double[][] inputs =
{
    new double[] { 0, 0 }, // the XOR function takes two booleans
    new double[] { 0, 1 }, // and computes their exclusive or: the
    new double[] { 1, 0 }, // output is true only if the two booleans
    new double[] { 1, 1 }  // are different
};

int[] xor = // this is the output of the xor function
{
    0, // 0 xor 0 = 0 (inputs are equal)
    1, // 0 xor 1 = 1 (inputs are different)
    1, // 1 xor 0 = 1 (inputs are different)
    0, // 1 xor 1 = 0 (inputs are equal)
};

// Now, we can create the sequential minimal optimization teacher
var learn = new SequentialMinimalOptimization<Gaussian>()
{
    UseComplexityHeuristic = true,
    UseKernelEstimation = true
};

// And then we can obtain a trained SVM by calling its Learn method
SupportVectorMachine<Gaussian> svm = learn.Learn(inputs, xor);

// Finally, we can obtain the decisions predicted by the machine:
bool[] prediction = svm.Decide(inputs);

The next example shows how to solve a multi-class problem using a one-vs-one SVM where the binary machines are learned using SMO.

// 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
double[][] inputs =
{
    new double[] { 1, 2, 0 },
    new double[] { 6, 2, 3 },
    new double[] { 1, 1, 1 },
    new double[] { 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<Linear>()
{
    // Configure the learning algorithm to use SMO to train the
    //  underlying SVMs in each of the binary class subproblems.
    Learner = (param) => new SequentialMinimalOptimization<Linear>()
    {
        // If you would like to use other kernels, simply replace
        // the generic parameter to the desired kernel class, such
        // as for example, Polynomial or Gaussian:

        Kernel = new Linear() // use the Linear kernel
    }
};

// Estimate the multi-class support vector machine using one-vs-one method
MulticlassSupportVectorMachine<Linear> 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);

The same as before, but using a Gaussian kernel.

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

// Get class scores for each sample
double[] scores = machine.Score(inputs);

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

The following example shows how to learn a simple binary SVM using a precomputed kernel matrix obtained from a Gaussian kernel.

// As an example, we will try to learn a decision machine 
// that can replicate the "exclusive-or" logical function:

double[][] inputs =
{
    new double[] { 0, 0 }, // the XOR function takes two booleans
    new double[] { 0, 1 }, // and computes their exclusive or: the
    new double[] { 1, 0 }, // output is true only if the two booleans
    new double[] { 1, 1 }  // are different
};

int[] xor = // this is the output of the xor function
{
    0, // 0 xor 0 = 0 (inputs are equal)
    1, // 0 xor 1 = 1 (inputs are different)
    1, // 1 xor 0 = 1 (inputs are different)
    0, // 1 xor 1 = 0 (inputs are equal)
};

// Let's use a Gaussian kernel
var kernel = new Gaussian(0.1);

// Create a pre-computed Gaussian kernel matrix
var precomputed = new Precomputed(kernel.ToJagged(inputs));

// Now, we can create the sequential minimal optimization teacher
var learn = new SequentialMinimalOptimization<Precomputed, int>()
{
    Kernel = precomputed // set the precomputed kernel we created
};

// And then we can obtain the SVM by using Learn
var svm = learn.Learn(precomputed.Indices, xor);

// Finally, we can obtain the decisions predicted by the machine:
bool[] prediction = svm.Decide(precomputed.Indices);

// We can also compute the machine prediction to new samples
double[][] sample =
{
    new double[] { 0, 1 }
};

// Update the precomputed kernel with the new samples
precomputed = new Precomputed(kernel.ToJagged2(inputs, sample));

// Update the SVM kernel
svm.Kernel = precomputed;

// Compute the predictions to the new samples
bool[] newPrediction = svm.Decide(precomputed.Indices);
See Also