CMDParser parser;

parser.parse_command_line(argc, argv);

/*

DataSet train_dataset;

char input_file_path[1024] = DATASET_DIR;

char model_file_path[1024] = DATASET_DIR;

strcat(input_file_path, parser.svmtrain_input_file_name.c_str());

strcat(model_file_path, parser.model_file_name.c_str());

train_dataset.load_from_file(input_file_path);

SvmModel *model = nullptr;

switch (parser.param_cmd.svm_type) {

case SvmParam::C_SVC:

model = new SVC();

break;

case SvmParam::NU_SVC:

model = new NuSVC();

break;

case SvmParam::ONE_CLASS:

model = new OneClassSVC();

break;

case SvmParam::EPSILON_SVR:

model = new SVR();

break;

case SvmParam::NU_SVR:

model = new NuSVR();

break;

}

//todo add this to check_parameter method

if (parser.param_cmd.svm_type == SvmParam::NU_SVC) {

train_dataset.group_classes();

for (int i = 0; i < train_dataset.n_classes(); ++i) {

int n1 = train_dataset.count()[i];

for (int j = i + 1; j < train_dataset.n_classes(); ++j) {

int n2 = train_dataset.count()[j];

if (parser.param_cmd.nu * (n1 + n2) / 2 > min(n1, n2)) {

printf("specified nu is infeasible\n");

return;

}

}

}

}

#ifdef USE_CUDA

CUDA_CHECK(cudaSetDevice(parser.gpu_id));

#endif

vector<float_type> predict_y, test_y;

if (parser.do_cross_validation) {

vector<float_type> test_predict = model->cross_validation(train_dataset, parser.param_cmd, parser.nr_fold);

int dataset_size = test_predict.size() / 2;

test_y.insert(test_y.end(), test_predict.begin(), test_predict.begin() + dataset_size);

predict_y.insert(predict_y.end(), test_predict.begin() + dataset_size, test_predict.end());

} else {

model->train(train_dataset, parser.param_cmd);

model->save_to_file(model_file_path);

//predict_y = model->predict(train_dataset.instances(), 10000);

//test_y = train_dataset.y();

}

/*

return;

CMDParser parser;

parser.parse_command_line(argc, argv);

char model_file_path[1024] = DATASET_DIR;

char predict_file_path[1024] = DATASET_DIR;

char output_file_path[1024] = DATASET_DIR;

strcat(model_file_path, parser.svmpredict_model_file_name.c_str());

strcat(predict_file_path, parser.svmpredict_input_file.c_str());

strcat(output_file_path, parser.svmpredict_output_file.c_str());

std::fstream file;

//FILE *fp;

//fp = fopen("model_file_path", "rb");

file.open(model_file_path, std::fstream::in);

string feature, svm_type;

//char feature[20];

//char svm_type[20];

//fscanf(fp, "%s", feature);

//fscanf(fp, "%s", svm_type);

file >> feature >> svm_type;

CHECK_EQ(feature, "svm_type");

SvmModel *model = nullptr;

Metric *metric = nullptr;

if (svm_type == "c_svc") {

model = new SVC();

metric = new Accuracy();

} else if (svm_type == "nu_svc") {

model = new NuSVC();

metric = new Accuracy();

} else if (svm_type == "one_class") {

model = new OneClassSVC();

//todo determine a metric

} else if (svm_type == "epsilon_svr") {

model = new SVR();

metric = new MSE();

} else if (svm_type == "nu_svr") {

model = new NuSVR();

metric = new MSE();

}

#ifdef USE_CUDA

CUDA_CHECK(cudaSetDevice(parser.gpu_id));

#endif

model->load_from_file(model_file_path);

//fclose(fp);

file.close();

//fp = fopen("output_file_path", "wb");

file.open(output_file_path, std::fstream::out);

DataSet predict_dataset;

predict_dataset.load_from_file(predict_file_path);

vector<float_type> predict_y;

predict_y = model->predict(predict_dataset.instances(), 10000);

for (int i = 0; i < predict_y.size(); ++i) {

//fprintf(fp, "%s\n", predict_y[i]);

file << predict_y[i] << std::endl;

}

//fclose(fp);

file.close();

if (metric) {

LOG(INFO) << metric->name() << " = " << metric->score(predict_y, predict_dataset.y());

}