Add unit tests

przemekwitek · przemekwitek · commit d3bec8647208 · 2019-10-03T17:08:26.000+02:00
diff --git a/lib/api/unittest/CDataFrameAnalysisRunnerTest.cc b/lib/api/unittest/CDataFrameAnalysisRunnerTest.cc
@@ -189,6 +189,36 @@ void CDataFrameAnalysisRunnerTest::testEstimateMemoryUsage_1000() {
     testEstimateMemoryUsage(1000, "450kB", "143kB", 0);
 }
 
+void testColumnsForWhichEmptyIsMissing(const std::string& analysis,
+                                       bool expected_dependentVariableEmptyAsMissing) {
+    using TBoolVec = std::vector<bool>;
+    using TStrVec = std::vector<std::string>;
+
+    std::string parameters{"{\"dependent_variable\": \"label\"}"};
+    std::string jsonSpec{api::CDataFrameAnalysisSpecificationJsonWriter::jsonString(
+        "testJob", 10000, 5, 100000000, 1, {}, true,
+        test::CTestTmpDir::tmpDir(), "", analysis, parameters)};
+    api::CDataFrameAnalysisSpecification spec{jsonSpec};
+
+    TStrVec fieldNames{"feature_1", "feature_2", "feature_3", "label"};
+    TBoolVec emptyAsMissing{spec.columnsForWhichEmptyIsMissing(fieldNames)};
+
+    CPPUNIT_ASSERT_EQUAL(fieldNames.size(), emptyAsMissing.size());
+    CPPUNIT_ASSERT_EQUAL(false, bool(emptyAsMissing[0]));
+    CPPUNIT_ASSERT_EQUAL(false, bool(emptyAsMissing[1]));
+    CPPUNIT_ASSERT_EQUAL(false, bool(emptyAsMissing[2]));
+    CPPUNIT_ASSERT_EQUAL(expected_dependentVariableEmptyAsMissing,
+                         bool(emptyAsMissing[3]));
+}
+
+void CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Classification() {
+    testColumnsForWhichEmptyIsMissing("classification", true);
+}
+
+void CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Regression() {
+    testColumnsForWhichEmptyIsMissing("regression", false);
+}
+
 CppUnit::Test* CDataFrameAnalysisRunnerTest::suite() {
     CppUnit::TestSuite* suiteOfTests = new CppUnit::TestSuite("CDataFrameAnalysisRunnerTest");
 
@@ -213,6 +243,12 @@ CppUnit::Test* CDataFrameAnalysisRunnerTest::suite() {
     suiteOfTests->addTest(new CppUnit::TestCaller<CDataFrameAnalysisRunnerTest>(
         "CDataFrameAnalysisRunnerTest::testEstimateMemoryUsage_1000",
         &CDataFrameAnalysisRunnerTest::testEstimateMemoryUsage_1000));
+    suiteOfTests->addTest(new CppUnit::TestCaller<CDataFrameAnalysisRunnerTest>(
+        "CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Classification",
+        &CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Classification));
+    suiteOfTests->addTest(new CppUnit::TestCaller<CDataFrameAnalysisRunnerTest>(
+        "CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Regression",
+        &CDataFrameAnalysisRunnerTest::testColumnsForWhichEmptyIsMissing_Regression));
 
     return suiteOfTests;
 }
diff --git a/lib/api/unittest/CDataFrameAnalysisRunnerTest.h b/lib/api/unittest/CDataFrameAnalysisRunnerTest.h
@@ -18,6 +18,8 @@ class CDataFrameAnalysisRunnerTest : public CppUnit::TestFixture {
     void testEstimateMemoryUsage_10();
     void testEstimateMemoryUsage_100();
     void testEstimateMemoryUsage_1000();
+    void testColumnsForWhichEmptyIsMissing_Classification();
+    void testColumnsForWhichEmptyIsMissing_Regression();
 
     static CppUnit::Test* suite();
 
diff --git a/lib/api/unittest/CDataFrameAnalyzerTest.cc b/lib/api/unittest/CDataFrameAnalyzerTest.cc
@@ -44,6 +44,7 @@ using TDoubleVecVec = std::vector<TDoubleVec>;
 using TSizeVec = std::vector<std::size_t>;
 using TStrVec = std::vector<std::string>;
 using TRowItr = core::CDataFrame::TRowItr;
+using TRowRef = core::CDataFrame::TRowRef;
 using TPoint = maths::CDenseVector<maths::CFloatStorage>;
 using TPointVec = std::vector<TPoint>;
 using TDataFrameUPtr = std::unique_ptr<core::CDataFrame>;
@@ -144,20 +145,21 @@ auto outlierSpec(std::size_t rows = 110,
     return std::make_unique<api::CDataFrameAnalysisSpecification>(spec);
 }
 
-auto regressionSpec(std::string dependentVariable,
-                    std::size_t rows = 100,
-                    std::size_t cols = 5,
-                    std::size_t memoryLimit = 3000000,
-                    std::size_t numberRoundsPerHyperparameter = 0,
-                    std::size_t bayesianOptimisationRestarts = 0,
-                    const TStrVec& categoricalFieldNames = TStrVec{},
-                    double lambda = -1.0,
-                    double gamma = -1.0,
-                    double eta = -1.0,
-                    std::size_t maximumNumberTrees = 0,
-                    double featureBagFraction = -1.0,
-                    CDataFrameAnalyzerTest::TPersisterSupplier* persisterSupplier = nullptr,
-                    CDataFrameAnalyzerTest::TRestoreSearcherSupplier* restoreSearcherSupplier = nullptr) {
+auto analysisSpec(std::string analysis,
+                  std::string dependentVariable,
+                  std::size_t rows = 100,
+                  std::size_t cols = 5,
+                  std::size_t memoryLimit = 3000000,
+                  std::size_t numberRoundsPerHyperparameter = 0,
+                  std::size_t bayesianOptimisationRestarts = 0,
+                  const TStrVec& categoricalFieldNames = TStrVec{},
+                  double lambda = -1.0,
+                  double gamma = -1.0,
+                  double eta = -1.0,
+                  std::size_t maximumNumberTrees = 0,
+                  double featureBagFraction = -1.0,
+                  CDataFrameAnalyzerTest::TPersisterSupplier* persisterSupplier = nullptr,
+                  CDataFrameAnalyzerTest::TRestoreSearcherSupplier* restoreSearcherSupplier = nullptr) {
 
     std::string parameters = "{\n\"dependent_variable\": \"" + dependentVariable + "\"";
     if (lambda >= 0.0) {
@@ -189,7 +191,7 @@ auto regressionSpec(std::string dependentVariable,
 
     std::string spec{api::CDataFrameAnalysisSpecificationJsonWriter::jsonString(
         "testJob", rows, cols, memoryLimit, 1, categoricalFieldNames, true,
-        test::CTestTmpDir::tmpDir(), "ml", "regression", parameters)};
+        test::CTestTmpDir::tmpDir(), "ml", analysis, parameters)};
 
     LOG_TRACE(<< "spec =\n" << spec);
 
@@ -614,7 +616,7 @@ void CDataFrameAnalyzerTest::testRunBoostedTreeTraining() {
 
     TStrVec fieldNames{"c1", "c2", "c3", "c4", "c5", ".", "."};
     TStrVec fieldValues{"", "", "", "", "", "0", ""};
-    api::CDataFrameAnalyzer analyzer{regressionSpec("c5"), outputWriterFactory};
+    api::CDataFrameAnalyzer analyzer{analysisSpec("regression", "c5"), outputWriterFactory};
     addRegressionTestData(fieldNames, fieldValues, analyzer, expectedPredictions);
 
     core::CStopWatch watch{true};
@@ -676,8 +678,8 @@ void CDataFrameAnalyzerTest::testRunBoostedTreeTrainingWithParams() {
     };
 
     api::CDataFrameAnalyzer analyzer{
-        regressionSpec("c5", 100, 5, 3000000, 0, 0, {}, lambda, gamma, eta,
-                       maximumNumberTrees, featureBagFraction),
+        analysisSpec("regression", "c5", 100, 5, 3000000, 0, 0, {}, lambda,
+                     gamma, eta, maximumNumberTrees, featureBagFraction),
         outputWriterFactory};
 
     TDoubleVec expectedPredictions;
@@ -728,8 +730,8 @@ void CDataFrameAnalyzerTest::testRunBoostedTreeTrainingWithRowsMissingTargetValu
 
     auto target = [](double feature) { return 10.0 * feature; };
 
-    api::CDataFrameAnalyzer analyzer{regressionSpec("target", 50, 2, 2000000),
-                                     outputWriterFactory};
+    api::CDataFrameAnalyzer analyzer{
+        analysisSpec("regression", "target", 50, 2, 2000000), outputWriterFactory};
 
     TDoubleVec feature;
     rng.generateUniformSamples(1.0, 3.0, 50, feature);
@@ -946,7 +948,8 @@ void CDataFrameAnalyzerTest::testCategoricalFields() {
 
     {
         api::CDataFrameAnalyzer analyzer{
-            regressionSpec("x5", 1000, 5, 8000000, 0, 0, {"x1", "x2"}), outputWriterFactory};
+            analysisSpec("regression", "x5", 1000, 5, 8000000, 0, 0, {"x1", "x2"}),
+            outputWriterFactory};
 
         TStrVec x[]{{"x11", "x12", "x13", "x14", "x15"},
                     {"x21", "x22", "x23", "x24", "x25", "x26", "x27"}};
@@ -972,7 +975,7 @@ void CDataFrameAnalyzerTest::testCategoricalFields() {
                 passed &= (expected[1] == (*row)[1]);
                 if (wasPassed && passed == false) {
                     LOG_ERROR(<< "expected " << core::CContainerPrinter::print(expected)
-                              << "got [" << (*row)[0] << ", " << (*row)[1] << "]");
+                              << ", got [" << (*row)[0] << ", " << (*row)[1] << "]");
                 }
             }
         });
@@ -984,9 +987,9 @@ void CDataFrameAnalyzerTest::testCategoricalFields() {
     {
         std::size_t rows{api::CDataFrameAnalyzer::MAX_CATEGORICAL_CARDINALITY + 3};
 
-        api::CDataFrameAnalyzer analyzer{
-            regressionSpec("x5", rows, 5, 8000000000, 0, 0, {"x1"}, 0, 0, 0, 0, 0),
-            outputWriterFactory};
+        api::CDataFrameAnalyzer analyzer{analysisSpec("regression", "x5", rows, 5, 8000000000,
+                                                      0, 0, {"x1"}, 0, 0, 0, 0, 0),
+                                         outputWriterFactory};
 
         TStrVec fieldNames{"x1", "x2", "x3", "x4", "x5", ".", "."};
         TStrVec fieldValues{"", "", "", "", "", "", ""};
@@ -1009,7 +1012,7 @@ void CDataFrameAnalyzerTest::testCategoricalFields() {
                 bool wasPassed{passed};
                 passed &= (expected == (*row)[0]);
                 if (wasPassed && passed == false) {
-                    LOG_ERROR(<< "expected " << expected << " got " << (*row)[0]);
+                    LOG_ERROR(<< "expected " << expected << ", got " << (*row)[0]);
                 }
             }
         });
@@ -1018,6 +1021,66 @@ void CDataFrameAnalyzerTest::testCategoricalFields() {
     }
 }
 
+void CDataFrameAnalyzerTest::testCategoricalFields_EmptyAsMissing() {
+
+    auto eq = [](double expected) {
+        return [expected](double actual) { return expected == actual; };
+    };
+
+    auto nan = []() { return [](double actual) { return isnan(actual); }; };
+
+    auto assertRow = [&](const std::size_t row_i,
+                         const std::vector<std::function<bool(double)>>& matchers,
+                         const TRowRef& row) {
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("row " + std::to_string(row_i),
+                                     matchers.size(), row.numberColumns());
+        for (std::size_t i = 0; i < row.numberColumns(); ++i) {
+            CPPUNIT_ASSERT_MESSAGE("row " + std::to_string(row_i) +
+                                       ", column " + std::to_string(i),
+                                   matchers[i](row[i]));
+        }
+    };
+
+    std::stringstream output;
+    auto outputWriterFactory = [&output]() {
+        return std::make_unique<core::CJsonOutputStreamWrapper>(output);
+    };
+
+    api::CDataFrameAnalyzer analyzer{analysisSpec("classification", "x5", 1000, 5,
+                                                  8000000, 0, 0, {"x1", "x2", "x5"}),
+                                     outputWriterFactory};
+
+    TStrVec fieldNames{"x1", "x2", "x3", "x4", "x5", ".", "."};
+    analyzer.handleRecord(fieldNames, {"x11", "x21", "0", "0", "x51", "0", ""});
+    analyzer.handleRecord(fieldNames, {"x12", "x22", "1", "1", "x52", "1", ""});
+    analyzer.handleRecord(fieldNames, {"",    "x23", "2", "2", "x51", "2", ""});
+    analyzer.handleRecord(fieldNames, {"x14", "x24", "3", "3", "",    "3", ""});
+    analyzer.handleRecord(fieldNames, {"x15", "x25", "4", "4", "x51", "4", ""});
+    analyzer.handleRecord(fieldNames, {"x11", "x26", "5", "5", "x52", "5", ""});
+    analyzer.handleRecord(fieldNames, {"x12", "",    "6", "6", "",    "6", ""});
+    analyzer.handleRecord(fieldNames, {"x13", "x21", "7", "7", "",    "7", ""});
+    analyzer.handleRecord(fieldNames, {"x14", "x22", "8", "8", "x51", "8", ""});
+    analyzer.handleRecord(fieldNames, {"",    "x23", "9", "9", "x52", "9", ""});
+    analyzer.receivedAllRows();
+
+    const core::CDataFrame& frame{analyzer.dataFrame()};
+    frame.readRows(1, [&](TRowItr beginRows, TRowItr endRows) {
+        std::vector<TRowRef> rows;
+        std::copy(beginRows, endRows, std::back_inserter(rows));
+        CPPUNIT_ASSERT_EQUAL(10UL, rows.size());
+        assertRow(0, {eq(0.0), eq(0.0), eq(0.0), eq(0.0), eq(0.0)}, rows[0]);
+        assertRow(1, {eq(1.0), eq(1.0), eq(1.0), eq(1.0), eq(1.0)}, rows[1]);
+        assertRow(2, {eq(2.0), eq(2.0), eq(2.0), eq(2.0), eq(0.0)}, rows[2]);
+        assertRow(3, {eq(3.0), eq(3.0), eq(3.0), eq(3.0), nan()  }, rows[3]);
+        assertRow(4, {eq(4.0), eq(4.0), eq(4.0), eq(4.0), eq(0.0)}, rows[4]);
+        assertRow(5, {eq(0.0), eq(5.0), eq(5.0), eq(5.0), eq(1.0)}, rows[5]);
+        assertRow(6, {eq(1.0), eq(6.0), eq(6.0), eq(6.0), nan()  }, rows[6]);
+        assertRow(7, {eq(5.0), eq(0.0), eq(7.0), eq(7.0), nan()  }, rows[7]);
+        assertRow(8, {eq(3.0), eq(1.0), eq(8.0), eq(8.0), eq(0.0)}, rows[8]);
+        assertRow(9, {eq(2.0), eq(2.0), eq(9.0), eq(9.0), eq(1.0)}, rows[9]);
+    });
+}
+
 CppUnit::Test* CDataFrameAnalyzerTest::suite() {
     CppUnit::TestSuite* suiteOfTests = new CppUnit::TestSuite("CDataFrameAnalyzerTest");
 
@@ -1058,6 +1121,9 @@ CppUnit::Test* CDataFrameAnalyzerTest::suite() {
     suiteOfTests->addTest(new CppUnit::TestCaller<CDataFrameAnalyzerTest>(
         "CDataFrameAnalyzerTest::testCategoricalFields",
         &CDataFrameAnalyzerTest::testCategoricalFields));
+    suiteOfTests->addTest(new CppUnit::TestCaller<CDataFrameAnalyzerTest>(
+        "CDataFrameAnalyzerTest::testCategoricalFields_EmptyAsMissing",
+        &CDataFrameAnalyzerTest::testCategoricalFields_EmptyAsMissing));
 
     return suiteOfTests;
 }
@@ -1137,9 +1203,9 @@ void CDataFrameAnalyzerTest::testRunBoostedTreeTrainingWithStateRecoverySubrouti
     // compute expected tree
 
     api::CDataFrameAnalyzer analyzer{
-        regressionSpec("c5", numberExamples, 5, 15000000,
-                       numberRoundsPerHyperparameter, 12, {}, lambda, gamma, eta,
-                       maximumNumberTrees, featureBagFraction, &persisterSupplier),
+        analysisSpec("regression", "c5", numberExamples, 5, 15000000,
+                     numberRoundsPerHyperparameter, 12, {}, lambda, gamma, eta,
+                     maximumNumberTrees, featureBagFraction, &persisterSupplier),
         outputWriterFactory};
     std::size_t dependentVariable(
         std::find(fieldNames.begin(), fieldNames.end(), "c5") - fieldNames.begin());
@@ -1161,9 +1227,9 @@ void CDataFrameAnalyzerTest::testRunBoostedTreeTrainingWithStateRecoverySubrouti
     };
 
     api::CDataFrameAnalyzer analyzerToRestore{
-        regressionSpec("c5", numberExamples, 5, 15000000, numberRoundsPerHyperparameter,
-                       12, {}, lambda, gamma, eta, maximumNumberTrees, featureBagFraction,
-                       &persisterSupplier, &restoreSearcherSupplier),
+        analysisSpec("regression", "c5", numberExamples, 5, 15000000, numberRoundsPerHyperparameter,
+                     12, {}, lambda, gamma, eta, maximumNumberTrees, featureBagFraction,
+                     &persisterSupplier, &restoreSearcherSupplier),
         outputWriterFactory};
 
     passDataToAnalyzer(fieldNames, fieldValues, analyzerToRestore, weights, values);
diff --git a/lib/api/unittest/CDataFrameAnalyzerTest.h b/lib/api/unittest/CDataFrameAnalyzerTest.h
@@ -39,6 +39,7 @@ class CDataFrameAnalyzerTest : public CppUnit::TestFixture {
     void testErrors();
     void testRoundTripDocHashes();
     void testCategoricalFields();
+    void testCategoricalFields_EmptyAsMissing();
 
     static CppUnit::Test* suite();
 
