public static void testSVMWrapperPackage() //rafal parsal { libSVM_Problem Problem = libSVM_Problem.Load("../../../LibSVMFull/testSvmWrapper/data/train.dat"); GuiPreferences.Instance.setLog("trainnig data loaded"); Problem.Save("../../../LibSVMFull/testSvmWrapper/data/train_saved"); GuiPreferences.Instance.setLog("training data saved"); libSVM_Extension svm = new libSVM_Extension(); libSVM_Parameter Parameter = new libSVM_Parameter(); Parameter.svm_type = SVM_TYPE.C_SVC; Parameter.kernel_type = KERNEL_TYPE.LINEAR; svm = new libSVM_Extension(); svm.Train(Problem, Parameter); libSVM_Problem Test = libSVM_Problem.Load("../../../LibSVMFull/testSvmWrapper/data/test.dat"); svm.GetAccuracyFromTest(Test); double accuracy = Preferences.Instance.svmWrapper.output.accuracy; GuiPreferences.Instance.setLog("Predicted accuracy from testing set: " + accuracy.ToString()); svm.Dispose(); svm = new libSVM_Extension(); //svm.TrainAuto(10, Problem, Parameter, libSVM_Grid.C(), libSVM_Grid.gamma(), libSVM_Grid.p(), libSVM_Grid.nu(), libSVM_Grid.coef0(), libSVM_Grid.degree()); libSVM_Grid grid = new libSVM_Grid(); accuracy = svm.TrainAuto(10, Problem, Parameter, grid, null, null, null, null, null); GuiPreferences.Instance.setLog("Predicted accuracy from 10 cross fold validation: " + accuracy.ToString()); svm.Save("../../../LibSVMFull/testSvmWrapper/data/model_file"); GuiPreferences.Instance.setLog("10 cfv best model saved"); svm.Dispose(); }
/*public IntPtr getModel() * { * if (_model_ptr == IntPtr.Zero) throw new Exception("model neither loaded nor trained"); * return _model_ptr; * } * * public void setModel(IntPtr model) * { * _model_ptr = model; * } * * /// <summary> * /// Reload libSVM model * /// added externally and is a duplication of the internal libsvm function * /// </summary> * /// <param name="filename">name of model file</param> * public new void Reload(string filename) * { * Dispose(); * * _model_ptr = svm_load_model(filename); * * if (_model_ptr == IntPtr.Zero) throw new Exception("bad model file"); * } * * /// <summary> * /// Load model from file * /// added externally and is a duplication of the internal libsvm function * /// </summary> * /// <param name="filename">Model file</param> * /// <returns>libSVM</returns> * public new static libSVM_Extension Load(string filename) * { * libSVM_Extension svm = new libSVM_Extension(); * * svm.Reload(filename); * * return svm; * }*/ // private void ptr_to_array(int len, ref double[] array, IntPtr array_ptr) public void CrossValidate(libSVM_ExtendedProblem problem, libSVM_Parameter parameter, int nr_fold) { int i; int total_correct = 0; double total_error = 0; double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; double[] predictedLabels = new double[problem.labels.Length]; IntPtr _target_ptr = array_to_ptr(predictedLabels); IntPtr _problem_ptr = libSVM_Problem_to_svm_problem_ptr(problem); IntPtr _parameter_ptr = libSVM_Parameter_to_svm_parameter_ptr(parameter); svm_cross_validation(_problem_ptr, _parameter_ptr, nr_fold, _target_ptr); ptr_to_array(problem.labels.Length, ref predictedLabels, _target_ptr); output.setDoubleArray(predictedLabels); predictedLabels = null; if (parameter.svm_type == SVM_TYPE.EPSILON_SVR || parameter.svm_type == SVM_TYPE.NU_SVR) { for (i = 0; i < problem.labels.Length; i++) { double y = problem.labels[i]; double v = output.getValue(i); total_error += (v - y) * (v - y); sumv += v; sumy += y; sumvv += v * v; sumyy += y * y; sumvy += v * y; } output.meanSquaredError = total_error / problem.labels.Length; output.squaredCorrelationCoefficient = ((problem.labels.Length * sumvy - sumv * sumy) * (problem.labels.Length * sumvy - sumv * sumy)) / ((problem.labels.Length * sumvv - sumv * sumv) * (problem.labels.Length * sumyy - sumy * sumy)); } else { for (i = 0; i < problem.labels.Length; i++) { if (output.getValue(i) == problem.labels[i]) { ++total_correct; } } //Console.Write("Cross Validation Accuracy = %g%%\n", 100.0 * total_correct / problem.labels.Length); output.accuracy = 100.0 * total_correct / problem.labels.Length; } }
/// <summary> /// Train model /// </summary> /// <param name="_problem">samples and labels</param> /// <param name="_parameter">model parameters</param> public void Train(libSVM_Problem _problem, libSVM_Parameter _parameter) { Dispose(); __problem_ptr = libSVM_Problem_to_svm_problem_ptr(_problem); __parameter_ptr = libSVM_Parameter_to_svm_parameter_ptr(_parameter); IntPtr error_ptr = svm_check_parameter(__problem_ptr, __parameter_ptr); if (error_ptr != IntPtr.Zero) { throw new Exception(ptr_to_string(error_ptr)); } __model_ptr = svm_train(__problem_ptr, __parameter_ptr); }
private IntPtr libSVM_Parameter_to_svm_parameter_ptr(libSVM_Parameter _parameter) { if (_parameter == null) { throw new Exception("libSVMParameter not initialized"); } if (_parameter.weight == null && _parameter.weight_label != null) { throw new Exception("libSVMParameter.weight = null and libSVMParameter.weight_label != null"); } if (_parameter.weight != null && _parameter.weight_label == null) { throw new Exception("libSVMParameter.weight_label = null and libSVMParameter.weight != null"); } if (_parameter.weight != null && _parameter.weight_label != null && _parameter.weight_label.Length != _parameter.weight.Length) { throw new Exception("libSVMParameter.weight_label.Length != libSVMParameter.weight.Length"); } svm_parameter parameter = new svm_parameter(); parameter.C = _parameter.C; parameter.cache_size = _parameter.cache_size; parameter.coef0 = _parameter.coef0; parameter.degree = _parameter.degree; parameter.eps = _parameter.eps; parameter.gamma = _parameter.gamma; parameter.kernel_type = (int)_parameter.kernel_type; parameter.nr_weight = _parameter.weight.Length; parameter.nu = _parameter.nu; parameter.p = _parameter.p; parameter.probability = _parameter.probability; parameter.shrinking = _parameter.shrinking; parameter.svm_type = (int)_parameter.svm_type; parameter.weight = array_to_ptr(_parameter.weight); parameter.weight_label = array_to_ptr(_parameter.weight_label); IntPtr parameter_ptr = Alloc_ptr(Marshal.SizeOf(typeof(svm_parameter))); Marshal.StructureToPtr(parameter, parameter_ptr, false); return(parameter_ptr); }
/// <summary> /// Trains model automatically using users grids. if your svm_type/kernel_type does not need it then set it to null /// </summary> /// <param name="fold">folds for samples >=2 </param> /// <param name="problem">samples and labels</param> /// <param name="parameter">model parameters</param> /// <param name="grid_c">grid for C</param> /// <param name="grid_gamma">grid for gamma</param> /// <param name="grid_p">grid for p</param> /// <param name="grid_nu">grid for nu</param> /// <param name="grid_coef0">grid for coef</param> /// <param name="grid_degree">grid for degree</param> /// <returns>Total Accuracy in %</returns> public void TrainAutoBestTotal(int fold, libSVM_Problem problem, libSVM_Parameter parameter, libSVM_Grid grid_c, libSVM_Grid grid_gamma, libSVM_Grid grid_p, libSVM_Grid grid_nu, libSVM_Grid grid_coef0, libSVM_Grid grid_degree) { Dispose(); if (problem == null) { throw new Exception("libSVMProblem not initialized"); } if (problem.samples == null) { throw new Exception("libSVMProblem.samples = null"); } if (problem.labels == null) { throw new Exception("libSVMProblem.labels = null"); } if (problem.samples.Length != problem.labels.Length) { throw new Exception("libSVMProblem.samples.Length != libSVMProblem.labels.length"); } if (parameter == null) { throw new Exception("libSVMParameter not initialized"); } if (parameter.weight == null && parameter.weight_label != null) { throw new Exception("libSVMParameter.weight = null and libSVMParameter.weight_label != null"); } if (parameter.weight != null && parameter.weight_label == null) { throw new Exception("libSVMParameter.weight_label = null and libSVMParameter.weight != null"); } if (parameter.weight != null && parameter.weight_label != null && parameter.weight_label.Length != parameter.weight.Length) { throw new Exception("libSVMParameter.weight_label.Length != libSVMParameter.weight.Length"); } if (fold < 2 || fold > problem.samples.Length) { throw new Exception("fold < 2 || fold > nr_samples"); } libSVM_Grid _grid_gamma = grid_gamma; libSVM_Grid _grid_coef0 = grid_coef0; libSVM_Grid _grid_degree = grid_degree; if (parameter.kernel_type == KERNEL_TYPE.LINEAR || parameter.kernel_type == KERNEL_TYPE.PRECOMPUTED) { _grid_gamma = new libSVM_Grid(); _grid_coef0 = new libSVM_Grid(); _grid_degree = new libSVM_Grid(); } else if (parameter.kernel_type == KERNEL_TYPE.POLY) { if (_grid_gamma == null) { throw new Exception("grid_gamma not set"); } if (_grid_coef0 == null) { throw new Exception("grid_coef0 not set"); } if (_grid_degree == null) { throw new Exception("grid_degree not set"); } } else if (parameter.kernel_type == KERNEL_TYPE.RBF) { if (_grid_gamma == null) { throw new Exception("grid_gamma not set"); } _grid_coef0 = new libSVM_Grid(); _grid_degree = new libSVM_Grid(); } else if (parameter.kernel_type == KERNEL_TYPE.SIGMOID) { if (_grid_gamma == null) { throw new Exception("grid_gamma not set"); } if (_grid_coef0 == null) { throw new Exception("grid_coef not set"); } _grid_degree = new libSVM_Grid(); } else { throw new Exception("unknown kernel_type"); } libSVM_Grid _grid_c = grid_c; libSVM_Grid _grid_p = grid_p; libSVM_Grid _grid_nu = grid_nu; if (parameter.svm_type == SVM_TYPE.C_SVC || parameter.svm_type == SVM_TYPE.ONE_CLASS) { if (_grid_c == null) { throw new Exception("grid_C not set"); } _grid_nu = new libSVM_Grid(); _grid_p = new libSVM_Grid(); } else if (parameter.svm_type == SVM_TYPE.NU_SVC || parameter.svm_type == SVM_TYPE.NU_SVR) { if (_grid_nu == null) { throw new Exception("grid_nu not set"); } _grid_c = new libSVM_Grid(); _grid_p = new libSVM_Grid(); } else if (parameter.svm_type == SVM_TYPE.EPSILON_SVR) { if (_grid_p == null) { throw new Exception("grid_p not set"); } _grid_c = new libSVM_Grid(); _grid_nu = new libSVM_Grid(); } else { throw new Exception("unknown svm_type"); } double c = _grid_c.min; double p = _grid_p.min; double nu = _grid_nu.min; double gamma = _grid_gamma.min; double coef0 = _grid_coef0.min; double degree = _grid_degree.min; int f = 0; int test_probe = 0; int test_samples = 0; //ori int total_test_probe = 0; int total_test_samples = 0; libSVM_Parameter train_parameter = new libSVM_Parameter(); //copy parameters set by user; train_parameter.weight = parameter.weight; train_parameter.weight_label = parameter.weight_label; train_parameter.shrinking = parameter.shrinking; train_parameter.svm_type = parameter.svm_type; train_parameter.kernel_type = parameter.kernel_type; train_parameter.probability = parameter.probability; train_parameter.cache_size = parameter.cache_size; libSVM_Problem train_problem = new libSVM_Problem(); libSVM_Problem test_problem = new libSVM_Problem(); //ori libSVM_output this_output = new libSVM_output(); //fold do { train_problem.labels = new double[1]; train_problem.samples = new SortedDictionary <int, double> [1]; test_problem.labels = new double[1]; test_problem.samples = new SortedDictionary <int, double> [1]; int j = 0; int k = 0; for (int i = 0; i < problem.samples.Length; i++) { if ((i + 1 + f) % fold == 0) { Array.Resize(ref test_problem.labels, j + 1); Array.Resize(ref test_problem.samples, j + 1); this_output.setValue(i, 999); test_problem.labels[j] = problem.labels[i]; test_problem.samples[j] = problem.samples[i]; j++; } else { Array.Resize(ref train_problem.labels, k + 1); Array.Resize(ref train_problem.samples, k + 1); train_problem.labels[k] = problem.labels[i]; train_problem.samples[k] = problem.samples[i]; k++; } } //p p = _grid_p.min; do { //nu nu = _grid_nu.min; do { //gamma gamma = _grid_gamma.min; do { //coef0 coef0 = _grid_coef0.min; do { //degree degree = _grid_degree.min; do { //c c = _grid_c.min; do { //svm_train alters problem_ptr so it's necessary to create it every time; IntPtr this_problem_ptr = libSVM_Problem_to_svm_problem_ptr(train_problem); //set generated parameters train_parameter.C = c; train_parameter.p = p; train_parameter.nu = nu; train_parameter.gamma = gamma; train_parameter.degree = (int)degree; train_parameter.coef0 = coef0; IntPtr this_parameter_ptr = libSVM_Parameter_to_svm_parameter_ptr(train_parameter); IntPtr error_ptr = svm_check_parameter(this_problem_ptr, this_parameter_ptr); if (error_ptr != IntPtr.Zero) { throw new Exception(ptr_to_string(error_ptr)); } IntPtr this_model_ptr = svm_train(this_problem_ptr, this_parameter_ptr); int this_test_probe = 0; //count propperly recognized test_problem.samples for (int i = 0; i < test_problem.labels.Length; i++) { IntPtr svm_nodes_ptr = sample_to_svm_nodes_ptr(test_problem.samples[i]); //ori double testPrediction = svm_predict(this_model_ptr, svm_nodes_ptr); this_output.setValue(this_output.getKeyByIndex(i), testPrediction); total_test_samples++; // can also be problem.labels.length if (test_problem.labels[i] == testPrediction) { this_test_probe++; total_test_probe++; } Free_ptr(ref svm_nodes_ptr); } //if first run then just copy this if (_model_ptr == IntPtr.Zero) { _model_ptr = this_model_ptr; _parameter_ptr = this_parameter_ptr; _problem_ptr = this_problem_ptr; test_probe = this_test_probe; test_samples = test_problem.samples.Length; //ori output = this_output; //!-uncommenting this gets mapping of predicted labels only for best model this_output = new libSVM_output(); //!-uncommenting this gets only best model and not runs on all 10 folds (unless best is 10th) //exit when no better solution could be found if (test_probe == test_problem.samples.Length) { goto leave; } } else //if model was better than previous then free previous data and copy this if (this_test_probe > test_probe) { Free_svm_parameter_ptr(ref _parameter_ptr); Free_svm_problem_ptr(ref _problem_ptr); svm_free_and_destroy_model(ref _model_ptr); _parameter_ptr = this_parameter_ptr; _problem_ptr = this_problem_ptr; _model_ptr = this_model_ptr; test_probe = this_test_probe; test_samples = test_problem.samples.Length; //ori output = this_output; //!-uncommenting this gets mapping of predicted labels only for best model this_output = new libSVM_output(); //!-uncommenting this gets only best model and not runs on all 10 folds (unless best is 10th) //exit when no better solution could be found; if (test_probe == test_problem.samples.Length) { goto leave; } } //if not then free this model else { Free_svm_problem_ptr(ref this_problem_ptr); Free_svm_parameter_ptr(ref this_parameter_ptr); svm_free_and_destroy_model(ref this_model_ptr); //!-uncommenting this gets mapping of predicted labels only for best model this_output = new libSVM_output(); } c *= _grid_c.step; } while (c < _grid_c.max); degree *= _grid_degree.step; } while (degree < _grid_degree.max); coef0 *= _grid_coef0.step; } while (coef0 < _grid_coef0.max); gamma *= _grid_gamma.step; } while (gamma < _grid_gamma.max); nu *= _grid_nu.step; } while (nu < _grid_nu.max); p *= _grid_p.step; } while (p < _grid_p.max); f++; } while (f < fold); leave: //return new double []{100.0 * test_probe / (double) test_samples,100.0 * total_test_probe / (double)total_test_samples}; output.accuracy = 100.0 * test_probe / (double)test_samples; return; }
/// <summary> /// Trains model automatically using users grids. if your svm_type/kernel_type does not need it then set it to null /// </summary> /// <param name="_fold">folds for samples >=2 </param> /// <param name="_problem">samples and labels</param> /// <param name="_parameter">model parameters</param> /// <param name="_grid_c">grid for C</param> /// <param name="_grid_gamma">grid for gamma</param> /// <param name="_grid_p">grid for p</param> /// <param name="_grid_nu">grid for nu</param> /// <param name="_grid_coef0">grid for coef</param> /// <param name="_grid_degree">grid for degree</param> public void TrainAuto(int _fold, libSVM_Problem _problem, libSVM_Parameter _parameter, libSVM_Grid _grid_c, libSVM_Grid _grid_gamma, libSVM_Grid _grid_p, libSVM_Grid _grid_nu, libSVM_Grid _grid_coef0, libSVM_Grid _grid_degree) { Dispose(); if (_problem == null) { throw new Exception("libSVMProblem not initialized"); } if (_problem.samples == null) { throw new Exception("libSVMProblem.samples = null"); } if (_problem.labels == null) { throw new Exception("libSVMProblem.labels = null"); } if (_problem.samples.Length != _problem.labels.Length) { throw new Exception("libSVMProblem.samples.Length != libSVMProblem.labels.length"); } if (_parameter == null) { throw new Exception("libSVMParameter not initialized"); } if (_parameter.weight == null && _parameter.weight_label != null) { throw new Exception("libSVMParameter.weight = null and libSVMParameter.weight_label != null"); } if (_parameter.weight != null && _parameter.weight_label == null) { throw new Exception("libSVMParameter.weight_label = null and libSVMParameter.weight != null"); } if (_parameter.weight != null && _parameter.weight_label != null && _parameter.weight_label.Length != _parameter.weight.Length) { throw new Exception("libSVMParameter.weight_label.Length != libSVMParameter.weight.Length"); } if (_fold < 2 || _fold > _problem.samples.Length) { throw new Exception("fold < 2 || fold > nr_samples"); } libSVM_Grid grid_gamma = _grid_gamma; libSVM_Grid grid_coef0 = _grid_coef0; libSVM_Grid grid_degree = _grid_degree; if (_parameter.kernel_type == KERNEL_TYPE.LINEAR || _parameter.kernel_type == KERNEL_TYPE.PRECOMPUTED) { grid_gamma = new libSVM_Grid(); grid_coef0 = new libSVM_Grid(); grid_degree = new libSVM_Grid(); } else if (_parameter.kernel_type == KERNEL_TYPE.POLY) { if (grid_gamma == null) { throw new Exception("grid_gamma not set"); } if (grid_coef0 == null) { throw new Exception("grid_coef0 not set"); } if (grid_degree == null) { throw new Exception("grid_degree not set"); } } else if (_parameter.kernel_type == KERNEL_TYPE.RBF) { if (grid_gamma == null) { throw new Exception("grid_gamma not set"); } grid_coef0 = new libSVM_Grid(); grid_degree = new libSVM_Grid(); } else if (_parameter.kernel_type == KERNEL_TYPE.SIGMOID) { if (grid_gamma == null) { throw new Exception("grid_gamma not set"); } if (grid_coef0 == null) { throw new Exception("grid_coef not set"); } grid_degree = new libSVM_Grid(); } else { throw new Exception("unknown kernel_type"); } libSVM_Grid grid_c = _grid_c; libSVM_Grid grid_p = _grid_p; libSVM_Grid grid_nu = _grid_nu; if (_parameter.svm_type == SVM_TYPE.C_SVC || _parameter.svm_type == SVM_TYPE.ONE_CLASS) { if (grid_c == null) { throw new Exception("grid_C not set"); } grid_nu = new libSVM_Grid(); grid_p = new libSVM_Grid(); } else if (_parameter.svm_type == SVM_TYPE.NU_SVC || _parameter.svm_type == SVM_TYPE.NU_SVR) { if (grid_nu == null) { throw new Exception("grid_nu not set"); } grid_c = new libSVM_Grid(); grid_p = new libSVM_Grid(); } else if (_parameter.svm_type == SVM_TYPE.EPSILON_SVR) { if (grid_p == null) { throw new Exception("grid_p not set"); } grid_c = new libSVM_Grid(); grid_nu = new libSVM_Grid(); } else { throw new Exception("unknown svm_type"); } double c = grid_c.min; double p = grid_p.min; double nu = grid_nu.min; double gamma = grid_gamma.min; double coef0 = grid_coef0.min; double degree = grid_degree.min; int f = 0; int nr_test_samples = _problem.labels.Length / (int)_fold; int nr_train_samples = _problem.labels.Length - nr_test_samples; double test_probe = 0.0; libSVM_Parameter train_parameter = new libSVM_Parameter(); //copy parameters set by user; train_parameter.weight = _parameter.weight; train_parameter.weight_label = _parameter.weight_label; train_parameter.shrinking = _parameter.shrinking; train_parameter.svm_type = _parameter.svm_type; train_parameter.kernel_type = _parameter.kernel_type; train_parameter.probability = _parameter.probability; train_parameter.cache_size = _parameter.cache_size; libSVM_Problem train_problem = new libSVM_Problem(); libSVM_Problem test_problem = new libSVM_Problem(); //fold do { train_problem.labels = new double[nr_train_samples]; train_problem.samples = new double[nr_train_samples][]; test_problem.labels = new double[nr_test_samples]; test_problem.samples = new double[nr_test_samples][]; int j = 0; int k = 0; for (int i = 0; i < nr_train_samples + nr_test_samples; i++) { if (i % _fold == 0) { test_problem.labels[j] = _problem.labels[i]; test_problem.samples[j] = _problem.samples[i]; j++; } else { train_problem.labels[k] = _problem.labels[i]; train_problem.samples[k] = _problem.samples[i]; } } //p p = grid_p.min; do { //nu nu = grid_nu.min; do { //gamma gamma = grid_gamma.min; do { //coef0 coef0 = grid_coef0.min; do { //degree degree = grid_degree.min; do { //c c = grid_c.min; do { //svm_train alters problem_ptr so it's necessary to create it every time; IntPtr this_problem_ptr = libSVM_Problem_to_svm_problem_ptr(train_problem); //set generated parameters train_parameter.C = c; train_parameter.p = p; train_parameter.nu = nu; train_parameter.gamma = gamma; train_parameter.degree = (int)degree; train_parameter.coef0 = coef0; IntPtr this_parameter_ptr = libSVM_Parameter_to_svm_parameter_ptr(train_parameter); IntPtr error_ptr = svm_check_parameter(__problem_ptr, __parameter_ptr); if (error_ptr != IntPtr.Zero) { throw new Exception(ptr_to_string(error_ptr)); } IntPtr this_model_ptr = svm_train(this_problem_ptr, this_parameter_ptr); double this_test_probe = 0.0; //count propperly recognized test_problem.samples for (int i = 0; i < test_problem.labels.Length; i++) { IntPtr svm_nodes_ptr = sample_to_svm_nodes_ptr(test_problem.samples[i]); if (test_problem.labels[i] == svm_predict(__model_ptr, svm_nodes_ptr)) { this_test_probe++; } Free_ptr(ref svm_nodes_ptr); } //if first run then just copy this if (__model_ptr == IntPtr.Zero) { __model_ptr = this_model_ptr; __parameter_ptr = this_parameter_ptr; __problem_ptr = this_problem_ptr; test_probe = this_test_probe; } else //if model was better than previous then free previous data and copy this if (this_test_probe > test_probe) { Free_svm_parameter_ptr(ref __parameter_ptr); Free_svm_problem_ptr(ref __problem_ptr); svm_free_and_destroy_model(ref __model_ptr); __parameter_ptr = this_parameter_ptr; __problem_ptr = this_problem_ptr; __model_ptr = this_model_ptr; test_probe = this_test_probe; } //if not then free this model else { Free_svm_problem_ptr(ref this_problem_ptr); Free_svm_parameter_ptr(ref this_parameter_ptr); svm_free_and_destroy_model(ref this_model_ptr); } c *= grid_c.step; }while(c < grid_c.max); degree *= grid_degree.step; }while(degree < grid_degree.max); coef0 *= grid_coef0.step; }while(coef0 < grid_coef0.max); gamma *= grid_degree.step; }while(gamma < grid_gamma.max); nu *= grid_nu.step; }while(nu < grid_nu.max); p *= grid_p.step; }while(p < grid_p.max); f++; }while(f < _fold); }
/// <summary> /// Trains model automatically, using default Grids for parameter value search /// Similar to OpenCV /// </summary> /// <param name="_fold">folds for samples >=2 </param> /// <param name="_problem">samples and labels</param> /// <param name="_parameter">model parameters</param> public void TrainAuto(int _fold, libSVM_Problem _problem, libSVM_Parameter _parameter) { TrainAuto(_fold, _problem, _parameter, libSVM_Grid.C(), libSVM_Grid.gamma(), libSVM_Grid.p(), libSVM_Grid.nu(), libSVM_Grid.coef(), libSVM_Grid.degree()); }