Esempio n. 1
0
    void thundersvm_predict(int argc, char **argv){
        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, "../python/");
//        strcat(predict_file_path, "../python/");
//        strcat(output_file_path, "../python/");
        strcpy(model_file_path, parser.svmpredict_model_file_name.c_str());
        strcpy(predict_file_path, parser.svmpredict_input_file.c_str());
        strcpy(output_file_path, parser.svmpredict_output_file.c_str());
        DataSet predict_dataset;
        predict_dataset.load_from_file(predict_file_path);
        thundersvm_predict_sub(predict_dataset, parser, model_file_path, output_file_path);
    }
Esempio n. 2
0
    void thundersvm_train(int argc, char **argv) {
        CMDParser parser;
        parser.parse_command_line(argc, argv);
        /*
        parser.param_cmd.svm_type = SvmParam::NU_SVC;
        parser.param_cmd.kernel_type = SvmParam::RBF;
        parser.param_cmd.C = 100;
        parser.param_cmd.gamma = 0;
        parser.param_cmd.nu = 0.1; 
        parser.param_cmd.epsilon = 0.001;
        */
        DataSet train_dataset;
        char input_file_path[1024] = DATASET_DIR;
        char model_file_path[1024] = DATASET_DIR;
//        strcat(input_file_path, "../python/");
//        strcat(model_file_path, "../python/");
        strcpy(input_file_path, parser.svmtrain_input_file_name.c_str());
        strcpy(model_file_path, parser.model_file_name.c_str());
        train_dataset.load_from_file(input_file_path);
        thundersvm_train_sub(train_dataset, parser, model_file_path);
        return;
    }
    void thundersvm_train_matlab(int argc, char **argv) {
        CMDParser parser;
        parser.parse_command_line(argc, argv);
        /*
        parser.param_cmd.svm_type = SvmParam::NU_SVC;
        parser.param_cmd.kernel_type = SvmParam::RBF;
        parser.param_cmd.C = 100;
        parser.param_cmd.gamma = 0;
        parser.param_cmd.nu = 0.1; 
        parser.param_cmd.epsilon = 0.001;
        */

        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);
        strcat(model_file_path, parser.model_file_name);
        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();
        }
	/*
        //perform svm testing
        Metric *metric = nullptr;
        switch (parser.param_cmd.svm_type) {
            case SvmParam::C_SVC:
            case SvmParam::NU_SVC: {
                metric = new Accuracy();
                break;
            }
            case SvmParam::EPSILON_SVR:
            case SvmParam::NU_SVR: {
                metric = new MSE();
                break;
            }
            case SvmParam::ONE_CLASS: {
            }
        }
        if (metric) {
            LOG(INFO) << metric->name() << " = " << metric->score(predict_y, test_y); 
        }
	*/
        return;
    }
    void thundersvm_predict_matlab(int argc, char **argv){
        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);
        strcat(predict_file_path, parser.svmpredict_input_file);
        strcat(output_file_path, parser.svmpredict_output_file);
        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());
        }
    }