From 7cf03929913aaa26ff829059f2351db2271ab596 Mon Sep 17 00:00:00 2001
From: Micooz <micooz@hotmail.com>
Date: Sat, 15 Aug 2015 11:47:25 +0800
Subject: [PATCH] Simplify SVM training.

---
 include/easypr/train/svm_train.h |  55 ++---
 src/train/svm_train.cpp          | 383 +++++++++++++------------------
 test/main.cpp                    |  98 ++------
 3 files changed, 201 insertions(+), 335 deletions(-)

diff --git a/include/easypr/train/svm_train.h b/include/easypr/train/svm_train.h
index 5ce0236..83c9cda 100644
--- a/include/easypr/train/svm_train.h
+++ b/include/easypr/train/svm_train.h
@@ -1,48 +1,37 @@
-#ifndef EASYPR_SVM_TRAIN_H
-#define EASYPR_SVM_TRAIN_H
+#ifndef EASYPR_TRAIN_SVMTRAIN_H_
+#define EASYPR_TRAIN_SVMTRAIN_H_
 
+#include "easypr/train/train.h"
 #include <vector>
-#include <opencv2/opencv.hpp>
 #include "easypr/config.h"
 
 namespace easypr {
 
-  class SvmTrain {
-  public:
-    typedef enum {
-      kForward = 1, // correspond to "has plate"
-      kInverse = 0  // correspond to "no plate"
-    } Label;
+class SvmTrain : public ITrain {
+ public:
+   typedef struct {
+     std::string file;
+     SvmLabel    label;
+   } TrainItem;
 
-    SvmTrain(const char* forward_data_folder, const char* inverse_data_folder);
+    SvmTrain(const char* plates_folder, const char* xml);
 
-    void train(bool divide = true, float divide_percentage = 0.7,
-      const char* out_svm_folder = kDefaultSvmPath);
+    virtual void train();
 
-    void runTest(const char* svm_path = kDefaultSvmPath);
+    virtual void test();
 
-  private:
-    /*
-     * divide images into train part and test part by percentage
-     */
-    void divide(const char* images_folder, float percentage = 0.7);
+ private:
+    void prepare();
 
-    void getTrain();
+    virtual cv::Ptr<cv::ml::TrainData> tdata();
 
-    void getTest();
-
-    const char* forward_;
-    const char* inverse_;
-
-    // these two variables are used for cv::CvSVM::train_auto()
-    cv::Mat classes_;
-    cv::Ptr<cv::ml::TrainData> trainingData_;
-
-    // these two variables are used for cv::CvSVM::predict()
-    std::vector<cv::Mat> test_imgaes_;
-    std::vector<Label> test_labels_;
-  };
+    cv::Ptr<cv::ml::SVM> svm_;
+    const char* plates_folder_;
+    const char* svm_xml_;
+    std::vector<TrainItem> train_file_list_;
+    std::vector<TrainItem> test_file_list_;
+};
 
 }
 
-#endif //EASYPR_SVM_TRAIN_H
+#endif // EASYPR_TRAIN_SVMTRAIN_H_
diff --git a/src/train/svm_train.cpp b/src/train/svm_train.cpp
index 42da939..516bd59 100644
--- a/src/train/svm_train.cpp
+++ b/src/train/svm_train.cpp
@@ -1,254 +1,199 @@
 #include "easypr/train/svm_train.h"
-#include <ctime>
+#include "easypr/config.h"
 #include "easypr/core/core_func.h"
+#include "easypr/core/plate_judge.h"
 #include "easypr/util/util.h"
 
