public void Run() { // Example AND problem double[][] inputs = { new double[] { 0, 0 }, // 0 and 0: 0 (label -1) new double[] { 0, 1 }, // 0 and 1: 0 (label -1) new double[] { 1, 0 }, // 1 and 0: 0 (label -1) new double[] { 1, 1 } // 1 and 1: 1 (label +1) }; // Dichotomy SVM outputs should be given as [-1;+1] int[] labels = { // 0, 0, 0, 1 -1, -1, -1, 1 }; // Create a Support Vector Machine for the given inputs SupportVectorMachine machine = new SupportVectorMachine(inputs[0].Length); // Instantiate a new learning algorithm for SVMs SequentialMinimalOptimization smo = new SequentialMinimalOptimization(machine, inputs, labels); // Set up the learning algorithm smo.Complexity = 1.0; // Run the learning algorithm double error = smo.Run(); // Compute the decision output for one of the input vectors int decision = System.Math.Sign(machine.Compute(inputs[0])); }
static KernelSupportVectorMachine LearnSVM(HSL[] positives, HSL[] negatives, double throwExceptionWhenErrorGreaterThan) { int[] classes = new int[positives.Length + negatives.Length]; double[][] vectors = new double[classes.Length][]; int index = 0; for (int c = 0; c < positives.Length; c++, index++) { classes[index] = 1; vectors[index] = HSLToDouble(positives[c]); } for (int c = 0; c < negatives.Length; c++, index++) { classes[index] = -1; vectors[index] = HSLToDouble(negatives[c]); } KernelSupportVectorMachine svm = new KernelSupportVectorMachine(new Gaussian(.1), vectors[0].Length); SequentialMinimalOptimization smo = new SequentialMinimalOptimization(svm, vectors.ToArray(), classes); //smo.Complexity = 1.0; double error = smo.Run(); if (error > throwExceptionWhenErrorGreaterThan) { throw new Exception("Failed to get reasonable error value."); } return svm; }
public override Func<double[], double> Learn(LearningData learningData) { var svm = new KernelSupportVectorMachine(_kernel, learningData.Variables.Count); var smo = new SequentialMinimalOptimization( svm, learningData.Inputs, learningData.Outputs); smo.Run(); return svm.Compute; }
public void LearnTest() { double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] xor = { -1, 1, 1, -1 }; // Create Kernel Support Vector Machine with a Polynomial Kernel of 2nd degree KernelSupportVectorMachine machine = new KernelSupportVectorMachine(new Polynomial(2), inputs[0].Length); // Create the sequential minimal optimization teacher SequentialMinimalOptimization learn = new SequentialMinimalOptimization(machine, inputs, xor); // Run the learning algorithm learn.Run(); int[] output = inputs.Apply(p => Math.Sign(machine.Compute(p))); for (int i = 0; i < output.Length; i++) Assert.AreEqual(System.Math.Sign(xor[i]), System.Math.Sign(output[i])); }
//public SupportVectorMachine SVM //{ // get { return svm; } // private set { svm = value; } //} public override void TrainningModel(TrainningData trainningData) { ContinuousDataTableAdapter continuousDataTableAdapter = new ContinuousDataTableAdapter(); DataTable continuousDataTable = continuousDataTableAdapter.GetData(); DataTable dataTable = continuousDataTable.DefaultView.ToTable(false, TableMetaData.TestingAttributes); string[] columnNames; double[][] inputs = dataTable.ToArray(out columnNames); int[] outputs = (int[])trainningData.ClassificationAttribute.Clone(); // Create output for SVM (-1 or 1) for (int index = 0; index < outputs.Length; index++) { if (outputs[index] == 0) { outputs[index] = -1; } } // Create a Support Vector Machine for the given inputs //this.svm = new SupportVectorMachine(inputs[0].Length); //// Create a Kernel Support Vector Machine for the given inputs this.svm = new KernelSupportVectorMachine(new Gaussian(0.1), inputs[0].Length); // Instantiate a new learning algorithm for SVMs SequentialMinimalOptimization smo = new SequentialMinimalOptimization(svm, inputs, outputs); // Set up the learning algorithm smo.Complexity = 1.0; // Run the learning algorithm double error = smo.Run(); }
public double v3_0_1() { var ksvm = new KernelSupportVectorMachine(new Polynomial(2), 2); var smo = new SequentialMinimalOptimization(ksvm, inputs, outputs); return smo.Run(computeError: false); }
public void ComputeTest() { // Example AND problem double[][] inputs = { new double[] { 0, 0 }, // 0 and 0: 0 (label -1) new double[] { 0, 1 }, // 0 and 1: 0 (label -1) new double[] { 1, 0 }, // 1 and 0: 0 (label -1) new double[] { 1, 1 } // 1 and 1: 1 (label +1) }; // Dichotomy SVM outputs should be given as [-1;+1] int[] labels = { // 0, 0, 0, 1 -1, -1, -1, 1 }; // Create a Support Vector Machine for the given inputs KernelSupportVectorMachine machine = new KernelSupportVectorMachine(new Gaussian(0.1), inputs[0].Length); // Instantiate a new learning algorithm for SVMs SequentialMinimalOptimization smo = new SequentialMinimalOptimization(machine, inputs, labels); // Set up the learning algorithm smo.Complexity = 1.0; // Run double error = smo.Run(); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[0]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[1]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[2]))); Assert.AreEqual(+1, Math.Sign(machine.Compute(inputs[3]))); Assert.AreEqual(error, 0); Assert.AreEqual(-0.6640625, machine.Threshold); Assert.AreEqual(1, machine.Weights[0]); Assert.AreEqual(-0.34375, machine.Weights[1]); Assert.AreEqual(-0.328125, machine.Weights[2]); Assert.AreEqual(-0.328125, machine.Weights[3]); }
public void TransformTest() { var inputs = yinyang.Submatrix(null, 0, 1).ToArray(); var labels = yinyang.GetColumn(2).ToInt32(); ConfusionMatrix actual, expected; SequentialMinimalOptimization a, b; var kernel = new Polynomial(2, 0); { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); a = new SequentialMinimalOptimization(machine, inputs, labels); a.UseComplexityHeuristic = true; a.Run(); int[] values = new int[labels.Length]; for (int i = 0; i < values.Length; i++) values[i] = Math.Sign(machine.Compute(inputs[i])); expected = new ConfusionMatrix(values, labels); } { var projection = inputs.Apply(kernel.Transform); var machine = new SupportVectorMachine(projection[0].Length); b = new SequentialMinimalOptimization(machine, projection, labels); b.UseComplexityHeuristic = true; b.Run(); int[] values = new int[labels.Length]; for (int i = 0; i < values.Length; i++) values[i] = Math.Sign(machine.Compute(projection[i])); actual = new ConfusionMatrix(values, labels); } Assert.AreEqual(a.Complexity, b.Complexity, 1e-15); Assert.AreEqual(expected.TrueNegatives, actual.TrueNegatives); Assert.AreEqual(expected.TruePositives, actual.TruePositives); Assert.AreEqual(expected.FalseNegatives, actual.FalseNegatives); Assert.AreEqual(expected.FalsePositives, actual.FalsePositives); }
public void TrainTest2() { double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] or = { -1, -1, -1, +1 }; // Create Kernel Support Vector Machine with a Polynomial Kernel of 2nd degree SupportVectorMachine machine = new SupportVectorMachine(inputs[0].Length); // Create the sequential minimal optimization teacher SequentialMinimalOptimization learn = new SequentialMinimalOptimization(machine, inputs, or); learn.Complexity = 1; // Run the learning algorithm learn.Run(); double[] output = machine.Compute(inputs); for (int i = 0; i < output.Length; i++) { bool sor = or[i] >= 0; bool sou = output[i] >= 0; Assert.AreEqual(sor, sou); } }
public void WeightRatioTest() { var dataset = KernelSupportVectorMachineTest.training; var inputs = dataset.Submatrix(null, 0, 3); var labels = Tools.Scale(0, 1, -1, 1, dataset.GetColumn(4)).ToInt32(); Gaussian kernel = Gaussian.Estimate(inputs); { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.WeightRatio = 10; double error = smo.Run(); Assert.AreEqual(1.0, smo.PositiveWeight); Assert.AreEqual(0.1, smo.NegativeWeight); Assert.AreEqual(0.7142857142857143, error); Assert.AreEqual(265.78327637381551, (machine.Kernel as Gaussian).Sigma); Assert.AreEqual(39, machine.SupportVectors.Length); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(12, matrix.TruePositives); // has more importance Assert.AreEqual(0, matrix.FalseNegatives); // has more importance Assert.AreEqual(30, matrix.FalsePositives); Assert.AreEqual(0, matrix.TrueNegatives); Assert.AreEqual(1.0, matrix.Sensitivity); Assert.AreEqual(0.0, matrix.Specificity); Assert.AreEqual(0.44444444444444448, matrix.FScore); Assert.AreEqual(0.0, matrix.MatthewsCorrelationCoefficient); } { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.WeightRatio = 0.1; double error = smo.Run(); Assert.AreEqual(0.1, smo.PositiveWeight); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(0.21428571428571427, error); Assert.AreEqual(265.78327637381551, (machine.Kernel as Gaussian).Sigma); Assert.AreEqual(18, machine.SupportVectors.Length); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(8, matrix.FalseNegatives); Assert.AreEqual(1, matrix.FalsePositives); // has more importance Assert.AreEqual(4, matrix.TruePositives); Assert.AreEqual(29, matrix.TrueNegatives); // has more importance Assert.AreEqual(0.33333333333333331, matrix.Sensitivity); Assert.AreEqual(0.96666666666666667, matrix.Specificity); Assert.AreEqual(0.47058823529411764, matrix.FScore); Assert.AreEqual(0.41849149947774944, matrix.MatthewsCorrelationCoefficient); } }
public void FixedWeightsTest() { var dataset = KernelSupportVectorMachineTest.training; var inputs = dataset.Submatrix(null, 0, 3); var labels = Tools.Scale(0, 1, -1, 1, dataset.GetColumn(4)).ToInt32(); KernelSupportVectorMachine machine = new KernelSupportVectorMachine( Gaussian.Estimate(inputs), inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 10; double error = smo.Run(); Assert.AreEqual(0.19047619047619047, error); Assert.AreEqual(265.78327637381551, (machine.Kernel as Gaussian).Sigma); Assert.AreEqual(29, machine.SupportVectors.Length); double[] expectedWeights = { 1.65717694716503, 1.20005456611466, -5.70824245415995, 10, 10, -2.38755497916487, 10, -8.15723436363058, 10, -10, 10, 10, -0.188634936781317, -5.4354281009458, -8.48341139483265, -5.91105702760141, -5.71489190049223, 10, -2.37289205235858, -3.33031262413522, -1.97545116517677, 10, -10, -9.563186799279, -3.917941544845, -0.532584110773336, 4.81951847548326, 0.343668292727091, -4.34159482731336 }; Assert.IsTrue(expectedWeights.IsEqual(machine.Weights, 1e-6)); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(8, matrix.FalseNegatives); Assert.AreEqual(0, matrix.FalsePositives); Assert.AreEqual(4, matrix.TruePositives); Assert.AreEqual(30, matrix.TrueNegatives); Assert.AreEqual(1 / 3.0, matrix.Sensitivity); Assert.AreEqual(1, matrix.Specificity); Assert.AreEqual(0.5, matrix.FScore); Assert.AreEqual(0.5129891760425771, matrix.MatthewsCorrelationCoefficient); }
public void ReceiverOperatingCharacteristicConstructorTest3() { // This example shows how to measure the accuracy of a // binary classifier using a ROC curve. For this example, // we will be creating a Support Vector Machine trained // on the following instances: double[][] inputs = { // Those are from class -1 new double[] { 2, 4, 0 }, new double[] { 5, 5, 1 }, new double[] { 4, 5, 0 }, new double[] { 2, 5, 5 }, new double[] { 4, 5, 1 }, new double[] { 4, 5, 0 }, new double[] { 6, 2, 0 }, new double[] { 4, 1, 0 }, // Those are from class +1 new double[] { 1, 4, 5 }, new double[] { 7, 5, 1 }, new double[] { 2, 6, 0 }, new double[] { 7, 4, 7 }, new double[] { 4, 5, 0 }, new double[] { 6, 2, 9 }, new double[] { 4, 1, 6 }, new double[] { 7, 2, 9 }, }; int[] outputs = { -1, -1, -1, -1, -1, -1, -1, -1, // fist eight from class -1 +1, +1, +1, +1, +1, +1, +1, +1 // last eight from class +1 }; // Create a linear Support Vector Machine with 4 inputs SupportVectorMachine machine = new SupportVectorMachine(inputs: 3); // Create the sequential minimal optimization teacher SequentialMinimalOptimization learn = new SequentialMinimalOptimization(machine, inputs, outputs); // Run the learning algorithm double error = learn.Run(); // Extract the input labels predicted by the machine double[] predicted = new double[inputs.Length]; for (int i = 0; i < predicted.Length; i++) predicted[i] = machine.Compute(inputs[i]); // Create a new ROC curve to assess the performance of the model var roc = new ReceiverOperatingCharacteristic(outputs, predicted); roc.Compute(100); // Compute a ROC curve with 100 points /* // Generate a connected scatter plot for the ROC curve and show it on-screen ScatterplotBox.Show(roc.GetScatterplot(includeRandom: true), nonBlocking: true) .SetSymbolSize(0) // do not display data points .SetLinesVisible(true) // show lines connecting points .SetScaleTight(true) // tighten the scale to points .WaitForClose(); */ Assert.AreEqual(0.7890625, roc.Area); // Assert.AreEqual(0.1174774, roc.StandardError, 1e-6); HanleyMcNeil Assert.AreEqual(0.11958120746409709, roc.StandardError, 1e-6); }
public void GridsearchConstructorTest() { Accord.Math.Tools.SetupGenerator(0); // Example binary data double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] xor = // xor labels { -1, 1, 1, -1 }; // Declare the parameters and ranges to be searched GridSearchRange[] ranges = { new GridSearchRange("complexity", new double[] { 0.00000001, 5.20, 0.30, 0.50 } ), new GridSearchRange("degree", new double[] { 1, 10, 2, 3, 4, 5 } ), new GridSearchRange("constant", new double[] { 0, 1, 2 } ) }; // Instantiate a new Grid Search algorithm for Kernel Support Vector Machines var gridsearch = new GridSearch<KernelSupportVectorMachine>(ranges); // Set the fitting function for the algorithm gridsearch.Fitting = delegate(GridSearchParameterCollection parameters, out double error) { // The parameters to be tried will be passed as a function parameter. int degree = (int)parameters["degree"].Value; double constant = parameters["constant"].Value; double complexity = parameters["complexity"].Value; // Use the parameters to build the SVM model Polynomial kernel = new Polynomial(degree, constant); KernelSupportVectorMachine ksvm = new KernelSupportVectorMachine(kernel, 2); // Create a new learning algorithm for SVMs SequentialMinimalOptimization smo = new SequentialMinimalOptimization(ksvm, inputs, xor); smo.Complexity = complexity; // Measure the model performance to return as an out parameter error = smo.Run(); return ksvm; // Return the current model }; // Declare some out variables to pass to the grid search algorithm GridSearchParameterCollection bestParameters; double minError; // Compute the grid search to find the best Support Vector Machine KernelSupportVectorMachine bestModel = gridsearch.Compute(out bestParameters, out minError); // A linear kernel can't solve the xor problem. Assert.AreNotEqual((int)bestParameters["degree"].Value, 1); // The minimum error should be zero because the problem is well-known. Assert.AreEqual(minError, 0.0); Assert.IsNotNull(bestModel); Assert.IsNotNull(bestParameters); Assert.AreEqual(bestParameters.Count, 3); }
public void CompactTest() { double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] xor = { -1, 1, 1, -1 }; { var machine = new KernelSupportVectorMachine(new Polynomial(2), inputs[0].Length); var learn = new SequentialMinimalOptimization(machine, inputs, xor); learn.Compact = false; double error = learn.Run(); Assert.AreEqual(0, error); } { var machine = new KernelSupportVectorMachine(new Polynomial(2), inputs[0].Length); var learn = new SequentialMinimalOptimization(machine, inputs, xor); bool thrown = false; try { learn.Compact = true; } catch { thrown = true; } Assert.IsTrue(thrown); } { var machine = new KernelSupportVectorMachine(new Linear(), inputs[0].Length); var learn = new SequentialMinimalOptimization(machine, inputs, xor); learn.Compact = false; double error = learn.Run(); Assert.AreEqual(0.5, error); } { var machine = new KernelSupportVectorMachine(new Linear(), inputs[0].Length); var learn = new SequentialMinimalOptimization(machine, inputs, xor); learn.Compact = false; double error = learn.Run(); Assert.AreEqual(0.5, error); } }
public void LearnTest5() { double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] positives = { 1, 1, 1, 1 }; // Create Kernel Support Vector Machine with a Polynomial Kernel of 2nd degree SupportVectorMachine machine = new SupportVectorMachine(inputs[0].Length); // Create the sequential minimal optimization teacher SequentialMinimalOptimization learn = new SequentialMinimalOptimization(machine, inputs, positives); learn.Complexity = 1; // Run the learning algorithm double error = learn.Run(); Assert.AreEqual(0, error); int[] output = inputs.Apply(p => (int)machine.Compute(p)); for (int i = 0; i < output.Length; i++) { bool sor = positives[i] >= 0; bool sou = output[i] >= 0; Assert.AreEqual(sor, sou); } }
public void WeightsTest1() { var dataset = yinyang; double[][] inputs = dataset.Submatrix(null, 0, 1).ToArray(); int[] labels = dataset.GetColumn(2).ToInt32(); Accord.Math.Tools.SetupGenerator(0); var kernel = new Linear(1); { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.PositiveWeight = 1; smo.NegativeWeight = 1; smo.Tolerance = 0.001; double error = smo.Run(); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(43, matrix.TruePositives); // both classes are Assert.AreEqual(43, matrix.TrueNegatives); // well equilibrated Assert.AreEqual(7, matrix.FalseNegatives); Assert.AreEqual(7, matrix.FalsePositives); Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(1.0, smo.WeightRatio); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(1.0, smo.PositiveWeight); Assert.AreEqual(0.14, error); Assert.AreEqual(0.001, smo.Tolerance); Assert.AreEqual(31, machine.SupportVectors.Length); } { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1; smo.PositiveWeight = 100; smo.NegativeWeight = 1; smo.Tolerance = 0.001; double error = smo.Run(); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(50, matrix.TruePositives); // has more importance Assert.AreEqual(23, matrix.TrueNegatives); Assert.AreEqual(0, matrix.FalseNegatives); // has more importance Assert.AreEqual(27, matrix.FalsePositives); Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(100, smo.WeightRatio); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(100, smo.PositiveWeight); Assert.AreEqual(0.001, smo.Tolerance); Assert.AreEqual(0.27, error); Assert.AreEqual(41, machine.SupportVectors.Length); } { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1; smo.PositiveWeight = 1; smo.NegativeWeight = 100; smo.Tolerance = 0.001; double error = smo.Run(); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); var matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(25, matrix.TruePositives); Assert.AreEqual(50, matrix.TrueNegatives); // has more importance Assert.AreEqual(25, matrix.FalseNegatives); Assert.AreEqual(0, matrix.FalsePositives); // has more importance Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(0.01, smo.WeightRatio); Assert.AreEqual(100, smo.NegativeWeight); Assert.AreEqual(1.0, smo.PositiveWeight); Assert.AreEqual(0.25, error); Assert.AreEqual(0.001, smo.Tolerance); Assert.AreEqual(40, machine.SupportVectors.Length); } }
private static void testWeights(double[][] inputs, int[] labels, IKernel kernel) { { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.PositiveWeight = 100; smo.NegativeWeight = 1; double error = smo.Run(); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(50, matrix.TruePositives); // has more importance Assert.AreEqual(0, matrix.FalseNegatives); // has more importance } { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.PositiveWeight = 1; smo.NegativeWeight = 100; double error = smo.Run(); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); var matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(50, matrix.TrueNegatives); // has more importance Assert.AreEqual(0, matrix.FalsePositives); // has more importance } }
public void ComputeTest5() { var dataset = SequentialMinimalOptimizationTest.yinyang; var inputs = dataset.Submatrix(null, 0, 1).ToArray(); var labels = dataset.GetColumn(2).ToInt32(); var kernel = new Polynomial(2, 0); { var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.UseComplexityHeuristic = true; double error = smo.Run(); Assert.AreEqual(0.2, error); Assert.AreEqual(0.11714451552090824, smo.Complexity); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(20, matrix.FalseNegatives); Assert.AreEqual(0, matrix.FalsePositives); Assert.AreEqual(30, matrix.TruePositives); Assert.AreEqual(50, matrix.TrueNegatives); } { Accord.Math.Tools.SetupGenerator(0); var projection = inputs.Apply(kernel.Transform); var machine = new SupportVectorMachine(projection[0].Length); var smo = new LinearNewtonMethod(machine, projection, labels); smo.UseComplexityHeuristic = true; double error = smo.Run(); Assert.AreEqual(0.18, error); Assert.AreEqual(0.11714451552090821, smo.Complexity, 1e-15); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(projection[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(17, matrix.FalseNegatives); Assert.AreEqual(1, matrix.FalsePositives); Assert.AreEqual(33, matrix.TruePositives); Assert.AreEqual(49, matrix.TrueNegatives); } }
private static void kernelSvm(double[][] inputs, int[] outputs) { // Estimate the kernel from the data var gaussian = Gaussian.Estimate(inputs); // Create a Gaussian binary support machine with 2 inputs var svm = new KernelSupportVectorMachine(gaussian, inputs: 2); // Create a new Sequential Minimal Optimization (SMO) learning // algorithm and estimate the complexity parameter C from data var teacher = new SequentialMinimalOptimization(svm, inputs, outputs) { UseComplexityHeuristic = true }; // Teach the vector machine double error = teacher.Run(); // Classify the samples using the model int[] answers = inputs.Apply(svm.Compute).Apply(System.Math.Sign); // Plot the results ScatterplotBox.Show("Expected results", inputs, outputs); ScatterplotBox.Show("GaussianSVM results", inputs, answers); // Grab the index of multipliers higher than 0 int[] idx = teacher.Lagrange.Find(x => x > 0); // Select the input vectors for those double[][] sv = inputs.Submatrix(idx); // Plot the support vectors selected by the machine ScatterplotBox.Show("Support vectors", sv).Hold(); }
/// <summary> /// Creates a Support Vector Machine and teaches it to recognize /// the previously loaded dataset using the current UI settings. /// </summary> /// private void btnCreate_Click(object sender, EventArgs e) { if (dgvLearningSource.DataSource == null) { MessageBox.Show("Please load some data first."); return; } // Finishes and save any pending changes to the given data dgvLearningSource.EndEdit(); // Creates a matrix from the entire source data table double[,] table = (dgvLearningSource.DataSource as DataTable).ToMatrix(out columnNames); // Get only the input vector values (first two columns) double[][] inputs = table.GetColumns(0, 1).ToArray(); // Get only the output labels (last column) int[] outputs = table.GetColumn(2).ToInt32(); // Create the specified Kernel IKernel kernel = createKernel(); // Creates the Support Vector Machine for 2 input variables svm = new KernelSupportVectorMachine(kernel, inputs: 2); // Creates a new instance of the SMO learning algorithm var smo = new SequentialMinimalOptimization(svm, inputs, outputs) { // Set learning parameters Complexity = (double)numC.Value, Tolerance = (double)numT.Value, PositiveWeight = (double)numPositiveWeight.Value, NegativeWeight = (double)numNegativeWeight.Value }; try { // Run double error = smo.Run(); lbStatus.Text = "Training complete!"; } catch (ConvergenceException) { lbStatus.Text = "Convergence could not be attained. "+ "The learned machine might still be usable."; } // Check if we got support vectors if (svm.SupportVectors.Length == 0) { dgvSupportVectors.DataSource = null; graphSupportVectors.GraphPane.CurveList.Clear(); return; } // Show support vectors on the Support Vectors tab page double[][] supportVectorsWeights = svm.SupportVectors.InsertColumn(svm.Weights); string[] supportVectorNames = columnNames.RemoveAt(columnNames.Length - 1).Concatenate("Weight"); dgvSupportVectors.DataSource = new ArrayDataView(supportVectorsWeights, supportVectorNames); // Show the support vector labels on the scatter plot double[] supportVectorLabels = new double[svm.SupportVectors.Length]; for (int i = 0; i < supportVectorLabels.Length; i++) { int j = inputs.Find(sv => sv == svm.SupportVectors[i])[0]; supportVectorLabels[i] = outputs[j]; } double[][] graph = svm.SupportVectors.InsertColumn(supportVectorLabels); CreateScatterplot(graphSupportVectors, graph.ToMatrix()); // Get the ranges for each variable (X and Y) DoubleRange[] ranges = Matrix.Range(table, 0); // Generate a Cartesian coordinate system double[][] map = Matrix.CartesianProduct( Matrix.Interval(ranges[0], 0.05), Matrix.Interval(ranges[1], 0.05)); // Classify each point in the Cartesian coordinate system double[] result = map.Apply(svm.Compute).Apply(Math.Sign).ToDouble(); double[,] surface = map.ToMatrix().InsertColumn(result); CreateScatterplot(zedGraphControl2, surface); }
public void ComputeTest() { // Example AND problem double[][] inputs = { new double[] { 0, 0 }, // 0 and 0: 0 (label -1) new double[] { 0, 1 }, // 0 and 1: 0 (label -1) new double[] { 1, 0 }, // 1 and 0: 0 (label -1) new double[] { 1, 1 } // 1 and 1: 1 (label +1) }; // Dichotomy SVM outputs should be given as [-1;+1] int[] labels = { // 0, 0, 0, 1 -1, -1, -1, 1 }; // Create a Support Vector Machine for the given inputs KernelSupportVectorMachine machine = new KernelSupportVectorMachine(new Linear(0), inputs[0].Length); // Instantiate a new learning algorithm for SVMs SequentialMinimalOptimization smo = new SequentialMinimalOptimization(machine, inputs, labels); // Set up the learning algorithm smo.Complexity = 100.0; // Run double error = smo.Run(); Assert.AreEqual(0, error); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[0]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[1]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[2]))); Assert.AreEqual(+1, Math.Sign(machine.Compute(inputs[3]))); // At this point we have the weighted support vectors // w sv b // (+4) * (1,1) -3 // (-2) * (1,0) // (-2) * (0,1) // // However, it can be seen that the last SV can be written // as a linear combination of the two first vectors: // // (0,1) = (1,1) - (1,0) // // Since we have a linear space (we are using a linear kernel) // this vector could be removed from the support vector set. // // f(x) = sum(alpha_i * x * x_i) + b // = 4*(1,1)*x - 2*(1,0)*x - 2*(0,1)*x - 3 // = 4*(1,1)*x - 2*(1,0)*x - 2*((1,1) - (1,0))*x - 3 // = 4*(1,1)*x - 2*(1,0)*x - 2*(1,1)*x + 2*(1,0)*x - 3 // = 4*(1,1)*x - 2*(1,0)*x - 2*(1,1)*x + 2*(1,0)*x - 3 // = 2*(1,1)*x - 3 // = 2*x1 + 2*x2 - 3 // SupportVectorReduction svr = new SupportVectorReduction(machine); double error2 = svr.Run(); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[0]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[1]))); Assert.AreEqual(-1, Math.Sign(machine.Compute(inputs[2]))); Assert.AreEqual(+1, Math.Sign(machine.Compute(inputs[3]))); }
public void ComputeTest5() { var dataset = yinyang; double[][] inputs = dataset.Submatrix(null, 0, 1).ToArray(); int[] labels = dataset.GetColumn(2).ToInt32(); { Linear kernel = new Linear(); var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; double error = smo.Run(); Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(1.0, smo.WeightRatio); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(1.0, smo.PositiveWeight); Assert.AreEqual(0.14, error); Assert.AreEqual(30, machine.SupportVectors.Length); double[] actualWeights = machine.Weights; double[] expectedWeights = { -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 0.337065120144639, -1, 1, -0.337065120144639, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1 }; Assert.IsTrue(expectedWeights.IsEqual(actualWeights, 1e-10)); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(7, matrix.FalseNegatives); Assert.AreEqual(7, matrix.FalsePositives); Assert.AreEqual(43, matrix.TruePositives); Assert.AreEqual(43, matrix.TrueNegatives); } { Linear kernel = new Linear(); var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.PositiveWeight = 0.3; smo.NegativeWeight = 1.0; double error = smo.Run(); Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(0.3 / 1.0, smo.WeightRatio); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(0.3, smo.PositiveWeight); Assert.AreEqual(0.21, error); Assert.AreEqual(24, machine.SupportVectors.Length); double[] actualWeights = machine.Weights; //string str = actualWeights.ToString(Accord.Math.Formats.CSharpArrayFormatProvider.InvariantCulture); double[] expectedWeights = { -0.771026323762095, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -0.928973676237905, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; Assert.IsTrue(expectedWeights.IsEqual(actualWeights, 1e-10)); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = (int)machine.Compute(inputs[i]); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(50, matrix.FalseNegatives); Assert.AreEqual(0, matrix.FalsePositives); Assert.AreEqual(0, matrix.TruePositives); Assert.AreEqual(50, matrix.TrueNegatives); } { Linear kernel = new Linear(); var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.PositiveWeight = 1.0; smo.NegativeWeight = 0.3; double error = smo.Run(); Assert.AreEqual(1.0, smo.Complexity); Assert.AreEqual(1.0 / 0.3, smo.WeightRatio); Assert.AreEqual(0.3, smo.NegativeWeight); Assert.AreEqual(1.0, smo.PositiveWeight); Assert.AreEqual(0.15, error); Assert.AreEqual(19, machine.SupportVectors.Length); double[] actualWeights = machine.Weights; double[] expectedWeights = new double[] { 1, 1, -0.3, 1, -0.3, 1, 1, -0.3, 1, 1, 1, 1, 1, 1, 1, 1, 0.129080057278249, 1, 0.737797469918795 }; Assert.IsTrue(expectedWeights.IsEqual(actualWeights, 1e-10)); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(0, matrix.FalseNegatives); Assert.AreEqual(50, matrix.FalsePositives); Assert.AreEqual(50, matrix.TruePositives); Assert.AreEqual(0, matrix.TrueNegatives); } }
public void BootstrapConstructorTest3() { Accord.Math.Tools.SetupGenerator(0); // This is a sample code on how to use 0.632 Bootstrap // to assess the performance of Support Vector Machines. // Consider the example binary data. We will be trying // to learn a XOR problem and see how well does SVMs // perform on this data. double[][] data = { new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, }; int[] xor = // result of xor for the sample input data { -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, }; // Create a new Bootstrap algorithm passing the set size and the number of resamplings var bootstrap = new Bootstrap(size: data.Length, subsamples: 50); // Define a fitting function using Support Vector Machines. The objective of this // function is to learn a SVM in the subset of the data indicated by the bootstrap. bootstrap.Fitting = delegate(int[] indicesTrain, int[] indicesValidation) { // The fitting function is passing the indices of the original set which // should be considered training data and the indices of the original set // which should be considered validation data. // Lets now grab the training data: var trainingInputs = data.Submatrix(indicesTrain); var trainingOutputs = xor.Submatrix(indicesTrain); // And now the validation data: var validationInputs = data.Submatrix(indicesValidation); var validationOutputs = xor.Submatrix(indicesValidation); // Create a Kernel Support Vector Machine to operate on the set var svm = new KernelSupportVectorMachine(new Polynomial(2), 2); // Create a training algorithm and learn the training data var smo = new SequentialMinimalOptimization(svm, trainingInputs, trainingOutputs); double trainingError = smo.Run(); // Now we can compute the validation error on the validation data: double validationError = smo.ComputeError(validationInputs, validationOutputs); // Return a new information structure containing the model and the errors achieved. return new BootstrapValues(trainingError, validationError); }; // Compute the bootstrap estimate var result = bootstrap.Compute(); // Finally, access the measured performance. double trainingErrors = result.Training.Mean; double validationErrors = result.Validation.Mean; // And compute the 0.632 estimate double estimate = result.Estimate; Assert.AreEqual(50, bootstrap.B); Assert.AreEqual(0, trainingErrors); Assert.AreEqual(0.021428571428571429, validationErrors); Assert.AreEqual(50, bootstrap.Subsamples.Length); Assert.AreEqual(0.013542857142857143, estimate); }
public void DynamicalTimeWarpingConstructorTest() { double[][] sequences = { new double[] // -1 { 0, 0, 0, 1, 1, 1, 2, 2, 2, }, new double[] // -1 { 0, 1, 0, 0, 2, 0, 0, 3, 0 }, new double[] // +1 { 1, 1, 0, 1, 2, 0, 2, 1, 0, }, new double[] // +1 { 0, 0, 1, 0, 0, 2, 0, 1, 3, }, }; int[] outputs = { -1, -1, +1, +1 }; // Set the parameters of the kernel double alpha = 0.85; int innerVectorLength = 3; // Create the kernel. Note that the input vector will be given out automatically DynamicTimeWarping target = new DynamicTimeWarping(innerVectorLength, alpha); // When using variable-length kernels, specify 0 as the input length. KernelSupportVectorMachine svm = new KernelSupportVectorMachine(target, 0); // Create the Sequential Minimal Optimization as usual SequentialMinimalOptimization smo = new SequentialMinimalOptimization(svm, sequences, outputs); smo.Complexity = 1.5; double error = smo.Run(); // Computing the training values var a0 = svm.Compute(sequences[0]); var a1 = svm.Compute(sequences[1]); var a2 = svm.Compute(sequences[2]); var a3 = svm.Compute(sequences[3]); Assert.AreEqual(-1, System.Math.Sign(a0)); Assert.AreEqual(-1, System.Math.Sign(a1)); Assert.AreEqual(+1, System.Math.Sign(a2)); Assert.AreEqual(+1, System.Math.Sign(a3)); // Computing a new testing value double[] test = { 1, 0, 1, 0, 0, 2, 0, 1, 3, }; var a4 = svm.Compute(test); }
public void LargeLearningTest1() { // Create large input vectors int rows = 1000; int dimension = 10000; double[][] inputs = new double[rows][]; int[] outputs = new int[rows]; Random rnd = new Random(); for (int i = 0; i < inputs.Length; i++) { inputs[i] = new double[dimension]; if (i > rows / 2) { for (int j = 0; j < dimension; j++) inputs[i][j] = rnd.NextDouble(); outputs[i] = -1; } else { for (int j = 0; j < dimension; j++) inputs[i][j] = rnd.NextDouble() * 4.21 + 5; outputs[i] = +1; } } KernelSupportVectorMachine svm = new KernelSupportVectorMachine(new Polynomial(2), dimension); SequentialMinimalOptimization smo = new SequentialMinimalOptimization(svm, inputs, outputs) { UseComplexityHeuristic = true }; double error = smo.Run(); Assert.AreEqual(0, error); }
public void SplitSetConstructorTest1() { Accord.Math.Tools.SetupGenerator(0); // This is a sample code on how to use two split sets // to assess the performance of Support Vector Machines. // Consider the example binary data. We will be trying // to learn a XOR problem and see how well does SVMs // perform on this data. double[][] data = { new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, new double[] { -1, -1 }, new double[] { 1, -1 }, new double[] { -1, 1 }, new double[] { 1, 1 }, }; int[] xor = // result of xor for the sample input data { -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, }; // Create a new split set validation algorithm passing the set size and the split set proportion var splitset = new SplitSetValidation<KernelSupportVectorMachine>(size: data.Length, proportion: 0.4); // Define a fitting function using Support Vector Machines. The objective of this // function is to learn a SVM in the subset of the data indicated by the split sets. splitset.Fitting = delegate(int[] indicesTrain) { // The fitting function is passing the indices of the original set which // should be considered training data and the indices of the original set // which should be considered validation data. // Lets now grab the training data: var trainingInputs = data.Submatrix(indicesTrain); var trainingOutputs = xor.Submatrix(indicesTrain); // Create a Kernel Support Vector Machine to operate on the set var svm = new KernelSupportVectorMachine(new Polynomial(2), 2); // Create a training algorithm and learn the training data var smo = new SequentialMinimalOptimization(svm, trainingInputs, trainingOutputs); double trainingError = smo.Run(); // Compute results for the training set int[] computedOutputs = trainingInputs.Apply(svm.Compute).Apply(Math.Sign); // Compute the absolute error int[] errors = (computedOutputs.Subtract(trainingOutputs)).Abs(); // Retrieve error statistics double mean = errors.Mean(); double variance = errors.Variance(); // Return a new information structure containing the model and the errors. return SplitSetStatistics.Create(svm, trainingInputs.Length, mean, variance); }; splitset.Evaluation = delegate(int[] indicesValidation, KernelSupportVectorMachine svm) { // Lets now grab the training data: var validationInputs = data.Submatrix(indicesValidation); var validationOutputs = xor.Submatrix(indicesValidation); // Compute results for the validation set int[] computedOutputs = validationInputs.Apply(svm.Compute).Apply(Math.Sign); // Compute the absolute error int[] errors = (computedOutputs.Subtract(validationOutputs)).Abs(); // Retrieve error statistics double mean = errors.Mean(); double variance = errors.Variance(); // Return a new information structure containing the model and the errors. return SplitSetStatistics.Create(svm, validationInputs.Length, mean, variance); }; // Compute the bootstrap estimate var result = splitset.Compute(); // Finally, access the measured performance. double trainingErrors = result.Training.Value; double validationErrors = result.Validation.Value; Assert.AreEqual(0, trainingErrors); Assert.AreEqual(0, validationErrors); }
public void DynamicalTimeWarpingConstructorTest2() { // Declare some testing data 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 = { -1,-1,-1,-1, // First four sequences are of class -1 1, 1, 1, 1, 1 // Last five sequences are of class +1 }; // Set the parameters of the kernel double alpha = 1.0; int degree = 1; int innerVectorLength = 1; // Create the kernel. Note that the input vector will be given out automatically DynamicTimeWarping target = new DynamicTimeWarping(innerVectorLength, alpha, degree); // When using variable-length kernels, specify 0 as the input length. KernelSupportVectorMachine svm = new KernelSupportVectorMachine(target, 0); // Create the Sequential Minimal Optimization as usual SequentialMinimalOptimization smo = new SequentialMinimalOptimization(svm, inputs, outputs); smo.Complexity = 1.5; double error = smo.Run(); // Check if the model has learnt the sequences correctly. for (int i = 0; i < inputs.Length; i++) { int expected = outputs[i]; int actual = System.Math.Sign(svm.Compute(inputs[i])); Assert.AreEqual(expected, actual); } // Testing new sequences Assert.AreEqual(-1,System.Math.Sign(svm.Compute(new double[] { 0, 1, 1, 0, 0 }))); Assert.AreEqual(+1,System.Math.Sign(svm.Compute(new double[] { 1, 1, 0, 0, 1, 1 }))); }
public void ComplexityHeuristicTest() { var dataset = yinyang; double[][] inputs = dataset.Submatrix(null, 0, 1).ToArray(); int[] labels = dataset.GetColumn(2).ToInt32(); var linear = new SupportVectorMachine(inputs[0].Length); Linear kernel = new Linear(0); var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo1 = new SequentialMinimalOptimization(machine, inputs, labels); smo1.UseClassProportions = true; smo1.UseComplexityHeuristic = true; double e1 = smo1.Run(); var smo2 = new SequentialMinimalOptimization(linear, inputs, labels); smo2.UseClassProportions = true; smo2.UseComplexityHeuristic = true; double e2 = smo2.Run(); Assert.AreEqual(smo1.Complexity, smo2.Complexity); Assert.AreEqual(e1, e2); }
private void button3_Click(object sender, EventArgs e) { string[] Second = File.ReadAllLines(textBox14.Text); string[] First = File.ReadAllLines(textBox13.Text); List<double[]> F = new List<double[]>(); List<double[]> S = new List<double[]>(); double Alpha1Thresh = int.MaxValue; //2000;// int.MaxValue;// double Alpha2Thresh = int.MaxValue; //2000; // for (int i=0;i<First.Length;i++) { string[] s1 = First[i].Split(' '); if ((double.Parse(s1[2]) < Alpha1Thresh) && (double.Parse(s1[3]) < Alpha2Thresh)) { double[] ar = new double[VectorSize]; double sum = 0; for (int j = 0; j < VectorSize; j++) { ar[j] = double.Parse(s1[j]); if ((j < VectorSize - 2) && (2<=j )) sum += ar[j]; } for (int j = 2; j < VectorSize-2; j++) ar[j] = ar[j] / 1000; if (ar[0] > 2000) { ar[0] = 2000; } if (ar[1] > 2000) { ar[1] = 2000; } ar[0] = ar[0] / 2000; ar[1] = ar[1] / 2000; ar[VectorSize - 2] = ar[VectorSize - 2] / 100; ar[VectorSize - 1] = ar[VectorSize - 1] / 100; F.Add(ar); } } for (int i = 0; i < Second.Length; i++) { string[] s1 = Second[i].Split(' '); if ((double.Parse(s1[2]) < Alpha1Thresh) && (double.Parse(s1[3]) < Alpha2Thresh)) { double[] ar = new double[VectorSize]; double sum = 0; for (int j = 0; j < VectorSize; j++) { ar[j] = double.Parse(s1[j]); if ((j < VectorSize - 2) && (2 <= j)) sum += ar[j]; } for (int j = 2; j < VectorSize - 2; j++) ar[j] = ar[j] / 1000; if (ar[0]>2000) { ar[0] = 2000; } if (ar[1] > 2000) { ar[1] = 2000; } ar[0] = ar[0] / 2000; ar[1] = ar[1] / 2000; ar[VectorSize - 2] = ar[VectorSize - 2] / 100; ar[VectorSize - 1] = ar[VectorSize - 1] / 100; S.Add(ar); } } int min = Math.Min(F.Count, S.Count); double[][] inputs = new double[2*min][]; int[] outputs = new int[2*min]; int VS = VectorSize; //ТУТ for (int j=0;j<min;j++) { inputs[j] = new double[VS]; inputs[j + min] = new double[VS]; for (int i = 0; i < VS; i++) // for (int i = VectorSize - 2; i < VectorSize; i++)//ТУТ { inputs[j][i] = F[j][i];//ТУТ inputs[j + min][i] = S[j][i];//ТУТ // inputs[j][i - VectorSize + 2] = F[j][i];//ТУТ // inputs[j + min][i - VectorSize + 2] = S[j][i];//ТУТ } outputs[j] = -1; outputs[j + min] = 1; } // Get only the output labels (last column) // Create the specified Kernel IKernel kernel = new Gaussian((double)0.560); // IKernel kernel = new Polynomial(5, 500.0); // Creates the Support Vector Machine for 2 input variables svm = new KernelSupportVectorMachine(kernel, inputs: VS); // Creates a new instance of the SMO learning algorithm var smo = new SequentialMinimalOptimization(svm, inputs, outputs) { // Set learning parameters Complexity = (double)1.50, Tolerance = (double)0.001, PositiveWeight = (double)1.00, NegativeWeight = (double)1.00, }; try { // Run double error = smo.Run(); } catch (ConvergenceException) { } // double d = svm.Compute(inputs[10]); points.Clear(); Points = 0; points_mid.Clear(); timer3.Enabled = true; }
public void UseClassProportionsTest() { var dataset = KernelSupportVectorMachineTest.training; var inputs = dataset.Submatrix(null, 0, 3); var labels = Tools.Scale(0, 1, -1, 1, dataset.GetColumn(4)).ToInt32(); Gaussian kernel = Gaussian.Estimate(inputs); var machine = new KernelSupportVectorMachine(kernel, inputs[0].Length); var smo = new SequentialMinimalOptimization(machine, inputs, labels); smo.Complexity = 1.0; smo.UseClassProportions = true; double error = smo.Run(); Assert.AreEqual(1, smo.Complexity); Assert.AreEqual(0.4, smo.PositiveWeight); Assert.AreEqual(1.0, smo.NegativeWeight); Assert.AreEqual(0.4, smo.WeightRatio, 1e-10); Assert.AreEqual(0.2857142857142857, error); Assert.AreEqual(265.78327637381551, (machine.Kernel as Gaussian).Sigma); Assert.AreEqual(26, machine.SupportVectors.Length); int[] actual = new int[labels.Length]; for (int i = 0; i < actual.Length; i++) actual[i] = Math.Sign(machine.Compute(inputs[i])); ConfusionMatrix matrix = new ConfusionMatrix(actual, labels); Assert.AreEqual(12, matrix.FalseNegatives); Assert.AreEqual(0, matrix.FalsePositives); Assert.AreEqual(0, matrix.TruePositives); Assert.AreEqual(30, matrix.TrueNegatives); }