int main(int argc, char **argv)
{
int nMedoids = 2;
int nData = 10000;
int nDim = 8;
int *medoids = new int(nMedoids);
int *assignment = new int(nMedoids);
cv::Mat training_data(nData,nDim,CV_32F);
cv::randu(training_data,cv::Scalar(0),cv::Scalar(256));
cvflann::UniqueRandom random_indices(nData);
for(int i=0; i < nMedoids; i++)
{
// Do some checks later
//medoids[i] = rand() % nData; //random_indices.next();
medoids[i] = random_indices.next();
}
kmedoids_wrapper((float *)training_data.data, &medoids[0], &assignment[0], nData, nMedoids, nDim);
//PlotClusters(training_data, &medoids[0], &assignment[0], nData, nMedoids);
delete[] medoids;
delete[] assignment;
}
inline
void
cv_dist_vector_GrassBC::svm_train()
{
int n_actions = actions.n_rows;
int n_test = 150 - 1; //Problem with Run-Side_001_dim14
int n_dim = n_test -1;
int k = 0;
field <std::string> action_seq_names (150,3); ///From the dataset description (150)
for (int act=0; act<n_actions; ++act)
{
std::stringstream ss_folders;
ss_folders << path_dataset << actions (act) << "/list_folders.txt";
field <std::string> list_folders;
list_folders.load( ss_folders.str() );
int n_folders = list_folders.n_rows;
//cout << actions (act) << endl;
//list_folders.print();
for (int i=0; i< n_folders; ++i)
{
std::ostringstream ss_action;
ss_action << act;
action_seq_names(k,0) = actions(act); //Action
action_seq_names(k,1) = list_folders(i); //Video Sequence
action_seq_names(k,2) = ss_action.str();; //Action index
k++;
}
}
//****************************************
#pragma omp parallel for
for (int seq_ts=0; seq_ts<action_seq_names.n_rows; ++seq_ts)
{
//cout << seq_ts << endl;
std::string action_name_ts = action_seq_names(seq_ts,0);
std::string folder_n_ts = action_seq_names(seq_ts,1);
if (!(action_name_ts=="Run-Side" && folder_n_ts=="001"))
{
fmat training_data;
fvec lab;
training_data.zeros(n_dim,n_test);
lab.zeros(n_test);
int k = 0;
for (int seq_tr=0; seq_tr<action_seq_names.n_rows; ++seq_tr) //Problem with Run-Side_001_dim14
{
std::string action_name_tr = action_seq_names(seq_tr,0);
std::string folder_n_tr = action_seq_names(seq_tr,1);
int act_tr = atoi( action_seq_names(seq_tr,2).c_str() );
if (!(action_name_tr=="Run-Side" && folder_n_tr=="001"))
{
fvec dist_vector;
std::stringstream load_vec_dist;
load_vec_dist << "./GrassBC/dist_vector_" << action_name_tr << "_" << folder_n_tr << "_dim" << dim << "_p" << p << ".h5";
dist_vector.load( load_vec_dist.str() );
training_data.col(k) = dist_vector;
lab(k) = act_tr;
++k;
}
}
//Training the model with OpenCV
//#pragma omp critical
//cout << "Using SVM to train run " << seq_ts+1 << endl;
//cout << "Preparing data to train the data" << endl;
cv::Mat cvMatTraining(n_test, n_dim, CV_32FC1);
float fl_labels[n_test] ;
//cout << "Preparing data" << endl;
for (uword m=0; m<n_test; ++m)
{
for (uword d=0; d<n_dim; ++d)
{
cvMatTraining.at<float>(m,d) = training_data(d,m);
//cout << " OpenCV: " << cvMatTraining.at<float>(m,d) << " - Arma: " <<training_data(d,m);
}
fl_labels[m] = lab(m);
//cout <<" OpenCVLabel: " << fl_labels[m] << " ArmaLabel: " << labels(m) << endl;
}
cv::Mat cvMatLabels(n_test, 1, CV_32FC1,fl_labels );
//cout << "Setting parameters" << endl;
CvSVMParams params;
params.svm_type = CvSVM::C_SVC;
params.kernel_type = CvSVM::LINEAR;
//params.gamma = 1;
params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, (int)1e7, 1e-6);
//params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
// Train the SVM
//cout << "...Training" << endl;
CvSVM SVM;
SVM.train( cvMatTraining , cvMatLabels, cv::Mat(), cv::Mat(), params);
#pragma omp critical
{
std::stringstream save_svm_model;
save_svm_model << "./svm_models/GrassBC_run_" << seq_ts+1;
//cout << "Saving" << endl;
SVM.save( save_svm_model.str().c_str() );
}
}
}
}
//Main function
int main ( int argc, char *argv[] )
{
//--- VARIABLES ---//
//saving database descriptors
cv::Mat training_descriptors;
//for measuring processing time
clock_t t;
// --- ---//
std::cout << std::endl;
std::cout << "+++ BOW FOR DATA SET +++" << std::endl;
std::cout << TRAIN_PATH << std::endl;
//--- DESCRIPTORS EXTRACTION ---//
std::string train_path = TRAIN_PATH;
//read descriptors from file
std::cout << "*** TRAIN DESCRIPTORS INFO ***" << std::endl;
cv::FileStorage fstore_descrip(DESCRIP_MAT_NAME, cv::FileStorage::READ);
std::cout << "No Documents: " << (int)fstore_descrip["noDocuments"] << std::endl;
std::cout << "No Classes: " << (int)fstore_descrip["noClasses"] << std::endl;
std::cout << "No total descriptors: " << (int)fstore_descrip["totalDescriptors"] << std::endl;
std::cout << "No max desrcriptors in an image: " << (int)fstore_descrip["maxDescriptors"] << std::endl;
std::cout << "Descriptors processing time: " << (float)fstore_descrip["procTime"] << std::endl;
std::cout << std::endl;
fstore_descrip["matDescriptors"] >> training_descriptors;
fstore_descrip.release();
//--- BUILD A DICTIONARY ---//
cv::TermCriteria tc(CV_TERMCRIT_ITER,100,0.001);
int cluster_attempts = 1;
int dictionary_size = atoi(argv[1]);
std::cout << "*** BOW DICTIONARY INFO ***" << std::endl;
std::cout << "Dictionary size: " << dictionary_size << std::endl;
cv::BOWKMeansTrainer bowTrainer(dictionary_size,tc,cluster_attempts, cv::KMEANS_PP_CENTERS);
bowTrainer.add(training_descriptors);
t = clock();
cv::Mat my_dictionary = bowTrainer.cluster();
t = clock()-t;
std::cout << "Dictionary processing time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
std::cout << std::endl;
//--- ---//
//--- NAIVE BAYES FOR CLASSIFICATION ---//
cv::NormalBayesClassifier nb_classifier;
cv::Mat training_data(0,dictionary_size,CV_32FC1);
cv::Mat labels(0,1,CV_32FC1);
//set the dictionary to bow descriptor extractor
bowDE.setVocabulary(my_dictionary);
std::cout << "*** CLASSIFIER TRAINING ***" << std::endl;
bow_encode(fs::path(train_path),training_data,labels);
// +++ for debugging - can be commented +++//
std::cout << training_data.size() << " * " << labels.size() << std::endl;
if(training_data.type() == CV_32FC1)
{std::cout << "training data matrix accepted" << std::endl;}
if(labels.type() == CV_32FC1)
{std::cout << "labels matrix accepted" << std::endl;}
// +++ +++ //
t = clock();
nb_classifier.train(training_data,labels,cv::Mat(),cv::Mat(),false);
t = clock() - t;
nb_classifier.save("nbModel_flavia_leaves_a.yml","nbModel_flavia_leaves_a");
std::cout << " Training processing time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
std::cout << std::endl;
//if you already have a classifier uncomment the next line and comment the all the
//Classifier Training section
//nb_classifier.load("nbModel_flavia_leaves_b.yml","nbModel_flavia_leaves_b");
//std::cout << "Classfier model loaded"<< std::endl;
//--- ---//
//--- BOW ENCODING OF TEST SET AND EVALUATION ---//
cv::Mat ground_truth(0,1,CV_32FC1);
cv::Mat eval_data(0,dictionary_size,CV_32FC1);
cv::Mat results;
std::string test_path = TEST_PATH;
double accuRate = 0.;
std::cout << "*** CLASSIFIER EVALUATION ***" << std::endl;
bow_encode(fs::path(test_path),eval_data,ground_truth);
t = clock();
nb_classifier.predict(eval_data,&results);
t = clock()-t;
std::cout << " Classifier evaluation time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
accuRate = 1. -( (double) cv::countNonZero(ground_truth - results) / eval_data.rows);
std::cout << "Accuracy rate: " << accuRate << std::endl;
std::cout << "Classifier Results" << std::endl;
std::cout << results << std::endl << std::endl;
return 0;
} /* ---------- end of function main ---------- */
