bool SVMPredict::load_svm_model(std::string& path){ this->model = svm_load_model(path.c_str()); //this->print_model(); //this->x = (struct svm_node *) malloc(max_nr_attr*sizeof(struct svm_node)); return (this->model == nullptr)? false :true; }
int pecker_svm_load_model(svm_model_s *svm_m, char *path, char *normal_para_path, uint32_t input_num, void (*generate_feat_vector)(void *, size_t, struct svm_node *, uint32_t)) { int ret = PECKER_MCLA_OK; if(NULL == svm_m || generate_feat_vector == NULL) return PECKER_MCLA_NULL_POINTER; pecker_svm_free_model(svm_m); svm_m->svm = svm_load_model(path); if(svm_m->svm == NULL) return PECKER_MCLA_SVM_LOAD_MODEL_FAIL; svm_m->generate_feat_vector = generate_feat_vector; svm_m->input_num = input_num; if(normal_para_path) { svm_m->normalized = 1; ret = svm_load_normalize_para(svm_m, normal_para_path); if(ret != PECKER_MCLA_OK) { pecker_svm_free_model(svm_m); } } return ret; }
void svm_train_and_test(const std::vector<feature_t> &feats, const std::vector<int> &labels, const char * model_file, std::ofstream &ofs) { svm_model * model; if(_access(model_file, 0) == -1) { auto param = svm_fill_parameter(); auto prob = svm_fill_problem(feats, labels); model = svm_train(prob, param); svm_save_model(model_file, model); auto acc = svm_test_acc(prob, model); svm_destroy_param(param); svm_free_problem(prob); std::cout<<model_file<<" acc: "<<acc*100<<std::endl; ofs<<model_file<<" acc: "<<acc*100<<std::endl; } else { model = svm_load_model(model_file); auto acc = svm_test_acc(feats, labels, model); std::cout<<model_file<<" acc: "<<acc*100<<std::endl; ofs<<model_file<<" acc: "<<acc*100<<std::endl; } //free svm_free_and_destroy_model(&model); }
int main(int argc, char **argv) { FILE *input; int rank; int nproc; int size; double *res, *conclusion; double time; input = fopen(argv[1],"r"); if(input == NULL) { fprintf(stderr,"can't open input file %s\n",argv[1]); exit(1); } if((model=svm_load_model(argv[2]))==0) { fprintf(stderr,"can't open model file %s\n",argv[2]); exit(1); } x = (struct svm_node *) malloc(max_nr_attr*sizeof(struct svm_node)); res = predict(input, size); evaluate(res, size); svm_free_and_destroy_model(&model); free(x); free(line); fclose(input); return 0; }
int svmpredict(double **values, int **indices, int rowNum, int *colNum, int isProb, const char *modelFile, int *labels, double **prob_estimates) { if((model=svm_load_model(modelFile))==0) { LOGD("can't open model file %s\n",modelFile); exit(1); } x = (struct svm_node *) malloc(max_nr_attr*sizeof(struct svm_node)); if(isProb) { if(svm_check_probability_model(model)==0) { LOGD("Model does not support probability estimates\n"); exit(1); } } else { if(svm_check_probability_model(model)!=0) LOGD("Model supports probability estimates, but disabled in prediction.\n"); } int r = predict(values, indices, rowNum, colNum, labels, prob_estimates, isProb); //LOGD("in svmpredict %.2f", prob_estimates[0]); svm_free_and_destroy_model(&model); free(x); free(line); return r; }
/** * @brief Constructor of SVMPredictorSingle */ SVMPredictorSingle::SVMPredictorSingle(std::string path, std::string filename) { if(path.size() == 0) path = SVM_MODEL; filename = path + filename; max_nr_attr = 64; predict_probability = true; if((model = svm_load_model(filename.c_str())) == 0) printf("[SVMPredictorSingle::SVMPredictorSingle] Error: Can't open model file: %s\n", filename.c_str()); #ifdef DEBUG else printf("[SVMPredictorSingle] Open model file: %s\n", filename.c_str()); #endif // allocate memory for model (and nodes) node = (struct svm_node *) malloc(max_nr_attr*sizeof(struct svm_node)); if(predict_probability) { if(svm_check_probability_model(model) == 0) { printf("[SVMPredictorSingle::SVMPredictorSingle] Error: Model does not support probability estimates.\n"); return; } } else { if(svm_check_probability_model(model) == 0) printf("[SVMPredictorSingle::SVMPredictorSingle] Warning: Model supports probability estimates, but disabled in prediction."); } }
bool One_Class_SVM::load_model( const char * file_name ){ struct svm_model * temp_model = svm_load_model( file_name ); // If load_model fails, this temp_model will be a null pointer. // If it succeeds and the resulting model's svm_type is not ONE_CLASS, // it can't be used as a model for one_class_svm (for obvious reasons) // and we should consider it a failure. if ( temp_model == NULL ) { return false; } else if ( temp_model->param.svm_type != ONE_CLASS ) { // Memory was allocated as a result of the successful load_model function, // but the svm type is incompatible. The pointer must be freed before // the function returns false. free ( temp_model ); return false; } // If the method hasn't returned false yet, temp_model is both non-NULL and // has svm_type ONE_CLASS. Set _model to temp_model, set trained to true, // and return trained. _model = temp_model; trained = true; _training_samples = _model->l; set_parameters( &(_model->param) ); return trained; }
void* jpcnn_load_predictor(const char* filename) { struct svm_model* model = svm_load_model(filename); SPredictorInfo* result = (SPredictorInfo*)(malloc(sizeof(SPredictorInfo))); result->model = model; result->problem = NULL; return result; }
static VALUE cModel_class_load(VALUE cls, VALUE filename) { struct svm_model *model; char *path; path = StringValueCStr(filename); model = svm_load_model(path); return Data_Wrap_Struct(cModel, 0, model_free, model); }
SVM( const std::string& libsvm_model_file, const std::string& libsvm_scale_file ): libsvm_model_file_(libsvm_scale_file), scale_info_(libsvm_scale_file) { if( (libsvm_model_ = svm_load_model( libsvm_model_file.c_str() ) ) == 0 ) { PRINT_ERROR( "Could not load LIBSVM model from " + libsvm_model_file ); abort(); } }
void ImgProcessing::init(string path) { if (model == 0) { cout << "load model" << endl; model = svm_load_model(path.c_str()); } else { cout << "Error while loading model, abort process" << endl; exit(-1); } }
struct svm_model *Clasificador::crea_svm(const char *f_svm, const char *f_med_desv, float *media, float *desv) { svm_model *svm; svm = svm_load_model(f_svm); le_media_desv(f_med_desv, media, desv); return(svm); }
gcm::gcm(void) { //Initial feature_ori = new double *[maxFrameNum]; for (int i=0; i<maxFrameNum; i++) { feature_ori[i] = new double[featureDim]; } gcm_subspace = new double*[featureDim]; for (int i=0; i<featureDim; i++) { gcm_subspace[i] = new double[subspaceDim]; } myModel = svm_load_model("..\\model\\model_UI4_noHandSeg_noPSVM"); //SVM model myModel_candi = svm_load_model("..\\model\\model_UI4_noHandSeg_PSVM"); //SVM model subFeaAll_model = newMatrix(featureDim, NClass*subSpaceDim*NTrainSample); //Training Matrix fstream infile("..\\model\\subFeaAll_UI4_noHandSeg_noPSVM.dat",ios::in|ios::binary); for (int i=0; i<featureDim; i++) { for(int j=0;j<NClass*subSpaceDim*NTrainSample;j++) { infile.read((char*)&subFeaAll_model[i][j],sizeof(subFeaAll_model[i][j])); } } infile.close( ); x = new svm_node[NClass*NTrainSample+1+1]; //To release votewhj = new int[NClass*NTrainSample]; //To release nFrames = 0; nDimension = featureDim; prob_estimates = new double[NClass]; subFea1 = newMatrix(featureDim, subSpaceDim); imgShow = cvCreateImage(cvSize(640, 480), 8,3); handSegmentVideo.init(); }
int cLibsvmLiveSink::myFinaliseInstance() { int ap=0; int ret = cDataSink::myFinaliseInstance(); if (ret==0) return 0; // TODO: binary model files... // load model SMILE_MSG(2,"loading LibSVM model for instance '%s' ...",getInstName()); if((model=svm_load_model(modelfile))==0) { COMP_ERR("can't open libSVM model file '%s'",modelfile); } nClasses = svm_get_nr_class(model); svmType = svm_get_svm_type(model); if(predictProbability) { if ((svmType==NU_SVR) || (svmType==EPSILON_SVR)) { nClasses = 0; SMILE_MSG(2,"LibSVM prob. model (regression) for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g",svm_get_svr_probability(model)); } else { labels=(int *) malloc(nClasses*sizeof(int)); svm_get_labels(model,labels); SMILE_MSG(3,"LibSVM %i labels in model '%s':",nClasses,modelfile); int j; for(j=0;j<nClasses;j++) SMILE_MSG(3," Label[%i] : '%d'",j,labels[j]); } } //?? move this in front of above if() block ? if ((predictProbability)&&(nClasses>0)) probEstimates = (double *) malloc(nClasses*sizeof(double)); // load scale if((scale=svm_load_scale(scalefile))==0) { COMP_ERR("can't open libSVM scale file '%s'",scalefile); } // load selection loadSelection(fselection); //TODO: check compatibility of getLevelN() (possibly after selection), number of features in model, and scale if (nClasses>0) { // load class mapping loadClasses(classes); } else { if (classes != NULL) SMILE_IWRN(2,"not loading given class mapping file for regression SVR model (there are no classes...)!"); } return ret; }
bool CmySvmArth::LoadModel(const char* pPath) { if(pPath==NULL) return false; if((model=svm_load_model(pPath))==0) { fprintf(stderr,"can't open model file %s\n",pPath); return false; } return true; }
bool PredictModel::CPredictModel::load(const FilePath& path) { if (m_model) { release(); } m_model = svm_load_model(path.narrow().c_str()); return (m_model != nullptr); }
// [ref] ${LIBSVM_HOME}/svm-predict.c void predict_example() { const bool predict_probability = false; const std::string test_file_name("./data/machine_learning/svm/heart_scale"); const std::string output_file_name("./data/machine_learning/svm/heart_scale.output"); const std::string model_file_name("./data/machine_learning/svm/heart_scale.model"); FILE *input = fopen(test_file_name.c_str(), "r"); if(input == NULL) { std::cout << "can't open input file " << test_file_name << std::endl; return; } FILE *output = fopen(output_file_name.c_str(), "w"); if(output == NULL) { std::cout << "can't open output file " << output_file_name << std::endl; return; } struct svm_model *model = svm_load_model(model_file_name.c_str()); if (NULL == model) { std::cout << "can't open model file " << model_file_name << std::endl; return; } if (predict_probability) { if (svm_check_probability_model(model) == 0) { std::cout << "Model does not support probabiliy estimates" << std::endl; return; } } else { if (svm_check_probability_model(model) != 0) std::cout << "Model supports probability estimates, but disabled in prediction." << std::endl; } int max_nr_attr = 64; struct svm_node *x = (struct svm_node *)malloc(max_nr_attr * sizeof(struct svm_node)); local::predict(input, output, model, predict_probability, max_nr_attr, x); free(x); fclose(input); fclose(output); svm_free_and_destroy_model(&model); }
void InitUserFeelModel(){ /* std::ostringstream ss; ss<<"a.model"; std::string fileName = ss.str(); svm_model* svmmodel = svm_load_model(fileName.c_str()); svmModel = svmmodel; //*svmModel = svm_load_model(fileName.c_str()); */ std::string modelPath = "userFeel.model"; svmModel_userFeel = svm_load_model(modelPath.c_str()); }
double UseSVM_Linear_FastEvaluationStructure(const char* modelfile,const int m,Array2dC<double>& result) { svm_model* model = svm_load_model(modelfile); if(model==0) { std::cout<<"SVM model "<<modelfile<<" can not be loaded."<<std::endl; exit(-1); } double rho = UseSVM_Linear_FastEvaluationStructure(*model,m,result); svm_destroy_model(model); return rho; }
void LibsvmSvm::load(std::string file) { std::string zipfile; if(!Util::unzip(file, zipfile)) { printf("Zipped model file doesn't exist.\n"); throw -1; } _model = svm_load_model(zipfile.c_str()); if(!_model) { printf("SVM Model file doesn't exist.\n"); throw -1; } assert(_model != 0); //printf("Loaded %s\n", file.c_str()); }
void CSvmModel::Train( const string& strTrainData, const string& strValidData ) { Release(); for( int i=0; i<GetOutputs(); i++ ){ TransformToSvmData( strTrainData, GetInputs(), GetOutputs(), i, SVM_TRAIN_FILE ); string strModelFile = CreateUniqueModelName(); RunSvmTrain( SVM_TRAIN_FILE, /*parameters*/GetOptions(i), strModelFile ); m_vcModelFiles.push_back( strModelFile ); SVM_MODEL* model=svm_load_model( strModelFile.c_str() ); m_vcModels.push_back( model ); } }
JNIEXPORT jint JNICALL Java_LibSVMTest_modelInitialize (JNIEnv *env, jclass cls, jstring modelFiles) { const char *modelFile = env->GetStringUTFChars(modelFiles, NULL); if ((model_F = svm_load_model(modelFile)) == 0) { fprintf(stderr, "can't open model file %s\n", modelFile); return -1; } env->ReleaseStringUTFChars(modelFiles, modelFile); env->DeleteLocalRef(modelFiles); svm_type=svm_get_svm_type(model_F); nr_class=svm_get_nr_class(model_F); printf("SVM Model Loaded\n"); return 0; }
int main(int argc, char *argv[]) { if(argc<3||argc>4){ cerr<<"Usage: "<<argv[0]<<" xk|mail|freshman ImageFilePath "<<" [libsvm_model]"<<endl; cerr<<endl; cerr<<"Note that if the libsvm model file is not specified, program will use the default model of current working mode under svm model directory."<<endl; cerr<<endl; return 1; } // if (string(argv[1])!=s_arg_mode){ // cerr << "ERROR: Please select working mode with -m" << endl; // return 1; // } if (string(argv[1]) == s_xk){ trained_model = "model/xk.model"; }else if (string(argv[1])==s_mail){ trained_model = "model/mail.model"; }else if (string(argv[1]) == s_freshman){ trained_model = "model/freshman.model"; }else{ cerr << "ERROR: Unknown mode" << endl; return 1; } Mat src=imread(argv[2],CV_LOAD_IMAGE_UNCHANGED); if(src.empty()){ cerr<<"ERROR: Could not load source file: "<<argv[2]<<endl; return 1; } if (argc == 4) trained_model = argv[3]; svm_model* model=svm_load_model(trained_model.c_str()); if(model==0){ cerr<<"ERROR: Could not load libsvm model: "<<trained_model<<endl; return 1; } if (string(argv[1]) == s_xk){ SVMCapSolver_XK svmsolver(*model); cout << svmsolver.solve(src) << endl; }else if (string(argv[1]) == s_mail){ SVMCapSolver_MAIL svmsolver(*model); cout << svmsolver.solve(src) << endl; }if (string(argv[1]) == s_freshman){ SVMCapSolver_FRESHMAN svmsolver(*model); cout << svmsolver.solve(src) << endl; } return 0; }
double SVM::classify(struct svm_node *data, char* filename_model) { double predict_label; double *prob_estimates = NULL; int svm_type; int nr_class; // load feature file only once if(!this->_bFeatureFileLoaded) { if((this->_svmModel = svm_load_model(filename_model))==0) { printf("can't open model file %s\n",filename_model); return -99; } this->_bFeatureFileLoaded = true; } svm_type = svm_get_svm_type(this->_svmModel); nr_class = svm_get_nr_class(this->_svmModel); prob_estimates = (double *) malloc(nr_class*sizeof(double)); if (svm_type==C_SVC || svm_type==NU_SVC) { predict_label = svm_predict_probability(this->_svmModel,data,prob_estimates); // printf("%g",predict_label); //for(int k=0; k < nr_class; k++) //printf(" %g",prob_estimates[k]); //printf("\n"); } else { predict_label = svm_predict(this->_svmModel, data); printf("%g\n",predict_label); } free(data); free(prob_estimates); return predict_label; }
CateTeller::CateTeller() { // load Chinese word segment tools bool init_res = seg.init("dependency/jieba.dict.utf8"); // word vector data conn = NULL; if( SQLITE_OK != sqlite3_open("dependency/new_dictionary.sqlite", &conn) ) { printf("can't open the database."); exit(-1); } // svm model svmModel = svm_load_model("dependency/trainingSet.txt.model"); // filter filter = termFilter("dependency/symbelTerms.txt"); }
void classifyInput(FILE *f, char *modelfile) { struct svm_model *model; struct svm_node features[NOSAMPS+1]; int samp[NOSAMPS]; int rmin[NOSAMPS]; int rmax[NOSAMPS]; double *decVals; int x, noLabels, noDecVals; double r; char buff[1024]; strcpy(buff, modelfile); strcat(buff, ".range"); loadRangeFile(buff, rmin, rmax); strcpy(buff, modelfile); strcat(buff, ".model"); model=svm_load_model(buff); if (model==NULL) { printf("Couldn't load model!\n"); exit(0); } noLabels=svm_get_nr_class(model); noDecVals=noLabels*(noLabels-1)/2; decVals=malloc(sizeof(double)*noDecVals); while(1) { getSamples(f, samp); for (x=0; x<NOSAMPS; x++) { features[x].index=x; //rescale to [-1, 1] r=(samp[x]-rmin[x+1]); r=r/(rmax[x+1]-rmin[x+1]); r=(r*2)-1; features[x+1].value=r; // printf("%f ", features[x].value); } // printf("\n"); features[x].index=-1; r=svm_predict_values(model,features,decVals); printf("prediction value: %f\n", r); // for (x=0; x<noDecVals; x++) printf("%f ", decVals[x]); // printf("\n"); } }
double UseSVM_Histogram_FastEvaluationStructure(const char* modelfile,const int m,const int upper_bound,Array2dC<double>& eval,svm_model** pmodel,const bool normalize) // NOTE: If you want exactly the same result as libsvm (and usually better results) when -b 1 is used, set normalize to false // if probability prediction of LIBSVM is not used (-b 0, which is default), the value of normalize does not have any effect. // refer to hik-predict.cpp for example usage { svm_model* model = svm_load_model(modelfile); if(model==0) { std::cout<<"SVM model "<<modelfile<<" can not be loaded."<<std::endl; exit(-1); } double rho = UseSVM_Histogram_FastEvaluationStructure(*model,m,upper_bound,eval,normalize); if(pmodel==NULL) svm_destroy_model(model); else *pmodel = model; return rho; }
int main(){ auto test_data = read_data("1_3"); svm_model* model = svm_load_model("1_3_b_model"); int nr_class = svm_get_nr_class(model); for (auto svmData : test_data){ svm_node* nodes = AssignSVMNode(svmData); double* probEstimates = new double[nr_class]; svm_predict_probability(model, nodes, probEstimates); for (int i = 0; i < nr_class; ++i){ std::cout<<i<<":"<<probEstimates[i]<<" "; } std::cout<<std::endl; } getchar(); return 0; }
int main () { svm_load_model("tu/model_reduced.txt"); //print_model("model_get.txt"); // hexagon_sim_init_timer(); // hexagon_sim_start_timer(); Real32 result = predict_sample("tu/testcase_200.txt"); printf("%lf\n", result); // hexagon_sim_end_timer(); // hexagon_sim_show_timer(stdout); // printf("test scaling\n"); // Real32 xxx = 0.5; // Word16 a = round_real(xxx); // printf("%d\n", a); // printf("%f\n", min); // printf("%f\n", max); return 0; }
HandTranslating::HandTranslating(QObject *parent) : QThread(parent) { databaseFolderPath = "../Database/Main"; modelFile = "databaseMain.model"; string model_file_name = databaseFolderPath + "/" + modelFile; if((model=svm_load_model(model_file_name.c_str()))==0) { STOP = true; cout << "ko mo duoc model\n"; } else { svm_type = svm_get_svm_type(model); nr_class = svm_get_nr_class(model); labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model,labels); prob_estimates = (double *) malloc(nr_class * sizeof(double)); STOP = false; enableToTranslate = false; } }