[tests] more metrics tests (#15)

* [tests] metrics

* more tests

* [travis] exclude build/ folder from coveralls

* [travis] minor fix

* refactor metrics

.travis.yml

@@ -6,7 +6,7 @@ before_install:
   - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
   - sudo apt-get update -q
   - sudo apt-get install -q gcc g++ cmake libeigen3-dev git wget python-dev valgrind
-  - pip install --user cpp-coveralls
+  - travis_wait pip install --user cpp-coveralls
   - git submodule add -f https://github.com/pybind/pybind11.git # add pybind11 submodule
   - git submodule update --init --recursive
 
@@ -19,7 +19,7 @@ script:
   - ./bin/unit_tests
 
 after_success:
-  - coveralls --root .. -E ".*pybind11.*" -E ".*external.*" -E ".*CMakeFiles.*" -E ".*test/.*.cpp.*"
+  - coveralls --include src --include include --gcov-options '\-lp' --root .. --build-root .;
 
 notifications:
   email: false

src/GBT.h

@@ -158,7 +158,6 @@ namespace microgbt {
                 std::cout << "[Duration: " << duration << " millis] | [Train Loss]: " << trainLoss
                     << " | [Valid Loss]: " << bestValidationLoss <<std::endl;
 
-
                 // Update best iteration / best validation error
                 if (currentValidationLoss < bestValidationLoss) {
                     bestValidationLoss = currentValidationLoss;
@@ -187,7 +186,7 @@ namespace microgbt {
         double predict(const Eigen::RowVectorXd &x, int numIterations) const {
             double score = sumScore(x, numIterations);
             return _metric->scoreToPrediction(score);
-        };
+        }
 
         /**
          * Return sum of scores up to numIterations
@@ -209,6 +208,7 @@ namespace microgbt {
                 else
                     break;
             }
+
             return (double)score;
         }
 

src/dataset.h

@@ -106,7 +106,6 @@ namespace microgbt {
 
             _sortedMatrixIdx = SortedMatrixType(rows, cols);
 
-            #pragma omp parallel for schedule(static)
             for ( long j = 0; j < cols; j++) {
                 _sortedMatrixIdx.col(j) = sortIndices(j);
             }

src/python_api.cpp

@@ -3,7 +3,6 @@
 #include <pybind11/stl.h>
 #include <vector>
 #include "GBT.h"
-#include "dataset.h"
 
 namespace py = pybind11;
 

test/CMakeLists.txt

@@ -2,7 +2,7 @@ add_executable(
     unit_tests
         main.cpp
         test_split_info.cpp
-        test_metrics.cpp
+        test_metric_rmse.cpp
         test_dataset.cpp
         test_treenode.cpp
         test_tree.cpp

test/test_metric_logloss.cpp

@@ -0,0 +1,80 @@
+#include <metrics/logloss.h>
+#include <metrics/rmse.h>
+#include "gtest/gtest.h"
+
+using namespace microgbt;
+
+TEST(LogLoss, LogLossLogit)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.logit(1.0), 1 / ( 1 + exp(-1.0)), 1.0e-11);
+}
+
+TEST(LogLoss, LogLossMiddleValue)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.logit(0.0), 0.5, 1.0e-11);
+}
+
+TEST(LogLoss, LogLossClipUpper)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(1.0), 1, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossClipUpperOverflow)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(100.0), 1, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossClipLower)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(0.0), 0, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossClipLowerUnderFlow)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(-10000.0), 0, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossGradient)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 100.0);
+    std::fill(targets.begin(), targets.end(), 99.0);
+
+    Vector grads = logloss.gradients(preds, targets);
+    ASSERT_EQ(grads.size(), preds.size());
+    ASSERT_NEAR(grads[0], 100.0 - 99, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossHessian)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 0.5);
+
+    Vector hessian = logloss.hessian(preds);
+    ASSERT_EQ(hessian.size(), preds.size());
+    ASSERT_NEAR(hessian[0], 0.25, 1.0e-7);
+}
+
+TEST(LogLoss, LogLossLossAtMustBeZero)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 1.0);
+    std::fill(targets.begin(), targets.end(), 1.0);
+
+    double loss = logloss.lossAt(preds, targets);
+    ASSERT_NEAR(loss, 0, 1.0e-7);
+}

test/test_metric_rmse.cpp

@@ -0,0 +1,125 @@
+#include <metrics/logloss.h>
+#include <metrics/rmse.h>
+#include "gtest/gtest.h"
+
+using namespace microgbt;
+
+TEST(microgbt, LogLoss)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.logit(1.0), 1 / ( 1 + exp(-1.0)), 1.0e-11);
+}
+
+TEST(microgbt, LogLossMiddleValue)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.logit(0.0), 0.5, 1.0e-11);
+}
+
+TEST(microgbt, LogLossClipUpper)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(1.0), 1, 1.0e-7);
+}
+
+TEST(microgbt, LogLossClipUpperOverflow)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(100.0), 1, 1.0e-7);
+}
+
+TEST(microgbt, LogLossClipLower)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(0.0), 0, 1.0e-7);
+}
+
+TEST(microgbt, LogLossClipLowerUnderFlow)
+{
+    LogLoss logloss;
+    ASSERT_NEAR(logloss.clip(-10000.0), 0, 1.0e-7);
+}
+
+TEST(microgbt, LogLossGradient)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 100.0);
+    std::fill(targets.begin(), targets.end(), 99.0);
+
+    Vector grads = logloss.gradients(preds, targets);
+    ASSERT_EQ(grads.size(), preds.size());
+    ASSERT_NEAR(grads[0], 100.0 - 99, 1.0e-7);
+}
+
+TEST(microgbt, LogLossHessian)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 0.5);
+
+    Vector hessian = logloss.hessian(preds);
+    ASSERT_EQ(hessian.size(), preds.size());
+    ASSERT_NEAR(hessian[0], 0.25, 1.0e-7);
+}
+
+TEST(microgbt, LogLossLossAtMustBeZero)
+{
+    LogLoss logloss;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 1.0);
+    std::fill(targets.begin(), targets.end(), 1.0);
+
+    double loss = logloss.lossAt(preds, targets);
+    ASSERT_NEAR(loss, 0, 1.0e-7);
+}
+
+TEST(microgbt, RMSE)
+{
+    RMSE rmse;
+    ASSERT_NEAR(rmse.scoreToPrediction(10.1), 10.1, 1.0e-11);
+}
+
+TEST(microgbt, RMSEHessian)
+{
+    RMSE rmse;
+    Vector preds = Vector(10);
+    Vector hessian = rmse.hessian(preds);
+    ASSERT_EQ(hessian.size(), preds.size());
+
+    // Hessian is the constant 2
+    ASSERT_NEAR(hessian[0], 2.0, 1.0e-11);
+    ASSERT_NEAR(hessian[9], 2.0, 1.0e-11);
+}
+
+TEST(microgbt, RMSEGradient)
+{
+    RMSE rmse;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 100.0);
+    std::fill(targets.begin(), targets.end(), 99.0);
+
+    Vector grads = rmse.gradients(preds, targets);
+    ASSERT_EQ(grads.size(), preds.size());
+    ASSERT_NEAR(grads[0], 2 * (100.0 - 99), 1.0e-7);
+}
+
+TEST(microgbt, RMSELossAtMustBeZero)
+{
+    RMSE rmse;
+    Vector preds = Vector(10);
+    Vector targets = Vector(10);
+
+    std::fill(preds.begin(), preds.end(), 1.0);
+    std::fill(targets.begin(), targets.end(), 1.0);
+
+    double loss = rmse.lossAt(preds, targets);
+    ASSERT_NEAR(loss, 0, 1.0e-7);
+}