-namespace easypr {
-
-  SvmTrain::SvmTrain(const char* forward_data_folder, const char* inverse_data_folder)
-    : forward_(forward_data_folder), inverse_(inverse_data_folder) {
-    assert(forward_);
-    assert(inverse_);
-  }
+#ifdef OS_WINDOWS
+#include <ctime>
+#endif
 
-  void SvmTrain::train(bool divide /* = true */, float divide_percentage /* = 0.7 */,
-    const char* out_svm_path /* = kDefaultSvmPath */) {
+using namespace cv::ml;
 
-    if (divide) {
-      std::cout << "Dividing data to be trained and tested..." << std::endl;
-      this->divide(forward_, divide_percentage);
-      this->divide(inverse_, divide_percentage);
-    }
+namespace easypr {
 
-    cv::Ptr<ml::SVM> svm;
-
-    // 70% training procedure
-    this->getTrain();
-
-    svm = ml::SVM::create();
-
-    if (!this->classes_.empty() && !this->trainingData_.empty()) {
-      // need to be trained first
-      svm->setType(ml::SVM::C_SVC);
-      svm->setKernel(ml::SVM::RBF);
-      svm->setDegree(0.1);
-      svm->setGamma(1);
-      svm->setCoef0(0.1);
-      svm->setC(1);
-      svm->setNu(0.1);
-      svm->setP(0.1);
-      svm->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 100000, 0.0001));
-
-      std::cout << "Generating svm model file, please wait..." << std::endl;
-
-      try {
-        svm->trainAuto(this->trainingData_, 10,
-          ml::SVM::getDefaultGrid(ml::SVM::C),
-          ml::SVM::getDefaultGrid(ml::SVM::GAMMA),
-          ml::SVM::getDefaultGrid(ml::SVM::P),
-          ml::SVM::getDefaultGrid(ml::SVM::NU),
-          ml::SVM::getDefaultGrid(ml::SVM::COEF),
-          ml::SVM::getDefaultGrid(ml::SVM::DEGREE), false);
-      }
-      catch (const cv::Exception& err) {
-        std::cout << err.what() << std::endl;
-      }
-
-      svm->save(out_svm_path);
-
-      std::cout << "Generate done! The model file is located at "
-        << out_svm_path << std::endl;
-    }
+SvmTrain::SvmTrain(const char* plates_folder, const char* xml)
+        : plates_folder_(plates_folder), svm_xml_(xml) {
+  assert(plates_folder);
+  assert(xml);
+  srand(unsigned(time(NULL)));
+  svm_ = cv::ml::SVM::create();
+}
+
+void SvmTrain::train() {
+  svm_->setType(cv::ml::SVM::C_SVC);
+  svm_->setKernel(cv::ml::SVM::RBF);
+  svm_->setDegree(0.1);
+  svm_->setGamma(1);
+  svm_->setCoef0(0.1);
+  svm_->setC(1);
+  svm_->setNu(0.1);
+  svm_->setP(0.1);
+  svm_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 100000, 0.0001));
+
+  auto train_data = tdata();
+
+  fprintf(stdout, "Training SVM model, please wait...\n");
+  long start = utils::getTimestamp();
+  svm_->trainAuto(train_data, 10,
+                  SVM::getDefaultGrid(SVM::C),
+                  SVM::getDefaultGrid(SVM::GAMMA),
+                  SVM::getDefaultGrid(SVM::P),
+                  SVM::getDefaultGrid(SVM::NU),
+                  SVM::getDefaultGrid(SVM::COEF),
+                  SVM::getDefaultGrid(SVM::DEGREE),
+                  true
+  );
+  long end = utils::getTimestamp();
+  fprintf(stdout, "Training done. Time elapse: %ldms\n", end - start);
+  svm_->save(svm_xml_);
+  fprintf(stdout, "Your ANN Model was saved to %s\n", svm_xml_);
+}
+
+void SvmTrain::test() {
+  this->prepare();
+
+  double count_all = test_file_list_.size();
+  double ptrue_rtrue = 0;
+  double ptrue_rfalse = 0;
+  double pfalse_rtrue = 0;
+  double pfalse_rfalse = 0;
+
+  size_t label_index = 0;
+  for (auto item : test_file_list_) {
+    auto image = cv::imread(item.file);
+    auto features = easypr::histeq(image);
+    features = features.reshape(1, 1);
+
+    int predict;
+    PlateJudge::instance()->plateJudge(features, predict);
+    auto real = item.label;
+
+    if (predict == kForward && real == kForward) ptrue_rtrue++;
+    if (predict == kForward && real == kInverse) ptrue_rfalse++;
+    if (predict == kInverse && real == kForward) pfalse_rtrue++;
+    if (predict == kInverse && real == kInverse) pfalse_rfalse++;
   }
 
-  void SvmTrain::runTest(const char* svm_path /* = kDefaultSvmPath */){
-    // TODO Check whether the model file exists or not.
-    auto svm = Algorithm::load<ml::SVM>(svm_path);
-
-    this->getTest();
-
-    std::cout << "Testing..." << std::endl;
-
-    double count_all = test_imgaes_.size();
-    double ptrue_rtrue = 0;
-    double ptrue_rfalse = 0;
-    double pfalse_rtrue = 0;
-    double pfalse_rfalse = 0;
-
-    size_t label_index = 0;
-    for (auto image : test_imgaes_) {
-      //调用回调函数决定特征
-      auto features = easypr::histeq(image);
-      features = features.reshape(1, 1);
-      cv::Mat out;
-      features.convertTo(out, CV_32FC1);
+  std::cout << "count_all: " << count_all << std::endl;
+  std::cout << "ptrue_rtrue: " << ptrue_rtrue << std::endl;
+  std::cout << "ptrue_rfalse: " << ptrue_rfalse << std::endl;
+  std::cout << "pfalse_rtrue: " << pfalse_rtrue << std::endl;
+  std::cout << "pfalse_rfalse: " << pfalse_rfalse << std::endl;
 
-      Label predict = ((int)svm->predict(out)) == 1 ? kForward : kInverse;
-      Label real = test_labels_[label_index++];
-
-      if (predict == kForward && real == kForward) ptrue_rtrue++;
-      if (predict == kForward && real == kInverse) ptrue_rfalse++;
-      if (predict == kInverse && real == kForward) pfalse_rtrue++;
-      if (predict == kInverse && real == kInverse) pfalse_rfalse++;
-    }
-
-    std::cout << "count_all: " << count_all << std::endl;
-    std::cout << "ptrue_rtrue: " << ptrue_rtrue << std::endl;
-    std::cout << "ptrue_rfalse: " << ptrue_rfalse << std::endl;
-    std::cout << "pfalse_rtrue: " << pfalse_rtrue << std::endl;
-    std::cout << "pfalse_rfalse: " << pfalse_rfalse << std::endl;
-
-    double precise = 0;
-    if (ptrue_rtrue + ptrue_rfalse != 0) {
-      precise = ptrue_rtrue / (ptrue_rtrue + ptrue_rfalse);
-      std::cout << "precise: " << precise << std::endl;
-    }
-    else {
-      std::cout << "precise: "
-        << "NA" << std::endl;
-    }
-
-    double recall = 0;
-    if (ptrue_rtrue + pfalse_rtrue != 0) {
-      recall = ptrue_rtrue / (ptrue_rtrue + pfalse_rtrue);
-      std::cout << "recall: " << recall << std::endl;
-    }
-    else {
-      std::cout << "recall: "
-        << "NA" << std::endl;
-    }
-
-    double Fsocre = 0;
-    if (precise + recall != 0) {
-      Fsocre = 2 * (precise * recall) / (precise + recall);
-      std::cout << "Fsocre: " << Fsocre << std::endl;
-    }
-    else {
-      std::cout << "Fsocre: "
-        << "NA" << std::endl;
-    }
+  double precise = 0;
+  if (ptrue_rtrue + ptrue_rfalse != 0) {
+    precise = ptrue_rtrue / (ptrue_rtrue + ptrue_rfalse);
+    std::cout << "precise: " << precise << std::endl;
+  }
+  else {
+    std::cout << "precise: "
+    << "NA" << std::endl;
   }
 
-  void SvmTrain::divide(const char* images_folder, float percentage /* = 0.7 */) {
-    auto files = utils::getFiles(images_folder);
-    if (files.empty()) {
-      std::cout << "No file found in " << images_folder << std::endl;
-      return;
-    }
+  double recall = 0;
+  if (ptrue_rtrue + pfalse_rtrue != 0) {
+    recall = ptrue_rtrue / (ptrue_rtrue + pfalse_rtrue);
+    std::cout << "recall: " << recall << std::endl;
+  }
+  else {
+    std::cout << "recall: "
+    << "NA" << std::endl;
+  }
 
-    srand(unsigned(time(NULL)));
-    random_shuffle(files.begin(), files.end());
-
-    size_t split_index = size_t(files.size() * percentage);
-    for (size_t i = 0; i < files.size(); ++i) {
-      // TODO: Move files directly to improve efficiency.
-      auto f = files[i];
-      auto file_name = utils::getFileName(f, true);
-      auto image = cv::imread(f);
-      char save_to[255] = { 0 };
-      assert(!image.empty());
-      if (i < split_index) {
-        sprintf(save_to, "%s/train/%s", images_folder, file_name.c_str());
-      }
-      else {
-        sprintf(save_to, "%s/test/%s", images_folder, file_name.c_str());
-      }
-      utils::imwrite(save_to, image);
-      std::cout << f << " -> " << save_to << std::endl;
-    }
+  double Fsocre = 0;
+  if (precise + recall != 0) {
+    Fsocre = 2 * (precise * recall) / (precise + recall);
+    std::cout << "Fsocre: " << Fsocre << std::endl;
+  }
+  else {
+    std::cout << "Fsocre: "
+    << "NA" << std::endl;
   }
+}
 
-  void SvmTrain::getTrain() {
-    std::cout << "Collecting train data..." << std::endl;
+void SvmTrain::prepare() {
+  char buffer[260] = { 0 };
 
-    cv::Mat samples;
-    cv::Mat responses;
-    auto folder = std::string(forward_).append("/train");
+  sprintf(buffer, "%s/has", plates_folder_);
+  auto has_file_list = utils::getFiles(buffer);
+  std::random_shuffle(has_file_list.begin(), has_file_list.end());
 
-    // iterate forward data
+  sprintf(buffer, "%s/no", plates_folder_);
+  auto no_file_list = utils::getFiles(buffer);
+  std::random_shuffle(no_file_list.begin(), no_file_list.end());
 
-    auto files = Utils::getFiles(folder);
+  auto has_num = has_file_list.size();
+  auto no_num = no_file_list.size();
 
-    if (files.empty()) {
-      std::cout << "No file found in " << folder << std::endl;
-      return;
-    }
+  fprintf(stdout, ">> Collecting train data...\n");
 
-    std::cout << "Collecting train data in " << folder << std::endl;
-    for (auto f : files) {
-      auto image = cv::imread(f);
+  auto has_for_train = static_cast<int>(has_num * kSvmPercentage);
+  auto no_for_train = static_cast<int>(no_num * kSvmPercentage);
 
-      auto features = easypr::histeq(image);
-      features = features.reshape(1, 1);
+  // copy kSvmPercentage of has_file_list to train_file_list_
+  train_file_list_.reserve(has_for_train + no_for_train);
+  for (auto i = 0; i < has_for_train; i++) {
+    train_file_list_.push_back({
+      has_file_list[i], 
+      kForward
+    });
+  }
+  // copy kSvmPercentage of no_file_list to the end of train_file_list_
+  for (auto i = 0; i < no_for_train; i++) {
+    train_file_list_.push_back({
+      no_file_list[i],
+      kInverse
+    });
+  }
 
-      samples.push_back(features);
-      responses.push_back(Label::kForward);  // Note here
-    }
+  fprintf(stdout, ">> Collecting test data...\n");
 
-    // iterate inverse data
+  auto has_for_test = has_num - has_for_train;
+  auto no_for_test = no_num - no_for_train;
 
-    files.clear();
-    folder = std::string(inverse_).append("/train");
-    files = Utils::getFiles(folder);
+  // copy the rest of has_file_list to the test_file_list_
+  test_file_list_.reserve(has_for_test + no_for_test);
+  for (auto i = has_for_test; i < has_num; i++) {
+    train_file_list_.push_back({
+      has_file_list[i],
+      kForward
+    });
+  }
 
-    if (files.empty()) {
-      std::cout << "No file found in " << folder << std::endl;
-      return;
-    }
+  // copy the rest of no_file_list to the end of the test_file_list_
+  for (auto i = no_for_test; i < no_num; i++) {
+    train_file_list_.push_back({
+      no_file_list[i],
+      kInverse
+    });
+  }
+}
 
-    std::cout << "Collecting train data in " << folder << std::endl;
-    for (auto f : files) {
-      auto image = cv::imread(f);
+cv::Ptr<cv::ml::TrainData> SvmTrain::tdata() {
+  this->prepare();
 
-      auto features = easypr::histeq(image);
-      features = features.reshape(1, 1);
+  cv::Mat samples;
+  std::vector<int> responses;
 
-      samples.push_back(features);
-      responses.push_back(Label::kInverse);  // Note here
+  for (auto f : train_file_list_) {
+    auto image = cv::imread(f.file);
+    if (!image.data) {
+      fprintf(stdout, ">> Invalid image: %s\n", f.file.c_str());
+      continue;
     }
+    auto features = easypr::histeq(image);
+    features = features.reshape(1, 1);
 
-    cv::Mat samples_row;
-    cv::Mat responses_row;
-
-    samples.convertTo(samples_row, CV_32FC1);
-    responses.convertTo(responses_row, CV_32FC1);
-
-    this->trainingData_ = cv::ml::TrainData::create(samples_row, ml::SampleTypes::ROW_SAMPLE, responses_row);
+    samples.push_back(features);
+    responses.push_back(f.label);
   }
 
-  void SvmTrain::getTest() {
-    std::cout << "Tesing preparation..." << std::endl;
+  cv::Mat samples_;
+  samples.convertTo(samples_, CV_32F);
 
-    auto folder = std::string(forward_).append("/test");
-    auto files = Utils::getFiles(folder);
-
-    size_t size = files.size();
-    if (0 == size) {
-      std::cout << "No file found in " << folder << std::endl;
-      return;
-    }
-    std::cout << "Prepare testing data in " << folder << std::endl;
-    for (auto f : files) {
-      auto img = cv::imread(f);
-      test_imgaes_.push_back(img);
-      test_labels_.push_back(kForward);
-    }
-
-    folder.clear();
-    folder = std::string(inverse_).append("/test");
-    files = Utils::getFiles(folder);
-
-    size = files.size();
-    if (0 == size) {
-      std::cout << "No file found in " << folder << std::endl;
-      return;
-    }
-    std::cout << "Prepare testing data in " << folder << std::endl;
-    for (auto f : files) {
-      auto img = cv::imread(f);
-      test_imgaes_.push_back(img);
-      test_labels_.push_back(kInverse);
-    }
-  }
+  return cv::ml::TrainData::create(samples_, ml::SampleTypes::ROW_SAMPLE,
+    cv::Mat(responses));
+}
 
 }  // namespace easypr
diff --git a/test/main.cpp b/test/main.cpp
index 91ba7e7..349ef01 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -130,43 +130,15 @@ void command_line_handler(int argc, const char* argv[]) {
      | SVM Training operations
      | ------------------------------------------
      |
-     | $ demo svm --[create|tag|train] options
+     | $ demo svm --plates=path/to/plates/ [--test] --svm=save/to/svm.xml
      |
      | ------------------------------------------
      */
     options("h,help", "show help information");
-    options(",svm", "resources/model/svm.xml",
-            "the svm model file,"
-                    " this option is used for '--tag'(required)"
-                    " and '--train'(save svm model to) functions");
-    // create
-    options(
-            ",create",
-            "create learn data, this function "
-                    "will intercept (--max) raw images (--in) and preprocess into (--out)");
-    options("i,in", "", "where is the raw images");
-    options("o,out", "", "where to put the preprocessed images");
-    options("m,max", "5000", "how many learn data would you want to create");
-    // tag
-    options(",tag",
-            "tag learn data, this function "
-                    "will find plate blocks in your images(--source) "
-                    "as well as classify them into (--has) and (--no)");
-    options("s,source", "", "where is your images to be classified");
-    options(",has", "", "put plates in this folder");
-    options(",no", "", "put images without plate in this folder");
-    // train
-    options(",train",
-            "train given data, "
-                    "including the forward(has plate) and the inverse(no plate).");
-    options(",has-plate", "", "where is the forward data");
-    options(",no-plate", "", "where is the inverse data");
-    options(",divide",
-            "whether divide train data into two parts by --percentage or not");
-    options(",percentage", "0.7",
-            "70% train data will be used for training,"
-                    " others will be used for testing");
-    options(",test", "don't train again, run testing directly");
+    options(",plates", "", 
+      "a folder contains both forward data and inverse data in the separated subfolders");
+    options(",svm", easypr::kDefaultSvmPath, "the svm model file");
+    options("t,test", "run tests in --plates");
   }
 
   options.add_subroutine("ann", "ann operation").make_usage("Usages:");
@@ -259,57 +231,17 @@ void command_line_handler(int argc, const char* argv[]) {
               std::cout << options("svm");
               return;
             }
-
-            if (parser->has("create")) {
-              assert(parser->has("in"));
-              assert(parser->has("out"));
-              assert(parser->has("max"));
-
-              auto in = parser->get("in")->val();
-              auto out = parser->get("out")->val();
-              auto max = parser->get("max")->as<int>();
-              easypr::preprocess::create_learn_data(in.c_str(), out.c_str(),
-                                                    max);
-            }
-
-            if (parser->has("tag")) {
-              assert(parser->has("source"));
-              assert(parser->has("has"));
-              assert(parser->has("no"));
-              assert(parser->has("svm"));
-
-              auto source = parser->get("source")->val();
-              auto has_path = parser->get("has")->val();
-              auto no_path = parser->get("no")->val();
-              auto svm = parser->get("svm")->val();
-              easypr::preprocess::tag_data(source.c_str(), has_path.c_str(),
-                                           no_path.c_str(), svm.c_str());
-              std::cout << "Tagging finished, check out output images "
-              << "and classify the wrong images manually." << std::endl;
+            
+            easypr::SvmTrain svm(
+              parser->get("plates")->c_str(),
+              parser->get("svm")->c_str()
+            );
+
+            if (parser->has("test")) {
+              svm.test();
             }
-
-            if (parser->has("train")) {
-              assert(parser->has("has-plate"));
-              assert(parser->has("no-plate"));
-              assert(parser->has("percentage"));
-              assert(parser->has("svm"));
-
-              auto forward_data_path = parser->get("has-plate")->val();
-              auto inverse_data_path = parser->get("no-plate")->val();
-              bool divide = parser->has("divide");
-              auto percentage = parser->get("percentage")->as<float>();
-              auto svm_model = parser->get("svm")->val();
-              bool test = parser->has("test");
-
-              easypr::SvmTrain svm(forward_data_path.c_str(),
-                                   inverse_data_path.c_str());
-
-              if (test) {
-                svm.runTest(svm_model.c_str());
-              }
-              else {
-                svm.train(divide, percentage, svm_model.c_str());
-              }
+            else {
+              svm.train();
             }
           })
           .found("ann", [&]() {