/// <summary> /// /// </summary> /// <param name="ptr_model"></param> /// <param name="x"></param> /// <param name="estimations"></param> /// <returns></returns> public static double PredictProbability(IntPtr ptr_model, SVMNode[] x, out double[] estimations) { if (ptr_model == IntPtr.Zero) { throw new ArgumentNullException("ptr_model"); } bool isProbabilityModel = libsvm.svm_check_probability_model(ptr_model); if (!isProbabilityModel) { SVMModel.Free(ptr_model); estimations = null; return(-1); } int classCount = libsvm.svm_get_nr_class(ptr_model); IntPtr ptr_estimations = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * classCount); List <SVMNode> nodes = x.Select(a => a.Clone()).ToList(); nodes.Add(new SVMNode(-1, 0)); IntPtr ptr_nodes = SVMNode.Allocate(nodes.ToArray()); double result = libsvm.svm_predict_probability(ptr_model, ptr_nodes, ptr_estimations); estimations = new double[classCount]; Marshal.Copy(ptr_estimations, estimations, 0, estimations.Length); SVMNode.Free(ptr_nodes); Marshal.FreeHGlobal(ptr_estimations); ptr_estimations = IntPtr.Zero; return(result); }
/// <summary> /// /// </summary> /// <param name="ptr_model"></param> /// <param name="x"></param> /// <param name="values"></param> /// <returns></returns> public static double PredictValues(IntPtr ptr_model, SVMNode[] x, out double[] values) { if (ptr_model == IntPtr.Zero) { throw new ArgumentNullException("ptr_model"); } int classCount = libsvm.svm_get_nr_class(ptr_model); int size = (int)(classCount * (classCount - 1) * 0.5); IntPtr ptr_values = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * size); List <SVMNode> nodes = x.Select(a => a.Clone()).ToList(); nodes.Add(new SVMNode(-1, 0)); IntPtr ptr_nodes = SVMNode.Allocate(nodes.ToArray()); double result = libsvm.svm_predict_values(ptr_model, ptr_nodes, ptr_values); values = new double[size]; Marshal.Copy(ptr_values, values, 0, values.Length); SVMNode.Free(ptr_nodes); Marshal.FreeHGlobal(ptr_values); ptr_values = IntPtr.Zero; return(result); }
public static SVMProblem Convert(svm_problem x) { double[] y_array = new double[x.l]; Marshal.Copy(x.y, y_array, 0, y_array.Length); List <SVMNode[]> x_array = new List <SVMNode[]>(); IntPtr i_ptr_x = x.x; for (int i = 0; i < x.l; i++) { IntPtr ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_x, typeof(IntPtr)); SVMNode[] nodes = SVMNode.Convert(ptr_nodes); x_array.Add(nodes); i_ptr_x = IntPtr.Add(i_ptr_x, Marshal.SizeOf(typeof(IntPtr))); } SVMProblem y = new SVMProblem(); for (int i = 0; i < x.l; i++) { y.Add(x_array[i], y_array[i]); } return(y); }
public static void Free(svm_model x) { Marshal.FreeHGlobal(x.rho); x.rho = IntPtr.Zero; Marshal.FreeHGlobal(x.probA); x.probA = IntPtr.Zero; Marshal.FreeHGlobal(x.probB); x.probB = IntPtr.Zero; Marshal.FreeHGlobal(x.sv_indices); x.sv_indices = IntPtr.Zero; Marshal.FreeHGlobal(x.label); x.label = IntPtr.Zero; Marshal.FreeHGlobal(x.nSV); x.nSV = IntPtr.Zero; SVMParameter.Free(x.param); IntPtr i_ptr_sv = x.SV; for (int i = 0; i < x.l; i++) { IntPtr ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_sv, typeof(IntPtr)); SVMNode.Free(ptr_nodes); i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr))); } Marshal.FreeHGlobal(x.SV); x.SV = IntPtr.Zero; IntPtr i_ptr_svcoef = x.sv_coef; for (int i = 0; i < x.nr_class - 1; i++) { IntPtr temp = (IntPtr)Marshal.PtrToStructure(i_ptr_svcoef, typeof(IntPtr)); Marshal.FreeHGlobal(temp); temp = IntPtr.Zero; i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr))); } Marshal.FreeHGlobal(x.sv_coef); x.sv_coef = IntPtr.Zero; }
/// <summary> /// This function does classification or regression on a test vector x given a model. /// </summary> /// <param name="model">SVM model.</param> /// <param name="x">Test vector.</param> /// <returns>For a classification model, the predicted class for x is returned. /// For a regression model, the function value of x calculated using the model is returned. /// For an one-class model, +1 or -1 is returned.</returns> public static double Predict(SVMModel model, SVMNode[] x) { IntPtr ptr_model = SVMModel.Allocate(model); List <SVMNode> nodes = x.Select(a => a.Clone()).ToList(); nodes.Add(new SVMNode(-1, 0)); IntPtr ptr_nodes = SVMNode.Allocate(nodes.ToArray()); double result = libsvm.svm_predict(ptr_model, ptr_nodes); SVMModel.Free(ptr_model); SVMNode.Free(ptr_nodes); return(result); }
/// <summary> /// /// </summary> /// <param name="ptr_model"></param> /// <param name="x"></param> /// <returns></returns> public static double Predict(IntPtr ptr_model, SVMNode[] x) { if (ptr_model == IntPtr.Zero) { throw new ArgumentNullException("ptr_model"); } List <SVMNode> nodes = x.Select(a => a.Clone()).ToList(); nodes.Add(new SVMNode(-1, 0)); IntPtr ptr_nodes = SVMNode.Allocate(nodes.ToArray()); double result = libsvm.svm_predict(ptr_model, ptr_nodes); SVMNode.Free(ptr_nodes); return(result); }
public static void Free(svm_problem x) { Marshal.FreeHGlobal(x.y); x.y = IntPtr.Zero; IntPtr i_ptr_x = x.x; for (int i = 0; i < x.l; i++) { IntPtr ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_x, typeof(IntPtr)); SVMNode.Free(ptr_nodes); i_ptr_x = IntPtr.Add(i_ptr_x, Marshal.SizeOf(typeof(IntPtr))); } Marshal.FreeHGlobal(x.x); x.x = IntPtr.Zero; }
public static IntPtr Allocate(SVMProblem x) { if (x == null || x.X == null || x.Y == null || x.Length < 1) { return(IntPtr.Zero); } svm_problem y = new svm_problem(); y.l = x.Length; // Allocate problem.y y.y = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.Y.Count); Marshal.Copy(x.Y.ToArray(), 0, y.y, x.Y.Count); // Allocate problem.x y.x = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)) * x.X.Count); IntPtr i_ptr_x = y.x; for (int i = 0; i < x.X.Count; i++) { // Prepare each node array // 1) All nodes containing zero value is removed // 2) A node which index is -1 is added to the end List <SVMNode> temp = x.X[i].Where(a => a.Value != 0).ToList(); temp.Add(new SVMNode(-1, 0)); SVMNode[] nodes = temp.ToArray(); // Allocate node array IntPtr ptr_nodes = SVMNode.Allocate(nodes); Marshal.StructureToPtr(ptr_nodes, i_ptr_x, true); i_ptr_x = IntPtr.Add(i_ptr_x, Marshal.SizeOf(typeof(IntPtr))); } // Allocate the problem int size = Marshal.SizeOf(y); IntPtr ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(y, ptr, true); return(ptr); }
public static IntPtr Allocate(SVMModel x) { if (x == null || x.ClassCount < 1 || x.Labels == null || x.Labels.Length < 1 || x.Parameter == null || x.Rho == null || x.Rho.Length < 1 || x.SVCoefs == null || x.SVCoefs.Count < 1 || x.TotalSVCount < 1 || x.SVCounts == null || x.SVCounts.Length < 1) { return(IntPtr.Zero); } svm_model y = new svm_model(); y.nr_class = x.ClassCount; y.l = x.TotalSVCount; y.free_sv = (int)x.Creation; // Allocate model.parameter IntPtr ptr_param = SVMParameter.Allocate(x.Parameter); y.param = (svm_parameter)Marshal.PtrToStructure(ptr_param, typeof(svm_parameter)); // Allocate model.rho y.rho = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.Rho.Length); Marshal.Copy(x.Rho, 0, y.rho, x.Rho.Length); // Allocate model.probA y.probA = IntPtr.Zero; if (x.ProbabilityA != null) { y.probA = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.ProbabilityA.Length); Marshal.Copy(x.ProbabilityA, 0, y.probA, x.ProbabilityA.Length); } // Allocate model.probB y.probB = IntPtr.Zero; if (x.ProbabilityB != null) { y.probB = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.ProbabilityB.Length); Marshal.Copy(x.ProbabilityB, 0, y.probB, x.ProbabilityB.Length); } // Allocate model.label y.label = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.Labels.Length); Marshal.Copy(x.Labels, 0, y.label, x.Labels.Length); // Allocate model.nSV y.nSV = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.SVCounts.Length); Marshal.Copy(x.SVCounts, 0, y.nSV, x.SVCounts.Length); // Allocate model.sv_coef y.sv_coef = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)) * x.SVCoefs.Count); IntPtr i_ptr_svcoef = y.sv_coef; for (int i = 0; i < x.SVCoefs.Count; i++) { IntPtr temp = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.SVCoefs[i].Length); Marshal.Copy(x.SVCoefs[i], 0, temp, x.SVCoefs[i].Length); Marshal.StructureToPtr(temp, i_ptr_svcoef, true); i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr))); } // Allocate model.sv_indices y.sv_indices = IntPtr.Zero; if (x.SVIndices != null) { y.sv_indices = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.SVIndices.Length); Marshal.Copy(x.SVIndices, 0, y.sv_indices, x.SVIndices.Length); } // Allocate model.SV y.SV = IntPtr.Zero; if (x.SV != null) { y.SV = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)) * x.SV.Count); IntPtr i_ptr_sv = y.SV; for (int i = 0; i < x.SV.Count; i++) { // Prepare each node array // 1) All nodes containing zero value is removed // 2) A node which index is -1 is added to the end List <SVMNode> temp = x.SV[i].Where(a => a.Value != 0).ToList(); temp.Add(new SVMNode(-1, 0)); SVMNode[] nodes = temp.ToArray(); // Allocate node array IntPtr ptr_nodes = SVMNode.Allocate(nodes); Marshal.StructureToPtr(ptr_nodes, i_ptr_sv, true); i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr))); } } // Allocate the model int size = Marshal.SizeOf(y); IntPtr ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(y, ptr, true); return(ptr); }
public static SVMModel Convert(svm_model x) { SVMModel y = new SVMModel(); y.Creation = (CreationType)x.free_sv; y.ClassCount = x.nr_class; y.TotalSVCount = x.l; if (y.Creation == CreationType.LOAD_MODEL) { y.Parameter = new SVMParameter(); y.Parameter.Type = (SVMType)x.param.svm_type; y.Parameter.Kernel = (SVMKernelType)x.param.kernel_type; switch (y.Parameter.Kernel) { case SVMKernelType.LINEAR: break; case SVMKernelType.POLY: y.Parameter.Gamma = x.param.gamma; y.Parameter.Coef0 = x.param.coef0; y.Parameter.Degree = x.param.degree; break; case SVMKernelType.RBF: y.Parameter.Gamma = x.param.gamma; break; case SVMKernelType.SIGMOID: y.Parameter.Gamma = x.param.gamma; y.Parameter.Coef0 = x.param.coef0; break; } } else { y.Parameter = SVMParameter.Convert(x.param); } int problemCount = (int)(y.ClassCount * (y.ClassCount - 1) * 0.5); y.Rho = new double[problemCount]; Marshal.Copy(x.rho, y.Rho, 0, y.Rho.Length); y.ProbabilityA = null; if (x.probA != IntPtr.Zero) { y.ProbabilityA = new double[problemCount]; Marshal.Copy(x.probA, y.ProbabilityA, 0, y.ProbabilityA.Length); } y.ProbabilityB = null; if (x.probB != IntPtr.Zero) { y.ProbabilityB = new double[problemCount]; Marshal.Copy(x.probB, y.ProbabilityB, 0, y.ProbabilityB.Length); } y.SVCounts = new int[y.ClassCount]; Marshal.Copy(x.nSV, y.SVCounts, 0, y.SVCounts.Length); y.Labels = new int[y.ClassCount]; Marshal.Copy(x.label, y.Labels, 0, y.Labels.Length); y.SVCoefs = new List <double[]>(y.ClassCount - 1); IntPtr i_ptr_svcoef = x.sv_coef; for (int i = 0; i < y.ClassCount - 1; i++) { y.SVCoefs.Add(new double[y.TotalSVCount]); IntPtr coef_ptr = (IntPtr)Marshal.PtrToStructure(i_ptr_svcoef, typeof(IntPtr)); Marshal.Copy(coef_ptr, y.SVCoefs[i], 0, y.SVCoefs[i].Length); i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr))); } y.SVIndices = null; if (x.sv_indices != IntPtr.Zero) { y.SVIndices = new int[y.TotalSVCount]; Marshal.Copy(x.sv_indices, y.SVIndices, 0, y.SVIndices.Length); } y.SV = new List <SVMNode[]>(); IntPtr i_ptr_sv = x.SV; for (int i = 0; i < x.l; i++) { IntPtr ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_sv, typeof(IntPtr)); SVMNode[] nodes = SVMNode.Convert(ptr_nodes); y.SV.Add(nodes); i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr))); } return(y); }