int train_fs(const char* input_file_name, const char* model_file_name){
// Initialization
const char* error_msg;
set_default_params();
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg){
fprintf(stderr,"Error: %s\n",error_msg);
return -1;
}
// Do the cross-validation and save accuracy
double accuracy = do_cross_validation(nr_fold);
std::string info_fpath = std::string(model_file_name) + ".info";
FILE* info = fopen(info_fpath.c_str(), "w");
fprintf(info, "Accuracy : %f", accuracy);
//fflush(info);
fclose(info);
// Train a model on the whole dataset
model_train=train(&prob, ¶m);
if(save_model(model_file_name, model_train)){
fprintf(stderr,"can't save model to file %s\n",model_file_name);
return -1;
}
// Free resources
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return 0;
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
exit(1);
}
if(flag_cross_validation)
{
do_cross_validation();
}
else
{
model_=train(&prob, ¶m);
save_model(model_file_name, model_);
destroy_model(model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return 0;
}
// Training SVM with feature vector X and label Y.
// Each row of X is a feature vector, with corresponding label in Y.
// Return a CV_32F weight Mat
Mat Objectness::trainSVM(CMat &X1f, const vecI &Y, int sT, double C, double bias, double eps)
{
// Set SVM parameters
parameter param; {
param.solver_type = sT; // L2R_L2LOSS_SVC_DUAL;
param.C = C;
param.eps = eps; // see setting below
param.p = 0.1;
param.nr_weight = 0;
param.weight_label = NULL;
param.weight = NULL;
set_print_string_function(print_null);
CV_Assert(X1f.rows == Y.size() && X1f.type() == CV_32F);
}
// Initialize a problem
feature_node *x_space = NULL;
problem prob;{
prob.l = X1f.rows;
prob.bias = bias;
prob.y = Malloc(double, prob.l);
prob.x = Malloc(feature_node*, prob.l);
const int DIM_FEA = X1f.cols;
prob.n = DIM_FEA + (bias >= 0 ? 1 : 0);
x_space = Malloc(feature_node, (prob.n + 1) * prob.l);
int j = 0;
for (int i = 0; i < prob.l; i++){
prob.y[i] = Y[i];
prob.x[i] = &x_space[j];
const float* xData = X1f.ptr<float>(i);
for (int k = 0; k < DIM_FEA; k++){
x_space[j].index = k + 1;
x_space[j++].value = xData[k];
}
if (bias >= 0){
x_space[j].index = prob.n;
x_space[j++].value = bias;
}
x_space[j++].index = -1;
}
CV_Assert(j == (prob.n + 1) * prob.l);
}
// Training SVM for current problem
const char* error_msg = check_parameter(&prob, ¶m);
if(error_msg){
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
model *svmModel = train(&prob, ¶m);
Mat wMat(1, prob.n, CV_64F, svmModel->w);
wMat.convertTo(wMat, CV_32F);
free_and_destroy_model(&svmModel);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
return wMat;
}
// Interface function of matlab
// now assume prhs[0]: label prhs[1]: features
int main(int argc, char **argv)
{
const char *error_msg;
// fix random seed to have same results for each run
// (for cross validation)
srand(1);
char input_file_name[1024];
char model_file_name[1024];
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
exit(1);
}
if(cross_validation_flag)
{
do_cross_validation();
}
else
{
model_=FGM_train(&prob, ¶m);
printf("training is done!\n");
save_model_poly(model_file_name, model_);
printf("model is saved!\n");
destroy_model(model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
if( flag_find_C && flag_warm_start)
{
fprintf(stderr,"ERROR: Option -C and -i can't both exist\n");
exit(1);
}
if (flag_find_C)
{
do_find_parameter_C();
}
else if(flag_cross_validation)
{
do_cross_validation();
}
else
{
if(flag_warm_start)
{
if(prob.n != initial_model->nr_feature)
fprintf(stderr,"WARNING: The number of features in the input file does not match that in the initial model\n");
model_=warm_start_train(&prob, ¶m, initial_model);
free_and_destroy_model(&initial_model);
}
else
model_=train(&prob, ¶m);
if(save_model(model_file_name, model_))
{
fprintf(stderr,"can't save model to file %s\n",model_file_name);
exit(1);
}
free_and_destroy_model(&model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return 0;
}
static void destroy_block(struct lp_block *b) {
int c;
for(c = 0; c < b->params_len; c++) {
if(b->params[c]) {
destroy_param(b->params[c]);
}
}
free(b->name);
free(b->params);
free(b);
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
exit(1);
}
if(flag_cross_validation)
{
if (nr_fold <= 10)
{
do_cross_validation();
}
else
{
double cv;
nr_fold = nr_fold - 10;
cv = binary_class_cross_validation(&prob, ¶m, nr_fold);
printf("Cross Validation = %g%%\n",100.0*cv);
}
}
else
{
model_=train(&prob, ¶m);
if(save_model(model_file_name, model_))
{
fprintf(stderr,"can't save model to file %s\n",model_file_name);
exit(1);
}
free_and_destroy_model(&model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(prob.W);
free(x_space);
free(line);
return 0;
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
param.train_file = Malloc(char,1024);
strcpy(param.train_file, input_file_name);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
if(flag_cross_validation)
{
do_cross_validation();
}
else
{
clock_t start_cpu, end_cpu;
double cpu_time_used;
start_cpu = clock();
model_=train(&prob, ¶m);
end_cpu = clock();
cpu_time_used = ((double) (end_cpu - start_cpu)) / CLOCKS_PER_SEC;
if(save_model(model_file_name, model_))
{
fprintf(stderr,"can't save model to file %s\n",model_file_name);
exit(1);
}
free_and_destroy_model(&model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return 0;
}
struct model* main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
auto prob = read_problem(input_file_name);
error_msg = check_parameter(&prob, ¶m);
if (error_msg)
{
fprintf(stderr, "ERROR: %s\n", error_msg);
exit(1);
}
struct model *pmodel;
if (flag_find_C)
{
do_find_parameter_C(&prob);
}
else if (flag_cross_validation)
{
do_cross_validation(&prob);
}
else
{
pmodel = train(&prob, ¶m);
/*if (save_model(model_file_name, pmodel))
{
fprintf(stderr, "can't save model to file %s\n", model_file_name);
exit(1);
}
free_and_destroy_model(&pmodel);*/
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return pmodel;
}
// 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;
// fix random seed to have same results for each run
// (for cross validation)
srand(1);
// Transform the input Matrix to libsvm 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();
destroy_param(¶m);
fake_answer(plhs);
return;
}
if(mxIsSparse(prhs[1]))
err = read_problem_sparse(prhs[0], prhs[1]);
else
{
mexPrintf("Training_instance_matrix must be sparse\n");
destroy_param(¶m);
fake_answer(plhs);
return;
}
// train's original code
error_msg = check_parameter(&prob, ¶m);
if(err || error_msg)
{
if (error_msg != NULL)
mexPrintf("Error: %s\n", error_msg);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
fake_answer(plhs);
return;
}
if(cross_validation_flag)
{
double *ptr;
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ptr = mxGetPr(plhs[0]);
ptr[0] = do_cross_validation();
}
else
{
const char *error_msg;
model_ = train(&prob, ¶m);
error_msg = model_to_matlab_structure(plhs, model_);
if(error_msg)
mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg);
destroy_model(model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
}
else
{
exit_with_help();
fake_answer(plhs);
return;
}
}
// Train an SVM classifier for the current node given the current feature
// and evaluate the obtained classifier using information gain.
float TrainCurrentRegion(float ftrX, float ftrY, float ftrWid, float ftrHgt,
int &ftrDim, float *ftrWeight, vector<SINGLEIM> imVec, vector<int> trainClassID,
vector<int> trainID, vector<int> valClassID, vector<int> valID, PARAMETER param,
vector<int> &leftTrainID, vector<int> &rightTrainID, vector<int> &leftValID,
vector<int> &rightValID, vector<PMREGION> &pmRegions)
{
//clock_t t1, t2;
//t1 = clock();
struct feature_node *x_space;
struct parameter svm_param;
struct problem prob;
struct model* model_;
// setup the problem
pmRegions.clear();
GetPmRegionConfig(ftrX, ftrY, ftrWid, ftrHgt, pmRegions);
prob.l = trainID.size(); // number of training data for the current node
// number of features for each data, note the bg feature dim is added
int fgFtrDim = pmRegions.size() * param.siftCodebookSize;
prob.n = fgFtrDim+1;// + imVec[0].bgFtrDim;//changing so background features are not considered!!!!!!!!!!!!!!
prob.bias = 0.1;
prob.y = (int*)malloc(sizeof(int) * prob.l);
prob.x = (struct feature_node**)malloc(sizeof(struct feature_node*) * prob.l);
x_space = (struct feature_node*)malloc(sizeof(struct feature_node) * prob.l * prob.n);
// do the max-pooling and get the features for the images
float *tmpFeature = (float*)malloc(sizeof(float) * prob.n);
int x_count = 0;
for (int i = 0; i < prob.l; i++)
{
// max pooling to obtain foreground features
MaxPooling(imVec[trainID[i]], tmpFeature, pmRegions, param, "fg");
// pad the foreground feature with background information
//memcpy(tmpFeature + fgFtrDim, imVec[trainID[i]].bgHist,
// imVec[trainID[i]].bgFtrDim * sizeof(float));
*(tmpFeature + prob.n - 1) = 0.1f; // the bias term
prob.y[i] = trainClassID[i];
prob.x[i] = &x_space[x_count];
float *featurePTR = tmpFeature;
for (int j = 1; j <= prob.n; j++)
{
if (*featurePTR > 0)
{
x_space[x_count].index = j;
x_space[x_count].value = *featurePTR;
x_count++;
}
featurePTR++;
}
x_space[x_count].index = -1;
x_count++;
}
// setup the training parameters
svm_param.solver_type = L2R_L2LOSS_SVC_DUAL;
svm_param.C = 1;
if ((svm_param.solver_type == L2R_LR) || (svm_param.solver_type == L2R_L2LOSS_SVC))
svm_param.eps = 0.2;
else if ((svm_param.solver_type == L2R_L2LOSS_SVC_DUAL) || (svm_param.solver_type == MCSVM_CS)
|| (svm_param.solver_type == L2R_L1LOSS_SVC_DUAL) || (svm_param.solver_type == L2R_LR_DUAL))
svm_param.eps = 2.0;
else if ((svm_param.solver_type == L1R_L2LOSS_SVC) || (svm_param.solver_type == L1R_LR))
svm_param.eps = 0.2;
svm_param.nr_weight = 0;
svm_param.weight_label = NULL;
svm_param.weight = NULL;
//t2 = clock();
//mexPrintf(" Time before SVM: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC);
// train the model
//t1 = clock();
model_ = train(&prob, &svm_param);
//t2 = clock();
//mexPrintf(" Time for SVM: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC);
// copy the model to return values
//t1 = clock();
ftrDim = prob.n;
float *ftrWeightPTR = ftrWeight;
double *modelWeightPTR = model_->w;
for (int i = 0; i < prob.n; i++)
{
*ftrWeightPTR = *modelWeightPTR;
ftrWeightPTR++;
modelWeightPTR++;
}
float leftDist[2], rightDist[2];
memset(leftDist, 0, sizeof(float) * 2);
memset(rightDist, 0, sizeof(float) * 2);
EvalOnTrain(ftrWeight, prob, leftDist, rightDist, trainID, leftTrainID, rightTrainID);
// mexPrintf(" Left: %d, %d; Right: %d, %d. ", (int)(leftDist[0]),
// (int)(leftDist[1]), (int)(rightDist[0]), (int)(rightDist[1]));
EvalOnVal(ftrWeight, ftrDim, imVec, pmRegions, param, leftDist,
rightDist, valID, valClassID, leftValID, rightValID);
// mexPrintf("Left: %d, %d; Right: %d, %d.\n", (int)(leftDist[0]),
// (int)(leftDist[1]), (int)(rightDist[0]), (int)(rightDist[1]));
float infoGain = ComputeInfoGain(leftDist, rightDist);
// destroy and free the memory
free_and_destroy_model(&model_);
free(tmpFeature);
destroy_param(&svm_param);
free(prob.y);
free(prob.x);
free(x_space);
//t2 = clock();
//mexPrintf(" Time after SVM: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC);
//mexPrintf("End of TrainCurrentRegion.\n");
return infoGain;
}
cv::Mat_<double> cRegression::__train_regressor(const cv::Mat_<double>& label_vec, const cv::Mat_<int>& instance_mat)
{
void(*print_func)(const char*) = &print_null;
const char *error_msg;
struct parameter param;
struct problem problem;
struct feature_node *x_space = NULL;
srand(1);
// std::cout << "initialize liblinear parameter." << std::endl;
param.solver_type = L2R_L2LOSS_SVR_DUAL;
param.C = 1.0 / (double)label_vec.rows;
param.eps = 0.1;
param.p = 0;
param.nr_weight = 0;
param.weight_label = NULL;
param.weight = NULL;
// std::cout << "initialize liblinear parameter finished." << std::endl;
set_print_string_function(print_func);
std::vector<int>* prob_x = NULL;
prob_x = new std::vector<int>[label_vec.rows]; // number of samples = label_vec.rows
size_t nzcount = 0;
// std::cout << "copy feature." << std::endl;
for (int i = 0; i < instance_mat.rows; ++i) {
for (int j = 0; j < instance_mat.cols; ++j) {
int elem = instance_mat(i, j);
if (elem != 0) {
prob_x[i].push_back(j);
++nzcount;
}
}
}
// std::cout << "copy feature finished." << std::endl;
//sort the vector
for (int i = 0; i < label_vec.rows; i++){
std::sort(prob_x[i].begin(), prob_x[i].end());
}
problem.l = label_vec.rows;
problem.n = instance_mat.cols;
problem.bias = -1;
int elements = (int)(nzcount + problem.l);
problem.y = Malloc(double, problem.l);
problem.x = Malloc(struct feature_node *, problem.l);
x_space = Malloc(struct feature_node, elements);
int j = 0;
for (int i = 0; i < problem.l; i++){
problem.y[i] = label_vec(i, 0);
problem.x[i] = &x_space[j];
for (int k = 0; k < prob_x[i].size(); k++){
x_space[j].index = prob_x[i][k] + 1;
x_space[j].value = 1;
j++;
}
x_space[j++].index = -1;
}
delete[] prob_x;
error_msg = check_parameter(&problem, ¶m);
if (error_msg){
fprintf(stderr, "ERROR: %s\n", error_msg);
}
// std::cout << "train model." << std::endl;
struct model *model = NULL;
model = train(&problem, ¶m);
// std::cout << "train model finished." << std::endl;
cv::Mat_<double> weight = cv::Mat::zeros(model->nr_feature, 1, CV_64FC1);
for (int i = 0; i < model->nr_feature; i++){
weight(i, 0) = model->w[i];
// std::cout << weight(i, 0) << " "; // std::endl;
}
free_and_destroy_model(&model);
destroy_param(¶m);
free((void*)(problem.y));
free((void*)(problem.x));
free((void*)(x_space));
return weight;
}
//void copy_parameter(param_temp,¶m)
//{
// param_t
//}
// Interface function of matlab
// now assume prhs[0]: label prhs[1]: features
int main(int argc, char **argv)
{
const char *error_msg;
// fix random seed to have same results for each run
// (for cross validation)
srand(1);
char input_file_name[1024];
char model_file_name[1024];
char param_file_name[1024];
int n_flag = 0;
parse_command_line(argc, argv, input_file_name, model_file_name,n_flag,param_file_name);
char char_para;
int length_param = 0;
double *para_entry; //
//n_flag = 1;
//int para_B[20] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 12,14,16, 18, 20, 25, 30,35,40,45,50};
int para_B[40] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 24, 25, 26, 30,32, 35, 38, 40, 42, 45, 48, 50, 55, 60, 65,70,75,80, 85, 90, 95, 100, 105, 110, 115, 120};
//int para_B[32] = { 20, 24, 25, 26, 30,32, 35, 38, 40, 42, 45, 48, 50, 55, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280};
if (n_flag==1)
{
read_parameter(param_file_name, para_entry, char_para, length_param);
}
read_problem(input_file_name);
error_msg = check_parameter(&prob,¶m);
//parameter *param_temp = new parameter[1];
//copy_parameter(param_temp,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
exit(1);
}
if(cross_validation_flag)
{
do_cross_validation();
}
else
{
if(n_flag==0)
{
model_ = FGM_train(&prob, ¶m);
printf("training is done!\n");
save_model_poly(model_file_name, model_);
printf("model is saved!\n");
destroy_model(model_);
}
else
{
int i;
if (char_para=='C')
{
length_param = length_param;
}else
{
length_param = 40;
}
for (i=0;i<length_param;i++)
{
char param_char[1000];
char model_file[1024];
strcpy(model_file,model_file_name);
if (char_para=='C')
{
param.C = para_entry[i];
sprintf(param_char, "%.10lf ", para_entry[i]);
strcat(model_file,".c.");
strcat(model_file,param_char);
model_=FGM_train(&prob, ¶m);
}
else
{
int B = para_B[i];
param.B = B;
sprintf(param_char, "%d ", param.B);
printf("%d\n ", param.B);
strcat(model_file,".B.");
strcat(model_file,param_char);
model_=FGM_train(&prob, ¶m);
}
printf("training is done!\n");
save_model_poly(model_file, model_);
printf("model is saved!\n");
destroy_model(model_);
if(model_->feature_pair>600)
{
break;
}
}
}
}
if (n_flag==1)
{
delete []para_entry;
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
}
// Interface function of matlab
// now assume prhs[0]: label prhs[1]: features prhs[2]: source models
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
const char *error_msg;
// fix random seed to have same results for each run
// (for cross validation)
srand(1);
// Transform the input Matrix to libsvm format
if(nrhs > 1 && nrhs < 7)
{
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();
destroy_param(¶m);
fake_answer(plhs);
return;
}
//read in the source models
const mxArray *cellModels = prhs[2];
mwSize num_ms = mxGetNumberOfElements(cellModels);
param.num_src = (int) num_ms;
if(param.num_src > 0)
src_models = Malloc(struct model*, param.num_src);
for(int i=0; i< param.num_src; i++)
{
const mxArray *src_model_mat = mxGetCell(cellModels, i);
src_models[i] = Malloc(struct model, 1);
if((matlab_matrix_to_model(src_models[i], src_model_mat)) != NULL){
mexPrintf("can't load source model\n");
fake_answer(plhs);
return;
}
}
//read in the weight of the source models
if(!mxIsDouble(prhs[3])) {
mexPrintf("Error: weight vector must be double\n");
fake_answer(plhs);
return;
}
// weight of source models
if (param.num_src > 0)
{
int num_row_src_weight = (int) mxGetM(prhs[3]);
int num_col_src_weight = (int) mxGetN(prhs[3]);
int dim_src_weight = (int) max(num_row_src_weight, num_col_src_weight);
if(dim_src_weight != param.num_src) {
mexPrintf("Error: lenght of weight vector must be equal to the number of source models!");
fake_answer(plhs);
return;
}
double *src_model_weight = (double *)mxGetPr(prhs[3]);
param.src_weights = Malloc(double, param.num_src);
for(int i=0; i< param.num_src; i++)
param.src_weights[i] = src_model_weight[i];
}
int main(int argc, char **argv)
{
#ifdef GPU
int dev = findCudaDevice(argc, (const char **) argv);
if (dev == -1)
return 0;
if (cublasCreate(&handle) != CUBLAS_STATUS_SUCCESS)
{
fprintf(stdout, "CUBLAS initialization failed!\n");
cudaDeviceReset();
exit(EXIT_FAILURE);
}
#endif // GPU
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
time_t t1 = clock();
read_problem(input_file_name);
time_t t2 = clock();
printf("reading the input file took %f seconds.\n", float(t2-t1)/CLOCKS_PER_SEC);
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
if(flag_cross_validation)
{
do_cross_validation();
}
else
{
model_=train(&prob, ¶m);
if(save_model(model_file_name, model_))
{
fprintf(stderr,"can't save model to file %s\n",model_file_name);
exit(1);
}
free_and_destroy_model(&model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
#ifdef GPU
cublasDestroy(handle);
cudaDeviceReset();
#endif // GPU
printf("reading the input file took %f seconds.\n", float(t2-t1)/CLOCKS_PER_SEC);
return 0;
}
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);
}
//---------------------------- global variables -------------------------------
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
#ifdef FIGURE56
char test_file_name[1024];
parse_command_line(argc, argv, input_file_name, test_file_name);
#else
parse_command_line(argc, argv, input_file_name, model_file_name);//initialize global struct param, according to commond line
//_parse_command_line(argc, argv, input_file_name, model_file_name);//initialize global struct param, according to commond line
#endif
read_problem(input_file_name);//get all possible information about the train file into global struct prob
#ifdef FIGURE56
read_problem_test(test_file_name);
#endif
error_msg = check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
// struct model
//{
// struct parameter param;
// int nr_class; /* number of classes */
// int nr_feature;
// double *w;
// int *label; /* label of each class */
//};
// model_=train(&prob, ¶m);
//--------apply memory for V matrix--------------
int i=0;
double * p = Malloc(double,param.col_size * prob.l);
//srand( (unsigned)time( NULL ) ); //种子函数
for (i=0;i<param.col_size * prob.l;i++)
{
p[i]=rand()/(RAND_MAX+1.0); //产生随机数的函数
//p[i]=rand();
}
double ** v_pp = Malloc(double* ,prob.l);
param.v_pp = v_pp;
for (i=0;i<prob.l;i++)
param.v_pp[i] = &p[param.col_size * i];
model_=_train(&prob, ¶m);
#ifdef FIGURE56
#else
if(save_model(model_file_name, model_))
{
fprintf(stderr,"can't save model to file %s\n",model_file_name);
exit(1);
}
#endif
free_and_destroy_model(&model_);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(prob.query);
free(x_space);
////////free the variable
free(v_pp);
free(p);
#ifdef FIGURE56
free(probtest.y);
free(probtest.x);
free(x_spacetest);
#endif
free(line);
return 0;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
const char *error_msg;
srand(1);
if(nrhs == 7) /* force alphas_in and w_in to be initialized */
{
int err=0;
if(!mxIsClass(prhs[0], "single") || !mxIsClass(prhs[1], "single") || !mxIsClass(prhs[4], "single") || !mxIsClass(prhs[4], "single") || !mxIsClass(prhs[6], "single")) {
mexPrintf("Error: label vector, instance matrix and alphas_in must be float\n");
fake_answer(plhs);
return;
}
if(parse_command_line(nrhs, prhs, NULL))
{
exit_with_help();
destroy_param(¶m);
fake_answer(plhs);
return;
}
#ifdef _DENSE_REP
if(!mxIsSparse(prhs[1]))
err = read_problem_sparse(prhs[0], prhs[1], prhs[4], prhs[5], prhs[6]);
else
{
mexPrintf("Training_instance_matrix must be dense\n");
destroy_param(¶m);
fake_answer(plhs);
return;
}
#else
if(mxIsSparse(prhs[1]))
err = read_problem_sparse(prhs[0], prhs[1], prhs[4]);
else
{
mexPrintf("Training_instance_matrix must be sparse\n");
destroy_param(¶m);
fake_answer(plhs);
return;
}
#endif
error_msg = check_parameter(&prob, ¶m);
if(err || error_msg)
{
if (error_msg != NULL)
mexPrintf("Error: %s\n", error_msg);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(prob.alphas_in);
free(prob.w_in);
/*free(x_space);*/
fake_answer(plhs);
return;
}
if(cross_validation_flag)
{
float *ptr;
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ptr = (float*) mxGetPr(plhs[0]);
ptr[0] = do_cross_validation();
}
else
{
const char *error_msg;
model_ = train(&prob, ¶m);
error_msg = model_to_matlab_structure(plhs, model_);
if(error_msg)
mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg);
destroy_model(model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(prob.alphas_in);
free(prob.w_in);
/*free(x_space);*/
}
else
{
exit_with_help();
fake_answer(plhs);
return;
}
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
/*
* Some bookkeeping variables for MPI. The 'rank' of a process is its numeric id
* in the process pool. For example, if we run a program via `mpirun -np 4 foo', then
* the process ranks are 0 through 3. Here, N and size are the total number of processes
* running (in this example, 4).
*/
start_t = time(NULL);
MPI_Init(&argc, &argv); // Initialize the MPI execution environment
MPI_Comm_rank(MPI_COMM_WORLD, ¶m.rank); // Determine current running process
MPI_Comm_size(MPI_COMM_WORLD, ¶m.size); // Total number of processes
//double N = (double) size; // Number of subsystems/slaves for ADMM
if (param.rank==param.root)
printf ("Number of subsystems: %d \n", param.size);
parse_command_line(argc, argv, input_file_name, model_file_name);
// Read the meta data
bprob.read_metadata(input_file_name);
bprob.set_bias(bias);
error_msg = block_check_parameter(&bprob,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
exit(1);
}
if (param.rank==param.root)
{
if (param.solver_type == L2R_L2LOSS_SVC)
printf("ADMM + Primal trust region Newton's method for L2 loss SVM:\n");
else if (param.solver_type == L2R_L2LOSS_SVC_DUAL)
printf("ADMM + Dual coordinate descent for L2 loss SVM: \n");
else if (param.solver_type == L2R_L1LOSS_SVC_DUAL)
printf("ADMM + Dual coordinate descent for L1 loss SVM:\n");
else
printf("Not supported. \n");
}
srand(1);
// Now read the local data
problem * prob = read_problem(&bprob, ¶m);
if(flag_cross_validation)
do_cross_validation(prob);
else
{
model_=block_train(prob, ¶m);
save_model(model_file_name, model_);
free_and_destroy_model(&model_);
}
destroy_param(¶m);
MPI_Finalize();
return 0;
}
// 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;
// fix random seed to have same results for each run
// (for cross validation)
srand(1);
// Transform the input Matrix to libsvm format
if(nrhs > 2 && nrhs <= 6)
{
int err=0;
if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1]) ) {
mexPrintf("Error: weight vector, label vector matrix must be double\n");
fake_answer(plhs);
return;
}
if(!mxIsSingle(prhs[2])) {
mexPrintf("Error: instance matrix must be single\n");
fake_answer(plhs);
return;
}
if(parse_command_line(nrhs, prhs, NULL))
{
exit_with_help();
destroy_param(¶m);
fake_answer(plhs);
return;
}
#ifdef _DENSE_REP
if(!mxIsSparse(prhs[2]))
err = read_problem_sparse(prhs[0], prhs[1],prhs[2]);
else
{
mexPrintf("Training_instance_matrix must be dense\n");
destroy_param(¶m);
fake_answer(plhs);
return;
}
#else
if(mxIsSparse(prhs[2]))
err = read_problem_sparse(prhs[0], prhs[1],prhs[2]);
else
{
mexPrintf("Training_instance_matrix must be sparse\n");
destroy_param(¶m);
fake_answer(plhs);
return;
}
#endif
// xren: delete the input instance matrix to free up space
if (nrhs==6) {
mxArray* var=(mxArray*)prhs[5];
int status=mexCallMATLAB(0,NULL,1, &var, "clear");
if (status!=0) mexPrintf("Failed to delete variable %s\n",mxArrayToString(prhs[5]));
//mxDestroyArray( (mxArray*)prhs[1] );
}
// train's original code
error_msg = check_parameter(&prob, ¶m);
if(err || error_msg)
{
if (error_msg != NULL)
mexPrintf("Error: %s\n", error_msg);
destroy_param(¶m);
free(prob.y);
free(prob.x);
if (!use_existing_space)
free(x_space);
fake_answer(plhs);
return;
}
if(cross_validation_flag)
{
double *ptr;
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ptr = mxGetPr(plhs[0]);
ptr[0] = do_cross_validation();
}
else
{
const char *error_msg;
model_ = train(&prob, ¶m);
error_msg = model_to_matlab_structure(plhs, model_);
if(error_msg)
mexPrintf("Error: can't convert libsvm model to matrix structure: %s\n", error_msg);
free_and_destroy_model(&model_);
}
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(prob.W);
if (!use_existing_space)
free(x_space);
}
else
{
exit_with_help();
fake_answer(plhs);
return;
}
}
