public MulticlassSupportVectorMachine<Polynomial> v3_1_0() { ksvm = new MulticlassSupportVectorMachine<Polynomial>( inputs: 2, kernel: new Polynomial(2), classes: 10); smo = new MulticlassSupportVectorLearning<Polynomial>() { Model = ksvm }; smo.Learn(problem.Training.Inputs, problem.Testing.Output); return ksvm; }
public void SparseLinearTest() { MulticlassSupportVectorMachine<Linear> svm1; MulticlassSupportVectorMachine<Linear, Sparse<double>> svm2; { Accord.Math.Random.Generator.Seed = 0; MemoryStream file = new MemoryStream( Encoding.Default.GetBytes(Resources.iris_scale)); var reader = new SparseReader(file, Encoding.Default); var samples = reader.ReadDenseToEnd(); double[][] x = samples.Item1; int[] y = samples.Item2.ToMulticlass(); var learner = new MulticlassSupportVectorLearning<Linear>() { Learner = (p) => new LinearDualCoordinateDescent<Linear>() }; svm1 = learner.Learn(x, y); } { Accord.Math.Random.Generator.Seed = 0; MemoryStream file = new MemoryStream( Encoding.Default.GetBytes(Resources.iris_scale)); // Create a new Sparse Sample Reader to read any given file, // passing the correct dense sample size in the constructor var reader = new SparseReader(file, Encoding.Default); var samples = reader.ReadSparseToEnd(); Sparse<double>[] x = samples.Item1; int[] y = samples.Item2.ToMulticlass(); var learner = new MulticlassSupportVectorLearning<Linear, Sparse<double>>() { Learner = (p) => new LinearDualCoordinateDescent<Linear, Sparse<double>>() }; svm2 = learner.Learn(x, y); } Assert.AreEqual(svm1.Models.Length, svm2.Models.Length); for (int i = 0; i < svm1.Models.Length; i++) { var ma = svm1[i].Value; var mb = svm2[i].Value; Assert.IsTrue(ma.Weights.IsEqual(mb.Weights)); Assert.AreEqual(ma.SupportVectors.Length, mb.SupportVectors.Length); for (int j = 0; j < ma.SupportVectors.Length; j++) { double[] expected = ma.SupportVectors[j]; double[] actual = mb.SupportVectors[j].ToDense(4); Assert.IsTrue(expected.IsEqual(actual, 1e-5)); } } }
public void multiclass_precomputed_matrix_smo() { #region doc_precomputed // Let's say we have the following data to be classified // into three possible classes. Those are the samples: // double[][] trainInputs = { // 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[] trainOutputs = // those are the training set class labels { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, }; // Let's chose a kernel function Polynomial kernel = new Polynomial(2); // Get the kernel matrix for the training set double[][] K = kernel.ToJagged(trainInputs); // Create a pre-computed kernel var pre = new Precomputed(K); // Create a one-vs-one learning algorithm using SMO var teacher = new MulticlassSupportVectorLearning<Precomputed, int>() { Learner = (p) => new SequentialMinimalOptimization<Precomputed, int>() { Kernel = pre } }; #if DEBUG teacher.ParallelOptions.MaxDegreeOfParallelism = 1; #endif // Learn a machine var machine = teacher.Learn(pre.Indices, trainOutputs); // Compute the machine's prediction for the training set int[] trainPrediction = machine.Decide(pre.Indices); // Evaluate prediction error for the training set using mean accuracy (mAcc) double trainingError = new ZeroOneLoss(trainOutputs).Loss(trainPrediction); // Now let's compute the machine's prediction for a test set double[][] testInputs = // test-set inputs { // input output new double[] { 0, 1, 1, 0 }, // 0 new double[] { 0, 1, 0, 0 }, // 0 new double[] { 0, 0, 0, 1 }, // 1 new double[] { 1, 1, 1, 1 }, // 2 }; int[] testOutputs = // those are the test set class labels { 0, 0, 1, 2, }; // Compute precomputed matrix between train and testing pre.Values = kernel.ToJagged2(trainInputs, testInputs); // Update the kernel machine.Kernel = pre; // Compute the machine's prediction for the test set int[] testPrediction = machine.Decide(pre.Indices); // Evaluate prediction error for the training set using mean accuracy (mAcc) double testError = new ZeroOneLoss(testOutputs).Loss(testPrediction); #endregion Assert.AreEqual(0, trainingError); Assert.AreEqual(0, testError); // Create a one-vs-one learning algorithm using SMO var teacher2 = new MulticlassSupportVectorLearning<Polynomial>() { Learner = (p) => new SequentialMinimalOptimization<Polynomial>() { Kernel = kernel } }; #if DEBUG teacher.ParallelOptions.MaxDegreeOfParallelism = 1; #endif // Learn a machine var expected = teacher2.Learn(trainInputs, trainOutputs); Assert.AreEqual(4, expected.NumberOfInputs); Assert.AreEqual(3, expected.NumberOfOutputs); Assert.AreEqual(0, machine.NumberOfInputs); Assert.AreEqual(3, machine.NumberOfOutputs); var machines = Enumerable.Zip(machine, expected, (a,b) => Tuple.Create(a.Value, b.Value)); foreach (var pair in machines) { var a = pair.Item1; var e = pair.Item2; Assert.AreEqual(0, a.NumberOfInputs); Assert.AreEqual(2, a.NumberOfOutputs); Assert.AreEqual(4, e.NumberOfInputs); Assert.AreEqual(2, e.NumberOfOutputs); Assert.IsTrue(a.Weights.IsEqual(e.Weights)); } }
public void learn_test() { #region doc_learn // 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); #endregion Assert.AreEqual(0, error); Assert.IsTrue(predicted.IsEqual(outputs)); Assert.IsTrue(ovo.Scores(inputs[0]).IsEqual(new double[] { 0.62, -0.25, -0.59, -0.62 }, 1e-2)); Assert.IsTrue(ovo.Scores(inputs[1]).IsEqual(new double[] { -0.62, -0.57, -0.13, 0.62 }, 1e-2)); Assert.IsTrue(ovo.Scores(inputs[2]).IsEqual(new double[] { -0.25, 0.63, -0.63, -0.51 }, 1e-2)); }
public void multiclass_calibration_generic_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, 1 }, // 1 new double[] { 0, 0, 0, 1 }, // 1 new double[] { 0, 0, 0, 1 }, // 1 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, 2, 2, 2, 2, }; // Create the multi-class learning algorithm for the machine var teacher = new MulticlassSupportVectorLearning<IKernel>() { // Configure the learning algorithm to use SMO to train the // underlying SVMs in each of the binary class subproblems. Learner = (param) => new SequentialMinimalOptimization<IKernel>() { UseKernelEstimation = false, Kernel = Gaussian.FromGamma(0.5) } }; // Learn a machine var machine = teacher.Learn(inputs, outputs); // Create the multi-class learning algorithm for the machine var calibration = new MulticlassSupportVectorLearning<IKernel>(machine) { // Configure the learning algorithm to use SMO to train the // underlying SVMs in each of the binary class subproblems. Learner = (param) => new ProbabilisticOutputCalibration<IKernel>(param.Model) }; // Configure parallel execution options calibration.ParallelOptions.MaxDegreeOfParallelism = 1; // Learn a machine calibration.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); // Get log-likelihoods (should be same as scores) double[][] logl = machine.LogLikelihoods(inputs); // Get probability for each sample double[][] prob = machine.Probabilities(inputs); // Compute classification error double error = new ZeroOneLoss(outputs).Loss(predicted); double loss = new CategoryCrossEntropyLoss(outputs).Loss(prob); //string str = logl.ToCSharp(); double[] expectedScores = { 1.87436400885238, 1.81168086449304, 1.74038320983522, 1.87436400885238, 1.81168086449304, 1.55446926953952, 1.67016543853596, 1.67016543853596, 1.83135194001403, 1.83135194001403, 1.59836868669125, 2.0618816310294 }; double[][] expectedLogL = { new double[] { 1.87436400885238, -1.87436400885238, -1.7463646841257 }, new double[] { 1.81168086449304, -1.81168086449304, -1.73142460658826 }, new double[] { 1.74038320983522, -1.58848669816072, -1.74038320983522 }, new double[] { 1.87436400885238, -1.87436400885238, -1.7463646841257 }, new double[] { 1.81168086449304, -1.81168086449304, -1.73142460658826 }, new double[] { -1.55446926953952, 1.55446926953952, -0.573599079216229 }, new double[] { -0.368823000428743, 1.67016543853596, -1.67016543853596 }, new double[] { -0.368823000428743, 1.67016543853596, -1.67016543853596 }, new double[] { -1.83135194001403, -1.20039293330558, 1.83135194001403 }, new double[] { -1.83135194001403, -1.20039293330558, 1.83135194001403 }, new double[] { -0.894598978116595, -1.59836868669125, 1.59836868669125 }, new double[] { -1.87336852014759, -2.0618816310294, 2.0618816310294 } }; double[][] expectedProbs = { new double[] { 0.95209908906855, 0.0224197237689656, 0.0254811871624848 }, new double[] { 0.947314032745205, 0.0252864560196241, 0.0273995112351714 }, new double[] { 0.937543314993345, 0.0335955309754816, 0.028861154031173 }, new double[] { 0.95209908906855, 0.0224197237689656, 0.0254811871624848 }, new double[] { 0.947314032745205, 0.0252864560196241, 0.0273995112351714 }, new double[] { 0.0383670466237636, 0.859316640577158, 0.102316312799079 }, new double[] { 0.111669460983068, 0.857937888238824, 0.0303926507781076 }, new double[] { 0.111669460983068, 0.857937888238824, 0.0303926507781076 }, new double[] { 0.0238971617859334, 0.0449126146360623, 0.931190223578004 }, new double[] { 0.0238971617859334, 0.0449126146360623, 0.931190223578004 }, new double[] { 0.0735735561383806, 0.0363980776342206, 0.890028366227399 }, new double[] { 0.0188668069460003, 0.0156252941482294, 0.96550789890577 } }; // Must be exactly the same as test above Assert.AreEqual(0, error); Assert.AreEqual(0.5, ((Gaussian)machine[0].Value.Kernel).Gamma); Assert.AreEqual(0.5, ((Gaussian)machine[1].Value.Kernel).Gamma); Assert.AreEqual(0.5, ((Gaussian)machine[2].Value.Kernel).Gamma); Assert.AreEqual(1.0231652126930515, loss); Assert.IsTrue(predicted.IsEqual(outputs)); Assert.IsTrue(expectedScores.IsEqual(scores, 1e-10)); Assert.IsTrue(expectedLogL.IsEqual(logl, 1e-10)); Assert.IsTrue(expectedProbs.IsEqual(prob, 1e-10)); }
public void multiclass_linear_smo_new_usage() { // 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 learning algorithm using LIBLINEAR's L2-loss SVC dual var teacher = new MulticlassSupportVectorLearning<Linear>(); teacher.Learner = (p) => new SequentialMinimalOptimization<Linear>() { UseComplexityHeuristic = true }; #if DEBUG teacher.ParallelOptions.MaxDegreeOfParallelism = 1; #endif // Learn a machine var machine = teacher.Learn(inputs, outputs); for (int i = 0; i < inputs.Length; i++) { double actual = machine.Decide(inputs[i]); double expected = outputs[i]; Assert.AreEqual(expected, actual); } }
public void multiclass_linear_new_usage() { #region doc_learn_ldcd // 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 } }; // 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); // Compute classification error double error = new ZeroOneLoss(outputs).Loss(predicted); #endregion Assert.AreEqual(0, error); Assert.IsTrue(predicted.IsEqual(outputs)); }
public void multiclass_gaussian_new_usage() { #region doc_learn_gaussian // 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); #endregion // Get log-likelihoods (should be same as scores) double[][] logl = machine.LogLikelihoods(inputs); // Get probability for each sample double[][] prob = machine.Probabilities(inputs); // Compute classification error double loss = new CategoryCrossEntropyLoss(outputs).Loss(prob); string str = scores.ToCSharp(); double[] expectedScores = { 1.00888999727541, 1.00303259868784, 1.00068403386636, 1.00888999727541, 1.00303259868784, 1.00831890183328, 1.00831890183328, 0.843757409449037, 0.996768862332386, 0.996768862332386, 1.02627325826713, 1.00303259868784, 0.996967401312164, 0.961947708617365, 1.02627325826713 }; double[][] expectedLogL = { new double[] { 1.00888999727541, -1.00888999727541, -1.00135670089335 }, new double[] { 1.00303259868784, -0.991681098166717, -1.00303259868784 }, new double[] { 1.00068403386636, -0.54983354268499, -1.00068403386636 }, new double[] { 1.00888999727541, -1.00888999727541, -1.00135670089335 }, new double[] { 1.00303259868784, -0.991681098166717, -1.00303259868784 }, new double[] { -1.00831890183328, 1.00831890183328, -0.0542719287771535 }, new double[] { -1.00831890183328, 1.00831890183328, -0.0542719287771535 }, new double[] { -0.843757409449037, 0.843757409449037, -0.787899083913034 }, new double[] { -0.178272229157676, 0.996768862332386, -0.996768862332386 }, new double[] { -0.178272229157676, 0.996768862332386, -0.996768862332386 }, new double[] { -1.02627325826713, -1.00323113766761, 1.02627325826713 }, new double[] { -1.00303259868784, -0.38657999872922, 1.00303259868784 }, new double[] { -0.996967401312164, -0.38657999872922, 0.996967401312164 }, new double[] { -0.479189991343958, -0.961947708617365, 0.961947708617365 }, new double[] { -1.02627325826713, -1.00323113766761, 1.02627325826713 } }; double[][] expectedProbs = { new double[] { 0.789324598208647, 0.104940932711551, 0.105734469079803 }, new double[] { 0.78704862182644, 0.107080012017624, 0.105871366155937 }, new double[] { 0.74223157627093, 0.157455631737191, 0.100312791991879 }, new double[] { 0.789324598208647, 0.104940932711551, 0.105734469079803 }, new double[] { 0.78704862182644, 0.107080012017624, 0.105871366155937 }, new double[] { 0.0900153422818135, 0.676287261796794, 0.233697395921392 }, new double[] { 0.0900153422818135, 0.676287261796794, 0.233697395921392 }, new double[] { 0.133985810363445, 0.72433118122885, 0.141683008407705 }, new double[] { 0.213703968297751, 0.692032433073136, 0.0942635986291124 }, new double[] { 0.213703968297751, 0.692032433073136, 0.0942635986291124 }, new double[] { 0.10192623206507, 0.104302095948601, 0.79377167198633 }, new double[] { 0.0972161784678357, 0.180077937396817, 0.722705884135347 }, new double[] { 0.0981785890979593, 0.180760971768703, 0.721060439133338 }, new double[] { 0.171157270099157, 0.105617610634377, 0.723225119266465 }, new double[] { 0.10192623206507, 0.104302095948601, 0.79377167198633 } }; Assert.AreEqual(0, error); Assert.AreEqual(4.5289447815997672, loss, 1e-10); Assert.IsTrue(predicted.IsEqual(outputs)); Assert.IsTrue(expectedScores.IsEqual(scores, 1e-10)); Assert.IsTrue(expectedLogL.IsEqual(logl, 1e-10)); Assert.IsTrue(expectedProbs.IsEqual(prob, 1e-10)); }
public void kaggle_digits_with_compress() { string root = Environment.CurrentDirectory; var training = Properties.Resources.trainingsample; var validation = Properties.Resources.validationsample; var tset = readData(training); var observations = tset.Item1; var labels = tset.Item2; var teacher = new MulticlassSupportVectorLearning<Linear>(); var svm = teacher.Learn(observations, labels); Assert.AreEqual(50, svm.Models[0][0].SupportVectors.Length); Assert.AreEqual(127, svm.Models[1][0].SupportVectors.Length); svm.Compress(); Assert.AreEqual(1, svm.Models[0][0].SupportVectors.Length); Assert.AreEqual(1, svm.Models[1][0].SupportVectors.Length); { var trainingLoss = new ZeroOneLoss(labels) { Mean = true }; double error = trainingLoss.Loss(svm.Decide(observations)); Assert.AreEqual(0.054, error); } { var vset = readData(validation); var validationData = vset.Item1; var validationLabels = vset.Item2; var validationLoss = new ZeroOneLoss(validationLabels) { Mean = true }; double val = validationLoss.Loss(svm.Decide(validationData)); Assert.AreEqual(0.082, val); } }
public void multiclass_new_usage_method_polynomial() { double[][] inputs = { new double[] { 1, 4, 2, 0, 1 }, new double[] { 1, 3, 2, 0, 1 }, new double[] { 3, 0, 1, 1, 1 }, new double[] { 3, 0, 1, 0, 1 }, new double[] { 0, 5, 5, 5, 5 }, new double[] { 1, 5, 5, 5, 5 }, new double[] { 1, 0, 0, 0, 0 }, new double[] { 1, 0, 0, 0, 0 }, }; int[] outputs = { 0, 0, 1, 1, 2, 2, 3, 3, }; var learner = new MulticlassSupportVectorLearning<Polynomial>() { Learner = (p) => new SequentialMinimalOptimization<Polynomial>() { Model = p.Model, Complexity = 1, Kernel = new Polynomial(2) } }; learner.ParallelOptions.MaxDegreeOfParallelism = 1; MulticlassSupportVectorMachine<Polynomial> msvm = learner.Learn(inputs, outputs); Assert.AreEqual(0, msvm.GetLastKernelEvaluations()); int[] evals = { 8, 8, 7, 7, 7, 7, 6, 6 }; for (int i = 0; i < inputs.Length; i++) { double expected = outputs[i]; msvm.Method = MulticlassComputeMethod.Elimination; double actual = msvm.Decide(inputs[i]); Assert.AreEqual(expected, actual); Assert.AreEqual(evals[i], msvm.GetLastKernelEvaluations()); } for (int i = 0; i < inputs.Length; i++) { double expected = outputs[i]; msvm.Method = MulticlassComputeMethod.Voting; double actual = msvm.Decide(inputs[i]); Assert.AreEqual(expected, actual); Assert.AreEqual(8, msvm.GetLastKernelEvaluations()); } }
public void multiclass_new_usage_method_linear() { double[][] inputs = { new double[] { 1, 4, 2, 0, 1 }, new double[] { 1, 3, 2, 0, 1 }, new double[] { 3, 0, 1, 1, 1 }, new double[] { 3, 0, 1, 0, 1 }, new double[] { 0, 5, 5, 5, 5 }, new double[] { 1, 5, 5, 5, 5 }, new double[] { 1, 0, 0, 0, 0 }, new double[] { 1, 0, 0, 0, 0 }, }; int[] outputs = { 0, 0, 1, 1, 2, 2, 3, 3, }; var learner = new MulticlassSupportVectorLearning<Linear>(); learner.Learner = (_) => new LinearCoordinateDescent() { Complexity = 1 }; learner.ParallelOptions.MaxDegreeOfParallelism = 1; MulticlassSupportVectorMachine<Linear> msvm = learner.Learn(inputs, outputs); // Linear machines in compact form do not require kernel evaluations Assert.AreEqual(0, msvm.GetLastKernelEvaluations()); for (int i = 0; i < inputs.Length; i++) { double expected = outputs[i]; msvm.Method = MulticlassComputeMethod.Elimination; double actual = msvm.Decide(inputs[i]); Assert.AreEqual(expected, actual); Assert.AreEqual(0, msvm.GetLastKernelEvaluations()); } for (int i = 0; i < inputs.Length; i++) { double expected = outputs[i]; msvm.Method = MulticlassComputeMethod.Voting; double actual = msvm.Decide(inputs[i]); Assert.AreEqual(expected, actual); Assert.AreEqual(0, msvm.GetLastKernelEvaluations()); } }
/// <summary> /// Creates a Support Vector Machine and estimate /// its parameters using a learning algorithm. /// </summary> /// private void btnRunTraining_Click(object sender, EventArgs e) { if (dgvTrainingSource.Rows.Count == 0) { MessageBox.Show("Please load the training data before clicking this button"); return; } lbStatus.Text = "Gathering data. This may take a while..."; Application.DoEvents(); // Extract inputs and outputs int rows = dgvTrainingSource.Rows.Count; double[][] input = new double[rows][]; int[] output = new int[rows]; for (int i = 0; i < rows; i++) { input[i] = (double[])dgvTrainingSource.Rows[i].Cells["colTrainingFeatures"].Value; output[i] = (int)dgvTrainingSource.Rows[i].Cells["colTrainingLabel"].Value; } // Create the chosen kernel function // using the user interface parameters // IKernel kernel = createKernel(); // Extract training parameters from the interface double complexity = (double)numComplexity.Value; double tolerance = (double)numTolerance.Value; int cacheSize = (int)numCache.Value; SelectionStrategy strategy = (SelectionStrategy)cbStrategy.SelectedItem; // Create the learning algorithm using the machine and the training data var ml = new MulticlassSupportVectorLearning<IKernel>() { // Configure the learning algorithm Learner = (param) => new SequentialMinimalOptimization<IKernel>() { Complexity = complexity, Tolerance = tolerance, CacheSize = cacheSize, Strategy = strategy, Kernel = kernel } }; lbStatus.Text = "Training the classifiers. This may take a (very) significant amount of time..."; Application.DoEvents(); Stopwatch sw = Stopwatch.StartNew(); // Train the machines. It should take a while. ksvm = ml.Learn(input, output); // If we created a linear machine, compress the support vectors // into one single parameter vector for increased performance: if (ksvm.Kernel is Linear) { ksvm.Compress(); } sw.Stop(); double error = new ZeroOneLoss(output) { Mean = true }.Loss(ksvm.Decide(input)); lbStatus.Text = String.Format( "Training complete ({0}ms, {1}er). Click Classify to test the classifiers.", sw.ElapsedMilliseconds, error); // Update the interface status btnClassifyVoting.Enabled = true; btnClassifyElimination.Enabled = true; btnCalibration.Enabled = true; // Populate the information tab with the machines dgvMachines.Rows.Clear(); int k = 1; for (int i = 0; i < 10; i++) { for (int j = 0; j < i; j++, k++) { var machine = ksvm[i, j]; int sv = machine.SupportVectors == null ? 0 : machine.SupportVectors.Length; int c = dgvMachines.Rows.Add(k, i + "-vs-" + j, sv, machine.Threshold); dgvMachines.Rows[c].Tag = machine; } } // approximate size in bytes = // number of support vectors * number of doubles in a support vector * size of double int bytes = ksvm.SupportVectorUniqueCount * 1024 * sizeof(double); float megabytes = bytes / (1024 * 1024); lbSize.Text = String.Format("{0} ({1} MB)", ksvm.SupportVectorUniqueCount, megabytes); }
/// <summary> /// Calibrates the current Support Vector Machine to produce /// probabilistic outputs using ProbabilisticOutputLearning. /// </summary> /// private void btnRunCalibration_Click(object sender, EventArgs e) { if (ksvm == null) { MessageBox.Show("Please train the machines first."); return; } // Extract inputs and outputs int rows = dgvTrainingSource.Rows.Count; double[][] input = new double[rows][]; int[] output = new int[rows]; for (int i = 0; i < rows; i++) { input[i] = (double[])dgvTrainingSource.Rows[i].Cells["colTrainingFeatures"].Value; output[i] = (int)dgvTrainingSource.Rows[i].Cells["colTrainingLabel"].Value; } // Create the calibration algorithm using the training data var ml = new MulticlassSupportVectorLearning<IKernel>() { Model = ksvm, // Configure the calibration algorithm Learner = (p) => new ProbabilisticOutputCalibration<IKernel>() { Model = p.Model } }; lbStatus.Text = "Calibrating the classifiers. This may take a (very) significant amount of time..."; Application.DoEvents(); Stopwatch sw = Stopwatch.StartNew(); // Train the machines. It should take a while. ml.Learn(input, output); sw.Stop(); double error = new ZeroOneLoss(output).Loss(ksvm.Decide(input)); lbStatus.Text = String.Format( "Calibration complete ({0}ms, {1}er). Click Classify to test the classifiers.", sw.ElapsedMilliseconds, error); btnClassifyVoting.Enabled = true; }