private void CreateTestData(FaceData faceData, int idx) { AuTestData = new svm_node[MaxAuFeatures]; FppTestData = new svm_node[MaxFppFeatures]; for (int i = 0; i < faceData.au_data.Count; i++) { AuTestData[i] = new svm_node(); AuTestData[i].index = i; AuTestData[i].value = faceData.au_data[i]; } int index = 0; int j = 0; while (index < faceData.point_3D.Count) { if (FeaturePoint.ContainsValue(index / 3)) { FppTestData[j] = new svm_node(); FppTestData[j].index = j; FppTestData[j].value = faceData.point_3D[index]; j++; } index++; } ScalingData(AuTestData, AuScaleMin, AuScaleMax, MaxAuFeatures, idx); ScalingData(FppTestData, FppScaleMin, FppScaleMax, MaxFppFeatures, idx); }
private static double ComputeValidationError(C_SVC svc, Matrix <double> xval, Vector <double> yval) { int m = xval.RowCount; double errorCount = 0; for (int i = 0; i < m; i++) { svm_node n1 = new svm_node(); n1.index = 1; n1.value = xval.Row(i)[0]; svm_node n2 = new svm_node(); n2.index = 2; n2.value = xval.Row(i)[1]; double pred = svc.Predict(new [] { n1, n2 }); if (pred != yval[i]) { errorCount++; } } return(errorCount / m); }
public static SVMNode[] Convert(IntPtr ptr) { if (ptr == IntPtr.Zero) { return(null); } List <SVMNode> nodes = new List <SVMNode>(); IntPtr i_ptr_nodes = ptr; while (true) { svm_node node = (svm_node)Marshal.PtrToStructure(i_ptr_nodes, typeof(svm_node)); i_ptr_nodes = IntPtr.Add(i_ptr_nodes, Marshal.SizeOf(typeof(svm_node))); if (node.index >= 0) { nodes.Add(new SVMNode(node.index, node.value)); } else { break; } } return(nodes.ToArray()); }
private svm_node[][] ReadSvmNodeArray(BinaryReader reader) { bool isNull = !reader.ReadBoolean(); if (isNull) { return(null); } else { int length = reader.ReadInt32(); svm_node[][] array = new svm_node[length][]; for (int i = 0; i < length; i++) { int sub_length = reader.ReadInt32(); array[i] = new svm_node[sub_length]; for (int j = 0; j < sub_length; j++) { svm_node node = new svm_node(); node.index = reader.ReadInt32(); node.value_Renamed = reader.ReadDouble(); array[i][j] = node; } } return(array); } }
// read in a problem (in svmlight format) private void read_problem() { /* UPGRADE_TODO: Expected value of parameters of constructor * 'java.io.BufferedReader.BufferedReader' are different in the equivalent in .NET. * 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"' */ System.IO.StreamReader fp = new System.IO.StreamReader(input_file_name); System.Collections.ArrayList vy = new System.Collections.ArrayList(10); System.Collections.ArrayList vx = new System.Collections.ArrayList(10); int max_index = 0; while (true) { System.String line = fp.ReadLine(); if ((System.Object)line == null) { break; } SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); vy.Add(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value_Renamed = atof(st.NextToken()); } if (m > 0) { max_index = System.Math.Max(max_index, x[m - 1].index); } vx.Add(x); } prob = new svm_problem(); prob.l = vy.Count; prob.x = new svm_node[prob.l][]; for (int i = 0; i < prob.l; i++) { prob.x[i] = (svm_node[])vx[i]; } prob.y = new double[prob.l]; for (int i = 0; i < prob.l; i++) { prob.y[i] = atof((System.String)vy[i]); } if (param.gamma == 0) { param.gamma = 1.0 / max_index; } fp.Close(); }
public static svm_node[][] CreateNodeArray(double [,] values) { svm_node[][] svm_nodes = new svm_node[values.GetLength(0)][]; for (int row_index = 0; row_index < values.GetLength(0); row_index++) { svm_nodes[row_index] = CreateNodeArray(values.Select1DIndex0(row_index));; } return(svm_nodes); }
public int Classify() { try { if (lengths != null) { var path = Environment.CurrentDirectory.Remove(Environment.CurrentDirectory.Length - 20, 20); path = path + "RethinopathyAnalysisModule\\bin\\Debug\\"; var DvCsvm = new C_SVC(System.IO.Path.Combine(path, DvC_MODEL_FILE)); var DvHsvm = new C_SVC(System.IO.Path.Combine(path, DvH_MODEL_FILE)); var HvCsvm = new C_SVC(System.IO.Path.Combine(path, HvC_MODEL_FILE)); svm_node[] x = new svm_node[lengths.Count]; for (int j = 0; j < lengths.Count; j++) { x[j] = new svm_node() { index = j, value = lengths[j] }; } double DvCresult = DvCsvm.Predict(x); double DvHresult = DvCsvm.Predict(x); double HvCresult = DvCsvm.Predict(x); if (DvCresult == 1) { if (DvHresult == 1) { return(1); } } else { if (HvCresult == -1) { return(0); } else if (DvHresult == -1) { return(2); } } return(-1); } else { return(-1); } } catch { return(-1); } }
private svm_node[] nodeMaking() { String st = ""; int l = 0; svm_node[] svmNodes = new svm_node[36]; for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { svm_node svmNode = new svm_node(); double value = countEdgesForBlock(i * 33, j * 33, 33, 33); svmNode.index = l + 1; svmNode.value = value; svmNodes[l++] = svmNode; } int q = 132; for (int j = 4; j < 6; j++) { svm_node svmNode = new svm_node(); double value = countEdgesForBlock(i * 33, q, 34, 34); svmNode.index = l + 1; svmNode.value = value; q = q + 34; svmNodes[l++] = svmNode; } } int p = 132; for (int i = 4; i < 6; i++) { for (int j = 0; j < 4; j++) { svm_node svmNode = new svm_node(); double value = countEdgesForBlock(p, j * 33, 33, 33); svmNode.index = l + 1; svmNode.value = value; svmNodes[l++] = svmNode; } int q = 132; for (int j = 4; j < 6; j++) { svm_node svmNode = new svm_node(); double value = countEdgesForBlock(p, q, 34, 34); svmNode.index = l + 1; svmNode.value = value; q = q + 34; svmNodes[l++] = svmNode; } p = p + 34; } return(svmNodes); }
/// <summary> /// Convert regular Encog NeuralData into the "sparse" data needed by an SVM. /// </summary> /// <param name="data">The data to convert.</param> /// <returns>The SVM sparse data.</returns> public svm_node[] MakeSparse(INeuralData data) { svm_node[] result = new svm_node[data.Count]; for (int i = 0; i < data.Count; i++) { result[i] = new svm_node(); result[i].index = i + 1; result[i].value_Renamed = data[i]; } return(result); }
public static svm_node [] CreateNodeArray(IReadOnlyList <double> values) { svm_node[] svm_node = new svm_node[values.Count + 1]; for (int index = 0; index < values.Count; index++) { svm_node[index] = new svm_node(); svm_node[index].index = index; svm_node[index].value = values[index]; } svm_node[values.Count] = new svm_node(); svm_node[values.Count].index = -1; //Each row of properties should be terminated with a -1 according to the readme return(svm_node); }
/// <summary> /// Convert regular Encog MLData into the "sparse" data needed by an SVM. /// </summary> /// /// <param name="data">The data to convert.</param> /// <returns>The SVM sparse data.</returns> public svm_node[] MakeSparse(IMLData data) { var result = new svm_node[data.Count]; for (int i = 0; i < data.Count; i++) { result[i] = new svm_node { index = i + 1, value_Renamed = data[i] }; } return(result); }
/// <summary> /// Transforms the input array based upon the values provided. /// </summary> /// <param name="input">The input array</param> /// <returns>A scaled array</returns> public svm_node[] Transform(svm_node[] input) { svm_node[] output = new svm_node[input.Length]; for (int i = 0; i < output.Length; i++) { int index = input[i].index; double value = input[i].value; output[i] = new svm_node() { index = index, value = Transform(value, index) }; } return(output); }
/// <summary> /// Transforms <paramref name="dataset"/> into a data structure as needed by libSVM. /// </summary> /// <param name="dataset">The source dataset</param> /// <param name="targetVariable">The target variable</param> /// <param name="inputVariables">The selected input variables to include in the svm_problem.</param> /// <param name="rowIndices">The rows of the dataset that should be contained in the resulting SVM-problem</param> /// <returns>A problem data type that can be used to train a support vector machine.</returns> public static svm_problem CreateSvmProblem(IDataset dataset, string targetVariable, IEnumerable <string> inputVariables, IEnumerable <int> rowIndices) { double[] targetVector; var nRows = rowIndices.Count(); if (string.IsNullOrEmpty(targetVariable)) { // if the target variable is not set (e.g. for prediction of a trained model) we just use a zero vector targetVector = new double[nRows]; } else { targetVector = dataset.GetDoubleValues(targetVariable, rowIndices).ToArray(); } svm_node[][] nodes = new svm_node[nRows][]; int maxNodeIndex = 0; int svmProblemRowIndex = 0; List <string> inputVariablesList = inputVariables.ToList(); foreach (int row in rowIndices) { List <svm_node> tempRow = new List <svm_node>(); int colIndex = 1; // make sure the smallest node index for SVM = 1 foreach (var inputVariable in inputVariablesList) { double value = dataset.GetDoubleValue(inputVariable, row); // SVM also works with missing values // => don't add NaN values in the dataset to the sparse SVM matrix representation if (!double.IsNaN(value)) { tempRow.Add(new svm_node() { index = colIndex, value = value }); // nodes must be sorted in ascending ordered by column index if (colIndex > maxNodeIndex) { maxNodeIndex = colIndex; } } colIndex++; } nodes[svmProblemRowIndex++] = tempRow.ToArray(); } return(new svm_problem { l = targetVector.Length, y = targetVector, x = nodes }); }
public SVM() { fileExistance = false; predictionDictionary = new Dictionary <int, string> { { 1, "Neutral" }, { 2, "Up" }, { 3, "Down" }, { 4, "Left" }, { 5, "Right" } }; scale = new SVMScale(); svmnode = new svm_node[25]; int i = 0; for (; i < 25; i++) { svmnode[i] = new svm_node(); svmnode[i].index = i + 1; } }
public svm_problem CreateProblem(List <DataEntry> dataEntry, List <string> vocabulary) { double[] y = new double[dataEntry.Count]; svm_node[][] x = new svm_node[dataEntry.Count][]; for (int i = 0; i < dataEntry.Count; i++) { y[i] = dataEntry[i].claimSentiment; x[i] = CreateNode(dataEntry[i].stemmedClaim, vocabulary); } return(new svm_problem { y = y, x = x, l = y.Length }); }
private static void PlotBoundary(Matrix <double> x, C_SVC svc) { double min = x.Column(0).Min(); double max = x.Column(0).Max(); double[] x0 = MathNet.Numerics.Generate.LinearSpaced(100, min, max); min = x.Column(1).Min(); max = x.Column(1).Max(); double[] x1 = MathNet.Numerics.Generate.LinearSpaced(100, min, max); int size = x0.Length * x1.Length; double[] sx = new double[size]; double[] sy = new double[size]; double[] sz = new double[size]; int idx = 0; for (int i = 0; i < x0.Length; i++) { for (int j = 0; j < x1.Length; j++) { sx[idx] = x0[i]; sy[idx] = x1[j]; svm_node n1 = new svm_node(); n1.index = 1; n1.value = x0[i]; svm_node n2 = new svm_node(); n2.index = 2; n2.value = x1[j]; double z = svc.Predict(new [] { n1, n2 }); sz[idx] = z; idx++; } } GnuPlot.Set("cntrparam levels discrete 0.5"); GnuPlot.Contour(sx, sy, sz, "title \"Decision Boundary\""); }
public static IntPtr Allocate(SVMNode[] x) { if (x == null) { return(IntPtr.Zero); } IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(svm_node)) * x.Length); IntPtr i_ptr_nodes = ptr; for (int i = 0; i < x.Length; i++) { svm_node node = new svm_node(); node.index = x[i].Index; node.value = x[i].Value; Marshal.StructureToPtr(node, i_ptr_nodes, true); i_ptr_nodes = IntPtr.Add(i_ptr_nodes, Marshal.SizeOf(typeof(svm_node))); } return(ptr); }
private static Vector <double> SvmPredic(Matrix <double> X, C_SVC svc) { int m = X.RowCount; int n = X.ColumnCount; Vector <double> prediction = Vector <double> .Build.Dense(m); for (int i = 0; i < m; i++) { svm_node[] nodes = new svm_node[n]; for (int k = 0; k < n; k++) { nodes[k] = new svm_node() { index = k + 1, value = X[i, k] }; } prediction[i] = svc.Predict(nodes); } return(prediction); }
private void checkXOR(SVM svm) { var predictions = new double[2, 2]; for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { var A = new svm_node() { index = 1, value = i == 0 ? -1 : 1 }; var B = new svm_node() { index = 2, value = j == 0 ? -1 : 1 }; predictions[i, j] = svm.Predict(new svm_node[] { A, B }); } } Assert.AreEqual(predictions[0, 0], 0); Assert.AreEqual(predictions[0, 1], 1); Assert.AreEqual(predictions[1, 0], 1); Assert.AreEqual(predictions[1, 1], 0); }
private static void predict(System.IO.StreamReader input, System.IO.BinaryWriter output, svm_model model, int predict_probability) { int correct = 0; int total = 0; double error = 0; double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; int svm_type = svm.svm_get_svm_type(model); int nr_class = svm.svm_get_nr_class(model); int[] labels = new int[nr_class]; double[] prob_estimates = null; if (predict_probability == 1) { if (svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR) { System.Console.Out.Write("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + svm.svm_get_svr_probability(model) + "\n"); } else { svm.svm_get_labels(model, labels); prob_estimates = new double[nr_class]; //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("labels"); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(" " + labels[j]); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } } while (true) { System.String line = input.ReadLine(); if ((System.Object) line == null) break; SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); double target = atof(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value = atof(st.NextToken()); } double v; if (predict_probability == 1 && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) { v = svm.svm_predict_probability(model, x, prob_estimates); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + " "); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(prob_estimates[j] + " "); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } else { v = svm.svm_predict(model, x); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + "\n"); } if (v == target) ++correct; error += (v - target) * (v - target); sumv += v; sumy += target; sumvv += v * v; sumyy += target * target; sumvy += v * target; ++total; } System.Console.Out.Write("Accuracy = " + (double) correct / total * 100 + "% (" + correct + "/" + total + ") (classification)\n"); System.Console.Out.Write("Mean squared error = " + error / total + " (regression)\n"); System.Console.Out.Write("Squared correlation coefficient = " + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv * sumy)) / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy * sumy)) + " (regression)\n"); }
static Tuple <double, double> RunPLAvsSVM(int experiments, int points) { const int TEST_POINTS = 10000; Random rnd = new Random(); long svmWins = 0, svCount = 0; for (int i = 1; i <= experiments; i++) { //pick a random line y = a * x + b double x1 = rnd.NextDouble(), y1 = rnd.NextDouble(), x2 = rnd.NextDouble(), y2 = rnd.NextDouble(); var Wf = new DenseVector(3); Wf[0] = 1; Wf[1] = (y1 - y2) / (x1 * y2 - y1 * x2); Wf[2] = (x2 - x1) / (x1 * y2 - y1 * x2); Func <MathNet.Numerics.LinearAlgebra.Generic.Vector <double>, int> f = x => Wf.DotProduct(x) >= 0 ? 1 : -1; //generate training set of N random points var X = new DenseMatrix(points, 3); do { for (int j = 0; j < points; j++) { X[j, 0] = 1; X[j, 1] = rnd.NextDouble() * 2 - 1; X[j, 2] = rnd.NextDouble() * 2 - 1; } }while (Enumerable.Range(0, X.RowCount).All(j => f(X.Row(0)) == f(X.Row(j)))); var W = new DenseVector(3); Func <MathNet.Numerics.LinearAlgebra.Generic.Vector <double>, int> h = x => W.DotProduct(x) >= 0 ? 1 : -1; //run Perceptron int k = 1; while (Enumerable.Range(0, points).Any(j => h(X.Row(j)) != f(X.Row(j)))) { //find all misclasified points int[] M = Enumerable.Range(0, points).Where(j => h(X.Row(j)) != f(X.Row(j))).ToArray(); int m = M[rnd.Next(0, M.Length)]; int sign = f(X.Row(m)); W[0] += sign; W[1] += sign * X[m, 1]; W[2] += sign * X[m, 2]; k++; } //calculate P[f(Xtest) != h(Xtest)] DenseVector Xtest = new DenseVector(3); Xtest[0] = 1; int matches = 0; for (int j = 0; j < TEST_POINTS; j++) { Xtest[1] = rnd.NextDouble() * 2 - 1; Xtest[2] = rnd.NextDouble() * 2 - 1; if (f(Xtest) == h(Xtest)) { matches++; } } double Ppla = (matches + 0.0) / TEST_POINTS; //Run SVM var prob = new svm_problem() { x = Enumerable.Range(0, points).Select(j => new svm_node[] { new svm_node() { index = 0, value = X[j, 1] }, new svm_node() { index = 1, value = X[j, 2] } }).ToArray(), y = Enumerable.Range(0, points).Select(j => (double)f(X.Row(j))).ToArray(), l = points }; var model = svm.svm_train(prob, new svm_parameter() { svm_type = (int)SvmType.C_SVC, kernel_type = (int)KernelType.LINEAR, C = 1000000, eps = 0.001, shrinking = 0 }); //calculate P[f(Xtest) != h_svm(Xtest)] svm_node[] Xsvm = new svm_node[] { new svm_node() { index = 0, value = 1.0 }, new svm_node() { index = 1, value = 1.0 } }; matches = 0; for (int j = 0; j < TEST_POINTS; j++) { Xtest[1] = rnd.NextDouble() * 2 - 1; Xsvm[0].value = Xtest[1]; Xtest[2] = rnd.NextDouble() * 2 - 1; Xsvm[1].value = Xtest[2]; if (f(Xtest) == (svm.svm_predict(model, Xsvm) > 0 ? 1 : -1)) { matches++; } } double Psvm = (matches + 0.0) / TEST_POINTS; svCount += model.l; if (Psvm >= Ppla) { svmWins++; } } return(Tuple.Create((svmWins + 0.0) / experiments, (svCount + 0.0) / experiments)); }