/** * Allows to set the call template, throws in case the * template parameters are not found! * @param call_templ the call template */ inline void set_call_template(string & call_templ) { //Store the template m_call_templ = call_templ; //Check the presence of the parameters check_parameter(WORK_DIR_TEMPL_PARAM_NAME); check_parameter(JOB_UID_TEMPL_PARAM_NAME); check_parameter(LANGUAGE_TEMPL_PARAM_NAME); }
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; }
void LVlinear_train(lvError *lvErr, const LVlinear_problem *prob_in, const LVlinear_parameter *param_in, LVlinear_model * model_out){ try{ // Input verification: Problem dimensions if ((*(prob_in->x))->dimSize != (*(prob_in->y))->dimSize) throw LVException(__FILE__, __LINE__, "The problem must have an equal number of labels and feature vectors (x and y)."); //-- Convert problem std::unique_ptr<problem> prob(new problem); uint32_t nr_nodes = (*(prob_in->y))->dimSize; prob->l = nr_nodes; prob->y = (*(prob_in->y))->elt; // Create and array of pointers (sparse datastructure) std::unique_ptr<feature_node*[]> x(new feature_node*[nr_nodes]); prob->x = x.get(); auto x_in = prob_in->x; for (unsigned int i = 0; i < (*x_in)->dimSize; i++){ // Assign the innermost svm_node array pointers to the array of pointers auto xi_in_Hdl = (*x_in)->elt[i]; x[i] = reinterpret_cast<feature_node*>((*xi_in_Hdl)->elt); } //-- Convert parameters std::unique_ptr<parameter> param(new parameter()); LVConvertParameter(param_in, param.get()); // Verify parameters const char * param_check = check_parameter(prob.get(), param.get()); if (param_check != nullptr) throw LVException(__FILE__, __LINE__, "Parameter check failed with the following error: " + std::string(param_check)); // Train model model *result = train(prob.get(), param.get()); // Copy model to LabVIEW memory LVConvertModel(result, model_out); // Release memory allocated by train free_model_content(result); } catch (LVException &ex) { ex.returnError(lvErr); // To avoid LabVIEW reading and utilizing bad memory, the dimension sizes of arrays is set to zero (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 0; } catch (std::exception &ex) { LVException::returnStdException(lvErr, __FILE__, __LINE__, ex); (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 0; } catch (...) { LVException ex(__FILE__, __LINE__, "Unknown exception has occurred"); ex.returnError(lvErr); (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 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_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; }
void rt_task4_thread_entry(void* parameter) { extern void start_transmit(void); extern void stop_transmit(void); extern uint8_t check_parameter(void); // extern uint8_t self_check(void); // extern void cpu_usage_init(); rt_uint32_t ev; if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0)) { coil.usRegCoilBuf |= M(0); } else { coil.usRegCoilBuf &= ~M(0); } rt_event_init(&key_event, "key_event", RT_IPC_FLAG_FIFO ); while(1) { if( rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &ev ) == RT_EOK ) { rt_thread_delay(6); if( (ev & FOOT_PUPD) && (coil.usRegCoilBuf & M(0)) &&(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)&& \ (check_parameter()) && (coil.usRegCoilBuf & M(7))) { start_transmit(); } else { stop_transmit(); } if(ev & KEY_PUPD) { if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0)) { coil.usRegCoilBuf |= M(0); } else { coil.usRegCoilBuf &= ~M(0); } } } rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 2, &ev ); rt_thread_delay(20); } }
void LVlinear_cross_validation(lvError *lvErr, const LVlinear_problem *prob_in, const LVlinear_parameter *param_in, const int32_t nr_fold, LVArray_Hdl<double> target_out){ try{ // Input verification: Problem dimensions if ((*(prob_in->x))->dimSize != (*(prob_in->y))->dimSize) throw LVException(__FILE__, __LINE__, "The problem must have an equal number of labels and feature vectors (x and y)."); // Convert LVsvm_problem to svm_problem std::unique_ptr<problem> prob(new problem); uint32_t nr_nodes = (*(prob_in->y))->dimSize; prob->l = nr_nodes; prob->y = (*(prob_in->y))->elt; // Create and array of pointers (sparse datastructure) std::unique_ptr<feature_node*[]> x(new feature_node*[nr_nodes]); prob->x = x.get(); auto x_in = prob_in->x; for (unsigned int i = 0; i < (*x_in)->dimSize; i++){ // Assign the innermost svm_node array pointers to the array of pointers auto xi_in_Hdl = (*x_in)->elt[i]; x[i] = reinterpret_cast<feature_node*>((*xi_in_Hdl)->elt); } // Assign parameters to svm_parameter std::unique_ptr<parameter> param(new parameter()); LVConvertParameter(param_in, param.get()); // Verify parameters const char * param_check = check_parameter(prob.get(), param.get()); if (param_check != nullptr) throw LVException(__FILE__, __LINE__, "Parameter check failed with the following error: " + std::string(param_check)); // Allocate room in target_out LVResizeNumericArrayHandle(target_out, nr_nodes); // Run cross validation cross_validation(prob.get(), param.get(), nr_fold, (*target_out)->elt); (*target_out)->dimSize = nr_nodes; } catch (LVException &ex) { ex.returnError(lvErr); (*target_out)->dimSize = 0; } catch (std::exception &ex) { LVException::returnStdException(lvErr, __FILE__, __LINE__, ex); (*target_out)->dimSize = 0; } catch (...) { LVException ex(__FILE__, __LINE__, "Unknown exception has occurred"); ex.returnError(lvErr); (*target_out)->dimSize = 0; } }
void LibLinearWrapper::trainModel(Mat labels, Mat trainingData, vector<float>& weight) { CV_Assert(labels.rows == trainingData.rows); m_prob.l = labels.rows; m_prob.n = trainingData.cols; auto num_samples = trainingData.total(); auto elements = num_samples + m_prob.l * 2; vector<double> y(m_prob.l); vector<struct feature_node*> x(m_prob.l); vector<struct feature_node> x_spaceVec (elements); m_prob.y = y.data(); m_prob.x = x.data(); auto x_space = x_spaceVec.data(); m_prob.bias = -1; int j = 0; for (int i = 0; i<m_prob.l; ++i) { m_prob.x[i] = &x_space[j]; m_prob.y[i] = labels.at<float>(i); auto row_ptr = trainingData.ptr<float>(i); for (int k = 0; k < trainingData.cols; ++k) { if (row_ptr[k]) { x_space[j].index = k + 1; x_space[j].value = row_ptr[k]; ++j; } } x_space[j++].index = -1; } auto error_msg = check_parameter(&m_prob, &m_param); if (error_msg) { std::clog << "Error: " << error_msg << std::endl; return; } struct model *model_ = train(&m_prob, &m_param); double norm = std::inner_product(model_->w, model_->w + model_->nr_feature, model_->w, 0.0); norm = sqrt(norm); weight.resize(model_->nr_feature); transform(model_->w, model_->w + model_->nr_feature, weight.begin(), [norm](double val) { return val / norm; }); }
int count_lines_parameters(FILE *fp) { int n_lines = 0; char * line = NULL; size_t n = 0; int r; while(!feof(fp)) { r = getline(&line, &n, fp); if(r > 0 && !check_parameter(line)) n_lines++; } SID_free(SID_FARG line); rewind(fp); return (n_lines); }
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 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[]) { int fd = 0; int ret = 0; struct aiocb my_aiocb = {0}; check_parameter(argc); fd = open(argv[argc-1], O_RDONLY); if (fd < 0) { fprintf(stderr, "open failure\n"); return EXIT_FAILURE; } my_aiocb.aio_buf = malloc(BUFSIZ+1); my_aiocb.aio_fildes = fd; my_aiocb.aio_nbytes = BUFSIZ; my_aiocb.aio_offset = 0; ret = aio_read(&my_aiocb); if (ret < 0) { fprintf(stderr, "aio_read failure\n"); return EXIT_FAILURE; } while (aio_error(&my_aiocb) == EINPROGRESS); if ((ret = aio_return(&my_aiocb)) > 0) { printf("%s", my_aiocb.aio_buf); } else { fprintf(stderr, "aio_return failure\n"); } return EXIT_SUCCESS; }
//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 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; } }
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; }
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; }
bool lt(ast * n1, ast * n2) { unsigned num; start: if (n1 == n2) return false; check_value(n1->get_kind(), n2->get_kind()); switch(n1->get_kind()) { case AST_SORT: check_symbol(to_sort(n1)->get_name(), to_sort(n2)->get_name()); check_value(to_sort(n1)->get_num_parameters(), to_sort(n2)->get_num_parameters()); num = to_sort(n1)->get_num_parameters(); SASSERT(num > 0); for (unsigned i = 0; i < num; i++) { parameter p1 = to_sort(n1)->get_parameter(i); parameter p2 = to_sort(n2)->get_parameter(i); check_parameter(p1, p2); } UNREACHABLE(); return false; case AST_FUNC_DECL: check_symbol(to_func_decl(n1)->get_name(), to_func_decl(n2)->get_name()); check_value(to_func_decl(n1)->get_arity(), to_func_decl(n2)->get_arity()); check_value(to_func_decl(n1)->get_num_parameters(), to_func_decl(n2)->get_num_parameters()); num = to_func_decl(n1)->get_num_parameters(); for (unsigned i = 0; i < num; i++) { parameter p1 = to_func_decl(n1)->get_parameter(i); parameter p2 = to_func_decl(n2)->get_parameter(i); check_parameter(p1, p2); } num = to_func_decl(n1)->get_arity(); for (unsigned i = 0; i < num; i++) { ast * d1 = to_func_decl(n1)->get_domain(i); ast * d2 = to_func_decl(n2)->get_domain(i); check_ast(d1, d2); } n1 = to_func_decl(n1)->get_range(); n2 = to_func_decl(n2)->get_range(); goto start; case AST_APP: check_value(to_app(n1)->get_num_args(), to_app(n2)->get_num_args()); check_value(to_app(n1)->get_depth(), to_app(n2)->get_depth()); check_ast(to_app(n1)->get_decl(), to_app(n2)->get_decl()); num = to_app(n1)->get_num_args(); for (unsigned i = 0; i < num; i++) { expr * arg1 = to_app(n1)->get_arg(i); expr * arg2 = to_app(n2)->get_arg(i); check_ast(arg1, arg2); } UNREACHABLE(); return false; case AST_QUANTIFIER: check_bool(to_quantifier(n1)->is_forall(), to_quantifier(n2)->is_forall()); check_value(to_quantifier(n1)->get_num_decls(), to_quantifier(n2)->get_num_decls()); check_value(to_quantifier(n1)->get_num_patterns(), to_quantifier(n2)->get_num_patterns()); check_value(to_quantifier(n1)->get_num_no_patterns(), to_quantifier(n2)->get_num_no_patterns()); check_value(to_quantifier(n1)->get_weight(), to_quantifier(n2)->get_weight()); num = to_quantifier(n1)->get_num_decls(); for (unsigned i = 0; i < num; i++) { check_symbol(to_quantifier(n1)->get_decl_name(i), to_quantifier(n2)->get_decl_name(i)); check_ast(to_quantifier(n1)->get_decl_sort(i), to_quantifier(n2)->get_decl_sort(i)); } num = to_quantifier(n1)->get_num_patterns(); for (unsigned i = 0; i < num; i++) { check_ast(to_quantifier(n1)->get_pattern(i), to_quantifier(n2)->get_pattern(i)); } num = to_quantifier(n1)->get_num_no_patterns(); for (unsigned i = 0; i < num; i++) { check_ast(to_quantifier(n1)->get_no_pattern(i), to_quantifier(n2)->get_no_pattern(i)); } n1 = to_quantifier(n1)->get_expr(); n2 = to_quantifier(n2)->get_expr(); goto start; case AST_VAR: check_value(to_var(n1)->get_idx(), to_var(n2)->get_idx()); n1 = to_var(n1)->get_sort(); n2 = to_var(n2)->get_sort(); goto start; default: UNREACHABLE(); return false; } }
bool QPredictLinearLearner::train(QPredictDocumentList &doc_list) { uint32_t cnt; struct problem prob; struct feature_node *x_space; int32_t max_index; size_t num_space; const char * error_msg; int i, j; cnt = 1; prob.l = doc_list.size(); prob.y = new int[prob.l]; memset(prob.y, 0, sizeof(int) * prob.l); prob.x = new struct feature_node *[prob.l]; memset(prob.x, 0, sizeof(struct feature_node *) * prob.l); prob.bias = m_bias; num_space = 0; QPredictDocumentListIter end_doc_it = doc_list.end(); for (QPredictDocumentListIter doc_it = doc_list.begin(); doc_it != end_doc_it; ++doc_it) { num_space += doc_it->feature_list.size() + 1; } x_space = new struct feature_node[num_space + prob.l]; memset(x_space, 0, sizeof(struct feature_node) * (num_space + prob.l)); max_index = 0; for (i = 0, j = 0; i < prob.l; i++) { std::vector<uint32_t>::iterator termIt; prob.x[i] = &x_space[j]; prob.y[i] = doc_list[i].class_index; QPredictFeatureList &feature_list = doc_list[i].feature_list; // sort feature sort(feature_list.begin(), feature_list.end(), QPredictFeature::feature_compare); const QPredictFeatureListIter &feature_end_it = feature_list.end(); for (QPredictFeatureListIter feature_it = feature_list.begin(); feature_it != feature_end_it; ++feature_it) { x_space[j].index = feature_it->id; x_space[j].value = feature_it->value; ++j; } if (j >= 1 && x_space[j - 1].index > max_index) max_index = x_space[j - 1].index; if(prob.bias >= 0) x_space[j++].value = prob.bias; x_space[j++].index = -1; cnt++; } if(prob.bias >= 0) { prob.n = max_index + 1; for(i = 1;i < prob.l; i++) (prob.x[i]-2)->index = prob.n; x_space[j-2].index = prob.n; } else { prob.n = max_index; } if ((error_msg = check_parameter(&prob, &m_param))) { // std::cerr << "error " << error_msg << std::endl; } m_model = ::train(&prob, &m_param); /*/ cross validation int total_correct = 0; int *target = (int*) malloc(sizeof(int) * prob.l); cross_validation(&prob,&m_param,10,target); for(int i=0;i<prob.l;i++) if(target[i] == prob.y[i]) ++total_correct; fprintf(stderr, "Cross Validation Accuracy = %g%%\n",100.0*total_correct/prob.l); free(target); */ //destroy_param(&m_param); delete []prob.y; delete []prob.x; delete []x_space; return true; }
// 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; } }
int grab_next_line_parameter(FILE *fp, char **line, size_t *n) { int rval = grab_next_line(fp, line, n); while(!feof(fp) && !check_parameter(*line)) rval = grab_next_line(fp, line, n); return (rval); }
/* ------------------------------------------------------------- * MAIN: * Check all parameters passed on the command line, calculate * the date to be displayed, and display it. * ------------------------------------------------------------- */ int main( int argc, char **argv, char **envp ) { struct tm *time_var; time_t time_number; signed long time_offset; char *ptr; int i, date_override; char saved_command[MAX_PARM_LEN+1]; char saved_format[MAX_MASK_LEN+1]; char saved_startdate_override[13]; /* YYYYMMDDHHMM_ */ /* * Check to see what command line parameters we have */ if (argc < 2) { printf( "%s: (c)Mark Dickinson, 2001\n", argv[0] ); show_syntax(); exit( 1 ); } time_offset = 0; /* default, and start point for adjustments */ date_override = 0; /* use current system date and time */ strcpy(saved_format,"YYYYMMDD"); /* default */ i = 1; /* use a while loop instead of a for loop as we may * increment the counter ourselves */ while ( i < argc ) { ptr = argv[i]; i++; if (i >= argc) { printf( "Missing value for %s\n", ptr ); exit( 1 ); } strncpy( saved_command, ptr, MAX_PARM_LEN ); ptr = argv[i]; if (strncmp("-format",saved_command,7) == 0) { validate_format( ptr, saved_format ); } else if (strncmp("-workingdate",saved_command,12) == 0) { date_override = 1; strncpy( saved_startdate_override, ptr, 12 ); /* YYYYMMDDHHMM */ } else { time_offset = time_offset + check_parameter( saved_command, ptr ); } i++; } /* * Work out the new time and print the result. */ if (date_override == 1) { /* have to get the dst flag setting for this */ time_number = time(0); time_var = localtime( &time_number ); /* then workout the callers passed time */ time_number = make_time( (char *)&saved_startdate_override, time_var->tm_isdst ); } else { time_number = time(0); /* time now in seconds from 00:00, Jan 1 1970 */ } time_number = time_number + time_offset; if (strcmp("CTIME",saved_format) == 0) { printf( "%s", ctime( &time_number ) ); } else { time_var = localtime( &time_number ); print_time( time_var, saved_format ); } exit( 0 ); } /* end main */
//---------------------------- 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 LVlinear_train(lvError *lvErr, const LVlinear_problem *prob_in, const LVlinear_parameter *param_in, LVlinear_model * model_out){ try{ // Input verification: Nonempty problem if (prob_in->x == nullptr || (*(prob_in->x))->dimSize == 0) throw LVException(__FILE__, __LINE__, "Empty problem passed to liblinear_train."); // Input verification: Problem dimensions if ((*(prob_in->x))->dimSize != (*(prob_in->y))->dimSize) throw LVException(__FILE__, __LINE__, "The problem must have an equal number of labels and feature vectors (x and y)."); uint32_t nr_nodes = (*(prob_in->y))->dimSize; // Input validation: Number of feature vectors too large (exceeds max signed int) if(nr_nodes > INT_MAX) throw LVException(__FILE__, __LINE__, "Number of feature vectors too large (grater than " + std::to_string(INT_MAX) + ")"); //-- Convert problem auto prob = std::make_unique<problem>(); prob->l = nr_nodes; prob->y = (*(prob_in->y))->elt; prob->n = 0; // Calculated later prob->bias = prob_in->bias; // Create and array of pointers (sparse datastructure) auto x = std::make_unique<feature_node*[]>(nr_nodes); prob->x = x.get(); auto x_in = prob_in->x; for (unsigned int i = 0; i < (*x_in)->dimSize; i++){ // Assign the innermost svm_node array pointers to the array of pointers auto xi_in_Hdl = (*x_in)->elt[i]; x[i] = reinterpret_cast<feature_node*>((*xi_in_Hdl)->elt); // Input validation: Final index -1? if ((*xi_in_Hdl)->elt[(*xi_in_Hdl)->dimSize - 1].index != -1) throw LVException(__FILE__, __LINE__, "The index of the last element of each feature vector needs to be -1 (liblinear_train)."); // Calculate the max index // This detail is not exposed in LabVIEW, as setting the wrong value causes a crash // Second to last element should contain the max index for that feature vector (as they are in ascending order). auto secondToLast = (*xi_in_Hdl)->dimSize - 2; // Ignoring -1 index auto largestIndex = (*xi_in_Hdl)->elt[secondToLast].index; if (secondToLast >= 0 && largestIndex > prob->n) prob->n = largestIndex; } //-- Convert parameters auto param = std::make_unique<parameter>(); LVConvertParameter(*param_in, *param); // Verify parameters const char * param_check = check_parameter(prob.get(), param.get()); if (param_check != nullptr) throw LVException(__FILE__, __LINE__, "Parameter check failed with the following error: " + std::string(param_check)); // Train model model *result = train(prob.get(), param.get()); // Copy model to LabVIEW memory LVConvertModel(*result, *model_out); // Release memory allocated by train free_model_content(result); } catch (LVException &ex) { (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 0; (*(model_out->param).weight)->dimSize = 0; (*(model_out->param).weight_label)->dimSize = 0; ex.returnError(lvErr); } catch (std::exception &ex) { (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 0; (*(model_out->param).weight)->dimSize = 0; (*(model_out->param).weight_label)->dimSize = 0; LVException::returnStdException(lvErr, __FILE__, __LINE__, ex); } catch (...) { (*(model_out->label))->dimSize = 0; (*(model_out->w))->dimSize = 0; (*(model_out->param).weight)->dimSize = 0; (*(model_out->param).weight_label)->dimSize = 0; LVException ex(__FILE__, __LINE__, "Unknown exception has occurred"); ex.returnError(lvErr); } }
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; } }
void BoostCart::GlobalRegression(const vector<Mat_<int> >& lbf, const Mat_<double>& shape_residual) { Config& c = Config::GetInstance(); const int landmark_n = c.landmark_n; const int n = lbf.size(); const int m = K; // true size of local binary feature const int f = m*carts[0].leafNum; // full size of local binary feature vector<int> idx; // prepare linear regression X, Y struct feature_node** X = (struct feature_node**)malloc(n*sizeof(struct feature_node*)); double** Y = (double**)malloc(2 * landmark_n*sizeof(double*)); for (int i = 0; i < n; i++) { X[i] = (struct feature_node*)malloc((m + 1)*sizeof(struct feature_node)); for (int j = 0; j < m; j++) { X[i][j].index = lbf[i](0, j) + 1; // index starts from 1 X[i][j].value = 1.; } X[i][m].index = -1; X[i][m].value = -1.; } for (int i = 0; i < landmark_n; i++) { Y[2 * i] = (double*)malloc(n*sizeof(double)); Y[2 * i + 1] = (double*)malloc(n*sizeof(double)); for (int j = 0; j < n; j++) { Y[2 * i][j] = shape_residual(j, 2 * i); Y[2 * i + 1][j] = shape_residual(j, 2 * i + 1); } } // train every landmark struct problem prob; struct parameter param; prob.l = n; prob.n = f; prob.x = X; prob.bias = -1; param.solver_type = L2R_L2LOSS_SVR_DUAL; param.C = 1. / n; param.p = 0; param.eps = 0.0001; #pragma omp parallel for for (int i = 0; i < landmark_n; i++) { struct problem prob_ = prob; prob_.y = Y[2 * i]; check_parameter(&prob_, ¶m); struct model *model = train(&prob_, ¶m); for (int j = 0; j < f; j++) w(j, 2 * i) = get_decfun_coef(model, j + 1, 0); freeModel(model); prob_.y = Y[2 * i + 1]; check_parameter(&prob_, ¶m); model = train(&prob_, ¶m); for (int j = 0; j < f; j++) w(j, 2 * i + 1) = get_decfun_coef(model, j + 1, 0); freeModel(model); } // free for (int i = 0; i < n; i++) free(X[i]); for (int i = 0; i < 2 * landmark_n; i++) free(Y[i]); free(X); free(Y); }
int main(int argc, char *argv[]) { return check_parameter(NULL); }
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); }