[MRG] auto replace gbdt::prediction with if-else prediction (#482)

* auto replace gbdt::prediction

* add test if_else_prediction

* not override gbdt_prediction.cpp

* close ifstream

* re-order .travis.yml

.travis.yml

@@ -36,15 +36,11 @@ install:
 
 script:
 - cd $TRAVIS_BUILD_DIR
-- mkdir build && cd build && cmake .. && make
+- mkdir build && cd build && cmake -DUSE_MPI=ON ..&& make
 - cd $TRAVIS_BUILD_DIR/tests/c_api_test && python test.py
 - cd $TRAVIS_BUILD_DIR/python-package && python setup.py install
 - cd $TRAVIS_BUILD_DIR/tests/python_package_test && python test_basic.py && python test_engine.py && python test_sklearn.py && python test_plotting.py
 - cd $TRAVIS_BUILD_DIR && pep8 --ignore=E501 --exclude=./compute .
-- rm -rf build && mkdir build && cd build && cmake -DUSE_MPI=ON ..&& make
-- cd $TRAVIS_BUILD_DIR/tests/c_api_test && python test.py
-- cd $TRAVIS_BUILD_DIR/python-package && python setup.py install
-- cd $TRAVIS_BUILD_DIR/tests/python_package_test && python test_basic.py && python test_engine.py && python test_sklearn.py && python test_plotting.py
 - cd $TRAVIS_BUILD_DIR
 - rm -rf build && mkdir build && cd build && cmake -DUSE_GPU=ON -DBOOST_ROOT="$HOME/miniconda/" -DOpenCL_INCLUDE_DIR=$AMDAPPSDK/include/ ..
 - sed -i 's/std::string device_type = "cpu";/std::string device_type = "gpu";/' ../include/LightGBM/config.h
@@ -53,6 +49,14 @@ script:
 - cd $TRAVIS_BUILD_DIR/tests/c_api_test && python test.py
 - cd $TRAVIS_BUILD_DIR/python-package && python setup.py install
 - cd $TRAVIS_BUILD_DIR/tests/python_package_test && python test_basic.py && python test_engine.py && python test_sklearn.py && python test_plotting.py
+- cd $TRAVIS_BUILD_DIR
+- rm -rf build && mkdir build && cd build && cmake .. && make
+- cd $TRAVIS_BUILD_DIR/tests/c_api_test && python test.py
+- cd $TRAVIS_BUILD_DIR/python-package && python setup.py install
+- cd $TRAVIS_BUILD_DIR/tests/python_package_test && python test_basic.py && python test_engine.py && python test_sklearn.py && python test_plotting.py
+- cd $TRAVIS_BUILD_DIR/tests/cpp_test && ../../lightgbm config=train.conf && ../../lightgbm config=predict.conf output_result=origin.pred
+- cd $TRAVIS_BUILD_DIR/build && make
+- cd $TRAVIS_BUILD_DIR/tests/cpp_test && ../../lightgbm config=predict.conf output_result=ifelse.pred && python test.py
 
 notifications:
   email: false

include/LightGBM/config.h

@@ -93,7 +93,7 @@ public:
   int snapshot_freq = 100;
   std::string output_model = "LightGBM_model.txt";
   std::string output_result = "LightGBM_predict_result.txt";
-  std::string convert_model = "LightGBM_convert_model.cpp";
+  std::string convert_model = "gbdt_prediction.cpp";
   std::string input_model = "";
   int verbosity = 1;
   int num_iteration_predict = -1;

src/boosting/gbdt.cpp

@@ -702,6 +702,19 @@ std::string GBDT::DumpModel(int num_iteration) const {
 std::string GBDT::ModelToIfElse(int num_iteration) const {
   std::stringstream str_buf;
 
+  str_buf << "#include \"gbdt.h\"" << std::endl;
+  str_buf << "#include <LightGBM/utils/openmp_wrapper.h>" << std::endl;
+  str_buf << "#include <LightGBM/utils/common.h>" << std::endl;
+  str_buf << "#include <LightGBM/objective_function.h>" << std::endl;
+  str_buf << "#include <LightGBM/metric.h>" << std::endl;
+  str_buf << "#include <ctime>" << std::endl;
+  str_buf << "#include <sstream>" << std::endl;
+  str_buf << "#include <chrono>" << std::endl;
+  str_buf << "#include <string>" << std::endl;
+  str_buf << "#include <vector>" << std::endl;
+  str_buf << "#include <utility>" << std::endl;
+  str_buf << "namespace LightGBM {" << std::endl;
+
   int num_used_model = static_cast<int>(models_.size());
   if (num_iteration > 0) {
     num_iteration += boost_from_average_ ? 1 : 0;
@@ -777,16 +790,32 @@ std::string GBDT::ModelToIfElse(int num_iteration) const {
   str_buf << "\t\t" << "output[i] = (*PredictTreeLeafPtr[i])(features);" << std::endl;
   str_buf << "\t" << "}" << std::endl;
   str_buf << "}" << std::endl;
+
+  str_buf << "}  // namespace LightGBM" << std::endl;
+
   return str_buf.str();
 }
 
 bool GBDT::SaveModelToIfElse(int num_iteration, const char* filename) const {
   /*! \brief File to write models */
   std::ofstream output_file;
-  output_file.open(filename);
-
-  output_file << ModelToIfElse(num_iteration);
+  std::ifstream ifs(filename);
+  if (ifs.good()) {
+    std::string origin((std::istreambuf_iterator<char>(ifs)),
+                       (std::istreambuf_iterator<char>()));
+    output_file.open(filename);
+    output_file << "#define USE_HARD_CODE 0" << std::endl;
+    output_file << "#ifndef USE_HARD_CODE" << std::endl;
+    output_file << origin << std::endl;
+    output_file << "#else" << std::endl;
+    output_file << ModelToIfElse(num_iteration);
+    output_file << "#endif" << std::endl;
+  } else {
+    output_file.open(filename);
+    output_file << ModelToIfElse(num_iteration);
+  }
 
+  ifs.close();
   output_file.close();
 
   return (bool)output_file;
@@ -974,55 +1003,4 @@ std::vector<std::pair<size_t, std::string>> GBDT::FeatureImportance() const {
   return pairs;
 }
 
-void GBDT::PredictRaw(const double* features, double* output) const {
-  if (num_threads_ <= num_tree_per_iteration_) {
-    #pragma omp parallel for schedule(static)
-    for (int k = 0; k < num_tree_per_iteration_; ++k) {
-      for (int i = 0; i < num_iteration_for_pred_; ++i) {
-        output[k] += models_[i * num_tree_per_iteration_ + k]->Predict(features);
-      }
-    }
-  } else {
-    for (int k = 0; k < num_tree_per_iteration_; ++k) {
-      double t = 0.0f;
-      #pragma omp parallel for schedule(static) reduction(+:t)
-      for (int i = 0; i < num_iteration_for_pred_; ++i) {
-        t += models_[i * num_tree_per_iteration_ + k]->Predict(features);
-      }
-      output[k] = t;
-    }
-  }
-}
-
-void GBDT::Predict(const double* features, double* output) const {
-  if (num_threads_ <= num_tree_per_iteration_) {
-    #pragma omp parallel for schedule(static)
-    for (int k = 0; k < num_tree_per_iteration_; ++k) {
-      for (int i = 0; i < num_iteration_for_pred_; ++i) {
-        output[k] += models_[i * num_tree_per_iteration_ + k]->Predict(features);
-      }
-    }
-  } else {
-    for (int k = 0; k < num_tree_per_iteration_; ++k) {
-      double t = 0.0f;
-      #pragma omp parallel for schedule(static) reduction(+:t)
-      for (int i = 0; i < num_iteration_for_pred_; ++i) {
-        t += models_[i * num_tree_per_iteration_ + k]->Predict(features);
-      }
-      output[k] = t;
-    }
-  }
-  if (objective_function_ != nullptr) {
-    objective_function_->ConvertOutput(output, output);
-  }
-}
-
-void GBDT::PredictLeafIndex(const double* features, double* output) const {
-  int total_tree = num_iteration_for_pred_ * num_tree_per_iteration_;
-  #pragma omp parallel for schedule(static)
-  for (int i = 0; i < total_tree; ++i) {
-    output[i] = models_[i]->PredictLeafIndex(features);
-  }
-}
-
 }  // namespace LightGBM

src/boosting/gbdt_prediction.cpp

+#include "gbdt.h"
+
+#include <LightGBM/utils/openmp_wrapper.h>
+
+#include <LightGBM/utils/common.h>
+
+#include <LightGBM/objective_function.h>
+#include <LightGBM/metric.h>
+
+#include <ctime>
+
+#include <sstream>
+#include <chrono>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace LightGBM {
+
+void GBDT::PredictRaw(const double* features, double* output) const {
+  if (num_threads_ <= num_tree_per_iteration_) {
+    #pragma omp parallel for schedule(static)
+    for (int k = 0; k < num_tree_per_iteration_; ++k) {
+      for (int i = 0; i < num_iteration_for_pred_; ++i) {
+        output[k] += models_[i * num_tree_per_iteration_ + k]->Predict(features);
+      }
+    }
+  } else {
+    for (int k = 0; k < num_tree_per_iteration_; ++k) {
+      double t = 0.0f;
+      #pragma omp parallel for schedule(static) reduction(+:t)
+      for (int i = 0; i < num_iteration_for_pred_; ++i) {
+        t += models_[i * num_tree_per_iteration_ + k]->Predict(features);
+      }
+      output[k] = t;
+    }
+  }
+}
+
+void GBDT::Predict(const double* features, double* output) const {
+  if (num_threads_ <= num_tree_per_iteration_) {
+    #pragma omp parallel for schedule(static)
+    for (int k = 0; k < num_tree_per_iteration_; ++k) {
+      for (int i = 0; i < num_iteration_for_pred_; ++i) {
+        output[k] += models_[i * num_tree_per_iteration_ + k]->Predict(features);
+      }
+    }
+  } else {
+    for (int k = 0; k < num_tree_per_iteration_; ++k) {
+      double t = 0.0f;
+      #pragma omp parallel for schedule(static) reduction(+:t)
+      for (int i = 0; i < num_iteration_for_pred_; ++i) {
+        t += models_[i * num_tree_per_iteration_ + k]->Predict(features);
+      }
+      output[k] = t;
+    }
+  }
+  if (objective_function_ != nullptr) {
+    objective_function_->ConvertOutput(output, output);
+  }
+}
+
+void GBDT::PredictLeafIndex(const double* features, double* output) const {
+  int total_tree = num_iteration_for_pred_ * num_tree_per_iteration_;
+  #pragma omp parallel for schedule(static)
+  for (int i = 0; i < total_tree; ++i) {
+    output[i] = models_[i]->PredictLeafIndex(features);
+  }
+}
+
+}  // namespace LightGBM
\ No newline at end of file

tests/cpp_test/predict.conf

+data=../../examples/regression/regression.test
+
+input_model=LightGBM_model.txt
+
+task=predict

tests/cpp_test/test.py

+# coding: utf-8
+import glob
+import numpy as np
+
+preds = [np.loadtxt(name) for name in glob.glob('*.pred')]
+np.testing.assert_array_almost_equal(preds[0], preds[1], decimal=5)

tests/cpp_test/train.conf

+data=../../examples/regression/regression.train
+
+num_trees=10
+
+convert_model=../../src/boosting/gbdt_prediction.cpp
+
+convert_model_language=cpp