8 #define Malloc(type,n) (type *)malloc((n)*sizeof(type))
11 void print_null(const char *s) {}
16 "Usage: train [options] training_set_file [model_file]\n"
18 "-s type : set type of solver (default 1)\n"
19 " for multi-class classification\n"
20 " 0 -- L2-regularized logistic regression (primal)\n"
21 " 1 -- L2-regularized L2-loss support vector classification (dual)\n"
22 " 2 -- L2-regularized L2-loss support vector classification (primal)\n"
23 " 3 -- L2-regularized L1-loss support vector classification (dual)\n"
24 " 4 -- support vector classification by Crammer and Singer\n"
25 " 5 -- L1-regularized L2-loss support vector classification\n"
26 " 6 -- L1-regularized logistic regression\n"
27 " 7 -- L2-regularized logistic regression (dual)\n"
29 " 11 -- L2-regularized L2-loss support vector regression (primal)\n"
30 " 12 -- L2-regularized L2-loss support vector regression (dual)\n"
31 " 13 -- L2-regularized L1-loss support vector regression (dual)\n"
32 "-c cost : set the parameter C (default 1)\n"
33 "-p epsilon : set the epsilon in loss function of SVR (default 0.1)\n"
34 "-e epsilon : set tolerance of termination criterion\n"
36 " |f'(w)|_2 <= eps*min(pos,neg)/l*|f'(w0)|_2,\n"
37 " where f is the primal function and pos/neg are # of\n"
38 " positive/negative data (default 0.01)\n"
40 " |f'(w)|_2 <= eps*|f'(w0)|_2 (default 0.0001)\n"
41 " -s 1, 3, 4, and 7\n"
42 " Dual maximal violation <= eps; similar to libsvm (default 0.1)\n"
44 " |f'(w)|_1 <= eps*min(pos,neg)/l*|f'(w0)|_1,\n"
45 " where f is the primal function (default 0.01)\n"
47 " |f'(alpha)|_1 <= eps |f'(alpha0)|,\n"
48 " where f is the dual function (default 0.1)\n"
49 "-B bias : if bias >= 0, instance x becomes [x; bias]; if < 0, no bias term added (default -1)\n"
50 "-wi weight: weights adjust the parameter C of different classes (see README for details)\n"
51 "-v n: n-fold cross validation mode\n"
52 "-C : find parameters (C for -s 0, 2 and C, p for -s 11)\n"
53 "-q : quiet mode (no outputs)\n"
58 void exit_input_error(int line_num)
60 fprintf(stderr,"Wrong input format at line %d\n", line_num);
64 static char *line = NULL;
65 static int max_line_len;
67 static char* readline(FILE *input)
71 if(fgets(line,max_line_len,input) == NULL)
74 while(strrchr(line,'\n') == NULL)
77 line = (char *) realloc(line,max_line_len);
78 len = (int) strlen(line);
79 if(fgets(line+len,max_line_len-len,input) == NULL)
85 void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name);
86 void read_problem(const char *filename);
87 void do_cross_validation();
88 void do_find_parameters();
90 struct feature_node *x_space;
91 struct parameter param;
94 int flag_cross_validation;
95 int flag_find_parameters;
98 int flag_solver_specified;
102 int main(int argc, char **argv)
104 char input_file_name[1024];
105 char model_file_name[1024];
106 const char *error_msg;
108 parse_command_line(argc, argv, input_file_name, model_file_name);
109 read_problem(input_file_name);
110 error_msg = check_parameter(&prob,¶m);
114 fprintf(stderr,"ERROR: %s\n",error_msg);
118 if (flag_find_parameters)
120 do_find_parameters();
122 else if(flag_cross_validation)
124 do_cross_validation();
128 model_=train(&prob, ¶m);
129 if(save_model(model_file_name, model_))
131 fprintf(stderr,"can't save model to file %s\n",model_file_name);
134 free_and_destroy_model(&model_);
136 destroy_param(¶m);
145 void do_find_parameters()
147 double start_C, start_p, best_C, best_p, best_score;
148 if (flag_C_specified)
152 if (flag_p_specified)
157 printf("Doing parameter search with %d-fold cross validation.\n", nr_fold);
158 find_parameters(&prob, ¶m, nr_fold, start_C, start_p, &best_C, &best_p, &best_score);
159 if(param.solver_type == L2R_LR || param.solver_type == L2R_L2LOSS_SVC)
160 printf("Best C = %g CV accuracy = %g%%\n", best_C, 100.0*best_score);
161 else if(param.solver_type == L2R_L2LOSS_SVR)
162 printf("Best C = %g Best p = %g CV MSE = %g\n", best_C, best_p, best_score);
165 void do_cross_validation()
168 int total_correct = 0;
169 double total_error = 0;
170 double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
171 double *target = Malloc(double, prob.l);
173 cross_validation(&prob,¶m,nr_fold,target);
174 if(param.solver_type == L2R_L2LOSS_SVR ||
175 param.solver_type == L2R_L1LOSS_SVR_DUAL ||
176 param.solver_type == L2R_L2LOSS_SVR_DUAL)
178 for(i=0;i<prob.l;i++)
180 double y = prob.y[i];
181 double v = target[i];
182 total_error += (v-y)*(v-y);
189 printf("Cross Validation Mean squared error = %g\n",total_error/prob.l);
190 printf("Cross Validation Squared correlation coefficient = %g\n",
191 ((prob.l*sumvy-sumv*sumy)*(prob.l*sumvy-sumv*sumy))/
192 ((prob.l*sumvv-sumv*sumv)*(prob.l*sumyy-sumy*sumy))
197 for(i=0;i<prob.l;i++)
198 if(target[i] == prob.y[i])
200 printf("Cross Validation Accuracy = %g%%\n",100.0*total_correct/prob.l);
206 void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name)
209 void (*print_func)(const char*) = NULL; // default printing to stdout
212 param.solver_type = L2R_L2LOSS_SVC_DUAL;
214 param.eps = INF; // see setting below
217 param.weight_label = NULL;
219 param.init_sol = NULL;
220 flag_cross_validation = 0;
221 flag_C_specified = 0;
222 flag_p_specified = 0;
223 flag_solver_specified = 0;
224 flag_find_parameters = 0;
230 if(argv[i][0] != '-') break;
236 param.solver_type = atoi(argv[i]);
237 flag_solver_specified = 1;
241 param.C = atof(argv[i]);
242 flag_C_specified = 1;
246 flag_p_specified = 1;
247 param.p = atof(argv[i]);
251 param.eps = atof(argv[i]);
255 bias = atof(argv[i]);
260 param.weight_label = (int *) realloc(param.weight_label,sizeof(int)*param.nr_weight);
261 param.weight = (double *) realloc(param.weight,sizeof(double)*param.nr_weight);
262 param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]);
263 param.weight[param.nr_weight-1] = atof(argv[i]);
267 flag_cross_validation = 1;
268 nr_fold = atoi(argv[i]);
271 fprintf(stderr,"n-fold cross validation: n must >= 2\n");
277 print_func = &print_null;
282 flag_find_parameters = 1;
287 fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
293 set_print_string_function(print_func);
295 // determine filenames
299 strcpy(input_file_name, argv[i]);
302 strcpy(model_file_name,argv[i+1]);
305 char *p = strrchr(argv[i],'/');
310 sprintf(model_file_name,"%s.model",p);
313 // default solver for parameter selection is L2R_L2LOSS_SVC
314 if(flag_find_parameters)
316 if(!flag_cross_validation)
318 if(!flag_solver_specified)
320 fprintf(stderr, "Solver not specified. Using -s 2\n");
321 param.solver_type = L2R_L2LOSS_SVC;
323 else if(param.solver_type != L2R_LR && param.solver_type != L2R_L2LOSS_SVC && param.solver_type != L2R_L2LOSS_SVR)
325 fprintf(stderr, "Warm-start parameter search only available for -s 0, -s 2 and -s 11\n");
332 switch(param.solver_type)
341 case L2R_L2LOSS_SVC_DUAL:
342 case L2R_L1LOSS_SVC_DUAL:
351 case L2R_L1LOSS_SVR_DUAL:
352 case L2R_L2LOSS_SVR_DUAL:
359 // read in a problem (in libsvm format)
360 void read_problem(const char *filename)
362 int max_index, inst_max_index, i;
364 FILE *fp = fopen(filename,"r");
366 char *idx, *val, *label;
370 fprintf(stderr,"can't open input file %s\n",filename);
377 line = Malloc(char,max_line_len);
378 while(readline(fp)!=NULL)
380 char *p = strtok(line," \t"); // label
385 p = strtok(NULL," \t");
386 if(p == NULL || *p == '\n') // check '\n' as ' ' may be after the last feature
390 elements++; // for bias term
397 prob.y = Malloc(double,prob.l);
398 prob.x = Malloc(struct feature_node *,prob.l);
399 x_space = Malloc(struct feature_node,elements+prob.l);
403 for(i=0;i<prob.l;i++)
405 inst_max_index = 0; // strtol gives 0 if wrong format
407 prob.x[i] = &x_space[j];
408 label = strtok(line," \t\n");
409 if(label == NULL) // empty line
410 exit_input_error(i+1);
412 prob.y[i] = strtod(label,&endptr);
413 if(endptr == label || *endptr != '\0')
414 exit_input_error(i+1);
418 idx = strtok(NULL,":");
419 val = strtok(NULL," \t");
425 x_space[j].index = (int) strtol(idx,&endptr,10);
426 if(endptr == idx || errno != 0 || *endptr != '\0' || x_space[j].index <= inst_max_index)
427 exit_input_error(i+1);
429 inst_max_index = x_space[j].index;
432 x_space[j].value = strtod(val,&endptr);
433 if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
434 exit_input_error(i+1);
439 if(inst_max_index > max_index)
440 max_index = inst_max_index;
443 x_space[j++].value = prob.bias;
445 x_space[j++].index = -1;
451 for(i=1;i<prob.l;i++)
452 (prob.x[i]-2)->index = prob.n;
453 x_space[j-2].index = prob.n;