void SVMTrainModel::setNoPrint(bool _no_print)
{
if(_no_print)
{
void (*print_func)(const char*) = &print_null;
svm_set_print_string_function(print_func);
}
else
{
void (*print_func)(const char*) = NULL; // default printing to stdout
svm_set_print_string_function(print_func);
}
}
bool SvmClassifier::Train(const Mat &feats, const vector<int> &labels)
{
if (svm_model_ != NULL)
{
svm_free_and_destroy_model(&svm_model_);
}
// Calculate the normalization parameters
TrainNormalize(feats, &normA_, &normB_);
// Normalize the features
Mat feats_norm;
Normalize(feats, &feats_norm);
// Prepare the input for SVM
svm_parameter param;
svm_problem problem;
svm_node* x_space = NULL;
PrepareParameter(feats_norm.cols, ¶m);
PrepareProblem(feats_norm, labels, &problem, x_space);
// Train the SVM model
svm_set_print_string_function(&PrintNull); // Close the training output
svm_model_ = svm_train(&problem, ¶m);
// Release the parameters for training
svm_destroy_param(¶m);
return true;
}
SVM::SVM(void (*f) (const char*)) {
problem.l = 0;
main_equation = NULL;
model = NULL;
param.svm_type = C_SVC;
param.kernel_type = LINEAR;
param.degree = 3;
param.gamma = 0; // 1/num_features
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 100;
// param.C = 1;
param.C = DBL_MAX;
//param.C = 1000;
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;
if (f != NULL)
svm_set_print_string_function(f);
for (int i = 0; i < 2 * max_items; i++)
training_label[i] = -1;
problem.x = (svm_node**)(training_set);
problem.y = training_label;
}
/****************************************
get the SVM results of classifying activation vectors of two categories for every voxel
the linear kernel of libSVM is applied here
input: the average activation matrix array, the blocks(trials), the number of blocks, the number of test samples, the number of folds in the cross validation, the location info
output: a list of voxels' scores in terms of SVM accuracies
*****************************************/
VoxelScore* GetSearchlightSVMPerformance(RawMatrix** avg_matrices, Trial* trials, int nTrials, int nTests, int nFolds, Point* pts) //classifiers for a r_matrix array
{
svm_set_print_string_function(&print_null);
int row = avg_matrices[0]->row; // assume all elements in r_matrices array have the same row
VoxelScore* score = new VoxelScore[row]; // get step voxels classification accuracy here
int i, j;
for (i=0; i<row; i++)
{
SVMProblem* prob = GetSearchlightSVMProblem(avg_matrices, trials, i, nTrials-nTests, pts);
if (i%1000==0) cout<<i<<" ";
//if (me==0) PrintSVMProblem(prob);
SVMParameter* param = SetSVMParameter(0); // 2 for RBF kernel
(score+i)->vid = i;
(score+i)->score = DoSVM(nFolds, prob, param);
delete param;
delete prob->y;
for (j=0; j<nTrials-nTests; j++)
{
delete prob->x[j];
}
delete prob->x;
delete prob;
}
//if (me == 0)
//{
// cout<<endl;
//}
return score;
}
SVMTrainModel::SVMTrainModel()
{
// default values
param.svm_type = C_SVC;
param.kernel_type = RBF;
param.degree = 3;
param.gamma = 0; // 1/num_features
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;
cross_validation = 0;
void (*print_func)(const char*) = NULL; // default printing to stdout
svm_set_print_string_function(print_func);
have_input_file_name = false;
have_model_file_name = false;
}
/* provide convenience wrapper */
void set_verbosity(int verbosity_flag){
if (verbosity_flag)
# if LIBSVM_VERSION < 291
svm_print_string = &print_string_stdout;
else
svm_print_string = &print_null;
# else
svm_set_print_string_function(&print_string_stdout);
else
/***************************************
predict a new sample based on a trained SVM model and a variation of the numbers of top voxels. if correlation, assume that it's a self correlation, so only one mask file is enough
input: the raw activation matrix array, the average activation matrix array, the number of subjects, the number of blocks(trials), the blocks, the number of test samples, the task type, the files to store the results, the mask file
output: the results are displayed on the screen
****************************************/
void SVMPredict(RawMatrix** r_matrices, RawMatrix** avg_matrices, int nSubs, int nTrials, Trial* trials, int nTests, int taskType, const char* topVoxelFile, const char* mask_file, int is_quiet_mode)
{
RawMatrix** masked_matrices=NULL;
int row = 0;
int col = 0;
svm_set_print_string_function(&print_null);
VoxelScore* scores = NULL;
int tops[] = {10, 20, 50, 100, 200, 500, 1000, 2000, 5000};//, 10000, 20000, 40000};
int maxtops = sizeof(tops)/sizeof((tops)[0]);
int ntops;
switch (taskType)
{
case 0:
case 1:
if (mask_file!=NULL)
masked_matrices = GetMaskedMatrices(r_matrices, nSubs, mask_file);
else
masked_matrices = r_matrices;
row = masked_matrices[0]->row;
col = masked_matrices[0]->col;
scores = ReadTopVoxelFile(topVoxelFile, row);
RearrangeMatrix(masked_matrices, scores, row, col, nSubs);
ntops = getNumTopIndices(tops, maxtops, row);
if (ntops > 0)
CorrelationBasedClassification(tops, ntops, nSubs, nTrials, trials, nTests, masked_matrices, is_quiet_mode);
else
cerr<<"less than "<<tops[0]<<"voxels!"<<endl;
break;
case 2:
if (mask_file!=NULL)
masked_matrices = GetMaskedMatrices(avg_matrices, nSubs, mask_file);
else
masked_matrices = avg_matrices;
row = masked_matrices[0]->row;
col = masked_matrices[0]->col;
scores = ReadTopVoxelFile(topVoxelFile, row);
RearrangeMatrix(masked_matrices, scores, row, col, nSubs);
ntops = getNumTopIndices(tops, maxtops, row);
if (ntops > 0)
ActivationBasedClassification(tops, ntops, nTrials, trials, nTests, masked_matrices, is_quiet_mode);
else
cerr<<"less than "<<tops[0]<<"voxels!"<<endl;
break;
default:
FATAL("Unknown task type");
}
delete[] scores;
}
/// <summary>
/// use a kernel matrix and solve the svm problem
/// </summary>
/// <param name="Labels">vector of all Labels</param>
/// <param name="C">regularisation parameter</param>
libSVMWrapper::libSVMWrapper(Eigen::VectorXd Labels, double C)
{
svm_set_print_string_function(print_null);
Y = Labels;
// we need these parameters
libSVM_Parameter.svm_type = C_SVC;
libSVM_Parameter.kernel_type = PRECOMPUTED;
libSVM_Parameter.C = C;
// dummy values
libSVM_Parameter.degree = 3;
libSVM_Parameter.gamma = 0;
libSVM_Parameter.coef0 = 0;
libSVM_Parameter.nu = 0.5;
libSVM_Parameter.cache_size = 100;
libSVM_Parameter.eps = 1e-3;
libSVM_Parameter.p = 0.1;
libSVM_Parameter.shrinking = 1;
libSVM_Parameter.probability = 0;
libSVM_Parameter.nr_weight = 0;
libSVM_Parameter.weight_label = NULL;
libSVM_Parameter.weight = NULL;
// the labels do not change
NumberOfData = Labels.rows();
int sc = Labels.rows() + 1;
libSVM_Problem.y = Malloc(double,NumberOfData);
libSVM_Problem.l = NumberOfData;
for (int i = 0; i < NumberOfData; i++)
libSVM_Problem.y[i] = Labels[i];
// get space for kernel matrix (fixed size) only once
libSVM_Problem.x = Malloc(struct svm_node *,NumberOfData);
libSVM_x_space = Malloc(struct svm_node, NumberOfData* (sc+1));
// get space only once
for (int i = 0; i < libSVM_Problem.l; i++)
{
libSVM_Problem.x[i] = &libSVM_x_space[i * (sc + 1)];
libSVM_Problem.y[i] = Labels[i];
}
}
// nrhs should be 3
int parse_command_line(int nrhs, const mxArray *prhs[], char *model_file_name)
{
int i, argc = 1;
char cmd[CMD_LEN];
char *argv[CMD_LEN/2];
void (*print_func)(const char *) = print_string_matlab; // default printing to matlab display
// default values
param.svm_type = C_SVC;
param.kernel_type = RBF;
param.degree = 3;
param.gamma = 0; // 1/num_features
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;
cross_validation = 0;
if(nrhs <= 1)
return 1;
if(nrhs > 2)
{
// put options in argv[]
mxGetString(prhs[2], cmd, mxGetN(prhs[2]) + 1);
if((argv[argc] = strtok(cmd, " ")) != NULL)
while((argv[++argc] = strtok(NULL, " ")) != NULL)
;
}
// parse options
for(i=1;i<argc;i++)
{
if(argv[i][0] != '-') break;
++i;
if(i>=argc && argv[i-1][1] != 'q') // since option -q has no parameter
return 1;
switch(argv[i-1][1])
{
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atoi(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case 'n':
param.nu = atof(argv[i]);
break;
case 'm':
param.cache_size = atof(argv[i]);
break;
case 'c':
param.C = atof(argv[i]);
break;
case 'e':
param.eps = atof(argv[i]);
break;
case 'p':
param.p = atof(argv[i]);
break;
case 'h':
param.shrinking = atoi(argv[i]);
break;
case 'b':
param.probability = atoi(argv[i]);
break;
case 'q':
print_func = &print_null;
i--;
break;
case 'v':
cross_validation = 1;
nr_fold = atoi(argv[i]);
if(nr_fold < 2)
{
mexPrintf("n-fold cross validation: n must >= 2\n");
return 1;
}
break;
case 'w':
++param.nr_weight;
param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]);
param.weight[param.nr_weight-1] = atof(argv[i]);
break;
default:
mexPrintf("Unknown option -%c\n", argv[i-1][1]);
return 1;
}
}
svm_set_print_string_function(print_func);
return 0;
}
void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name)
{
int i;
void (*print_func)(const char*) = NULL; // default printing to stdout
// default values
param.svm_type = C_SVC;
param.kernel_type = RBF;
param.degree = 3;
param.gamma = 0; // 1/num_features
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;
cross_validation = 0;
// parse options
for(i=1;i<argc;i++)
{
if(argv[i][0] != '-') break;
if(++i>=argc)
exit_with_help();
switch(argv[i-1][1])
{
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atoi(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case 'n':
param.nu = atof(argv[i]);
break;
case 'm':
param.cache_size = atof(argv[i]);
break;
case 'c':
param.C = atof(argv[i]);
break;
case 'e':
param.eps = atof(argv[i]);
break;
case 'p':
param.p = atof(argv[i]);
break;
case 'h':
param.shrinking = atoi(argv[i]);
break;
case 'b':
param.probability = atoi(argv[i]);
break;
case 'q':
print_func = &print_null;
i--;
break;
case 'v':
cross_validation = 1;
nr_fold = atoi(argv[i]);
if(nr_fold < 2)
{
fprintf(stderr,"n-fold cross validation: n must >= 2\n");
exit_with_help();
}
break;
case 'w':
++param.nr_weight;
param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]);
param.weight[param.nr_weight-1] = atof(argv[i]);
break;
case 'W':
weight_file = argv[i];
break;
default:
fprintf(stderr,"Unknown option: -%c\n", argv[i-1][1]);
exit_with_help();
}
}
svm_set_print_string_function(print_func);
// determine filenames
if(i>=argc)
exit_with_help();
strcpy(input_file_name, argv[i]);
if(i<argc-1)
strcpy(model_file_name,argv[i+1]);
else
{
char *p = strrchr(argv[i],'/');
if(p==NULL)
p = argv[i];
else
++p;
sprintf(model_file_name,"%s.model",p);
}
}
/* provide convenience wrapper */
void set_verbosity(int verbosity_flag){
if (verbosity_flag)
svm_set_print_string_function(&print_string_stdout);
else
svm_set_print_string_function(&print_null);
}
void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name)
{
int i;
void (*print_func)(const char*) = NULL; // default printing to stdout
// default values
param.scale = 1.0;
param.kMeansperLabel = 10;
param.kNN = 20;
param.svmIterations = 500;
param.distanceCoefficient = 0.1;
param.jointClustering = 0;
walltime = -1;
savetime = -1;
subsamplingAmount = -1;
// parse options
for(i=1;i<argc;i++)
{
if(argv[i][0] != '-') break;
if(++i>=argc)
exit_with_help();
switch(argv[i-1][1])
{
case 's':
param.scale = atof(argv[i]);
break;
case 'k':
param.kMeansperLabel = atoi(argv[i]);
break;
case 'n':
param.kNN = atoi(argv[i]);
break;
case 'i':
param.svmIterations = atoi(argv[i]);
break;
case 'd':
param.distanceCoefficient = atof(argv[i]);
break;
case 'j':
param.jointClustering = atoi(argv[i]);
break;
case 'a':
savetime = atoi(argv[i]);
break;
case 'l':
walltime = atoi(argv[i]);
break;
default:
fprintf(stderr,"Unknown option: -%c\n", argv[i-1][1]);
exit_with_help();
}
}
svm_set_print_string_function(print_func);
// determine filenames
if(i>=argc)
exit_with_help();
strcpy(input_file_name, argv[i]);
if(i<argc-1)
strcpy(model_file_name,argv[i+1]);
else
{
char *p = strrchr(argv[i],'/');
if(p==NULL)
p = argv[i];
else
++p;
sprintf(model_file_name,"%s.model",p);
}
}
int main(void){
list_t passengerList,testPassengerList;
FILE *fp;
int i;
svm_set_print_string_function(print_null);
memset(&passengerList,0,sizeof(passengerList));
memset(&testPassengerList,0,sizeof(passengerList));
char buf[1024];
char **token;
dfopen(fp,"data/train.csv","r",exit(EXIT_FAILURE));
fgets(buf,sizeof(buf),fp);
while(fgets(buf,sizeof(buf),fp)){
int n=explode(&token,buf,',');
passenger *human=Calloc(passenger,1);
human->passengerId=atoi(token[0]);
human->survived=atoi(token[1]);
human->sex=(strcmp("male",token[4])==0) ? 0 : 1;
human->age=(*token[5]=='\0') ? -1 : atoi(token[5]);
human->rank=atoi(token[2]);
human->fare=atoi(token[9]);
human->name=parseName(token[3]);
human->ticketNo=strdup(token[8]);
human->cabin=strdup(token[10]);
addList(&passengerList,human);
for(i=0;i<n;i++){
free(token[i]);
}
free(token);
}
fclose(fp);
sameTicketScale(&passengerList);
dfopen(fp,"data/test.csv","r",exit(EXIT_FAILURE));
fgets(buf,sizeof(buf),fp);
while(fgets(buf,sizeof(buf),fp)){
int n=explode(&token,strdup(buf),',');
passenger *human=Calloc(passenger,1);
human->passengerId=atoi(token[0]);
human->sex=(strcmp("male",token[3])==0) ? 0 : 1;
human->age=(*token[4]=='\0') ? -1 : atoi(token[4]);
human->rank=atoi(token[1]);
human->fare=atoi(token[8]);
human->name=parseName(token[2]);
human->ticketNo=strdup(token[7]);
human->cabin=strdup(token[9]);
addList(&testPassengerList,human);
for(i=0;i<n;i++){
free(token[i]);
}
free(token);
}
fclose(fp);
sameTicketScale(&testPassengerList);
fillAge(&passengerList,&testPassengerList);
checkAlone(&passengerList,&testPassengerList);
ML_bayesianNetwork(&passengerList,&testPassengerList);
exit(0);
return 0;
}
int main(int argc, char** argv)
{
if (argc < 1) {
std::cout << "Arguments less than 2.\n";
exit(-1);
}
if (argc >= 3) {
minv = atoi(argv[1]);
maxv = atoi(argv[2]);
}
struct svm_parameter param;
param.svm_type = C_SVC;
param.kernel_type = LINEAR;
param.degree = 3;
param.gamma = 0; // 1/num_features
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 100;
// param.C = 1;
param.C = DBL_MAX;
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;
svm_set_print_string_function(print_null);
int rnd = 1;
srand(time(NULL));
#ifdef _TEST0_
std::cout << "[1]******************************************************" << std::endl;
std::cout << "\t(1) running programs... [" << inputs_init <<"]" << std::endl;
#endif
for (int i = 0; i < inputs_init; i++) {
for (int j = 0; j < vars; j++) {
inputs[j] = rand() % (maxv - minv + 1) + minv;
}
before_loop();
m(inputs);
after_loop();
}
start_processing:
if (positive_set_changed) {
qsort(positive_set, positive_idx, sizeof(node), node::compare);
positive_set_changed = false;
}
if (negative_set_changed) {
qsort(negative_set, negative_idx, sizeof(node), node::compare);
negative_set_changed = false;
}
// nice_set_print();
#ifdef _TEST0_
std::cout << "\t(2) converting data into svm format..." << std::endl;
#endif
svm_linker sl;
sl.add_node_set(positive_set, positive_idx, 1);
sl.add_node_set(negative_set, negative_idx, -1);
#ifdef _TEST0_
std::cout << "\t(3) svm training...[" << sl.l << "]" << std::endl;
#endif
struct svm_model* model = svm_train((const struct svm_problem *)&sl, ¶m);
// svm_save_model("model_file", model);
struct coef co;
svm_model_visualization(model, &co);
printf(" %.16g [0]", co.theta[0]);
for (int j = 1; j < vars; j++)
printf (" + %.16g [%d]", co.theta[j], j);
printf (" >= %.16g\n", -co.theta0);
print_svm_samples((const struct svm_problem*)&sl);
svm_free_and_destroy_model(&model);
rnd++;
if (rnd <= max_iter) {
#ifdef _TEST0_
std::cout << "[" << rnd << "]*********************************************************" << std::endl;
std::cout << "\t(1) running programs...[" << inputs_aft << "]" << std::endl;
#endif
for (int i = 0; i < inputs_aft; i++) {
linear_solver(co, inputs);
before_loop();
m(inputs);
after_loop();
}
goto start_processing;
}
return 0;
}
/***************************************
Get two parts of the brain to compute the correlation and then use the correlation vectors to predict
input: the raw activation matrix array, the number of subjects, the number of subjects, the first mask file, the second mask file, the number of blocks(trials), the blocks, the number of test samples
output: the results are displayed on the screen and returned
****************************************/
int SVMPredictCorrelationWithMasks(RawMatrix** r_matrices, int nSubs, const char* maskFile1, const char* maskFile2, int nTrials, Trial* trials, int nTests, int is_quiet_mode)
{
int i, j;
svm_set_print_string_function(&print_null);
RawMatrix** masked_matrices1=NULL;
RawMatrix** masked_matrices2=NULL;
if (maskFile1!=NULL)
masked_matrices1 = GetMaskedMatrices(r_matrices, nSubs, maskFile1);
else
masked_matrices1 = r_matrices;
if (maskFile2!=NULL)
masked_matrices2 = GetMaskedMatrices(r_matrices, nSubs, maskFile2);
else
masked_matrices2 = r_matrices;
cout<<"masked matrices generating done!"<<endl;
cout<<"#voxels for mask1: "<<masked_matrices1[0]->row<<" #voxels for mask2: "<<masked_matrices2[0]->row<<endl;
float* simMatrix = new float[nTrials*nTrials];
int corrRow = masked_matrices1[0]->row;
//int corrCol = masked_matrices2[0]->row; // no use here
memset((void*)simMatrix, 0, nTrials*nTrials*sizeof(float));
int sr = 0, rowLength = 100;
int result = 0;
while (sr<corrRow)
{
if (rowLength >= corrRow - sr)
{
rowLength = corrRow - sr;
}
float* tempSimMatrix = GetPartialInnerSimMatrixWithMasks(nSubs, nTrials, sr, rowLength, trials, masked_matrices1, masked_matrices2);
for (i=0; i<nTrials*nTrials; i++) simMatrix[i] += tempSimMatrix[i];
delete[] tempSimMatrix;
sr += rowLength;
}
SVMParameter* param = SetSVMParameter(4); // precomputed
SVMProblem* prob = GetSVMTrainingSet(simMatrix, nTrials, trials, nTrials-nTests);
struct svm_model *model = svm_train(prob, param);
int nTrainings = nTrials-nTests;
SVMNode* x = new SVMNode[nTrainings+2];
double predict_distances[nTrials-nTrainings];
bool predict_correctness[nTrials-nTrainings];
for (i=nTrainings; i<nTrials; i++)
{
x[0].index = 0;
x[0].value = i-nTrainings+1;
for (j=0; j<nTrainings; j++)
{
x[j+1].index = j+1;
x[j+1].value = simMatrix[i*nTrials+j];
}
x[j+1].index = -1;
predict_distances[i-nTrainings] = svm_predict_distance(model, x);
int predict_label = predict_distances[i-nTrainings]>0?0:1;
if (trials[i].label == predict_label)
{
result++;
predict_correctness[i-nTrainings] = true;
}
else
{
predict_correctness[i-nTrainings] = false;
}
}
if (!is_quiet_mode)
{
cout<<"blocking testing confidence:"<<endl;
for (i=nTrainings; i<nTrials; i++)
{
cout<<fabs(predict_distances[i-nTrainings])<<" (";
if (predict_correctness[i-nTrainings])
{
cout<<"Correct) ";
}
else
{
cout<<"Incorrect) ";
}
}
cout<<endl;
}
svm_free_and_destroy_model(&model);
delete[] x;
delete prob->y;
for (i=0; i<nTrainings; i++)
{
delete prob->x[i];
}
delete prob->x;
delete prob;
svm_destroy_param(param);
delete[] simMatrix;
for (i=0; i<nSubs; i++)
{
delete masked_matrices1[i]->matrix;
if (maskFile2!=NULL) delete masked_matrices2[i]->matrix;
}
delete masked_matrices1;
if (maskFile2!=NULL) delete masked_matrices2;
return result;
}
/***************************************
Get one part of the brain to compute the averaged activation and then use the normalized activation vectors to predict
input: the raw activation matrix array, the number of voxels, the number of subjects, the ROI mask file, the number of blocks(trials), the blocks, the number of test samples
output: the results are displayed on the screen and returned
****************************************/
int SVMPredictActivationWithMasks(RawMatrix** avg_matrices, int nSubs, const char* maskFile, int nTrials, Trial* trials, int nTests, int is_quiet_mode)
{
int i, j;
int nTrainings = nTrials-nTests;
SVMParameter* param = SetSVMParameter(0); // linear
SVMProblem* prob = new SVMProblem();
prob->l = nTrainings;
prob->y = new double[nTrainings];
prob->x = new SVMNode*[nTrainings];
svm_set_print_string_function(&print_null);
RawMatrix** masked_matrices=NULL;
if (maskFile!=NULL)
masked_matrices = GetMaskedMatrices(avg_matrices, nSubs, maskFile);
else
masked_matrices = avg_matrices;
cout<<"masked matrices generating done!"<<endl;
cout<<"#voxels for mask "<<masked_matrices[0]->row<<endl;
int nVoxels = masked_matrices[0]->row;
for (i=0; i<nTrainings; i++)
{
int sid = trials[i].sid;
prob->y[i] = trials[i].label;
prob->x[i] = new SVMNode[nVoxels+1];
for (j=0; j<nVoxels; j++)
{
prob->x[i][j].index = j+1;
int col = masked_matrices[sid]->col;
int offset = trials[i].tid_withinsubj;
prob->x[i][j].value = masked_matrices[sid]->matrix[j*col+offset];
}
prob->x[i][j].index = -1;
}
struct svm_model *model = svm_train(prob, param);
SVMNode* x = new SVMNode[nVoxels+1];
double predict_distances[nTrials-nTrainings];
bool predict_correctness[nTrials-nTrainings];
int result = 0;
for (i=nTrainings; i<nTrials; i++)
{
int sid = trials[i].sid;
for (j=0; j<nVoxels; j++)
{
x[j].index = j+1;
int col = masked_matrices[sid]->col;
int offset = trials[i].tid_withinsubj;
x[j].value = masked_matrices[sid]->matrix[j*col+offset];
}
x[j].index = -1;
predict_distances[i-nTrainings] = svm_predict_distance(model, x);
int predict_label = predict_distances[i-nTrainings]>0?0:1;
if (trials[i].label == predict_label)
{
result++;
predict_correctness[i-nTrainings] = true;
}
else
{
predict_correctness[i-nTrainings] = false;
}
}
if (!is_quiet_mode)
{
cout<<"blocking testing confidence:"<<endl;
for (i=nTrainings; i<nTrials; i++)
{
cout<<fabs(predict_distances[i-nTrainings])<<" (";
if (predict_correctness[i-nTrainings])
{
cout<<"Correct) ";
}
else
{
cout<<"Incorrect) ";
}
}
cout<<endl;
}
svm_free_and_destroy_model(&model);
delete[] x;
delete[] prob->y;
for (i=0; i<nTrainings; i++)
{
delete prob->x[i];
}
delete[] prob->x;
delete prob;
svm_destroy_param(param);
for (i=0; i<nSubs; i++)
{
delete masked_matrices[i]->matrix;
}
delete masked_matrices;
return result;
}
