// 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) srand(1); if(nlhs > 1) { exit_with_help(); fake_answer(nlhs, plhs); return; } // Transform the input Matrix to libsvm format if(nrhs > 1 && nrhs < 5) { int err=0; if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) { mexPrintf("Error: label vector and instance matrix must be double\n"); fake_answer(nlhs, plhs); return; } if(mxIsSparse(prhs[0])) { mexPrintf("Error: label vector should not be in sparse format"); fake_answer(nlhs, plhs); return; } if(parse_command_line(nrhs, prhs, NULL)) { exit_with_help(); destroy_param(¶m); fake_answer(nlhs, plhs); return; } if(mxIsSparse(prhs[1])) err = read_problem_sparse(prhs[0], prhs[1]); else { mexPrintf("Training_instance_matrix must be sparse; " "use sparse(Training_instance_matrix) first\n"); destroy_param(¶m); fake_answer(nlhs, plhs); return; } // train's original code error_msg = check_parameter(&prob, ¶m); if(err || error_msg) { if (error_msg != NULL) mexPrintf("Error: %s\n", error_msg); destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); fake_answer(nlhs, plhs); return; } if (flag_find_C) { double best_C, best_rate, *ptr; do_find_parameter_C(&best_C, &best_rate); plhs[0] = mxCreateDoubleMatrix(2, 1, mxREAL); ptr = mxGetPr(plhs[0]); ptr[0] = best_C; ptr[1] = best_rate; } else if(flag_cross_validation) { double *ptr; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(plhs[0]); ptr[0] = do_cross_validation(); } else { const char *error_msg; model_ = train(&prob, ¶m); error_msg = model_to_matlab_structure(plhs, model_); if(error_msg) mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg); free_and_destroy_model(&model_); } destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); } else { exit_with_help(); fake_answer(nlhs, plhs); return; } }
// 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(mxIsSparse(prhs[0])) { mexPrintf("Error: label vector should not be in sparse format\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) { #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) srand(1); // Transform the input Matrix to libsvm format if(nrhs > 0 && nrhs <= 5) { int err=0; //if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) { if(!mxIsDouble(prhs[0])) { mexPrintf("Error: label vector and instance matrix must be double\n"); fake_answer(plhs); return; } if(parse_command_line(nrhs, prhs, NULL)) { exit_with_help(); destroy_param(¶m); fake_answer(plhs); return; } #ifdef DEBUG mexPrintf("reading problem sparse...\n"); mexEvalString("drawnow"); wait(5); #endif #ifdef _DENSE_REP if(!mxIsSparse(prhs[1])) err = read_problem_sparse(prhs[0], prhs[1]); else { mexPrintf("Training_instance_matrix must be dense\n"); destroy_param(¶m); fake_answer(plhs); return; } #else if(mxIsSparse(prhs[1])) err = read_problem_sparse(prhs[0], prhs[1]); else { mexPrintf("Training_instance_matrix must be sparse\n"); destroy_param(¶m); fake_answer(plhs); return; } #endif #ifdef DEBUG mexPrintf("read_problem_sparse done.\n"); mexEvalString("drawnow"); wait(5); #endif // xren: delete the input instance matrix to free up space if (nrhs==5) { mxArray* var=(mxArray*)prhs[4]; int status=mexCallMATLAB(0,NULL,1, &var, "clear"); if (status!=0) mexPrintf("Failed to delete variable %s\n",mxArrayToString(prhs[4])); //mxDestroyArray( (mxArray*)prhs[1] ); } #ifdef DEBUG mexPrintf("free memory done.\n"); mexEvalString("drawnow"); wait(5); #endif // train's original code error_msg = check_parameter(&prob, ¶m); if(err || error_msg) { if (error_msg != NULL) mexPrintf("Error: %s\n", error_msg); destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); fake_answer(plhs); return; } if(cross_validation_flag) { double *ptr; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(plhs[0]); ptr[0] = do_cross_validation(); } else { const char *error_msg; model_ = train(&prob, ¶m); error_msg = model_to_matlab_structure(plhs, model_); if(error_msg) mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg); destroy_model(model_); } destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); } else { exit_with_help(); fake_answer(plhs); return; } }
int main(int argc, char **argv) { #ifdef GPU int dev = findCudaDevice(argc, (const char **) argv); if (dev == -1) return 0; if (cublasCreate(&handle) != CUBLAS_STATUS_SUCCESS) { fprintf(stdout, "CUBLAS initialization failed!\n"); cudaDeviceReset(); exit(EXIT_FAILURE); } #endif // GPU 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); time_t t1 = clock(); read_problem(input_file_name); time_t t2 = clock(); printf("reading the input file took %f seconds.\n", float(t2-t1)/CLOCKS_PER_SEC); error_msg = check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"ERROR: %s\n",error_msg); exit(1); } if(flag_cross_validation) { do_cross_validation(); } else { model_=train(&prob, ¶m); if(save_model(model_file_name, model_)) { fprintf(stderr,"can't save model to file %s\n",model_file_name); exit(1); } free_and_destroy_model(&model_); } destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); free(line); #ifdef GPU cublasDestroy(handle); cudaDeviceReset(); #endif // GPU printf("reading the input file took %f seconds.\n", float(t2-t1)/CLOCKS_PER_SEC); return 0; }
//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; }
//does grid search and finds the optimal set of parameters with the best performance in that grid void ML2::paramSelection() { //parameters defining grid of parameters, min, max, step double c_min = -5; double c_max = 15; double c_step = 2; double gamma_min = -15; double gamma_max = 3; double gamma_step = 2; int c_length = (int)((c_max-c_min) / c_step); int gamma_length = (int)((gamma_max-gamma_min) / gamma_step); double C[ c_length ]; double gamma[gamma_length]; //fill the array of parameters for(int i = 0 ; i < c_length ; i++){ C[i] = c_min + c_step * i; } for(int i = 0 ; i < gamma_length ; i++){ gamma[i] = gamma_min + gamma_step * i; } //[C,gamma] = meshgrid(-5:2:15, -15:2:3); // grid search, and cross-validation double cv_acc[c_length * gamma_length]; //= zeros(numel(C),1); for (int i = 0 ; i < c_length; i++){ for(int j = 0 ; j < gamma_length; j++){ int index = i * c_length + j; param.C = pow(2, C[i]); param.gamma = pow(2 , gamma[j]); double accuracy = do_cross_validation(); cv_acc[index] = accuracy; cout<<"********************************************************************"<<endl<<flush; } } // find pair (C,gamma) with best accuracy, lowest rmse double min_error = 1000; int cv_length = c_length * gamma_length; cout<<"cv_length "<< cv_length<< c_length<<endl<<flush; int index = 0; for(int i = 0 ; i < cv_length ; i ++){ if(cv_acc[i] != 0 && cv_acc[i] < min_error){ cout<<"found min\n"<<endl<<flush; min_error = cv_acc[i]; index = i; } } //print the performance of the whole grid for (int i = 0 ; i < c_length; i++){ for(int j = 0 ; j < gamma_length; j++){ int index = i * c_length + j; cout<<cv_acc[index]<<" \t" <<flush; } cout<<endl<<flush; } cout<<"best accuracy , min rmse = "<< min_error<<endl<<flush; // now you can train you model using best_C and best_gamma int c_index = int(index / c_length) ; int gamma_index = index - c_index * c_length; best_C = pow( 2, C[c_index]); best_gamma = pow(2, gamma[gamma_index]); cout<<"*************************************************\n"<<endl<<flush; cout<<"best_C = "<< best_C<<endl<<flush; cout<<"best_gamma = "<< best_gamma<<endl<<flush; }
int main(int argc, char **argv) { const char *error_msg; // fix random seed to have same results for each run // (for cross validation) srand(1); char input_file_name[1024]; char model_file_name[1024]; char param_file_name[1024]; int n_flag = 0; parse_command_line(argc, argv, input_file_name, model_file_name,n_flag,param_file_name); char char_para; int length_param = 0; double *para_entry; // int para_B[40] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 24, 25, 26, 30,32, 35, 38, 40, 42, 45, 48, 50, 55, 60, 65,70,75,80, 85, 90, 95, 100, 105, 110, 115, 120}; if (n_flag==1) { read_parameter(param_file_name, para_entry, char_para, length_param); } read_problem(input_file_name); error_msg = check_parameter(&prob,¶m); if(error_msg) { fprintf(stderr,"Error: %s\n",error_msg); exit(1); } if(cross_validation_flag) { do_cross_validation(); } else { if(n_flag==0) { model_ = FGM_train(&prob, ¶m); printf("training is done!\n"); save_model_poly(model_file_name, model_); printf("model is saved!\n"); destroy_model(model_); } else { int i; if (char_para=='C') { length_param = length_param; }else { length_param = 40; } for (i=0;i<length_param;i++) { char param_char[1000]; char model_file[1024]; strcpy(model_file,model_file_name); if (char_para=='C') { param.C = para_entry[i]; sprintf(param_char, "%.10lf ", para_entry[i]); strcat(model_file,".c."); strcat(model_file,param_char); model_=FGM_train(&prob, ¶m); } else { int B = para_B[i]; param.B = B; sprintf(param_char, "%d ", param.B); printf("%d\n ", param.B); strcat(model_file,".B."); strcat(model_file,param_char); model_=FGM_train(&prob, ¶m); } printf("training is done!\n"); save_model_poly(model_file, model_); printf("model is saved!\n"); destroy_model(model_); if(model_->feature_pair>600) { break; } } } } if (n_flag==1) { delete []para_entry; } destroy_param(¶m); free(prob.y); free(prob.x); free(x_space); }