/// <summary>
///
/// </summary>
/// <param name="problem"></param>
/// <param name="parameter"></param>
/// <returns></returns>
public static string CheckParameter(SVMProblem problem, SVMParameter parameter)
{
if (problem == null)
{
throw new ArgumentNullException("problem");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
IntPtr ptr_output = libsvm.svm_check_parameter(ptr_problem, ptr_parameter);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
string output = Marshal.PtrToStringAnsi(ptr_output);
Marshal.FreeHGlobal(ptr_output);
ptr_output = IntPtr.Zero;
return(output);
}
/// <summary>
///
/// </summary>
/// <param name="problem"></param>
/// <param name="parameter"></param>
/// <param name="nFolds"></param>
/// <param name="target"></param>
public static void CrossValidation(SVMProblem problem, SVMParameter parameter, int nFolds, out double[] target)
{
if (problem == null)
{
throw new ArgumentNullException("problem");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (nFolds < 2)
{
throw new ArgumentOutOfRangeException("nFolds");
}
IntPtr ptr_target = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * problem.Length);
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
libsvm.svm_cross_validation(ptr_problem, ptr_parameter, nFolds, ptr_target);
target = new double[problem.Length];
Marshal.Copy(ptr_target, target, 0, target.Length);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
Marshal.FreeHGlobal(ptr_target);
ptr_target = IntPtr.Zero;
}
/// <summary>
/// This function constructs and returns an SVM model according to the given training data and parameters.
/// </summary>
/// <param name="problem">Training data.</param>
/// <param name="parameter">Parameter set.</param>
/// <returns>SVM model according to the given training data and parameters.</returns>
public static SVMModel Train(SVMProblem problem, SVMParameter parameter)
{
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
IntPtr ptr_model = libsvm.svm_train(ptr_problem, ptr_parameter);
SVMModel model = SVMModel.Convert(ptr_model);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
libsvm.svm_free_model_content(ptr_model);
return(model);
}
/// <summary>
///
/// </summary>
/// <param name="problem"></param>
/// <param name="parameter"></param>
/// <param name="nFolds"></param>
/// <param name="target"></param>
public static void CrossValidation(SVMProblem problem, SVMParameter parameter, int nFolds, out double[] target)
{
IntPtr ptr_target = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * problem.Length);
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
libsvm.svm_cross_validation(ptr_problem, ptr_parameter, nFolds, ptr_target);
target = new double[problem.Length];
Marshal.Copy(ptr_target, target, 0, target.Length);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
Marshal.FreeHGlobal(ptr_target);
ptr_target = IntPtr.Zero;
}
/// <summary>
///
/// </summary>
/// <param name="problem"></param>
/// <param name="parameter"></param>
/// <returns></returns>
public static string CheckParameter(SVMProblem problem, SVMParameter parameter)
{
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
IntPtr ptr_output = libsvm.svm_check_parameter(ptr_problem, ptr_parameter);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
string output = Marshal.PtrToStringAnsi(ptr_output);
Marshal.FreeHGlobal(ptr_output);
ptr_output = IntPtr.Zero;
return(output);
}
/// <summary>
/// This function constructs and returns an SVM model according to the given training data and parameters.
/// </summary>
/// <param name="problem">Training data.</param>
/// <param name="parameter">Parameter set.</param>
/// <returns>SVM model according to the given training data and parameters.</returns>
public static SVMModel Train(SVMProblem problem, SVMParameter parameter)
{
if (problem == null)
{
throw new ArgumentNullException("problem");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
IntPtr ptr_problem = SVMProblem.Allocate(problem);
IntPtr ptr_parameter = SVMParameter.Allocate(parameter);
IntPtr ptr_model = libsvm.svm_train(ptr_problem, ptr_parameter);
SVMModel model = SVMModel.Convert(ptr_model);
SVMProblem.Free(ptr_problem);
SVMParameter.Free(ptr_parameter);
libsvm.svm_free_model_content(ptr_model);
return(model);
}
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);
}