int main(int argc, char **argv) { char input_file_name[1024]; char model_file_name[1024]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"Error: %s\n",error_msg); exit(1); } if(cross_validation) { do_cross_validation(); } else { model = svm_train(&prob,¶m); svm_save_model(model_file_name,model); svm_destroy_model(model); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); return 0; }
void TrainableOneClassSvmClassifier::train() { problem = move(createProblem()); const char* message = svm_check_parameter(problem.get(), param.get()); if (message != 0) throw invalid_argument(string("invalid SVM parameters: ") + message); model.reset(svm_train(problem.get(), param.get())); updateSvmParameters(); }
svm_classifier_t *svm_finish_classifier(svm_classifier_t *svm) { int i, j, nr_fold=5, total_correct, best_correct=0, best_c=svm->param.C, best_g=svm->param.gamma; const char *error_msg; double *result = (double *) rs_malloc(sizeof(double)*svm->problem.l,"cross validation result"); rs_msg("Building SVM classifier..."); if (svm->finished) rs_warning("SVM classifier is already trained!"); error_msg = svm_check_parameter(&(svm->problem),&(svm->param)); if(error_msg) rs_error("%s",error_msg); /* Skalierung */ _create_scaling(svm->problem,svm->feature_dim,&(svm->max),&(svm->min)); for (i=0;i<svm->problem.l;i++) _scale_instance(&(svm->problem.x[i]),svm->feature_dim,svm->max,svm->min); /* Cross-Validation, um C und G zu bestimmen bei RBF-Kernel */ if (svm->param.kernel_type == RBF) { svm->param.probability = 0; for (i=0;i<C_G_ITER;i++) { total_correct=0; svm->param.C=pow(2,C[i]); svm->param.gamma=pow(2,G[i]); svm_cross_validation(&(svm->problem),&(svm->param),nr_fold,result); for(j=0;j<svm->problem.l;j++) { if(result[j] == svm->problem.y[j]) ++total_correct; } if (total_correct > best_correct) { best_correct=total_correct; best_c=C[i]; best_g=G[i]; } rs_msg("C-G-Selektion-Iteration # %d: tried c=%g and g=%g => CV rate is %g; current best c=%g and g=%g with CV rate %g",i+1,pow(2,C[i]),pow(2,G[i]),total_correct*100.0/svm->problem.l,pow(2,best_c),pow(2,best_g),best_correct*100.0/svm->problem.l); } /* Training */ svm->param.C=pow(2,best_c); svm->param.gamma=pow(2,best_g); svm->param.probability = 1; } svm->model=svm_train(&(svm->problem),&(svm->param)); svm->finished=1; // @begin_add_johannes rs_free (result); // @end_add_johannes return svm; }
// Calls LibSVM function svm_train for simplicity. int SupportVectorMachine::Train() { // Calls svm_train to train an SVM model. const char *svm_check_param = svm_check_parameter(&svm_problem_,\ &svm_parameter_); struct svm_model *curr_svm_model = svm_train(&svm_problem_,&svm_parameter_); memcpy(&svm_model_,curr_svm_model,sizeof(struct svm_model)); return 0; }
bool SVM::validateProblemAndParameters(){ //Check the parameters match the problem const char *errorMsg = svm_check_parameter(&prob,¶m); if( errorMsg ){ errorLog << "validateProblemAndParameters() - Parameters do not match problem!" << endl; return false; } return true; }
svm_model * SupportVectorMachine::get_svm_model(std::vector<Abalone> &learning_Abalones) { svm_problem SVM_Problem; SVM_Problem.l = learning_Abalones.size(); SVM_Problem.y = Abalone::get_target_values(learning_Abalones); svm_node **x = new svm_node*[learning_Abalones.size()]; for (int i = 0; i < learning_Abalones.size(); i++) { x[i] = new svm_node[9]; svm_node node1; node1.index = 1; node1.value = learning_Abalones[i].get_Sex(); x[i][0] = node1; svm_node node2; node2.index = 2; node2.value = learning_Abalones[i].get_Diameter(); x[i][1] = node2; svm_node node3; node3.index = 3; node3.value = learning_Abalones[i].get_Height(); x[i][2] = node3; svm_node node4; node4.index = 4; node4.value = learning_Abalones[i].get_Length(); x[i][3] = node4; svm_node node5; node5.index = 5; node5.value = learning_Abalones[i].get_Shell_weight(); x[i][4] = node5; svm_node node6; node6.index = 6; node6.value = learning_Abalones[i].get_Shucked_weight(); x[i][5] = node6; svm_node node7; node7.index = 7; node7.value = learning_Abalones[i].get_Viscera_weight(); x[i][6] = node7; svm_node node8; node8.index = 8; node8.value = learning_Abalones[i].get_Whole_weight(); x[i][7] = node8; svm_node node9; node9.index = -1; node9.value = '?'; x[i][8] = node9; } SVM_Problem.x = x; svm_parameter SVM_Parameter; SVM_Parameter.C = 1; SVM_Parameter.svm_type = C_SVC; SVM_Parameter.kernel_type = LINEAR; SVM_Parameter.degree = 3; /* for poly */ SVM_Parameter.gamma = 2; /* for poly/rbf/sigmoid */ SVM_Parameter.coef0 = 1; /* for poly/sigmoid */ SVM_Parameter.cache_size = 64; SVM_Parameter.eps = 0.001; SVM_Parameter.nr_weight = 0; svm_check_parameter(&SVM_Problem, &SVM_Parameter); svm_model *model = svm_train(&SVM_Problem, &SVM_Parameter); /*for (int i = 0; i < learning_Abalones.size(); i++) { delete[] x[i]; } delete[] x; delete SVM_Problem.y;*/ return model; }
svm_model* LibSVMRunner::load_model_from_config(SVMConfiguration& config, svm_parameter* param) { const char *error_msg; error_msg = svm_check_parameter(&prob, param,config.log); if (error_msg) { LOG(config.log, LogLevel::ERR_LEVEL, "ERROR: " + to_string(error_msg)) return 0; } model = Malloc(svm_model, 1); model->l = config.getSVCount(); //support vectors number model->nr_class = config.nr_class; model->param = *param; model->sv_coef = (double **) malloc(model->nr_class * sizeof(double*)); for (int i = 0; i < config.nr_class - 1; i++) { model->sv_coef[i] = (double *) malloc(config.getSVCount() * sizeof(double)); std::copy(config.alpha_y.begin(), config.alpha_y.end(), model->sv_coef[i * config.getSVCount()]); } model->SV = armatlib(arma::mat(config.support_vectors.t())); // FIXME: Why below is not working? //model->SV = ArmaSpMatToSvmNode(config.support_vectors); model->rho = (double *) malloc( config.nr_class * (config.nr_class - 1) / 2 * sizeof(double)); //i need change sign in b double local_rho = -config.b; if(config.nr_class != 2) { throw std::invalid_argument( "Code is not implemented for more than 2 classes right now"); } memcpy(model->rho, &local_rho, config.nr_class * (config.nr_class - 1) / 2 * sizeof(double)); model->free_sv = 1; if (config.svm_type < 2) { model->label = (int *) malloc(config.nr_class * sizeof(int)); model->nSV = (int *) malloc(config.nr_class * sizeof(int)); memcpy(model->label, config.label, config.nr_class * sizeof(int)); memcpy(model->nSV, config.nSV, config.nr_class * sizeof(int)); } return model; }
int main(int argc, char **argv) { char input_file_name[1024]; char model_file_name[1024]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); #ifdef CUSTOM_SOLVER if (param.svm_type == ONE_CLASS) { param.strong_footlier_indexes = filter_strong_footliers(input_file_name); } #endif error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"Error: %s\n",error_msg); exit(1); } if(cross_validation) { if(param.svm_type == R2 || param.svm_type == R2q) fprintf(stderr, "\"R^2\" cannot do cross validation.\n"); else do_cross_validation(); } else { model = svm_train(&prob,¶m); if(param.svm_type == R2 || param.svm_type == R2q) fprintf(stderr, "\"R^2\" does not generate model.\n"); else if(svm_save_model(model_file_name,model)) { fprintf(stderr, "can't save model to file %s\n", model_file_name); exit(1); } svm_free_and_destroy_model(&model); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); free(line); return 0; }
void* jpcnn_create_predictor_from_trainer(void* trainerHandle) { SLibSvmTrainingInfo* trainer = (SLibSvmTrainingInfo*)(trainerHandle); SLibSvmProblem* problem = create_svm_problem_from_training_info(trainer); const char* parameterCheckError = svm_check_parameter(problem->svmProblem, problem->svmParameters); if (parameterCheckError != NULL) { fprintf(stderr, "libsvm parameter check error: %s\n", parameterCheckError); destroy_svm_problem(problem); return NULL; } struct svm_model* model = svm_train(problem->svmProblem, problem->svmParameters); SPredictorInfo* result = (SPredictorInfo*)(malloc(sizeof(SPredictorInfo))); result->model = model; result->problem = problem; return result; }
int main(int argc, char **argv) { char input_file_name[1024]; char model_file_name[1024]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"ERROR: %s\n",error_msg); exit(1); } if(cross_validation) { if (nr_fold <= 10) { do_cross_validation(); } else { double cv; nr_fold = nr_fold - 10; cv = binary_class_cross_validation(&prob, ¶m, nr_fold); printf("Cross Validation = %g%%\n",100.0*cv); } } else { model = svm_train(&prob,¶m); if(svm_save_model(model_file_name,model)) { fprintf(stderr, "can't save model to file %s\n", model_file_name); exit(1); } svm_free_and_destroy_model(&model); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); free(line); return 0; }
static VALUE cModel_class_train(VALUE obj,VALUE problem,VALUE parameter) { const struct svm_problem *prob; const struct svm_parameter *param; struct svm_model *model; const char *check_error; Data_Get_Struct(problem, struct svm_problem, prob); Data_Get_Struct(parameter, struct svm_parameter, param); check_error = svm_check_parameter(prob, param); if(check_error != NULL) { rb_raise(rb_eArgError, "Parameters not valid for Problem: '%s'", check_error); } model = svm_train(prob,param); return Data_Wrap_Struct(cModel, 0, model_free, model); }
int SVM::train() { if (problem.y == NULL || problem.x == NULL) return -1; const char* error_msg = svm_check_parameter(&problem, ¶m); if (error_msg) { std::cout << "ERROR: " << error_msg << std::endl; exit(-1); } model = svm_train(&problem, ¶m); /*for (int i = 0; i < 100000; i++) if (sin(i) + cos(i) > 1.414) std::cout << "."; */ main_equation = new Equation(); svm_model_visualization(model, main_equation); svm_free_and_destroy_model(&model); return 0; }
bool CmySvmArth::Train( char* path) { const char *error_msg; error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"ERROR: %s\n",error_msg); free(prob.y); free(prob.x); free(x_space); free(line); line = NULL; x_space = NULL; return false; } if(cross_validation) { do_cross_validation(); } else { model = svm_train(&prob,¶m); if(path!=NULL&&svm_save_model(path,model)) { fprintf(stderr, "can't save model to file %s\n", path); return false; } if(path!=NULL) { svm_free_and_destroy_model(&model); } } svm_destroy_param(¶m); free(prob.y); free(prob.x); if(path!=NULL) { free(x_space); free(line); line = NULL; x_space = NULL; } return true; }
int main(int argc, char **argv) { char input_file_name[1024]; char model_file_name[1024]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"ERROR: %s\n",error_msg); exit(1); } if(cross_validation) { do_cross_validation(); } else { model = svm_train(&prob,¶m); if(svm_save_model(model_file_name,model)) { fprintf(stderr, "can't save model to file %s\n", model_file_name); exit(1); } svm_free_and_destroy_model(&model); } svm_destroy_param(¶m); free(prob.y); #ifdef _DENSE_REP for (int i = 0; i < prob.l; ++i) free((prob.x+i)->values); #else free(x_space); #endif free(prob.x); free(line); return 0; }
int SVMTrainModel::train(double &RecRate, std::vector<int> &ConfusionTable) { if((!have_input_file_name) || (!have_model_file_name)) { fprintf(stderr,"ERROR: Set Input and Model files first!\n"); exit(1); } const char *error_msg; readProblem(input_file_name); error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"ERROR: %s\n",error_msg); exit(1); } if(cross_validation) { do_cross_validation(RecRate,ConfusionTable); } else { model = svm_train(&prob,¶m); if(svm_save_model(model_file_name,model)) { fprintf(stderr, "can't save model to file %s\n", model_file_name); exit(1); } svm_free_and_destroy_model(&model); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); free(line); return 0; }
void SVM::train(char* pInputSampleFileName, char* OutputModelFilename, double &dRetTrainError, double &dRetCrossValError) { struct svm_parameter strSvmParameters; struct svm_problem strSvmProblem; struct svm_model *pstrSvmModel; const char *error_msg; double dCrossValError = -1; double dTrainError = -1; //set parameters this->setParameters(strSvmParameters); //read sample file this->read_problem(pInputSampleFileName, strSvmProblem, strSvmParameters); //check parameters error_msg = svm_check_parameter(&strSvmProblem, &strSvmParameters); //train model pstrSvmModel = svm_train(&strSvmProblem, &strSvmParameters); //do cross validation check dCrossValError = this->crossValidationSamples(strSvmProblem, strSvmParameters, 5); //save trained model svm_save_model(OutputModelFilename, pstrSvmModel); //test trained model with training set -> train error cout << "test model " << OutputModelFilename << " with the training set " << pInputSampleFileName << std::endl; this->test(pInputSampleFileName, OutputModelFilename, dTrainError); //clean up svm_destroy_model(pstrSvmModel); svm_destroy_param(&strSvmParameters); free(strSvmProblem.y); free(strSvmProblem.x); dRetTrainError = dTrainError; dRetCrossValError = dCrossValError; }
int svmtrain(int argc, char **argv) { char input_file_name[1024]; char model_file_name[1024]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { LOGD("ERROR: %s\n",error_msg); exit(1); } if(cross_validation) { do_cross_validation(); } else { modelt = svm_train(&prob,¶m); if(svm_save_model(model_file_name,modelt)) { LOGD("can't save model to file %s\n", model_file_name); exit(1); } svm_free_and_destroy_model(&modelt); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); free(line); return 0; }
void SvmOneVsAll::train() { scaling = buildScalingSetting(histgrams_by_name); models_by_name.clear(); for (const auto& hist_positive: histgrams_by_name) { list<vector<LibSVM::NodeArray::Classified> > data_set, data_set_positive, data_set_rest; for (const auto& hist : histgrams_by_name) { if (hist_positive.first == hist.first) { auto d = buildClassfiedData(hist.second, 1); data_set.push_back(d); data_set_positive.push_back(d); } else { auto d = buildClassfiedData(hist.second, 0); data_set.push_back(d); data_set_rest.push_back(d); } } auto data_set_merged = LibSVM::mergeClassified(data_set); LibSVM::scale(scaling, data_set_merged); LibSVM::Problem prob(data_set_merged); const char* param_error_message = svm_check_parameter(&prob, param); if (param_error_message) { OmpStream(cerr) << "Parameter is wrong: " << param_error_message << endl; continue; } LibSVM::Model model(svm_train(&prob, param)); models_by_name[hist_positive.first] = make_tuple(model, prob); } }
void svmtrain (double *x, int *r, int *c, double *y, int *rowindex, int *colindex, int *svm_type, int *kernel_type, int *degree, double *gamma, double *coef0, double *cost, double *nu, int *weightlabels, double *weights, int *nweights, double *cache, double *tolerance, double *epsilon, int *shrinking, int *cross, int *sparse, int *probability, int *nclasses, int *nr, int *index, int *labels, int *nSV, double *rho, double *coefs, double *sigma, double *probA, double *probB, double *cresults, double *ctotal1, double *ctotal2, char **error) { struct svm_parameter par; struct svm_problem prob; struct svm_model *model = NULL; int i, ii; const char* s; /* set parameters */ par.svm_type = *svm_type; par.kernel_type = *kernel_type; par.degree = *degree; par.gamma = *gamma; par.coef0 = *coef0; par.cache_size = *cache; par.eps = *tolerance; par.C = *cost; par.nu = *nu; par.nr_weight = *nweights; if (par.nr_weight > 0) { par.weight = (double *) malloc (sizeof(double) * par.nr_weight); memcpy(par.weight, weights, par.nr_weight * sizeof(double)); par.weight_label = (int *) malloc (sizeof(int) * par.nr_weight); memcpy(par.weight_label, weightlabels, par.nr_weight * sizeof(int)); } par.p = *epsilon; par.shrinking = *shrinking; par.probability = *probability; /* set problem */ prob.l = *r; prob.y = y; if (*sparse > 0) prob.x = transsparse(x, *r, rowindex, colindex); else prob.x = sparsify(x, *r, *c); /* check parameters & copy error message */ s = svm_check_parameter(&prob, &par); if (s) { strcpy(*error, s); } else { /* call svm_train */ model = svm_train(&prob, &par); /* set up return values */ /* for (ii = 0; ii < model->l; ii++) for (i = 0; i < *r; i++) if (prob.x[i] == model->SV[ii]) index[ii] = i+1; */ svm_get_sv_indices(model, index); *nr = model->l; *nclasses = model->nr_class; memcpy (rho, model->rho, *nclasses * (*nclasses - 1)/2 * sizeof(double)); if (*probability && par.svm_type != ONE_CLASS) { if (par.svm_type == EPSILON_SVR || par.svm_type == NU_SVR) *sigma = svm_get_svr_probability(model); else { memcpy(probA, model->probA, *nclasses * (*nclasses - 1)/2 * sizeof(double)); memcpy(probB, model->probB, *nclasses * (*nclasses - 1)/2 * sizeof(double)); } } for (i = 0; i < *nclasses-1; i++) memcpy (coefs + i * *nr, model->sv_coef[i], *nr * sizeof (double)); if (*svm_type < 2) { memcpy (labels, model->label, *nclasses * sizeof(int)); memcpy (nSV, model->nSV, *nclasses * sizeof(int)); } /* Perform cross-validation, if requested */ if (*cross > 0) do_cross_validation (&prob, &par, *cross, cresults, ctotal1, ctotal2); /* clean up memory */ svm_free_and_destroy_model(&model); } /* clean up memory */ if (par.nr_weight > 0) { free(par.weight); free(par.weight_label); } for (i = 0; i < *r; i++) free (prob.x[i]); free (prob.x); }
void SVMClassifier::train() { if(class_data.size() == 0){ printf("SVMClassifier::train() -- No training data available! Doing nothing.\n"); return; } int n_classes = class_data.size(); //Count the training data int n_data = 0; int dims = class_data.begin()->second[0].size(); for(ClassMap::iterator iter = class_data.begin(); iter != class_data.end(); iter++){ CPointList cpl = iter->second; if(cpl.size() == 1) n_data += 2; //There's a bug in libSVM for classes with only 1 data point, so we will duplicate them later else n_data += cpl.size(); } //Allocate space for data in an svm_problem structure svm_data.l = n_data; svm_data.y = new double[n_data]; svm_data.x = new svm_node*[n_data]; for(int i=0; i<n_data; i++) svm_data.x[i] = new svm_node[dims+1]; //Create maps between string labels and int labels label_str_to_int.clear(); label_int_to_str.clear(); int label_n = 0; for(ClassMap::iterator iter = class_data.begin(); iter != class_data.end(); iter++){ string cname = iter->first; label_str_to_int[cname] = label_n; label_int_to_str[label_n] = cname; //cout << "MAP: " << label_n << " " << cname << " Size: " << iter->second.size() << endl; ++label_n; } //Find the range of the data in each dim and calc the scaling factors to scale from 0 to 1 scaling_factors = new double*[dims]; for(int i=0; i<dims; i++) scaling_factors[i] = new double[2]; //Scale each dimension separately for(int j=0; j<dims; j++){ //First find the min, max, and scaling factor double minval = INFINITY; double maxval = -INFINITY; for(ClassMap::iterator iter = class_data.begin(); iter != class_data.end(); iter++){ CPointList cpl = iter->second; for(size_t i=0; i<cpl.size(); i++){ if(cpl[i][j] < minval) minval = cpl[i][j]; if(cpl[i][j] > maxval) maxval = cpl[i][j]; } } double factor = maxval-minval; double offset = minval; //Do the scaling and save the scaling factor and offset for(ClassMap::iterator iter = class_data.begin(); iter != class_data.end(); iter++){ for(size_t i=0; i<iter->second.size(); i++){ iter->second[i][j] = (iter->second[i][j] - offset) / factor; } } scaling_factors[j][0] = offset; scaling_factors[j][1] = factor; } //Put the training data into the svm_problem int n = 0; for(ClassMap::iterator iter = class_data.begin(); iter != class_data.end(); iter++){ string cname = iter->first; CPointList cpl = iter->second; //Account for bug in libSVM with classes with only 1 data point by duplicating it. if(cpl.size() == 1){ svm_data.y[n] = label_str_to_int[cname]; svm_data.y[n+1] = label_str_to_int[cname]; for(int j=0; j<dims; j++){ svm_data.x[n][j].index = j; svm_data.x[n][j].value = cpl[0][j] + 0.001; svm_data.x[n+1][j].index = j; svm_data.x[n+1][j].value = cpl[0][j] + 0.001; } svm_data.x[n][dims].index = -1; svm_data.x[n+1][dims].index = -1; n = n + 2; } else{ for(size_t i=0; i<cpl.size(); i++){ svm_data.y[n] = label_str_to_int[cname]; for(int j=0; j<dims; j++){ svm_data.x[n][j].index = j; svm_data.x[n][j].value = cpl[i][j]; } svm_data.x[n][dims].index = -1; n = n + 1; } } } //Set the training params svm_parameter params; params.svm_type = C_SVC; params.kernel_type = RBF; params.cache_size = 100.0; params.gamma = 1.0; params.C = 1.0; params.eps = 0.001; params.shrinking = 1; params.probability = 0; params.degree = 0; params.nr_weight = 0; //params.weight_label = //params.weight = const char *err_str = svm_check_parameter(&svm_data, ¶ms); if(err_str){ printf("SVMClassifier::train() -- Bad SVM parameters!\n"); printf("%s\n",err_str); return; } //Grid Search for best C and gamma params int n_folds = min(10, n_data); //Make sure there at least as many points as folds double *resp = new double[n_data]; double best_accy = 0.0; double best_g = 0.0; double best_c = 0.0; //First, do a coarse search for(double c = -5.0; c <= 15.0; c += 2.0){ for(double g = 3.0; g >= -15.0; g -= 2.0){ params.gamma = pow(2,g); params.C = pow(2,c); svm_cross_validation(&svm_data, ¶ms, n_folds, resp); //Figure out the accuracy using these params int correct = 0; for(int i=0; i<n_data; i++){ if(resp[i] == svm_data.y[i]) ++correct; double accy = double(correct) / double(n_data); if(accy > best_accy){ best_accy = accy; best_g = params.gamma; best_c = params.C; } } } } //Now do a finer grid search based on coarse results double start_c = best_c - 1.0; double end_c = best_c + 1.0; double start_g = best_g + 1.0; double end_g = best_g - 1.0; for(double c = start_c; c <= end_c; c += 0.1){ for(double g = start_g; g >= end_g; g -= 0.1){ params.gamma = pow(2,g); params.C = pow(2,c); svm_cross_validation(&svm_data, ¶ms, n_folds, resp); //Figure out the accuracy using these params int correct = 0; for(int i=0; i<n_data; i++){ if(resp[i] == svm_data.y[i]) ++correct; double accy = double(correct) / double(n_data); if(accy > best_accy){ best_accy = accy; best_g = params.gamma; best_c = params.C; } } } } // Set params to best found in grid search params.gamma = best_g; params.C = best_c; printf("BEST PARAMS ncl: %i c: %f g: %f accy: %f \n\n", n_classes, best_c, best_g, best_accy); //Train the SVM trained_model = svm_train(&svm_data, ¶ms); }
void BagOfFeatures::trainSVM(int type = NU_SVC, int kernel = RBF, double degree = 0.05, double gamma = 0.25, double coef0 = 0.5, double C = .05, double cache = 300, double eps = 0.000001, double nu = 0.5, int shrinking = 0, int probability = 0, int weight = 0) { if(SVMModel != NULL) { svm_destroy_model(SVMModel); //svm_destroy_param(&SVMParam); } int i, j, k, l = -1; int totalData = 0; int size, length = dictionary->rows; int count; //Get the total number of training data for(i = 0; i < numClasses; i++) totalData += data[i].getTrainSize(); // Set up the data struct svm_problem SVMProblem; SVMProblem.l = totalData; SVMProblem.y = new double [totalData]; SVMProblem.x = new struct svm_node* [totalData]; // Allocate memory //for(i = 0; i < totalData; i++) //{ // SVMProblem.x[i] = new struct svm_node [length+1]; //} // For each class for(i = 0; i < numClasses; i++) { // Get the number of images size = data[i].getTrainSize(); for(j = 0; j < size; j++) { l++; count = 0; for(k = 0; k < length; k++) { if(trainObject[i].histogramSet.histogram[j][k] != 0) count++; } SVMProblem.x[l] = new struct svm_node [count+1]; count = 0; for(k = 0; k < length; k++) { if(trainObject[i].histogramSet.histogram[j][k] != 0) { SVMProblem.x[l][count].index = k; SVMProblem.x[l][count].value = trainObject[i].histogramSet.histogram[j][k]; //cout << "(" << SVMProblem.x[l][count].index // << ", " << SVMProblem.x[l][count].value << ")" << endl; count++; } } SVMProblem.x[l][count].index = -1; //cout << endl; //SVMProblem.x[l][count].value = -1; // Copy the histograms //for(k = 0; k < length; k++) //{ // SVMProblem.x[l][k].index = k; // SVMProblem.x[l][k].value = trainObject[i].histogramSet.histogram[j][k]; //} // End of the data //SVMProblem.x[l][length].index = -1; //SVMProblem.x[l][length].value = -1; //Attach the labels SVMProblem.y[l] = data[i].getLabel(); //cout << "Label: " << SVMProblem.y[l] << endl; } } // Types SVMParam.svm_type = type; SVMParam.kernel_type = kernel; // Parameters SVMParam.degree = degree; SVMParam.gamma = gamma; SVMParam.coef0 = coef0; SVMParam.C = C; // For training only SVMParam.cache_size = cache; SVMParam.eps = eps; SVMParam.nu = nu; SVMParam.shrinking = shrinking; SVMParam.probability = probability; // Don't change the weights SVMParam.nr_weight = weight; double* target = new double [totalData]; svm_check_parameter(&SVMProblem, &SVMParam); svm_cross_validation(&SVMProblem, &SVMParam, 10, target); SVMModel = svm_train(&SVMProblem, &SVMParam); delete [] target; classifierType = LIBSVM_CLASSIFIER; }
//train the svm using the parameters defined inside this method void ML2::trainData() { //file to store the svm model structure string model_file_name1 = flowstatistics_train_name+"_model.csv"; const char *model_file_name = model_file_name1.c_str(); //file to read the data from char input_file_name[1024] = "velocityArray.csv"; //char input_file_name2[1024] = "data/flowstatistics_train_mu.csv"; const char *error_msg; //parameters of the svm /* "-s svm_type : set type of SVM (default 0)\n" " 0 -- C-SVC (multi-class classification)\n" " 1 -- nu-SVC (multi-class classification)\n" " 2 -- one-class SVM\n" " 3 -- epsilon-SVR (regression)\n" " 4 -- nu-SVR (regression)\n" "-t kernel_type : set type of kernel function (default 2)\n" " 0 -- linear: u'*v\n" " 1 -- polynomial: (gamma*u'*v + coef0)^degree\n" " 2 -- radial basis function: exp(-gamma*|u-v|^2)\n" " 3 -- sigmoid: tanh(gamma*u'*v + coef0)\n" " 4 -- precomputed kernel (kernel values in training_set_file)\n" "-d degree : set degree in kernel function (default 3)\n" "-g gamma : set gamma in kernel function (default 1/num_features)\n" "-r coef0 : set coef0 in kernel function (default 0)\n" "-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)\n" "-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)\n" "-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)\n" "-m cachesize : set cache memory size in MB (default 100)\n" "-e epsilon : set tolerance of termination criterion (default 0.001)\n" "-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n" "-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)\n" "-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)\n" "-v n: n-fold cross validation mode\n" "-q : quiet mode (no outputs)\n" */ //set the parameters to be used for svm param.svm_type = 4; param.kernel_type = 1;//RBF; param.degree = 2; param.gamma = 0.125; // 1/num_features param.coef0 = 0; param.nu = 0.4; param.cache_size = 100; param.C = 0.125; param.eps = 1e-3; param.p = 0.1; param.shrinking = 1; param.probability = 0; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; //param.v = 10; nr_fold =10; //read from the data file read_problem_data( input_file_name, flowcol); //checking the parameters, if they are set correctly error_msg = svm_check_parameter(&prob,¶m); if(error_msg) { cout<<"ERROR: "<<error_msg<<endl<<flush; exit(1); } //do_cross_validation(); // first do grid search do find optimal parameters //paramSelection(); // then do training with optimal parameters //param.gamma = best_gamma; //param.C = best_C; cout<< "start training\n"<<endl<<flush; model = svm_train(&prob,¶m); cout<< "end training\n"<<endl<<flush; // then do cross fold validation cout<< "start with cross validation" <<endl<<flush; do_cross_validation(); cout<< "end cross validation" <<endl<<flush; //save model if(svm_save_model(model_file_name,model)) { cout<< "can't save model to file "<< model_file_name <<endl<<flush; exit(1); } //free all the pointers used, except the model which is required for prediction // svm_destroy_param(¶m); // free(prob.y); // free(prob.x); // free(x_space); // free(line); return; }
void SVModel::initStrutturaDati(int LabelTrSelSize,int *label_training_selection, // info sul Training Set int FeatSelSize,int *feature_sel, // info sulle feature da usare int LabelSelIdx, // info sulla label da usare double *f,size_t *FeatSize,double *l,size_t *LabelSize){ // info su tutto il dataset int i, ii, j, k, kk; int elements, max_index, sc, label_vector_row_num, featsize; double *samples, *labels; prob.x = NULL; prob.y = NULL; x_space = NULL; labels = l; samples = f; sc = (int)FeatSize[1]; elements = 0; // the number of instance prob.l = LabelTrSelSize; featsize = (int)FeatSize[0]; label_vector_row_num = (int)LabelSize[0]; if(label_vector_row_num!=featsize) { fprintf(stderr,"#Labels != #Features!!!"); exit(1); } int TotIstanze=featsize; if(param.kernel_type == PRECOMPUTED) elements = prob.l * (sc + 1); else { for(ii = 0; ii < prob.l; ii++) { i=label_training_selection[ii]; for(kk = 0; kk < FeatSelSize /*sc*/; kk++){ k = feature_sel[kk]; if(samples[k * prob.l + i] != 0) elements++; } // count the '-1' element elements++; } } prob.y = new double [prob.l]; prob.x = new struct svm_node* [prob.l]; x_space = new struct svm_node [elements]; max_index = sc; j = 0; for(ii = 0; ii < prob.l; ii++) { i=label_training_selection[ii]; prob.x[ii] = &x_space[j]; prob.y[ii] = labels[LabelSelIdx * TotIstanze + i]; for(kk = 0; kk < FeatSelSize /*sc*/; kk++) { k = feature_sel[kk]; if(param.kernel_type == PRECOMPUTED || samples[k * prob.l + i] != 0) { x_space[j].index = k + 1; x_space[j].value = samples[k * TotIstanze + i]; j++; } } x_space[j++].index = -1; } // ROBA PER DEBUG if (0){ for(ii = 0; ii < 10; ii++){ i=label_training_selection[ii]; cout << " " << labels[LabelSelIdx * TotIstanze + i]; } cout << endl<< endl; for(ii = 0; ii < 10; ii++){ i=label_training_selection[ii]; cout << " " << i; } cout << endl<< endl; for(ii = 0; ii < 10; ii++){ i=label_training_selection[ii]; for(kk = 0; kk < FeatSelSize /*sc*/; kk++){ k = feature_sel[kk]; if(param.kernel_type == PRECOMPUTED || samples[k * prob.l + i] != 0){ cout << " " << samples[k * TotIstanze + i]; } } cout << endl; } // exit(1); } // FINE DI ROBA if(param.gamma == 0 && max_index > 0) param.gamma = 1.0/max_index; if(param.kernel_type == PRECOMPUTED) for(ii=0; ii<prob.l; ii++) { if((int)prob.x[ii][0].value <= 0 || (int)prob.x[ii][0].value > max_index) { fprintf(stderr,"Wrong input format: sample_serial_number out of range\n"); exit(1); } } const char* error_msg = svm_check_parameter(&prob, ¶m); if(error_msg) { if (error_msg != NULL) fprintf(stderr,"Errore: %s\n", error_msg); exit(1); } // assegnato=true; }
Transformation SVMTrain::analyze(const DataSet* dataset) const { G_INFO("Doing SVMTrain analysis..."); QStringList sdescs = selectDescriptors(dataset->layout(), StringType, _descriptorNames, _exclude, false); if (!sdescs.isEmpty()) { throw GaiaException("SVMTrain: if you want to use string descriptors for training your SVM, " "you first need to enumerate them using the 'enumerate' transform on them. " "String descriptors: ", sdescs.join(", ")); } QStringList descs = selectDescriptors(dataset->layout(), UndefinedType, _descriptorNames, _exclude); // sort descriptors in the order in which they are taken inside the libsvm dataset sort(descs.begin(), descs.end(), DescCompare(dataset->layout())); Region region = dataset->layout().descriptorLocation(descs); QStringList classMapping = svm::createClassMapping(dataset, _className); // first, convert the training data into an SVM problem structure // NB: all checks about fixed-length and type of descriptors are done in this function struct svm_problem prob = svm::dataSetToLibsvmProblem(dataset, _className, region, classMapping); // also get dimension (this trick works because a vector in there is the number // of dimensions + 1 for the sentinel, and we're not in a sparse representation) int dimension = prob.x[1] - prob.x[0] - 1; // default values struct svm_parameter param; //param.svm_type = C_SVC; //param.kernel_type = RBF; //param.degree = 3; //param.gamma = 0; // 1/k param.coef0 = 0; param.nu = 0.5; param.cache_size = 100; //param.C = 1; param.eps = 1e-3; param.p = 0.1; param.shrinking = 1; //param.probability = 0; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; // get parameters QString svmType = _params.value("type", "C-SVC").toString().toLower(); param.svm_type = _svmTypeMap.value(svmType); QString kernelType = _params.value("kernel", "RBF").toString().toLower(); param.kernel_type = _kernelTypeMap.value(kernelType); param.degree = _params.value("degree", 3).toInt(); param.C = _params.value("c", 1).toDouble(); param.gamma = _params.value("gamma", 1.0/dimension).toDouble(); param.probability = _params.value("probability", false).toBool() ? 1 : 0; const char* error_msg = svm_check_parameter(&prob, ¶m); if (error_msg) { throw GaiaException(error_msg); } // do it! struct svm_model* model; const bool crossValidation = false; if (crossValidation) { int nr_fold = 10; int total_correct = 0; double total_error = 0; double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; double* target = new double[prob.l]; svm_cross_validation(&prob, ¶m, nr_fold, target); if (param.svm_type == EPSILON_SVR || param.svm_type == NU_SVR) { for (int i=0; i<prob.l; i++) { double y = prob.y[i]; double v = target[i]; total_error += (v-y)*(v-y); sumv += v; sumy += y; sumvv += v*v; sumyy += y*y; sumvy += v*y; } G_INFO("Cross Validation Mean squared error =" << total_error/prob.l); G_INFO("Cross Validation Squared correlation coefficient =" << ((prob.l*sumvy - sumv*sumy) * (prob.l*sumvy - sumv*sumy)) / ((prob.l*sumvv - sumv*sumv) * (prob.l*sumyy - sumy*sumy)) ); } else { for (int i=0; i<prob.l; i++) if (target[i] == prob.y[i]) ++total_correct; G_INFO("Cross Validation Accuracy =" << 100.0*total_correct/prob.l << "%"); } } else { // !crossValidation model = svm_train(&prob, ¶m); } // save model to a temporary file (only method available from libsvm...), // reload it and put it into a gaia2::Parameter QTemporaryFile modelFile; modelFile.open(); QString modelFilename = modelFile.fileName(); modelFile.close(); if (svm_save_model(modelFilename.toAscii().constData(), model) == -1) { throw GaiaException("SVMTrain: error while saving SVM model to temp file"); } modelFile.open(); QByteArray modelData = modelFile.readAll(); modelFile.close(); // if we asked for the model to be output specifically, also do it if (_params.value("modelFilename", "").toString() != "") { QString filename = _params.value("modelFilename").toString(); svm_save_model(filename.toAscii().constData(), model); } // destroy the model allocated by libsvm svm_destroy_model(model); Transformation result(dataset->layout()); result.analyzerName = "svmtrain"; result.analyzerParams = _params; result.applierName = "svmpredict"; result.params.insert("modelData", modelData); result.params.insert("className", _params.value("className")); result.params.insert("descriptorNames", descs); result.params.insert("classMapping", classMapping); result.params.insert("probability", (param.probability == 1 && (param.svm_type == C_SVC || param.svm_type == NU_SVC))); return result; }
int svmTrain (double gamma, std::vector<std::vector<svm_node> > data, std::vector<int> labels) { struct svm_model* model; struct svm_problem prob; struct svm_node* x_space; struct svm_parameter param; // Make sure we have data if (data.empty ()) { CORE_ERROR ("No training data\n"); return (-1); } prob.l = data.size (); prob.y = Malloc (double, prob.l); prob.x = Malloc (struct svm_node* , prob.l); x_space = Malloc (struct svm_node, data.size () * data[0].size ()); int j = 0; for (int i = 0; i < prob.l; ++i) { prob.y[i] = *(labels.begin () + i); prob.x[i] = &x_space[j]; for (std::vector<svm_node>::iterator it = data[i].begin (); it != data[i].end (); ++it) { x_space[j].index = it->index; x_space[j].value = it->value; ++j; } } param.svm_type = C_SVC; param.kernel_type = RBF; param.gamma = gamma; param.degree = 3; param.coef0 = 0; param.nu = 0.5; param.cache_size = 100; param.C = 1; param.eps = 1e-3; param.p = 0.1; param.shrinking = 1; param.probability = 0; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; // Check whether the parameters are within a feasible range of the problem const char* error_msg = svm_check_parameter (&prob, ¶m); if (error_msg) { CORE_ERROR ("Error checking SVM parameters: %s\n", error_msg); return (-1); } model = svm_train (&prob, ¶m); if (svm_save_model ("model.txt", model)) { CORE_ERROR ("Save SVM model failed\n"); return (-1); } svm_free_and_destroy_model (&model); svm_destroy_param (¶m); free (prob.y); free (prob.x); free (x_space); return (0); }
bool LibSVMRunner::save_model_to_config(SVMConfiguration& config, svm_parameter* param, svm_problem& problem) { const char *error_msg; error_msg = svm_check_parameter(&prob, param, config.log); if (error_msg) { LOG(config.log, LogLevel::ERR_LEVEL, "ERROR: " + to_string(error_msg)) return false; } //int* nr = Malloc(int, 1); int* nclasses = Malloc(int, 1); model = svm_train(&prob, param, config.log); //*nr = config.support_vectors.n_rows; //support vectors *nclasses = model->nr_class; config.nr_class = model->nr_class; LOG(config.log, LogLevel::TRACE_LEVEL, "save_model_to_config writing down alphas, nclasses= " + svm_to_str(config.nr_class)); int nr_support_vectors = model->l; //conversion vec->SpCol arma::vec alpha_y_tmp = arma::vec(model->sv_coef[0], nr_support_vectors); //not my fault. Arma fault :) config.alpha_y = arma::zeros(nr_support_vectors); for(int i=0;i<nr_support_vectors;++i){ if(alpha_y_tmp(i) != 0){ config.alpha_y(i) = alpha_y_tmp(i); } } if(config.nr_class != 2) { throw std::invalid_argument( "Code is not implemented for more than 2 classes right now"); } config.b = -model->rho[0]; config.iter = model->iter; // memcpy(config.rho, , // config.nr_class * (config.nr_class - 1) / 2 * sizeof(double)); //config.sv_indices = (int*) malloc(config.l * sizeof(int)); //svm_get_sv_indices(model, config.sv_indices, config.log); int dim = config.getDataDim(); ASSERT(dim > 0); //config.support_vectors = SvmUtils::libtoarma(model->SV, nr_support_vectors, dim); // LOG(config.log, LogLevel::TRACE_LEVEL, "save_model_to_config writing down SV, n_SV = " + svm_to_str(nr_support_vectors)); config.support_vectors = SvmUtils::SvmNodeToArmaSpMat(model->SV, nr_support_vectors, dim); LOG(config.log, LogLevel::TRACE_LEVEL, "save_model_to_config wrote down SV, n_SV = " + svm_to_str(config.support_vectors.n_cols)); LOG(config.log, LogLevel::TRACE_LEVEL, "save_model_to_config wrote down SV, dim = " + svm_to_str(config.support_vectors.n_rows)); // TODO: WTF!!!!!??? if (config.svm_type < 2) { config.label = (int *) malloc(*nclasses * sizeof(int)); config.nSV = (int *) malloc(*nclasses * sizeof(int)); memcpy(config.label, model->label, *nclasses * sizeof(int)); memcpy(config.nSV, model->nSV, *nclasses * sizeof(int)); } config.neg_target = model->label[1]; config.pos_target = model->label[0]; svm_destroy_param(param,config.log); svm_free_and_destroy_model(&model,config.log); return true; }
/* @return -> cross validation error * -1 -> could not open statistic_filename * */ int SVM::crossValidationParameters(char* pSampleFilename, char* pFixedTestFilename, char* pStatisticsFilename) { struct svm_parameter strSvmParameters; struct svm_problem strSvmProblem; struct svm_model* pstrSvmModel; const char *error_msg; double dCrossValError = -1; double dFixTestSetError = -1; double dTrainError = -1; ofstream outputStatisticFile; char *pTempModelFilename = "tempSvmModel.tmp"; double dGamma = -1; double dC = -1; char tempText[1000]; //open statistic file outputStatisticFile.open(pStatisticsFilename, std::ios::trunc); if(!outputStatisticFile.is_open()) { cout << "can not open statistic file " << pStatisticsFilename << std::endl; return -1; } //initial parameters this->setParameters(strSvmParameters); this->read_problem(pSampleFilename, strSvmProblem, strSvmParameters); error_msg = svm_check_parameter(&strSvmProblem, &strSvmParameters); outputStatisticFile << "\% " << pSampleFilename << std::endl; outputStatisticFile << "\% Gamma \t C \t TrainError \t CrossValError \t FixedTestError" << std::endl; cout << "\% Gamma \t C \t TrainError \t CrossValError \t FixedTestError" << std::endl; for(int iExponentGamma = -25; iExponentGamma <= -2; ++iExponentGamma) { dGamma = pow(2.0, iExponentGamma); strSvmParameters.gamma = dGamma; for(int iExponentC = -1; iExponentC <= 15; ++iExponentC) { dC = pow(2.0, iExponentC); strSvmParameters.C = dC; //train pstrSvmModel = svm_train(&strSvmProblem, &strSvmParameters); svm_save_model(pTempModelFilename, pstrSvmModel); svm_destroy_model(pstrSvmModel); //test with train-set this->test(pSampleFilename, pTempModelFilename, dTrainError); //crossval dCrossValError = this->crossValidationSamples(strSvmProblem, strSvmParameters, 5); //test with fixed test-set this->test(pFixedTestFilename, pTempModelFilename, dFixTestSetError); remove(pTempModelFilename); sprintf(tempText, "%.15lf\t%10lf\t%10lf\t%10lf\t%10lf", dGamma, dC, dTrainError, dCrossValError, dFixTestSetError); outputStatisticFile << tempText << std::endl; cout << "\n#######################################################################" << std::endl; cout << tempText << std::endl; cout << "#######################################################################\n" << std::endl; } } //clean up outputStatisticFile.close(); svm_destroy_param(&strSvmParameters); free(strSvmProblem.y); free(strSvmProblem.x); //free(pTempModelFilename); return 0; }
int main(int argc, char **argv) { #ifdef WIN32 // Send all reports to STDOUT _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE ); _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT ); _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE ); _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT ); _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE ); _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDOUT ); // enable the options SET_CRT_DEBUG_FIELD( _CRTDBG_DELAY_FREE_MEM_DF ); SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF ); #endif printf("int %d, short int %d, char %d, double %d, float %d, node %d\n",sizeof(int),sizeof(short int), sizeof(char), sizeof(double), sizeof(float), sizeof(svm_node)); char input_file_name[FILENAME_LEN]; char model_file_name[FILENAME_LEN]; const char *error_msg; parse_command_line(argc, argv, input_file_name, model_file_name); read_problem(input_file_name); param.modelFile = model_file_name; printf ("Finish reading input files!\n"); error_msg = svm_check_parameter(&prob,¶m); #ifdef WIN32 assert(_CrtCheckMemory()); #endif if(error_msg) { fprintf(stderr,"Error: %s\n",error_msg); exit(1); } double duration; double start = getRunTime(); if(cross_validation) { do_cross_validation(); } else { printf("kernel: %d\n",param.kernel_type); model = svm_train(&prob,¶m); double finish = getRunTime(); duration = (double)(finish - start); #ifdef WIN32 assert(_CrtCheckMemory()); #endif svm_save_model(model_file_name,model); svm_destroy_model(model); } printf("CPU Time = %f second\n", duration); FILE* fModel = fopen(model_file_name, "a+t"); // append mode fprintf(fModel, "CPU Time = %f second\n", duration); fclose(fModel); svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); #ifdef WIN32 assert(_CrtCheckMemory()); #endif return 0; }
// Interface function of matlab // now assume prhs[0]: label prhs[1]: features void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { const char *error_msg; // fix random seed to have same results for each run // (for cross validation and probability estimation) srand(1); if(nlhs > 1) { exit_with_help(); fake_answer(nlhs, plhs); return; } // Transform the input Matrix to libsvm format if(nrhs > 1 && nrhs < 4) { int err; if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) { mexPrintf("Error: label vector and instance matrix must be double\n"); fake_answer(nlhs, plhs); return; } if(parse_command_line(nrhs, prhs, NULL)) { exit_with_help(); svm_destroy_param(¶m); fake_answer(nlhs, plhs); return; } if(mxIsSparse(prhs[1])) { if(param.kernel_type == PRECOMPUTED) { // precomputed kernel requires dense matrix, so we make one mxArray *rhs[1], *lhs[1]; rhs[0] = mxDuplicateArray(prhs[1]); if(mexCallMATLAB(1, lhs, 1, rhs, "full")) { mexPrintf("Error: cannot generate a full training instance matrix\n"); svm_destroy_param(¶m); fake_answer(nlhs, plhs); return; } err = read_problem_dense(prhs[0], lhs[0]); mxDestroyArray(lhs[0]); mxDestroyArray(rhs[0]); } else err = read_problem_sparse(prhs[0], prhs[1]); } else err = read_problem_dense(prhs[0], prhs[1]); // svmtrain's original code error_msg = svm_check_parameter(&prob, ¶m); if(err || error_msg) { if (error_msg != NULL) mexPrintf("Error: %s\n", error_msg); svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); fake_answer(nlhs, plhs); return; } if(cross_validation) { double *ptr; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(plhs[0]); ptr[0] = do_cross_validation(); } else { int nr_feat = (int)mxGetN(prhs[1]); const char *error_msg; model = svm_train(&prob, ¶m); error_msg = model_to_matlab_structure(plhs, nr_feat, model); if(error_msg) mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg); svm_free_and_destroy_model(&model); } svm_destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); } else { exit_with_help(); fake_answer(nlhs, plhs); return; } }
int main(int argc, char *argv[]) { float labels[4] = {1.0, 1.0, -1.0, -1.0}; cv::Mat labelsMat(4, 1, CV_32FC1, labels); float trainingData[4][2] = {{501, 10}, {255, 10}, {501, 255}, {10, 501}}; cv::Mat trainingDataMat(4, 2, CV_32FC1, trainingData); svm_parameter param; param.svm_type = C_SVC; param.kernel_type = LINEAR; param.degree = 3; param.gamma = 0; param.coef0 = 0; param.nu = 0.5; param.cache_size = 100; param.C = 1; param.eps = 1e-6; param.p = 0.1; param.shrinking = 1; param.probability = 1; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; svm_problem svm_prob_vector = libSVMWrapper( trainingDataMat, labelsMat, param); struct svm_model *model = new svm_model; if (svm_check_parameter(&svm_prob_vector, ¶m)) { std::cout << "ERROR" << std::endl; } else { model = svm_train(&svm_prob_vector, ¶m); } bool is_compute_probability = true; std::string model_file_name = "svm"; bool save_model = true; if (save_model) { try { svm_save_model(model_file_name.c_str(), model); std::cout << "Model file Saved Successfully..." << std::endl; } catch(std::exception& e) { std::cout << e.what() << std::endl; } } bool is_probability_model = svm_check_probability_model(model); int svm_type = svm_get_svm_type(model); int nr_class = svm_get_nr_class(model); // number of classes double *prob_estimates = new double[nr_class]; cv::Vec3b green(0, 255, 0); cv::Vec3b blue(255, 0, 0); int width = 512, height = 512; cv::Mat image = cv::Mat::zeros(height, width, CV_8UC3); for (int i = 0; i < image.rows; ++i) { for (int j = 0; j < image.cols; ++j) { cv::Mat sampleMat = (cv::Mat_<float>(1, 2) << j, i); int dims = sampleMat.cols; svm_node* test_pt = new svm_node[dims]; for (int k = 0; k < dims; k++) { test_pt[k].index = k + 1; test_pt[k].value = static_cast<double>(sampleMat.at<float>(0, k)); } test_pt[dims].index = -1; float response = 0.0f; if (is_probability_model && is_compute_probability) { response = svm_predict_probability(model, test_pt, prob_estimates); } else { response = svm_predict(model, test_pt); } /* std::cout << "Predict: " << prob << std::endl; for (int y = 0; y < nr_class; y++) { std::cout << prob_estimates[y] << " "; }std::cout << std::endl; */ if (prob_estimates[0] > 0.5 || response == 1) { image.at<cv::Vec3b>(i, j) = green; } else if (prob_estimates[1] >= 0.5 || response == -1) { image.at<cv::Vec3b>(i, j) = blue; } } } cv::imshow("image", image); cv::waitKey(0); return 0; }