int main(int argc, char **argv) { FILE *input, *output; int i; // parse options for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; ++i; switch(argv[i-1][1]) { // case 'b': // flag_predict_probability = atoi(argv[i]); // break; case 'o': output_option = atoi(argv[i]); break; case 'q': info = &print_null; i--; break; default: fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]); exit_with_help(); break; } } if(i>=argc) exit_with_help(); input = fopen(argv[i],"r"); if(input == NULL) { fprintf(stderr,"can't open input file %s\n",argv[i]); exit(1); } output = fopen(argv[i+2],"w"); if(output == NULL) { fprintf(stderr,"can't open output file %s\n",argv[i+2]); exit(1); } if((model_=load_model(argv[i+1]))==0) { fprintf(stderr,"can't open model file %s\n",argv[i+1]); exit(1); } x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node)); do_predict(input, output); free_and_destroy_model(&model_); free(line); free(x); fclose(input); fclose(output); return 0; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int prob_estimate_flag = 0; struct model *model_; char cmd[CMD_LEN]; col_format_flag = 0; if(nrhs > 5 || nrhs < 3) { exit_with_help(); fake_answer(plhs); return; } if(nrhs == 5) { mxGetString(prhs[4], cmd, mxGetN(prhs[4])+1); if(strcmp(cmd, "col") == 0) { col_format_flag = 1; } } if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) { mexPrintf("Error: label vector and instance matrix must be double\n"); fake_answer(plhs); return; } if(mxIsStruct(prhs[2])) { const char *error_msg; // parse options if(nrhs>=4) { int i, argc = 1; char *argv[CMD_LEN/2]; // put options in argv[] mxGetString(prhs[3], cmd, mxGetN(prhs[3]) + 1); if((argv[argc] = strtok(cmd, " ")) != NULL) while((argv[++argc] = strtok(NULL, " ")) != NULL) ; for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; if(++i>=argc) { exit_with_help(); fake_answer(plhs); return; } switch(argv[i-1][1]) { case 'b': prob_estimate_flag = atoi(argv[i]); break; default: mexPrintf("unknown option\n"); exit_with_help(); fake_answer(plhs); return; } } } model_ = Malloc(struct model, 1); error_msg = matlab_matrix_to_model(model_, prhs[2]); if(error_msg) { mexPrintf("Error: can't read model: %s\n", error_msg); free_and_destroy_model(&model_); fake_answer(plhs); return; } if(prob_estimate_flag) { if(!check_probability_model(model_)) { mexPrintf("probability output is only supported for logistic regression\n"); prob_estimate_flag=0; } } if(mxIsSparse(prhs[1])) do_predict(plhs, prhs, model_, prob_estimate_flag); else { mexPrintf("Testing_instance_matrix must be sparse; " "use sparse(Testing_instance_matrix) first\n"); fake_answer(plhs); } // destroy model_ free_and_destroy_model(&model_); } else {
// 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=NULL; // transform the input matrix to libspline format if(nrhs > 0 && 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(plhs); return; } if(parse_command_line(nrhs, prhs, NULL)){ exit_with_help(); fake_answer(plhs); return; } if(!mxIsSparse(prhs[1])) err = read_problem_dense(prhs[0], prhs[1]); else{ mexPrintf("Error: test_instance_matrix must be dense\n"); fake_answer(plhs); return; } if(err || error_msg){ if (error_msg != NULL) mexPrintf("Error: %s\n", error_msg); fake_answer(plhs); delete [] x; return; } //initialize an empty model model = new additiveModel(); error_msg = matlab_matrix_to_model(model,prhs[2]); if(error_msg){ mexPrintf("Error: can't read model: %s\n", error_msg); delete [] x; delete model; fake_answer(plhs); return; } //compute predictions if(do_predict(plhs) < 0){ delete [] x; delete [] model; fake_answer(plhs); return; } delete [] x; delete model; }else{ exit_with_help(); fake_answer(plhs); return; } }
int main(int argc, char **argv) { const char *error_msg; parse_command_line(argc, argv); // also load data error_msg = check_parameter(prob,¶m); if(error_msg) { fprintf(stderr,"Error: %s\n",error_msg); exit(1); } std::vector< std::pair<double, double> > test_errors(nb_runs); std::vector< std::pair<double, double> > train_errors(nb_runs); double trn_mean=0; double tst_mean=0; double mse_trn_mean=0; double mse_tst_mean=0; int *start = NULL; // perform runs for (int run=0; run<nb_runs; run++) { if ((trnsz>=prob->l) || (trnsz<=0)) { fprintf(stderr,"\nRun %d (from 0 to %d)\n", run, prob->l-1); //train model_=train(prob, ¶m); // test test_errors[run]=do_predict(tprob, model_); train_errors[run]=do_predict(prob, model_); } else { // select all the splits before optimizing if(run == 0) { start = Malloc(int,nb_runs); for (int run2=0; run2<nb_runs; run2++) start[run2] = (rand() % (prob->l-trnsz)); } // select examples fprintf(stderr,"\nRun %d (from %d to %d)\n", run, start[run], start[run]+trnsz-1); struct problem* subprob=extract_subprob(prob, start[run], trnsz); //train model_=train(subprob, ¶m); // test test_errors[run]=do_predict(tprob, model_); train_errors[run]=do_predict(subprob, model_); free(subprob->y); free(subprob->x); } tst_mean+=test_errors[run].first; printf("Test classification ERROR = %g\n",test_errors[run].first); trn_mean+=train_errors[run].first; printf("Train classification ERROR = %g\n",train_errors[run].first); mse_tst_mean+=test_errors[run].second; printf("Test normalized ACCURACY (ET requirement) = %g\n",test_errors[run].second); mse_trn_mean+=train_errors[run].second; printf("Train normalized ACCURACY (ET requirement) = %g\n",train_errors[run].second); //destroy model free_and_destroy_model(&model_); destroy_param(¶m); }
int main(int argc, char **argv) { FILE *input, *output; int i; char model_file[1024]; // parse options for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; ++i; switch(argv[i-1][1]) { case 'b': flag_predict_probability = atoi(argv[i]); break; case 'q': info = &print_null; i--; break; default: fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]); exit_with_help(); break; } } if(i>=argc) exit_with_help(); input = fopen(argv[i],"r"); if(input == NULL) { fprintf(stderr,"can't open input file %s\n",argv[i]); exit(1); } output = fopen(argv[i+2],"w"); if(output == NULL) { fprintf(stderr,"can't open output file %s\n",argv[i+2]); exit(1); } // if((model_=load_model(argv[i+1]))==0) // { // fprintf(stderr,"can't open model file %s\n",argv[i+1]); // exit(1); // } for ( int pid = 0; pid < sum_pro; pid++) { sprintf(model_file,"L%d%s%d%s",pid/(BLOCK * N) + 1, "_R", pid%(BLOCK * N) + 1,".model"); printf("%s\n", model_file); if ((model_[pid] = load_model(model_file)) == 0) { fprintf(stderr,"can't open model file %s\n",argv[i+1]); exit(1); } } x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node)); do_predict(input, output); for ( int pid = 0; pid < sum_pro; pid++) { free_and_destroy_model(&model_[pid]); } free(line); free(x); fclose(input); fclose(output); return 0; }