public void GammaSigmaTest() { var dtw = new DynamicTimeWarping(1); var gaussian = new Gaussian<DynamicTimeWarping>(dtw, 1); double expected, actual, gamma, sigma; expected = 0.01; gaussian.Sigma = expected; gamma = gaussian.Gamma; gaussian.Gamma = gamma; actual = gaussian.Sigma; Assert.AreEqual(expected, actual); expected = 0.01; gaussian.Gamma = expected; sigma = gaussian.Sigma; gaussian.Sigma = sigma; actual = gaussian.Gamma; Assert.AreEqual(expected, actual, 1e-12); }
public void DistanceTest() { Gaussian dense = new Gaussian(3.6); SparseGaussian target = new SparseGaussian(3.6); double[] sx = { 1, -0.555556, 2, +0.250000, 3, -0.864407, 4, -0.916667 }; double[] sy = { 1, -0.666667, 2, -0.166667, 3, -0.864407, 4, -0.916667 }; double[] sz = { 1, -0.944444, 3, -0.898305, 4, -0.916667 }; double[] dx = { -0.555556, +0.250000, -0.864407, -0.916667 }; double[] dy = { -0.666667, -0.166667, -0.864407, -0.916667 }; double[] dz = { -0.944444, +0.000000, -0.898305, -0.916667 }; double expected, actual; expected = dense.Distance(dx, dy); actual = target.Distance(sx, sy); Assert.AreEqual(expected, actual); expected = dense.Distance(dx, dz); actual = target.Distance(sx, sz); Assert.AreEqual(expected, actual); expected = dense.Distance(dy, dz); actual = target.Distance(sy, sz); Assert.AreEqual(expected, actual); }
public void SVMGaussianKernel() { Console.WriteLine("SottoProgramma chiamato: GaussianKernel; Kernel = Gaussian."); this.clock = DateTime.Now; // if sigma is to be set, uncomment the next two lines (and line >> Kernel = Kker in the teacher properties) // otherwise, comment the following two lines and uncomment // >> UseKernelEstimation = false // in such a way, SMO algorithm shall optimize the constrained // problem // min _{w} || w ||^2 / 2 // given y_i (x_i * w + b) >= 1 // to find the parameters ( w , b ) \in R ^ (d x 1) IKernel ker = new Gaussian(0.1); Accord.Statistics.Kernels.Gaussian Kker = (Gaussian)ker; var teacher = new MulticlassSupportVectorLearning <Gaussian>() { Learner = (p) => new SequentialMinimalOptimization <Gaussian>() { // UseComplexityHeuristic = false, Complexity = 3 }, Kernel = Kker }; teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // NOTE: here <<teacher>> is the MODEL (so with its parameters and optimization) // so there KERNEL PARAMETERS are comptued (accordingly to the proper command, // based on an initial guess that has been ESTIMATED) // while <<machine>> is the learning algorithm itself, where the MODEL PARAMETERS // are indeed computed, using the SMO before set in the teacher properties // here learning algorithm is taught the training examples to learn // the model parameters ( w , b ) \in R ^ (d + 1) var machine = teacher.Learn(DataSets[1].ItemsFeatures, DataSets[1].CatIDs); // learned being ( w , b ) , we can predict the categories the test examples belong to int[] predicted = machine.Decide(DataSets[0].ItemsFeatures); // error (zero to one loss) is computed double error = new ZeroOneLoss(DataSets[0].CatIDs).Loss(predicted); // results print PrintReport(predicted, error, "Gaussian"); Console.WriteLine("SottoProgramma GaussianKernel terminato.\nErrore: {0}", error); Console.WriteLine("Tempo richiesto per l'operazione: " + (DateTime.Now - clock).TotalSeconds + " secondi."); }
public void GaussianFunctionTest() { var x = new double[] { 0, 4, 2, 1 }; var y = new double[] { 3, 2, }; var dtw = new DynamicTimeWarping(1); IKernel gaussian = new Gaussian<DynamicTimeWarping>(dtw, 1); double actual = gaussian.Function(x, y); Assert.AreEqual(0.3407192298459587, actual); gaussian = new Gaussian<DynamicTimeWarping>(dtw, 11.5); x = new double[] { 0.2, 5 }; y = new double[] { 3, 0.7 }; actual = gaussian.Function(x, y); Assert.AreEqual(0.99065918303292089, actual); }
public void GaussianDistanceTest() { var gaussian = new Gaussian<Linear>(new Linear(0), 1); double[] x = { 1, 1 }; double[] y = { 1, 1 }; double actual = gaussian.Distance(x, y); double expected = 0; Assert.AreEqual(expected, actual); gaussian = new Gaussian<Linear>(new Linear(0), 11.5); x = new double[] { 0.2, 0.5 }; y = new double[] { 0.3, -0.7 }; actual = gaussian.Distance(x, y); expected = Accord.Statistics.Tools.Distance(gaussian, x, y); Assert.AreEqual(expected, actual, 1e-10); }
public void GaussianDistanceTest() { IDistance gaussian = new Gaussian(1); double[] x = { 1, 1 }; double[] y = { 1, 1 }; double actual = gaussian.Distance(x, y); double expected = 0; Assert.AreEqual(expected, actual); gaussian = new Gaussian(11.5); x = new double[] { 0.2, 0.5 }; y = new double[] { 0.3, -0.7 }; actual = gaussian.Distance(x, y); expected = 341.46531595796711; Assert.AreEqual(expected, actual, 1e-10); }
public void GaussianFunctionTest() { IKernel gaussian = new Gaussian(1); double[] x = { 1, 1 }; double[] y = { 1, 1 }; double actual = gaussian.Function(x, y); double expected = 1; Assert.AreEqual(expected, actual); gaussian = new Gaussian(11.5); x = new double[] { 0.2, 5 }; y = new double[] { 3, 0.7 }; actual = gaussian.Function(x, y); expected = 0.9052480234; Assert.AreEqual(expected, actual, 1e-10); }
public void FunctionTest2() { // Tested against R's kernlab double[][] data = { new double[] { 5.1, 3.5, 1.4, 0.2 }, new double[] { 5.0, 3.6, 1.4, 0.2 }, new double[] { 4.9, 3.0, 1.4, 0.2 }, new double[] { 5.8, 4.0, 1.2, 0.2 }, new double[] { 4.7, 3.2, 1.3, 0.2 }, }; // rbf <- rbfdot(sigma = 1) // R's sigma is framework's Gaussian's gamma: Gaussian kernel = new Gaussian() { Gamma = 1 }; // Compute the kernel matrix double[,] actual = new double[5, 5]; for (int i = 0; i < 5; i++) for (int j = 0; j < 5; j++) actual[i, j] = kernel.Function(data[i], data[j]); double[,] expected = { { 1.0000000, 0.9801987, 0.7482636, 0.4584060, 0.7710516 }, { 0.9801987, 1.0000000, 0.6907343, 0.4317105, 0.7710516 }, { 0.7482636, 0.6907343, 1.0000000, 0.1572372, 0.9139312 }, { 0.4584060, 0.4317105, 0.1572372, 1.0000000, 0.1556726 }, { 0.7710516, 0.7710516, 0.9139312, 0.1556726, 1.0000000 }, }; // Assert both are equal for (int i = 0; i < 5; i++) for (int j = 0; j < 5; j++) Assert.AreEqual(expected[i, j], actual[i, j], 1e-6); }
public void KernelFunctionCacheConstructorTest6() { IKernel kernel = new Gaussian(0.6); int cacheSize = inputs.Length; KernelFunctionCache target = new KernelFunctionCache(kernel, inputs, cacheSize); Assert.AreEqual(10, target.Size); Assert.AreEqual(0, target.Hits); Assert.AreEqual(0, target.Misses); for (int i = 0; i < inputs.Length; i++) { double expected = kernel.Function(inputs[i], inputs[i]); double actual = target.GetOrCompute(i); Assert.AreEqual(expected, actual); } Assert.AreEqual(0, target.Hits); for (int i = 0; i < inputs.Length; i++) { for (int j = 0; j < inputs.Length; j++) { double expected = kernel.Function(inputs[i], inputs[j]); double actual = target.GetOrCompute(i, j); Assert.AreEqual(expected, actual); } } for (int i = 0; i < inputs.Length; i++) { for (int j = 0; j < inputs.Length; j++) { double expected = kernel.Function(inputs[i], inputs[j]); double actual = target.GetOrCompute(i, j); Assert.AreEqual(expected, actual); } } Assert.AreEqual(45, target.Misses); Assert.AreEqual(135, target.Hits); Assert.AreEqual(1.0, target.Usage); }
private void btnRunAnalysis_Click(object sender, EventArgs e) { if (dgvAnalysisSource.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 = dgvAnalysisSource.Rows.Count; double[][] input = Jagged.Zeros(rows, 32 * 32); int[] output = new int[rows]; for (int i = 0; i < rows; i++) { input.SetRow(i, (double[])dgvAnalysisSource.Rows[i].Cells["colTrainingFeatures"].Value); output[i] = (int)dgvAnalysisSource.Rows[i].Cells["colTrainingLabel"].Value; } // Create the chosen Kernel with given parameters IKernel kernel; if (rbGaussian.Checked) kernel = new Gaussian((double)numSigma.Value); else kernel = new Polynomial((int)numDegree.Value, (double)numConstant.Value); // Create the Kernel Discriminant Analysis using the selected Kernel kda = new KernelDiscriminantAnalysis(kernel) { Threshold = (double)numThreshold.Value, Regularization = (double)numRegularization.Value }; lbStatus.Text = "Computing the analysis. This may take a significant amount of time..."; Application.DoEvents(); // Compute the analysis. kda.Learn(input, output); // Show information about the analysis in the form dgvPrincipalComponents.DataSource = kda.Discriminants; dgvFeatureVectors.DataSource = new ArrayDataView(kda.DiscriminantVectors); dgvClasses.DataSource = kda.Classes; // Create the component graphs distributionView.DataSource = kda.Discriminants; cumulativeView.DataSource = kda.Discriminants; lbStatus.Text = "Analysis complete. Click Classify to test the analysis."; btnClassify.Enabled = true; }
public void ThresholdTest() { double[,] inputs = { { 1 }, { 2 }, { 3 }, }; int[] output = { 0, 1, 1 }; IKernel kernel = new Gaussian(0.1); KernelDiscriminantAnalysis target = new KernelDiscriminantAnalysis(inputs, output, kernel); bool thrown = false; try { target.Threshold = -1; } catch (ArgumentOutOfRangeException) { thrown = true; } Assert.IsTrue(thrown); thrown = false; try { target.Threshold = 1.1; } catch (ArgumentOutOfRangeException) { thrown = true; } Assert.IsTrue(thrown); target.Threshold = 1.0; target.Compute(); Assert.AreEqual(2, target.Classes.Count); Assert.AreEqual(0, target.Classes[0].Number); Assert.AreEqual(1, target.Classes[0].Indices.Length); Assert.AreEqual(0, target.Classes[0].Indices[0]); Assert.AreEqual(1, target.Classes[1].Number); Assert.AreEqual(2, target.Classes[1].Indices.Length); Assert.AreEqual(1, target.Classes[1].Indices[0]); Assert.AreEqual(2, target.Classes[1].Indices[1]); Assert.AreEqual(0, target.CumulativeProportions.Length); Assert.AreEqual(3, target.DiscriminantMatrix.GetLength(0)); // dimension Assert.AreEqual(0, target.DiscriminantMatrix.GetLength(1)); // components kept Assert.AreEqual(0, target.DiscriminantProportions.Length); Assert.AreEqual(0, target.Discriminants.Count); }
public void ComputeTest() { double[,] inputs = { { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, }; int[] output = { 0, 1 }; IKernel kernel = new Gaussian(0.1); KernelDiscriminantAnalysis target = new KernelDiscriminantAnalysis(inputs, output, kernel); target.Threshold = 0; target.Compute(); double[,] actual = target.Transform(inputs); double[,] expected = { { 1.0, -1.0}, { -1.0, -1.0}, }; Assert.IsTrue(Matrix.IsEqual(actual, expected)); }
private void btnKernel_Click(object sender, EventArgs e) { double[,] sourceMatrix; double[,] inputs; int[] labels; GetData(out sourceMatrix, out inputs, out labels); //_svm.SimpleSMO(inputs, labels); // Perform classification SequentialMinimalOptimization smo; var kernel = new Gaussian(1.2236000); // Creates the Support Vector Machine using the selected kernel var svm = new KernelSupportVectorMachine(kernel, 2); //SupportVectorMachine svm = new SupportVectorMachine(2); // Creates a new instance of the SMO Learning Algorithm smo = new SequentialMinimalOptimization(svm, inputs.ToArray(), labels); // Set learning parameters smo.Complexity = 1.0; smo.Tolerance = 0.001; bool converged = true; try { // Run double error = smo.Run(); } catch { converged = false; } //var a = sourceMatrix.Submatrix(0, sourceMatrix.GetLength(0) - 1, 0, 2); //CreateScatterplot(graphInput, a, svm); var ranges = Matrix.Range(sourceMatrix); double[][] map = Matrix.CartesianProduct( Matrix.Interval(ranges[0], 0.05), Matrix.Interval(ranges[1], 0.05)); var result = map.Apply(svm.Compute).Apply(Math.Sign); var graph2 = map.ToMatrix().InsertColumn(result.ToDouble()); CreateDecisionBoundaryplot(graphInput, graph2, sourceMatrix); }
public void learn_precomputed() { #region doc_precomputed // 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); #endregion Assert.AreEqual(prediction, Classes.Decide(xor)); Assert.AreEqual(newPrediction.Length, 1); Assert.AreEqual(newPrediction[0], true); }
public void RevertTest2() { string path = @"..\..\..\..\Unit Tests\Accord.Tests.Statistics\Resources\examples.xls"; // Create a new reader, opening a given path ExcelReader reader = new ExcelReader(path); // Afterwards, we can query the file for all // worksheets within the specified workbook: string[] sheets = reader.GetWorksheetList(); // Finally, we can request an specific sheet: DataTable table = reader.GetWorksheet("Wikipedia"); // Now, we have loaded the Excel file into a DataTable. We // can go further and transform it into a matrix to start // running other algorithms on it: double[,] matrix = table.ToMatrix(); IKernel kernel = new Gaussian(5); // Create analysis KernelPrincipalComponentAnalysis target = new KernelPrincipalComponentAnalysis(matrix, kernel, AnalysisMethod.Center, centerInFeatureSpace: false); target.Compute(); double[,] forward = target.Result; double[,] reversion = target.Revert(forward); Assert.IsTrue(!reversion.HasNaN()); }
public void TransformTest5() { int element = 10; int dimension = 20; double[,] data = new double[element, dimension]; int x = 0; for (int i = 0; i < element; i++) { for (int j = 0; j < dimension; j++) data[i, j] = x; x += 10; } IKernel kernel = new Gaussian(10.0); var kpca = new KernelPrincipalComponentAnalysis(data, kernel, AnalysisMethod.Center); kpca.Compute(); double[,] result = kpca.Transform(data, 2); double[,] expected = new double[,] { { -0.23053882357602, -0.284413654763538 }, { -0.387883199575312, -0.331485820285834 }, { -0.422077400361521, -0.11134948984113 }, { -0.322265008788599, 0.23632015508648 }, { -0.12013575394419, 0.490928809797139 }, { 0.120135753938394, 0.490928809796094 }, { 0.322265008787236, 0.236320155085067 }, { 0.422077400363969, -0.111349489837512 }, { 0.38788319957867, -0.331485820278937 }, { 0.230538823577373, -0.28441365475783 } }; Assert.IsTrue(result.IsEqual(expected, 1e-10)); }
public void TransformTest4() { // Tested against R's kernlab // test <- c(16, 117, 94, 132, 13, 73, 68, 129, 91, 50, 56, 12, 145, 105, 35, 53, 38, 51, 85, 116) int[] test = { 15, 116, 93, 131, 12, 72, 67, 128, 90, 49, 55, 11, 144, 104, 34, 52, 37, 50, 84, 115 }; // data(iris) double[,] iris = { #region Fisher's iris dataset { 5.1, 3.5, 1.4, 0.2, 0 }, { 4.9, 3.0, 1.4, 0.2, 0 }, { 4.7, 3.2, 1.3, 0.2, 0 }, { 4.6, 3.1, 1.5, 0.2, 0 }, { 5.0, 3.6, 1.4, 0.2, 0 }, { 5.4, 3.9, 1.7, 0.4, 0 }, { 4.6, 3.4, 1.4, 0.3, 0 }, { 5.0, 3.4, 1.5, 0.2, 0 }, { 4.4, 2.9, 1.4, 0.2, 0 }, { 4.9, 3.1, 1.5, 0.1, 0 }, { 5.4, 3.7, 1.5, 0.2, 0 }, { 4.8, 3.4, 1.6, 0.2, 0 }, { 4.8, 3.0, 1.4, 0.1, 0 }, { 4.3, 3.0, 1.1, 0.1, 0 }, { 5.8, 4.0, 1.2, 0.2, 0 }, { 5.7, 4.4, 1.5, 0.4, 0 }, { 5.4, 3.9, 1.3, 0.4, 0 }, { 5.1, 3.5, 1.4, 0.3, 0 }, { 5.7, 3.8, 1.7, 0.3, 0 }, { 5.1, 3.8, 1.5, 0.3, 0 }, { 5.4, 3.4, 1.7, 0.2, 0 }, { 5.1, 3.7, 1.5, 0.4, 0 }, { 4.6, 3.6, 1.0, 0.2, 0 }, { 5.1, 3.3, 1.7, 0.5, 0 }, { 4.8, 3.4, 1.9, 0.2, 0 }, { 5.0, 3.0, 1.6, 0.2, 0 }, { 5.0, 3.4, 1.6, 0.4, 0 }, { 5.2, 3.5, 1.5, 0.2, 0 }, { 5.2, 3.4, 1.4, 0.2, 0 }, { 4.7, 3.2, 1.6, 0.2, 0 }, { 4.8, 3.1, 1.6, 0.2, 0 }, { 5.4, 3.4, 1.5, 0.4, 0 }, { 5.2, 4.1, 1.5, 0.1, 0 }, { 5.5, 4.2, 1.4, 0.2, 0 }, { 4.9, 3.1, 1.5, 0.2, 0 }, { 5.0, 3.2, 1.2, 0.2, 0 }, { 5.5, 3.5, 1.3, 0.2, 0 }, { 4.9, 3.6, 1.4, 0.1, 0 }, { 4.4, 3.0, 1.3, 0.2, 0 }, { 5.1, 3.4, 1.5, 0.2, 0 }, { 5.0, 3.5, 1.3, 0.3, 0 }, { 4.5, 2.3, 1.3, 0.3, 0 }, { 4.4, 3.2, 1.3, 0.2, 0 }, { 5.0, 3.5, 1.6, 0.6, 0 }, { 5.1, 3.8, 1.9, 0.4, 0 }, { 4.8, 3.0, 1.4, 0.3, 0 }, { 5.1, 3.8, 1.6, 0.2, 0 }, { 4.6, 3.2, 1.4, 0.2, 0 }, { 5.3, 3.7, 1.5, 0.2, 0 }, { 5.0, 3.3, 1.4, 0.2, 0 }, { 7.0, 3.2, 4.7, 1.4, 1 }, { 6.4, 3.2, 4.5, 1.5, 1 }, { 6.9, 3.1, 4.9, 1.5, 1 }, { 5.5, 2.3, 4.0, 1.3, 1 }, { 6.5, 2.8, 4.6, 1.5, 1 }, { 5.7, 2.8, 4.5, 1.3, 1 }, { 6.3, 3.3, 4.7, 1.6, 1 }, { 4.9, 2.4, 3.3, 1.0, 1 }, { 6.6, 2.9, 4.6, 1.3, 1 }, { 5.2, 2.7, 3.9, 1.4, 1 }, { 5.0, 2.0, 3.5, 1.0, 1 }, { 5.9, 3.0, 4.2, 1.5, 1 }, { 6.0, 2.2, 4.0, 1.0, 1 }, { 6.1, 2.9, 4.7, 1.4, 1 }, { 5.6, 2.9, 3.6, 1.3, 1 }, { 6.7, 3.1, 4.4, 1.4, 1 }, { 5.6, 3.0, 4.5, 1.5, 1 }, { 5.8, 2.7, 4.1, 1.0, 1 }, { 6.2, 2.2, 4.5, 1.5, 1 }, { 5.6, 2.5, 3.9, 1.1, 1 }, { 5.9, 3.2, 4.8, 1.8, 1 }, { 6.1, 2.8, 4.0, 1.3, 1 }, { 6.3, 2.5, 4.9, 1.5, 1 }, { 6.1, 2.8, 4.7, 1.2, 1 }, { 6.4, 2.9, 4.3, 1.3, 1 }, { 6.6, 3.0, 4.4, 1.4, 1 }, { 6.8, 2.8, 4.8, 1.4, 1 }, { 6.7, 3.0, 5.0, 1.7, 1 }, { 6.0, 2.9, 4.5, 1.5, 1 }, { 5.7, 2.6, 3.5, 1.0, 1 }, { 5.5, 2.4, 3.8, 1.1, 1 }, { 5.5, 2.4, 3.7, 1.0, 1 }, { 5.8, 2.7, 3.9, 1.2, 1 }, { 6.0, 2.7, 5.1, 1.6, 1 }, { 5.4, 3.0, 4.5, 1.5, 1 }, { 6.0, 3.4, 4.5, 1.6, 1 }, { 6.7, 3.1, 4.7, 1.5, 1 }, { 6.3, 2.3, 4.4, 1.3, 1 }, { 5.6, 3.0, 4.1, 1.3, 1 }, { 5.5, 2.5, 4.0, 1.3, 1 }, { 5.5, 2.6, 4.4, 1.2, 1 }, { 6.1, 3.0, 4.6, 1.4, 1 }, { 5.8, 2.6, 4.0, 1.2, 1 }, { 5.0, 2.3, 3.3, 1.0, 1 }, { 5.6, 2.7, 4.2, 1.3, 1 }, { 5.7, 3.0, 4.2, 1.2, 1 }, { 5.7, 2.9, 4.2, 1.3, 1 }, { 6.2, 2.9, 4.3, 1.3, 1 }, { 5.1, 2.5, 3.0, 1.1, 1 }, { 5.7, 2.8, 4.1, 1.3, 1 }, { 6.3, 3.3, 6.0, 2.5, 2 }, { 5.8, 2.7, 5.1, 1.9, 2 }, { 7.1, 3.0, 5.9, 2.1, 2 }, { 6.3, 2.9, 5.6, 1.8, 2 }, { 6.5, 3.0, 5.8, 2.2, 2 }, { 7.6, 3.0, 6.6, 2.1, 2 }, { 4.9, 2.5, 4.5, 1.7, 2 }, { 7.3, 2.9, 6.3, 1.8, 2 }, { 6.7, 2.5, 5.8, 1.8, 2 }, { 7.2, 3.6, 6.1, 2.5, 2 }, { 6.5, 3.2, 5.1, 2.0, 2 }, { 6.4, 2.7, 5.3, 1.9, 2 }, { 6.8, 3.0, 5.5, 2.1, 2 }, { 5.7, 2.5, 5.0, 2.0, 2 }, { 5.8, 2.8, 5.1, 2.4, 2 }, { 6.4, 3.2, 5.3, 2.3, 2 }, { 6.5, 3.0, 5.5, 1.8, 2 }, { 7.7, 3.8, 6.7, 2.2, 2 }, { 7.7, 2.6, 6.9, 2.3, 2 }, { 6.0, 2.2, 5.0, 1.5, 2 }, { 6.9, 3.2, 5.7, 2.3, 2 }, { 5.6, 2.8, 4.9, 2.0, 2 }, { 7.7, 2.8, 6.7, 2.0, 2 }, { 6.3, 2.7, 4.9, 1.8, 2 }, { 6.7, 3.3, 5.7, 2.1, 2 }, { 7.2, 3.2, 6.0, 1.8, 2 }, { 6.2, 2.8, 4.8, 1.8, 2 }, { 6.1, 3.0, 4.9, 1.8, 2 }, { 6.4, 2.8, 5.6, 2.1, 2 }, { 7.2, 3.0, 5.8, 1.6, 2 }, { 7.4, 2.8, 6.1, 1.9, 2 }, { 7.9, 3.8, 6.4, 2.0, 2 }, { 6.4, 2.8, 5.6, 2.2, 2 }, { 6.3, 2.8, 5.1, 1.5, 2 }, { 6.1, 2.6, 5.6, 1.4, 2 }, { 7.7, 3.0, 6.1, 2.3, 2 }, { 6.3, 3.4, 5.6, 2.4, 2 }, { 6.4, 3.1, 5.5, 1.8, 2 }, { 6.0, 3.0, 4.8, 1.8, 2 }, { 6.9, 3.1, 5.4, 2.1, 2 }, { 6.7, 3.1, 5.6, 2.4, 2 }, { 6.9, 3.1, 5.1, 2.3, 2 }, { 5.8, 2.7, 5.1, 1.9, 2 }, { 6.8, 3.2, 5.9, 2.3, 2 }, { 6.7, 3.3, 5.7, 2.5, 2 }, { 6.7, 3.0, 5.2, 2.3, 2 }, { 6.3, 2.5, 5.0, 1.9, 2 }, { 6.5, 3.0, 5.2, 2.0, 2 }, { 6.2, 3.4, 5.4, 2.3, 2 }, { 5.9, 3.0, 5.1, 1.8, 2 }, #endregion }; // kpc <- kpca(~.,data=iris[-test,-5],kernel="rbfdot",kpar=list(sigma=0.2),features=2) var data = iris.Remove(test, new[] { 4 }); var kernel = new Gaussian() { Gamma = 1 }; var kpc = new KernelPrincipalComponentAnalysis(data, kernel); kpc.Compute(2); var rotated = kpc.Result; var pcv = kpc.ComponentMatrix; var eig = kpc.Eigenvalues; double[] expected_eig = { 28.542404060412132, 15.235596653653861 }; double[,] expected_pcv = { #region expected PCV without R's / m normalization { -0.0266876243479222, -0.00236424647855596 }, { -0.0230827502249994, -0.00182207284533632 }, { -0.0235846044938792, -0.00184417084258023 }, { -0.0219741114149703, -0.00162806197434679 }, { -0.0262369254935451, -0.00228351232176506 }, { -0.0194129527129315, -0.00128157547584046 }, { -0.0233710173690426, -0.00183018780267092 }, { -0.0270621345426091, -0.00244551460941156 }, { -0.01660360115437, -0.000759995006404066 }, { -0.0241543595644871, -0.00200028851593623 }, { -0.0229396684027426, -0.00178791975184668 }, { -0.0141003945759371, -0.000349601250510858 }, { -0.0122801944616023, -0.00011745003303124 }, { -0.0195599909514198, -0.00123924882430174 }, { -0.0267285199984888, -0.00237835151986576 }, { -0.0164051441608544, -0.000826433392421186 }, { -0.0241385103747907, -0.00196921837902471 }, { -0.0228276819006861, -0.00190280719845395 }, { -0.0250090125071634, -0.00212322482498387 }, { -0.018268574949505, -0.00103729989327242 }, { -0.0239555047501124, -0.00216590896337712 }, { -0.0218837974825259, -0.00180921340210779 }, { -0.0228699114274226, -0.00189079843025579 }, { -0.0262414571955617, -0.00238666692022459 }, { -0.02628286882499, -0.00232756740052467 }, { -0.0261369413490628, -0.00229661111040973 }, { -0.0237893959503383, -0.00195315162891338 }, { -0.0237354902927562, -0.00197089686864334 }, { -0.0234996712936547, -0.0019545398678434 }, { -0.0179796342021205, -0.00100004281923827 }, { -0.0143171193045046, -0.000421228427584423 }, { -0.0241702773143143, -0.00196078350204665 }, { -0.0215781675204649, -0.00158425565875557 }, { -0.0174405137049866, -0.000872162100068597 }, { -0.0268982927662575, -0.00242925852652081 }, { -0.0261930727206913, -0.00227548913089953 }, { -0.00807266421494459, 0.000505384268295841 }, { -0.0189832707329651, -0.00111618515851182 }, { -0.023789443724428, -0.00203239968623136 }, { -0.0201457716377357, -0.00150731437393246 }, { -0.0226387870826046, -0.00174799717649726 }, { -0.0237772220904885, -0.00192536309172948 }, { -0.0227864577886965, -0.00172757669197999 }, { -0.0241368046325238, -0.00197147776349598 }, { 0.0162307596401467, -0.00932217153629181 }, { 0.00924104683890504, -0.0371256298132236 }, { 0.0172460604733757, -0.00601678602419225 }, { 0.0164784470762724, -0.00012129053123478 }, { 0.00225808467595593, -0.0155701555363185 }, { 0.0152659569368524, -0.00695503994803249 }, { 0.00795619200816849, -0.034188555904496 }, { 0.00255986394744671, -0.0156335839305463 }, { 0.0157735235376026, -0.0339711483141172 }, { 0.00860192955815661, -0.0310332456913026 }, { 0.0188286198627367, -0.0143146603067418 }, { 0.0081385823965042, -0.0358483794263587 }, { 0.0131727085950618, -0.00748671161967017 }, { 0.0150373592446138, -0.0269773780381651 }, { 0.0126779242124717, -0.0162727482334416 }, { 0.00983265072294127, -0.0416039968698012 }, { 0.0162669562079483, -0.000151449934923387 }, { 0.0137854766363786, -0.0375070307423622 }, { 0.0170058660389757, -0.0184237621007135 }, { 0.0154946725649067, -0.0227889410670457 }, { 0.014708096275464, -0.011169199019916 }, { 0.0135541309647514, 0.00627293040317239 }, { 0.0153982178833786, 0.0228745884070871 }, { 0.0186116855914761, -0.0238281923214434 }, { 0.00661605660296714, -0.0332168101819555 }, { 0.00812230548276198, -0.0380947707628449 }, { 0.00704157480127114, -0.0353293378234606 }, { 0.0118813500247593, -0.0433955442329169 }, { 0.0168403649935284, 0.00717417511929008 }, { 0.0144885311444922, -0.0128879186387195 }, { 0.0148385454088314, 0.00481616750741218 }, { 0.0127847825706042, -0.0211295878510692 }, { 0.0126141523297424, -0.0394948238730571 }, { 0.0105804278587419, -0.0411832808826231 }, { 0.0185081272399827, -0.0181339486962481 }, { 0.0124993892884636, -0.0434407731971394 }, { 0.0135227934497893, -0.0415894662412569 }, { 0.0136028421755366, -0.0388446289823116 }, { 0.0144604273990706, -0.0404041262573942 }, { 0.0165646866155949, -0.0294021220435322 }, { 0.00146858312783178, -0.0134333124454357 }, { 0.0137785343752508, -0.0429733697468562 }, { 0.00510997410924024, 0.0292833047881736 }, { 0.014720812085274, 0.00944264118212137 }, { 0.00598583015620509, 0.038742545754176 }, { 0.0125544895333347, 0.0349170237345097 }, { 0.00140911493699792, 0.0164126558963803 }, { 0.00546764790022381, -0.0140904440836446 }, { 0.0029496609416271, 0.0249945804373137 }, { 0.00769932014045035, 0.0313261912102264 }, { 0.00266139821119332, 0.0231665860038695 }, { 0.0147368620502789, 0.0315131740192214 }, { 0.0149582869669828, 0.0314622232024109 }, { 0.0106818628524054, 0.0443273862959601 }, { 0.0123400540017047, 0.00422397833506881 }, { 0.0101542521522688, 0.0157643916651046 }, { 0.000660568495239385, 0.0087957765410289 }, { 0.000634971613911479, 0.00896839373841372 }, { 0.0119909422310846, -0.0019235494568038 }, { 0.00742254354227651, 0.0421145349479265 }, { 0.0130658707704511, 0.000658712215109605 }, { 0.00103199141821948, 0.0130131637684367 }, { 0.0180388007633923, 0.0112135357385706 }, { 0.00879897568153878, 0.0428371609763469 }, { 0.00466754803065601, 0.0321456973019424 }, { 0.0188135431637204, 0.00458127473828957 }, { 0.0184728744733845, 0.00843677964296344 }, { 0.0055676853191067, 0.0305087649038716 }, { 0.0033635667326866, 0.026834775073324 }, { 0.0108405706484462, 0.0394739066547236 }, { 0.0172770225385115, 0.0124967454210229 }, { 0.0100507351970463, 0.0166565450918105 }, { 0.00209404741665691, 0.0205532162586405 }, { 0.0078782378323636, 0.0341148825697675 }, { 0.0132731813046484, 0.0368540207320806 }, { 0.0182550250587539, 0.000797957664175355 }, { 0.0102561686092287, 0.0420705939254378 }, { 0.00857331992305152, 0.0423810139397453 }, { 0.00964648674506066, 0.0337591223497657 }, { 0.014720812085274, 0.00944264118212137 }, { 0.00659947194015947, 0.0404655648392282 }, { 0.011337029514041, 0.0378339231578959 }, { 0.0154602034267052, 0.0153085911335171 }, { 0.0152371977428677, 0.0355309408870963 }, { 0.0096520854263212, 0.0316677099444034 }, { 0.016280981143395, 0.011860068380509 } #endregion }; Assert.IsTrue(Matrix.IsEqual(expected_eig, eig, 1e-10)); Assert.IsTrue(Matrix.IsEqual(expected_pcv, pcv, 1e-10)); double[,] irisSubset = { #region Iris subset for testing { 5.7, 4.4, 1.5, 0.4 }, { 6.5, 3.0, 5.5, 1.8 }, { 5.0, 2.3, 3.3, 1.0 }, { 7.9, 3.8, 6.4, 2.0 }, { 4.8, 3.0, 1.4, 0.1 }, { 6.3, 2.5, 4.9, 1.5 }, { 5.8, 2.7, 4.1, 1.0 }, { 6.4, 2.8, 5.6, 2.1 }, { 5.5, 2.6, 4.4, 1.2 }, { 5.0, 3.3, 1.4, 0.2 }, { 5.7, 2.8, 4.5, 1.3 }, { 4.8, 3.4, 1.6, 0.2 }, { 6.7, 3.3, 5.7, 2.5 }, { 6.5, 3.0, 5.8, 2.2 }, { 4.9, 3.1, 1.5, 0.2 }, { 6.9, 3.1, 4.9, 1.5 }, { 4.9, 3.6, 1.4, 0.1 }, { 7.0, 3.2, 4.7, 1.4 }, { 5.4, 3.0, 4.5, 1.5 }, { 6.4, 3.2, 5.3, 2.3 }, #endregion }; var testing = iris.Submatrix(test, new[] { 0, 1, 2, 3 }); Assert.IsTrue(Matrix.IsEqual(irisSubset, testing)); double[,] proj = kpc.Transform(testing); double[,] expectedProjection = { #region expected projection without R's /m normalization { -0.262045246354652, 0.00522592803297944 }, { 0.379100878015288, 0.588655883281293 }, { 0.071459976634984, -0.256289120689712 }, { 0.0208479105625222, 0.139976227370984 }, { -0.634360697174036, -0.0253624940325211 }, { 0.467841054198416, 0.0142078237631541 }, { 0.3464723948387, -0.62695357333265 }, { 0.327328144102457, 0.603762286061834 }, { 0.351964514241981, -0.539035845068089 }, { -0.759054821003877, -0.035920361137046 }, { 0.449638018323254, -0.492049890038061 }, { -0.732335083049923, -0.0341252836840602 }, { 0.192183096200302, 0.580343336854431 }, { 0.256170478557119, 0.639157216957949 }, { -0.703212303846621, -0.0317868463626801 }, { 0.3515430820112, 0.224868844202495 }, { -0.722813976459246, -0.0325608519534802 }, { 0.286990265042346, 0.102161459040097 }, { 0.354904620698745, -0.390810675482863 }, { 0.332125880099634, 0.566660263312128 } #endregion }; Assert.IsTrue(expectedProjection.IsEqual(proj, 1e-6)); }
public void GaussianReverseDistanceTest() { var gaussian = new Gaussian(4.2); var x = new double[] { 0.2, 0.5 }; var y = new double[] { 0.3, -0.7 }; double expected = Distance.SquareEuclidean(x, y); double df = gaussian.Distance(x, y); double actual = gaussian.ReverseDistance(df); Assert.AreEqual(expected, actual, 1e-10); }
public void RevertTest2_new_method() { string path = @"Resources\examples.xls"; // Create a new reader, opening a given path ExcelReader reader = new ExcelReader(path); // Afterwards, we can query the file for all // worksheets within the specified workbook: string[] sheets = reader.GetWorksheetList(); // Finally, we can request an specific sheet: DataTable table = reader.GetWorksheet("Wikipedia"); // Now, we have loaded the Excel file into a DataTable. We // can go further and transform it into a matrix to start // running other algorithms on it: double[][] matrix = table.ToArray(); IKernel kernel = new Gaussian(5); // Create analysis var target = new KernelPrincipalComponentAnalysis(kernel) { Method = PrincipalComponentMethod.Center, Center = true // Center in feature space }; var regression = target.Learn(matrix); double[][] forward = regression.Transform(matrix); double[][] reversion = target.Revert(forward); Assert.IsTrue(!reversion.HasNaN()); }
public void test_kernlab_new_method() { // Tested against R's kernlab // test <- c(16, 117, 94, 132, 13, 73, 68, 129, 91, 50, 56, 12, 145, 105, 35, 53, 38, 51, 85, 116) int[] test = { 15, 116, 93, 131, 12, 72, 67, 128, 90, 49, 55, 11, 144, 104, 34, 52, 37, 50, 84, 115 }; // data(iris) double[,] iris = create_iris(); // kpc <- kpca(~.,data=iris[-test,-5],kernel="rbfdot",kpar=list(sigma=0.2),features=2) var data = iris.Remove(test, new[] { 4 }); var kernel = new Gaussian() { Gamma = 1 }; var kpc = new KernelPrincipalComponentAnalysis(kernel); kpc.NumberOfOutputs = 2; var transform = kpc.Learn(data); var rotated = kpc.Result; var pcv = kpc.ComponentMatrix; var eig = kpc.Eigenvalues; double[] expected_eig = { 28.542404060412132, 15.235596653653861 }; double[,] expected_pcv = expected_r(); Assert.IsTrue(Matrix.IsEqual(expected_eig, eig, 1e-10)); Assert.IsTrue(Matrix.IsEqual(expected_pcv, pcv, 1e-10)); double[,] irisSubset = iris_sub(); var testing = iris.Submatrix(test, new[] { 0, 1, 2, 3 }); Assert.IsTrue(Matrix.IsEqual(irisSubset, testing)); double[,] expectedProjection = expected_p(); double[,] proj = kpc.Transform(testing); Assert.IsTrue(expectedProjection.IsEqual(proj, 1e-6)); double[][] proj2 = kpc.Transform(testing.ToJagged()); Assert.IsTrue(expectedProjection.IsEqual(proj, 1e-6)); double[][] proj3 = transform.Transform(testing.ToJagged()); Assert.IsTrue(expectedProjection.IsEqual(proj, 1e-6)); }
public void FunctionTest_EqualInputs() { var x = new double[] { 1, 2, 5, 1 }; var y = new double[] { 1, 2, 5, 1 }; var target = new Gaussian<Linear>(new Linear(1), 4.2); double expected = target.Function(x, y); double actual = target.Function(x, x); Assert.AreEqual(expected, actual); }
/// <summary> /// Estimates a suitable value for SMO's Complexity parameter C. /// </summary> /// private void btnEstimateC_Click(object sender, EventArgs e) { // Extract inputs int rows = dgvTrainingSource.Rows.Count; double[][] input = new double[rows][]; for (int i = 0; i < rows; i++) input[i] = (double[])dgvTrainingSource.Rows[i].Cells["colTrainingFeatures"].Value; IKernel kernel; if (rbGaussian.Checked) kernel = new Gaussian((double)numSigma.Value); else kernel = new Polynomial((int)numDegree.Value, (double)numConstant.Value); numComplexity.Value = (decimal)SequentialMinimalOptimization.EstimateComplexity(kernel, input); }
public void FunctionTest_EqualInputs() { var x = new double[] { 1, 2, 5, 1 }; var y = new double[] { 1, 2, 5, 1 }; var target = new Gaussian<DynamicTimeWarping>(new DynamicTimeWarping(1), 4.2); double expected = target.Function(x, y); double actual = target.Function(x, x); Assert.AreEqual(expected, actual, 0.000001); }
public void ConstructorTest1() { double[,] inputs = { { 1, 1, }, { 2, 2, }, { 3, 3, }, }; int[] output = { 1, 2, 3 }; IKernel kernel = new Gaussian(0.1); KernelDiscriminantAnalysis target = new KernelDiscriminantAnalysis(inputs, output, kernel); Assert.AreEqual(3, target.Classes.Count); Assert.AreEqual(0, target.Classes[0].Index); Assert.AreEqual(1, target.Classes[1].Index); Assert.AreEqual(2, target.Classes[2].Index); Assert.AreEqual(1, target.Classes[0].Number); Assert.AreEqual(2, target.Classes[1].Number); Assert.AreEqual(3, target.Classes[2].Number); Assert.AreEqual(output, target.Classifications); Assert.AreEqual(kernel, target.Kernel); Assert.AreEqual(1e-4, target.Regularization); Assert.AreEqual(inputs, target.Source); Assert.AreEqual(0.001, target.Threshold); Assert.IsNull(target.CumulativeProportions); Assert.IsNull(target.DiscriminantMatrix); Assert.IsNull(target.DiscriminantProportions); Assert.IsNull(target.Discriminants); Assert.IsNull(target.Eigenvalues); Assert.IsNull(target.Result); Assert.IsNull(target.ScatterBetweenClass); Assert.IsNull(target.ScatterMatrix); Assert.IsNull(target.ScatterWithinClass); Assert.IsNull(target.StandardDeviations); Assert.IsNull(target.Means); }
void IEstimable <TInput> .Estimate(TInput[] inputs) { this.Gamma = Gaussian.Estimate <TInput, TDistance>(inputs, distance).Gamma; }
public void ComputeTest3() { // Schölkopf KPCA toy example double[][] inputs = scholkopf().ToArray(); int[] output = Matrix.Expand(new int[,] { { 1 }, { 2 }, { 3 } }, new int[] { 30, 30, 30 }).GetColumn(0); IKernel kernel = new Gaussian(0.2); KernelDiscriminantAnalysis target = new KernelDiscriminantAnalysis(inputs, output, kernel); target.Compute(); double[][] actual = target.Transform(inputs, 2); double[][] expected1 = { new double[] { 1.2785801485080475, 0.20539157505913622}, new double[] { 1.2906613255489541, 0.20704272225753775}, new double[] { 1.2978134597266808, 0.20802649628632208}, }; double[][] actual1 = actual.Submatrix(0, 2, 0, 1); Assert.IsTrue(Matrix.IsEqual(actual1, expected1, 0.0000001)); // Assert the result equals the transformation of the input double[][] result = target.Result.ToArray(); double[][] projection = target.Transform(inputs); Assert.IsTrue(Matrix.IsEqual(result, projection)); }
void IEstimable <double[]> .Estimate(double[][] inputs) { this.Gamma = Gaussian.Estimate(distance, inputs).Gamma; }
/// <summary> /// Estimates kernel parameters from the data. /// </summary> /// /// <param name="inputs">The input data.</param> /// void IEstimable <double[]> .Estimate(double[][] inputs) { this.Gamma = Gaussian.Estimate(innerKernel, inputs).Gamma; }
public void GammaSigmaSquaredTest() { Gaussian gaussian = new Gaussian(3.6); Assert.AreEqual(3.6 * 3.6, gaussian.SigmaSquared); Assert.AreEqual(3.6, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 3.6 * 3.6), gaussian.Gamma); gaussian.SigmaSquared = 81; Assert.AreEqual(81, gaussian.SigmaSquared); Assert.AreEqual(9, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 81), gaussian.Gamma); gaussian.Sigma = 6; Assert.AreEqual(36, gaussian.SigmaSquared); Assert.AreEqual(6, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 36), gaussian.Gamma); gaussian.Gamma = 1.0 / (2 * 49); Assert.AreEqual(49, gaussian.SigmaSquared, 1e-10); Assert.AreEqual(7, gaussian.Sigma, 1e-10); Assert.AreEqual(1.0 / (2 * 49), gaussian.Gamma); }
public void GammaSigmaSquaredTest() { var dtw = new DynamicTimeWarping(1); var gaussian = new Gaussian<DynamicTimeWarping>(dtw, 3.6); Assert.AreEqual(3.6 * 3.6, gaussian.SigmaSquared); Assert.AreEqual(3.6, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 3.6 * 3.6), gaussian.Gamma); gaussian.SigmaSquared = 81; Assert.AreEqual(81, gaussian.SigmaSquared); Assert.AreEqual(9, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 81), gaussian.Gamma); gaussian.Sigma = 6; Assert.AreEqual(36, gaussian.SigmaSquared); Assert.AreEqual(6, gaussian.Sigma); Assert.AreEqual(1.0 / (2 * 36), gaussian.Gamma); gaussian.Gamma = 1.0 / (2 * 49); Assert.AreEqual(49, gaussian.SigmaSquared, 1e-10); Assert.AreEqual(7, gaussian.Sigma, 1e-10); Assert.AreEqual(1.0 / (2 * 49), gaussian.Gamma); }
private void button1_Click(object sender, EventArgs e) { // Finishes and save any pending changes to the given data dgvAnalysisSource.EndEdit(); if (dgvAnalysisSource.DataSource == null) return; // Creates a matrix from the source data table double[,] sourceMatrix = (dgvAnalysisSource.DataSource as DataTable).ToMatrix(out sourceColumns); int rows = sourceMatrix.GetLength(0); int cols = sourceMatrix.GetLength(1); // Creates a new Simple Descriptive Analysis sda = new DescriptiveAnalysis(sourceMatrix, sourceColumns); sda.Compute(); // Populates statistics overview tab with analysis data dgvDistributionMeasures.DataSource = sda.Measures; IKernel kernel; if (rbGaussian.Checked) { kernel = new Gaussian((double)numSigma.Value); } else { kernel = new Polynomial((int)numDegree.Value, (double)numConstant.Value); } // Get only the input values (exclude the class label indicator column) double[,] data = sourceMatrix.Submatrix(null, startColumn: 0, endColumn: 1); // Get only the associated labels int[] labels = sourceMatrix.GetColumn(2).ToInt32(); // Creates the Kernel Principal Component Analysis of the given source kpca = new KernelPrincipalComponentAnalysis(data, kernel, (AnalysisMethod)cbMethod.SelectedValue); kpca.Center = cbCenter.Checked; // Compute the analysis kpca.Compute(); double[,] result; if (kpca.Components.Count >= 2) { // Perform the transformation of the data using two components result = kpca.Transform(data, 2); } else { result = kpca.Transform(data, 1); result = result.InsertColumn(Matrix.Vector(result.GetLength(0), 0.0)); } // Create a new plot with the original Z column double[,] points = result.InsertColumn(sourceMatrix.GetColumn(2)); // Create output scatter plot outputScatterplot.DataSource = points; CreateScatterplot(graphMapFeature, points); // Create output table dgvProjectionResult.DataSource = new ArrayDataView(points, sourceColumns); dgvReversionSource.DataSource = new ArrayDataView(kpca.Result); // Populates components overview with analysis data dgvFeatureVectors.DataSource = new ArrayDataView(kpca.ComponentMatrix); dgvPrincipalComponents.DataSource = kpca.Components; dgvProjectionComponents.DataSource = kpca.Components; dgvReversionComponents.DataSource = kpca.Components; numComponents.Maximum = kpca.Components.Count; numNeighbor.Maximum = kpca.Result.GetLength(0); numNeighbor.Value = System.Math.Min(10, numNeighbor.Maximum); CreateComponentCumulativeDistributionGraph(graphCurve); CreateComponentDistributionGraph(graphShare); }
public void FunctionTest() { double sigma = 0.1; Gaussian target = new Gaussian(sigma); double[] x = { 2.0, 3.1, 4.0 }; double[] y = { 2.0, 3.1, 4.0 }; double expected = 1; double actual; actual = target.Function(x, y); Assert.AreEqual(expected, actual); actual = target.Function(x, x); Assert.AreEqual(expected, actual); actual = target.Function(y, y); Assert.AreEqual(expected, actual); }
public void GammaSigmaTest() { Gaussian gaussian = new Gaussian(1); double expected, actual, gamma, sigma; expected = 0.01; gaussian.Sigma = expected; gamma = gaussian.Gamma; gaussian.Gamma = gamma; actual = gaussian.Sigma; Assert.AreEqual(expected, actual); expected = 0.01; gaussian.Gamma = expected; sigma = gaussian.Sigma; gaussian.Sigma = sigma; actual = gaussian.Gamma; Assert.AreEqual(expected, actual, 1e-12); }
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; }
void IEstimable <Sparse <double> > .Estimate(Sparse <double>[] inputs) { this.Gamma = Gaussian.Estimate(inputs).Gamma; }