int main(int argc, char* argv[]) {
double avgloss,l;
long i, correct;
char testfile[1024];
char modelfile[1024];
STRUCTMODEL model;
STRUCT_LEARN_PARM sparm;
LEARN_PARM lparm;
KERNEL_PARM kparm;
SAMPLE testsample;
LABEL y;
LATENT_VAR h;
/* read input parameters */
read_input_parameters(argc,argv,testfile,modelfile,&sparm);
/* read model file */
printf("Reading model..."); fflush(stdout);
// model = read_struct_model(modelfile, &sparm);
printf("done.\n");
/* read test examples */
printf("Reading test examples..."); fflush(stdout);
testsample = read_struct_examples(testfile,&sparm);
printf("done.\n");
init_struct_model(testsample,&model,&sparm,&lparm,&kparm);
avgloss = 0.0;
correct = 0;
for (i=0;i<testsample.n;i++) {
classify_struct_example(testsample.examples[i].x,&y,&h,&model,&sparm);
l = loss(testsample.examples[i].y,y,h,&sparm);
avgloss += l;
if (l==0) correct++;
free_label(y);
free_latent_var(h);
}
printf("Average loss on test set: %.4f\n", avgloss/testsample.n);
printf("Zero/one error on test set: %.4f\n", 1.0 - ((float) correct)/testsample.n);
free_struct_sample(testsample);
free_struct_model(model,&sparm);
return(0);
}
double compute_current_loss(SAMPLE val, STRUCTMODEL *sm, STRUCT_LEARN_PARM *sparm)
{
long i;
LABEL y;
double cur_loss = 0.0;
double store;
for(i = 0; i < val.n; i++)
{
classify_struct_example(val.examples[i].x,&y,sm,sparm);
store = loss(val.examples[i].y,y,sparm);
cur_loss += store;
}
cur_loss /= (double) val.n;
return cur_loss;
}
int main(int argc, char* argv[]) {
double *scores = NULL;
long i;
char testfile[1024];
char modelfile[1024];
char scoreFile[1024];
FILE *fscore;
STRUCTMODEL model;
STRUCT_LEARN_PARM sparm;
LEARN_PARM lparm;
KERNEL_PARM kparm;
SAMPLE testsample;
/* read input parameters */
read_input_parameters(argc,argv,testfile,modelfile,scoreFile,&sparm);
fscore = fopen(scoreFile,"w");
/* read model file */
printf("Reading model..."); fflush(stdout);
model = read_struct_model(modelfile, &sparm);
printf("done.\n");
/* read test examples */
printf("Reading test examples..."); fflush(stdout);
testsample = read_struct_test_examples(testfile,&sparm);
printf("done.\n");
init_struct_model(testsample,&model,&sparm,&lparm,&kparm);
scores = classify_struct_example(testsample.examples[0].x,&model);
for(i = 0; i < (testsample.examples[0].n_pos+testsample.examples[0].n_neg); i++){
fprintf(fscore, "%0.5f\n", scores[i]);
}
fclose(fscore);
//free_struct_sample(testsample); TODO: Uncomment this, and fix this function. It frees h.h_is which was never allocated while classifying.
free_struct_model(model,&sparm);
return(0);
}
int main (int argc, char* argv[])
{
long correct=0,incorrect=0,no_accuracy=0;
long i;
double t1,runtime=0;
double avgloss=0,l;
FILE *predfl;
STRUCTMODEL model;
STRUCT_LEARN_PARM sparm;
STRUCT_TEST_STATS teststats;
SAMPLE testsample;
LABEL y;
svm_struct_classify_api_init(argc,argv);
read_input_parameters(argc,argv,testfile,modelfile,predictionsfile,&sparm,
&verbosity,&struct_verbosity);
if(struct_verbosity>=1) {
printf("Reading model..."); fflush(stdout);
}
model=read_struct_model(modelfile,&sparm);
if(struct_verbosity>=1) {
fprintf(stdout, "done.\n");
}
if(model.svm_model->kernel_parm.kernel_type == LINEAR) { /* linear kernel */
/* compute weight vector */
//add_weight_vector_to_linear_model(model.svm_model);
//model.w=model.svm_model->lin_weights;
}
if(struct_verbosity>=1) {
printf("Reading test examples..."); fflush(stdout);
}
testsample=read_struct_examples(testfile,&sparm);
if(struct_verbosity>=1) {
printf("done.\n"); fflush(stdout);
}
if(struct_verbosity>=1) {
printf("Classifying test examples..."); fflush(stdout);
}
if ((predfl = fopen (predictionsfile, "w")) == NULL)
{ perror (predictionsfile); exit (1); }
for(i=0;i<testsample.n;i++) {
t1=get_runtime();
y=classify_struct_example(testsample.examples[i].x,&model,&sparm);
runtime+=(get_runtime()-t1);
write_label(predfl,y);
l=loss(testsample.examples[i].y,y,&sparm);
avgloss+=l;
if(l == 0)
correct++;
else
incorrect++;
eval_prediction(i,testsample.examples[i],y,&model,&sparm,&teststats);
if(empty_label(testsample.examples[i].y))
{ no_accuracy=1; } /* test data is not labeled */
if(struct_verbosity>=2) {
if((i+1) % 100 == 0) {
printf("%ld..",i+1); fflush(stdout);
}
}
free_label(y);
}
avgloss/=testsample.n;
fclose(predfl);
if(struct_verbosity>=1) {
printf("done\n");
printf("Runtime (without IO) in cpu-seconds: %.2f\n",
(float)(runtime/100.0));
}
if((!no_accuracy) && (struct_verbosity>=1)) {
printf("Average loss on test set: %.4f\n",(float)avgloss);
printf("Zero/one-error on test set: %.2f%% (%ld correct, %ld incorrect, %d total)\n",(float)100.0*incorrect/testsample.n,correct,incorrect,testsample.n);
}
print_struct_testing_stats(testsample,&model,&sparm,&teststats);
free_struct_sample(testsample);
free_struct_model(model);
svm_struct_classify_api_exit();
return(0);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
#endif
{
long correct=0,incorrect=0,no_accuracy=0;
long i;
double t1,runtime=0;
double avgloss=0,l;
#ifndef COMPILE_MEX_INTERFACE
FILE *predfl;
#endif
STRUCTMODEL model;
STRUCT_LEARN_PARM sparm;
STRUCT_TEST_STATS teststats;
SAMPLE testsample;
LABEL y;
#ifdef COMPILE_MEX_INTERFACE
int argc;
char **argv;
if (nrhs < 3) {
print_help();
return;
}
else if (nrhs==3) {
argc=1;
argv=(char **)my_malloc(MAX_ARGVS*sizeof(char *));
argv[0]="OLR";
}
else
create_argc_argv(prhs[3],&argc,&argv);
#endif
svm_struct_classify_api_init(argc,argv);
#ifndef COMPILE_MEX_INTERFACE
read_input_parameters(argc,argv,testfile,modelfile,predictionsfile,&sparm,
&verbosity,&struct_verbosity);
#else
read_input_parameters(argc,argv,&sparm,&verbosity,&struct_verbosity);
#endif
if(struct_verbosity>=1) {
printf("Reading model..."); fflush(stdout);
}
#ifndef COMPILE_MEX_INTERFACE
model=read_struct_model(modelfile,&sparm);
#else
model=read_struct_model(prhs[2],&sparm);
#endif
if(struct_verbosity>=1) {
fprintf(stdout, "done.\n");
}
if(model.svm_model->kernel_parm.kernel_type == LINEAR) { /* linear kernel */
/* compute weight vector */
add_weight_vector_to_linear_model(model.svm_model);
model.w=model.svm_model->lin_weights;
}
if(struct_verbosity>=1) {
printf("Reading test examples..."); fflush(stdout);
}
#ifndef COMPILE_MEX_INTERFACE
testsample=read_struct_examples(testfile,&sparm);
#else
testsample=read_struct_examples(prhs,&sparm);
#endif
if(struct_verbosity>=1) {
printf("done.\n"); fflush(stdout);
}
if(struct_verbosity>=1) {
printf("Classifying test examples..."); fflush(stdout);
}
#ifndef COMPILE_MEX_INTERFACE
if ((predfl = fopen (predictionsfile, "w")) == NULL)
{ perror (predictionsfile); exit (1); }
#else
mwSize rows=mxGetM(prhs[0]);
mxArray *predictions=mxCreateDoubleMatrix(rows,1,mxREAL);
double *pred_ptr=mxGetPr(predictions);
#endif
for(i=0;i<testsample.n;i++) {
t1=get_runtime();
y=classify_struct_example(testsample.examples[i].x,&model,&sparm);
runtime+=(get_runtime()-t1);
#ifndef COMPILE_MEX_INTERFACE
write_label(predfl,y);
#else
write_label(&pred_ptr,y);
#endif
l=loss(testsample.examples[i].y,y,&sparm);
avgloss+=l;
if(l == 0)
correct++;
else
incorrect++;
eval_prediction(i,testsample.examples[i],y,&model,&sparm,&teststats);
if(empty_label(testsample.examples[i].y))
{ no_accuracy=1; } /* test data is not labeled */
if(struct_verbosity>=2) {
if((i+1) % 100 == 0) {
printf("%ld..",i+1); fflush(stdout);
}
}
free_label(y);
}
avgloss/=testsample.n;
#ifndef COMPILE_MEX_INTERFACE
fclose(predfl);
#endif
if(struct_verbosity>=1) {
printf("done\n");
printf("Runtime (without IO) in cpu-seconds: %.2f\n",
(float)(runtime/100.0));
}
if((!no_accuracy) && (struct_verbosity>=1)) {
printf("Average loss on test set: %.4f\n",(float)avgloss);
printf("Zero/one-error on test set: %.2f%% (%ld correct, %ld incorrect, %d total)\n",(float)100.0*incorrect/testsample.n,correct,incorrect,testsample.n);
}
print_struct_testing_stats(testsample,&model,&sparm,&teststats);
free_struct_sample(testsample);
free_struct_model(model);
svm_struct_classify_api_exit();
#ifndef COMPILE_MEX_INTERFACE
return(0);
#else
plhs[0]=predictions;
#endif
}
/* data mining hard negative samples */
void data_mining_hard_examples(char *trainfile, char *testfile, STRUCT_LEARN_PARM *sparm, STRUCTMODEL *sm)
{
int i, j, n, ntrain, ntest, num, object_label, count, count_pos, count_neg;
char line[BUFFLE_SIZE];
double *energy, *energies;
SAMPLE testsample;
LABEL *y = NULL;
ENERGYINDEX *energy_index;
FILE *fp, *ftrain, *ftest;
/* MPI process */
int rank;
int procs_num;
int start, end, block_size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &procs_num);
/* read negative examples */
printf("Reading negative samples for data mining...");
testsample = read_struct_examples(testfile, sparm, sm);
printf("Done\n");
n = testsample.n;
block_size = (n+procs_num-1) / procs_num;
start = rank*block_size;
end = start+block_size-1 > n-1 ? n-1 : start+block_size-1;
energy = (double*)my_malloc(sizeof(double)*n);
energies = (double*)my_malloc(sizeof(double)*n);
memset(energy, 0, sizeof(double)*n);
memset(energies, 0, sizeof(double)*n);
for(i = start; i <= end; i++)
{
y = classify_struct_example(testsample.examples[i].x, &num, 0, sm, sparm);
count = 0;
for(j = 0; j < num; j++)
{
if(y[j].object_label)
count++;
}
printf("Data mining hard negative example %d/%d: %d objects detected\n", i+1, n, count);
if(count == 0)
energy[i] = -sparm->loss_value;
else
{
for(j = 0; j < num; j++)
{
if(y[j].object_label)
{
energy[i] = y[j].energy;
break;
}
}
}
/* free labels */
for(j = 0; j < num; j++)
free_label(y[j]);
free(y);
}
MPI_Allreduce(energy, energies, n, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
if(rank == 0)
{
energy_index = (ENERGYINDEX*)my_malloc(sizeof(ENERGYINDEX)*n);
for(i = 0; i < n; i++)
{
energy_index[i].index = i;
energy_index[i].energy = energies[i];
}
/* sort energies */
qsort(energy_index, n, sizeof(ENERGYINDEX), compare_energy);
/* construct new training data and write to file */
printf("Writing data to temp.dat...\n");
fp = fopen("temp.dat", "w");
ftrain = fopen(trainfile, "r");
if(ftrain == NULL)
{
printf("Cannot open file %s to read\n", trainfile);
exit(1);
}
ftest = fopen(testfile, "r");
if(ftest == NULL)
{
printf("Cannot open file %s to read\n", testfile);
exit(1);
}
/* positive samples from training data file */
fscanf(ftrain, "%d\n", &ntrain);
count_pos = ntrain/2;
fscanf(ftest, "%d\n", &ntest);
if(ntest < ntrain/2)
n = ntest + ntrain/2;
else
n = ntrain;
count_neg = n - count_pos;
fprintf(fp, "%d\n", n);
for(i = 0; i < ntrain; i++)
{
fgets(line, BUFFLE_SIZE, ftrain);
sscanf(line, "%d", &object_label);
if(object_label == 1)
fputs(line, fp);
else
break;
}
fclose(ftrain);
/* negative samples from hard negative examples */
count = 0;
for(i = 0; i < ntest; i++)
{
fgets(line, BUFFLE_SIZE, ftest);
for(j = 0; j < count_neg; j++)
{
if(i == energy_index[j].index)
{
count++;
fputs(line, fp);
break;
}
}
if(count >= count_neg)
break;
}
fclose(ftest);
fclose(fp);
free(energy_index);
printf("Done\n");
}
MPI_Barrier(MPI_COMM_WORLD);
free(energy);
free(energies);
free_struct_sample(testsample);
}
int main(int argc, char* argv[]) {
double avghingeloss;
LABEL y;
long i, correct;
double weighted_correct;
char testfile[1024];
char modelfile[1024];
char labelfile[1024];
char latentfile[1024];
char scorefile[1024];
FILE *flabel;
FILE *flatent;
FILE *fscore;
STRUCTMODEL model;
STRUCT_LEARN_PARM sparm;
SAMPLE testsample;
/* read input parameters */
read_input_parameters(argc,argv,testfile,modelfile,labelfile,latentfile,scorefile,model.kernel_info_file,model.filestub, &sparm);
printf("C: %f\n",sparm.C);
flabel = fopen(labelfile,"w");
flatent = fopen(latentfile,"w");
fscore = fopen(scorefile, "w");
init_struct_model(model.kernel_info_file, &model, &sparm);
read_struct_model(modelfile, &model);
/* read test examples */
printf("Reading test examples..."); fflush(stdout);
testsample = read_struct_examples(testfile, &model, &sparm);
printf("done.\n");
IMAGE_KERNEL_CACHE ** cached_images = init_cached_images(testsample.examples,&model);
avghingeloss = 0.0;
correct = 0;
weighted_correct=0.0;
int *valid_example_kernel = (int *) malloc(5*sizeof(int));
for(i = 0; i < model.num_kernels; i++)
valid_example_kernel[i] = 1;
double total_example_weight = 0;
int num_distinct_examples = 0;
int last_image_id = -1;
LATENT_VAR h = make_latent_var(&model);
double * scores = (double *)calloc(sparm.n_classes, sizeof(double));
for (i=0;i<testsample.n;i++) {
while (testsample.examples[i].x.image_id == last_image_id) i++;
last_image_id = testsample.examples[i].x.image_id;
num_distinct_examples++;
// if(finlatent) {
// read_latent_var(&h,finlatent);
//printf("%d %d\n",h.position_x,h.position_y);
// }
//printf("%f\n",sparm.C);
struct timeval start_time;
struct timeval finish_time;
gettimeofday(&start_time, NULL);
classify_struct_example(testsample.examples[i].x,&y,&h,cached_images,&model,&sparm,1);
gettimeofday(&finish_time, NULL);
double microseconds = 1e6 * (finish_time.tv_sec - start_time.tv_sec) + (finish_time.tv_usec - start_time.tv_usec);
//printf("This ESS call took %f milliseconds.\n", microseconds/1e3);
total_example_weight += testsample.examples[i].x.example_cost;
//double hinge_l = get_hinge_l_from_pos_score(pos_score,testsample.examples[i].y);
//printf("with a pos_score of %f, a label of %d we get a hinge_l of %f\n", pos_score, testsample.examples[i].y.label, hinge_l);
// double weighted_hinge_l = hinge_l * testsample.examples[i].x.example_cost;
//avghingeloss += weighted_hinge_l;
//if (hinge_l<1) {
//A classification is considered "correct" if it guesses one of the objects in the image
if (y.label == testsample.examples[i].y.label || testsample.examples[i].x.also_correct[y.label]) {
correct++;
weighted_correct+=testsample.examples[i].x.example_cost;
}
print_label(y, flabel);
fprintf(flabel,"\n"); fflush(flabel);
print_latent_var(testsample.examples[i].x, h, flatent);
get_class_scores(testsample.examples[i].x, cached_images, scores, &model, &sparm);
fprintf(fscore, "%s ", testsample.examples[i].x.image_path);
for (int j = 0; j < sparm.n_classes; ++j) {
fprintf(fscore, "%f ", scores[j]);
}
fprintf(fscore, "\n");
}
free_latent_var(h);
fclose(flabel);
fclose(flatent);
free(scores);
//double w_cost = regularizaton_cost(model.w_curr.get_vec(), model.sizePsi);
//avghingeloss = avghingeloss/testsample.n;
printf("\n");
//printf("Objective Value with C=%f is %f\n\n\n", sparm.C, (sparm.C * avghingeloss) + w_cost);
//printf("Average hinge loss on dataset: %.4f\n", avghingeloss);
printf("Zero/one error on test set: %.4f\n", 1.0 - ((float) correct) / (1.0 * num_distinct_examples));
printf("Weighted zero/one error on the test set %.4f\n", 1.0 - (weighted_correct/total_example_weight));
printf("zeroone %.4f weightedzeroone %.4f\n", 1.0 - ((float) correct) / (1.0 * num_distinct_examples), 1.0 - (weighted_correct/total_example_weight));
fclose(fscore);
free_cached_images(cached_images, &model);
//free_struct_sample(testsample);
free_struct_model(model,&sparm);
return(0);
}
