/// <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);
}