int main ( int argc, char *argv[] )
{
//Variables for parsing the data file
	std::string filename = "SPECT.train";
	std::string line;
	std::stringstream parse;
	int ssize = 100; //establish a buffer size to store attribute values,
			 //which for binary classification string are no bigger than 1
	char c[ssize];
	char delimiter = ',';

	//Variables to store the values in the data file
	std::vector<int> tmpcase;
	std::vector< std::vector<int> > training_set;

	cv::Mat sample(0, 1, CV_32FC1);
	cv::Mat labels(0, 1 , CV_16SC1);
	cv::Mat train_set;

	std::ifstream dataset_file(filename.c_str(), std::ios::in);

	if(!dataset_file)
	{
		std::cerr << "Cannot load training set file" << std::endl;
	}
	else
	{
		while( (getline(dataset_file, line))!= NULL )
		{
			parse << line;

			while( parse.getline(c,ssize,delimiter) )
			{
				tmpcase.push_back( (*c-'0') );
				sample.push_back( (float)(*c-'0') );
			}

			parse.str(""); //safety measure to erase previous contents
			parse.clear(); //clear flags to be able to read from it again

			training_set.push_back(tmpcase);
			tmpcase.clear(); 

			train_set.push_back(sample.reshape(0,1));
			labels.push_back((int)(sample.at<float>(0)));
			sample = cv::Mat();
			
		}
	}

	std::cout << train_set << std::endl;
	cv::FileStorage fstore_traindata("spect_train.yml",cv::FileStorage::WRITE);
	cv::Mat train_samples(train_set.colRange(1,train_set.cols));
	fstore_traindata << "train_samples" << train_samples;
	fstore_traindata << "train_labels" << labels;
	fstore_traindata.release();
	std::cout << train_samples << std::endl;
	std::cout << labels << std::endl;

	std::vector<int> tmp;
	for(std::vector< std::vector<int> >::iterator it = training_set.begin(); it != training_set.end(); ++it)
	{
		tmp = *it;
		for(std::vector<int>::iterator it2 = tmp.begin(); it2 != tmp.end(); ++it2)
		{
			std::cout << *it2 << " ";
		}
		std::cout << std::endl;
		tmp.clear();
	}

}
Beispiel #2
0
int main(int argc, char* argv[]) {

  // Let us make libsvm quiet
  gaml::libsvm::quiet();
  // random seed initialization
  std::srand(std::time(0));

  try {

    // Let us collect samples.
    
    DataSet basis;

    basis.resize(100);
    for(auto& data : basis) {
      double theta = gaml::random::uniform(0,2*M_PI);
      data = Data(theta,oracle(theta));
    }

    // Let us set configure a svm

    struct svm_parameter params;
    gaml::libsvm::init(params);
    params.kernel_type = RBF;          // RBF kernel
    params.gamma       = 1;            // k(u,v) = exp(-gamma*(u-v)^2)
    params.svm_type    = EPSILON_SVR;
    params.p           = .01;          // epsilon
    params.C           = 10;
    params.eps         = 1e-10;        // numerical tolerence

    // This sets up a svm learning algorithm for predicting a scalar.
    auto scalar_learner = gaml::libsvm::supervized::learner<double,double>(params, nb_nodes_of, fill_nodes);

    // Let us use it for learning x, y and z.
    auto learner = gaml::multidim::learner<Point,3>(scalar_learner, array_of_output, output_of_array);

    // Let us train it and get some predictor f. f is a function, as the oracle.
    std::cout << "Learning..." << std::endl;
    auto f = learner(basis.begin(), basis.end(), input_of, output_of);

    // Let us retrieve the three SVMs in order to save each one.
    auto f_predictors                   = f.predictors();
    std::array<std::string,3> filenames = {{std::string("x.pred"),"y.pred","z.pred"}};
    auto name_iter                      = filenames.begin();
    for(auto& pred : f_predictors) pred.save_model(*(name_iter++));

    // We can compute the empirical risk with gaml tools.
    auto evaluator = gaml::risk::empirical(Loss());
    double risk = evaluator(f, basis.begin(), basis.end(), input_of, output_of);
    std::cout << "Empirical risk : " << risk << std::endl
	      << "    sqrt(risk) : " << sqrt(risk) << std::endl;

    // Let us load our predictor. We need first to gather each loaded
    // scalar predictor in a collection...
    std::list<gaml::libsvm::Predictor<double,double>> predictors;
    name_iter= filenames.begin();
    for(unsigned int dim = 0; dim < 3; ++dim) {
      gaml::libsvm::Predictor<double,double> predictor(nb_nodes_of, fill_nodes);
      predictor.load_model(*(name_iter++));
      predictors.push_back(predictor);
    }
    // ... and create the 3D predictor (variable g) from the
    // collection of scalar predictors.
    gaml::multidim::Predictor<Point,
			      gaml::libsvm::Predictor<double,double>,
			      3> g(output_of_array, predictors.begin(), predictors.end());

    // let us gnuplot what we have.

    std::ofstream dataset_file("dataset.data");
    for(auto& data : basis)
      dataset_file << data.first << ' '  << data.second.x << ' ' << data.second.y << ' ' << data.second.z << std::endl;
    dataset_file.close();

    std::ofstream prediction_file("prediction.data");
    for(double theta = 0; theta <= 2*M_PI; theta += .01) {
      Point p = g(theta);
      prediction_file << theta << ' ' << p.x   << ' ' << p.y   << ' ' << p.z   << std::endl;
    }
    prediction_file.close();

    std::ofstream gnuplot_file_3d("3D.plot"); 
    gnuplot_file_3d << "set ticslevel 0" << std::endl
		    << "set xlabel 'x(theta)'" << std::endl
		    << "set ylabel 'y(theta)'" << std::endl
		    << "set zlabel 'z(theta)' " << std::endl
		    << "splot 'dataset.data' using 2:3:4 with points notitle, "
		    << "'prediction.data' using 2:3:4 with lines notitle" << std::endl;
    gnuplot_file_3d.close();
    std::cout << std::endl
	      << "Try 'gnuplot -p 3D.plot'" << std::endl;

    std::ofstream gnuplot_file_1d("1D-x.plot"); 
    gnuplot_file_1d << "set xlabel 'theta'" << std::endl
		    << "set ylabel 'x(theta)'" << std::endl
		    << "plot 'dataset.data' using 1:2 with points notitle, "
		    << "'prediction.data' using 1:2 with lines notitle" << std::endl;
    gnuplot_file_1d.close();
    std::cout << "Try 'gnuplot -p 1D-x.plot'" << std::endl
	      << std::endl;
  }
  catch(gaml::exception::Any& e) {
    std::cout << e.what() << std::endl;
  }
  
  return 0;
}