| public Transform ( double input ) : double[] | ||
| input | double | The input point to be projected into feature space. |
| Résultat | double[] | |
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
};
var kernel = new Polynomial(2, 0.0);
double[][] augmented = new double[inputs.Length][];
for (int i = 0; i < inputs.Length; i++)
augmented[i] = kernel.Transform(inputs[i]);
SupportVectorMachine machine = new SupportVectorMachine(augmented[0].Length);
// Create the Least Squares Support Vector Machine teacher
var learn = new LinearDualCoordinateDescent(machine, augmented, xor);
// Run the learning algorithm
double error = learn.Run();
Assert.AreEqual(0, error);
int[] output = augmented.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 void ExpandReverseDistanceTest()
{
for (int i = 1; i <= 10; i++)
{
Polynomial kernel = new Polynomial(i, 0);
var x = new double[] { 0.5, 2.0 };
var y = new double[] { 1.3, -0.2 };
var phi_x = kernel.Transform(x);
var phi_y = kernel.Transform(y);
//int expected_size = (int)System.Math.Pow(x.Length, i);
//Assert.AreEqual(phi_x.Length, phi_y.Length);
//Assert.AreEqual(phi_x.Length, expected_size);
double d = Distance.SquareEuclidean(x, y);
double phi_d = kernel.ReverseDistance(phi_x, phi_y);
Assert.AreEqual(phi_d, d, 1e-6);
Assert.IsFalse(double.IsNaN(phi_d));
Assert.IsFalse(double.IsNaN(d));
}
}
public void ExpandDistanceTest()
{
for (int i = 1; i <= 10; i++)
{
Polynomial kernel = new Polynomial(i, 0);
var x = new double[] { 0.5, 2.0 };
var y = new double[] { 1.3, -0.2 };
var phi_x = kernel.Transform(x);
var phi_y = kernel.Transform(y);
double d1 = Distance.SquareEuclidean(phi_x, phi_y);
double d2 = kernel.Distance(x, y);
double d3 = Accord.Statistics.Tools.Distance(kernel, x, y);
Assert.AreEqual(d1, d2, 1e-4);
Assert.AreEqual(d1, d3, 1e-4);
Assert.IsFalse(double.IsNaN(d1));
Assert.IsFalse(double.IsNaN(d2));
Assert.IsFalse(double.IsNaN(d3));
}
}
public void ComputeTest5()
{
var dataset = SequentialMinimalOptimizationTest.yinyang;
double[][] inputs = dataset.Submatrix(null, 0, 1).ToJagged();
int[] 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 LinearDualCoordinateDescent(machine, projection, labels);
smo.UseComplexityHeuristic = true;
smo.Tolerance = 0.01;
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);
}
{
Accord.Math.Random.Generator.Seed = 0;
var projection = inputs.Apply(kernel.Transform);
var machine = new SupportVectorMachine(projection[0].Length);
var smo = new LinearDualCoordinateDescent(machine, projection, labels);
smo.UseComplexityHeuristic = true;
smo.Loss = Loss.L1;
double error = smo.Run();
Assert.AreEqual(0.2, 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(kernel.Transform(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);
}
}
