OrgLion-ML
/
dlib
mirror of https://github.com/davisking/dlib.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Switched this example to use the svm C instead of nu trainer.

This commit is contained in:
Davis King 2017-11-25 08:26:16 -05:00
parent 0e7e433096
commit 1aa6667481
1 changed files with 25 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
examples/model_selection_ex.cpp
View File

@ -78,36 +78,37 @@ int main() try
// Now that we have some data we want to train on it. We are going to train a
// binary SVM with the RBF kernel to classify the data. However, there are two
// parameters to the training. These are the nu and gamma parameters. Our choice
// for these parameters will influence how good the resulting decision function is.
// To test how good a particular choice of these parameters is we can use the
// binary SVM with the RBF kernel to classify the data. However, there are
// three parameters to the training. These are the SVM C parameters for each
// class and the RBF kernel's gamma parameter. Our choice for these
// parameters will influence how good the resulting decision function is. To
// test how good a particular choice of these parameters is we can use the
// cross_validate_trainer() function to perform n-fold cross validation on our
// training data. However, there is a problem with the way we have sampled our
// distribution above. The problem is that there is a definite ordering to the
// samples. That is, the first half of the samples look like they are from a
// different distribution than the second half. This would screw up the cross
// validation process, but we can fix it by randomizing the order of the samples
// with the following function call.
// training data. However, there is a problem with the way we have sampled
// our distribution above. The problem is that there is a definite ordering
// to the samples. That is, the first half of the samples look like they are
// from a different distribution than the second half. This would screw up
// the cross validation process, but we can fix it by randomizing the order of
// the samples with the following function call.
randomize_samples(samples, labels);
// And now we get to the important bit. Here we define a function,
// cross_validation_score(), that will do the cross-validation we
// mentioned and return a number indicating how good a particular setting
// of gamma and nu is.
auto cross_validation_score = [&](const double gamma, const double nu)
// of gamma, c1, and c2 is.
auto cross_validation_score = [&](const double gamma, const double c1, const double c2)
{
// Make a RBF SVM trainer and tell it what the parameters are supposed to be.
typedef radial_basis_kernel<sample_type> kernel_type;
svm_nu_trainer<kernel_type> trainer;
svm_c_trainer<kernel_type> trainer;
trainer.set_kernel(kernel_type(gamma));
trainer.set_nu(nu);
trainer.set_c_class1(c1);
trainer.set_c_class2(c2);
// Finally, perform 10-fold cross validation and then print and return the results.
matrix<double> result = cross_validate_trainer(trainer, samples, labels, 10);
cout << "gamma: " << setw(11) << gamma << " nu: " << setw(11) << nu << " cross validation accuracy: " << result;
cout << "gamma: " << setw(11) << gamma << " c1: " << setw(11) << c1 << " c2: " << setw(11) << c2 << " cross validation accuracy: " << result;
// Now return a number indicating how good the parameters are. Bigger is
// better in this example. Here I'm returning the harmonic mean between the
@ -119,33 +120,26 @@ int main() try
return 2*prod(result)/sum(result);
};
// The nu parameter has a maximum value that is dependent on the ratio of the +1 to -1
// labels in the training data. This function finds that value. The 0.999 is here
// because the maximum allowable nu is strictly less than the value returned by
// maximum_nu(). So shrinking the limit a little will prevent us from hitting it.
const double max_nu = 0.999*maximum_nu(labels);
// And finally, we call this global optimizer that will search for the best parameters.
// It will call cross_validation_score() 50 times with different settings and return
// It will call cross_validation_score() 30 times with different settings and return
// the best parameter setting it finds. find_max_global() uses a global optimization
// method based on a combination of non-parametric global function modeling and
// quadratic trust region modeling to efficiently find a global maximizer. It usually
// does a good job with a relatively small number of calls to cross_validation_score().
// In this example, you should observe that it finds settings that give perfect binary
// classification on the data.
// classification of the data.
auto result = find_max_global(cross_validation_score,
{1e-5, 1e-5}, // lower bound constraints on gamma and nu, respectively
{100, max_nu}, // upper bound constraints on gamma and nu, respectively
max_function_calls(50));
{1e-5, 1e-5, 1e-5}, // lower bound constraints on gamma, c1, and c2, respectively
{100, 1e6, 1e6}, // upper bound constraints on gamma, c1, and c2, respectively
max_function_calls(30));
double best_gamma = result.x(0);
double best_nu = result.x(1);
double best_c1 = result.x(1);
double best_c2 = result.x(2);
cout << " best cross-validation score: " << result.y << endl;
cout << " best gamma: " << best_gamma << " best nu: " << best_nu << endl;
cout << " best gamma: " << best_gamma << " best c1: " << best_c1 << " best c2: "<< best_c2 << endl;
}
catch (exception& e)
{