[GPU-Plugin] Add GPU accelerated prediction (#2593)

* [GPU-Plugin] Add GPU accelerated prediction

* Improve allocation message

* Update documentation

* Resolve linker error for predictor

* Add unit tests

plugin/updater_gpu/test/cpp/test_device_helpers.cu

@@ -37,7 +37,7 @@ void SpeedTest() {
 
   dh::Timer t;
   dh::TransformLbs(
-      0, &temp_memory, h_rows.size(), dh::raw(row_ptr), row_ptr.size() - 1,
+      0, &temp_memory, h_rows.size(), dh::raw(row_ptr), row_ptr.size() - 1, false,
       [=] __device__(size_t idx, size_t ridx) { d_output_row[idx] = ridx; });
 
   dh::safe_cuda(cudaDeviceSynchronize());
@@ -65,7 +65,7 @@ void TestLbs() {
       auto d_output_row = output_row.data();
 
       dh::TransformLbs(0, &temp_memory, h_rows.size(), dh::raw(row_ptr),
-                       row_ptr.size() - 1,
+                       row_ptr.size() - 1, false,
                        [=] __device__(size_t idx, size_t ridx) {
                          d_output_row[idx] = ridx;
                        });

plugin/updater_gpu/test/cpp/test_gpu_predictor.cu

@@ -0,0 +1,73 @@
+
+/*!
+ * Copyright 2017 XGBoost contributors
+ */
+#include <xgboost/c_api.h>
+#include <xgboost/predictor.h>
+#include "gtest/gtest.h"
+#include "../../../../tests/cpp/helpers.h"
+
+namespace xgboost {
+namespace predictor {
+TEST(gpu_predictor, Test) {
+  std::unique_ptr<Predictor> gpu_predictor =
+      std::unique_ptr<Predictor>(Predictor::Create("gpu_predictor"));
+  std::unique_ptr<Predictor> cpu_predictor =
+      std::unique_ptr<Predictor>(Predictor::Create("cpu_predictor"));
+
+  std::vector<std::unique_ptr<RegTree>> trees;
+  trees.push_back(std::make_unique<RegTree>());
+  trees.back()->InitModel();
+  (*trees.back())[0].set_leaf(1.5f);
+  gbm::GBTreeModel model(0.5);
+  model.CommitModel(std::move(trees), 0);
+  model.param.num_output_group = 1;
+
+  int n_row = 5;
+  int n_col = 5;
+
+  auto dmat = CreateDMatrix(n_row, n_col, 0);
+
+  // Test predict batch
+  std::vector<float> gpu_out_predictions;
+  std::vector<float> cpu_out_predictions;
+  gpu_predictor->PredictBatch(dmat.get(), &gpu_out_predictions, model, 0);
+  cpu_predictor->PredictBatch(dmat.get(), &cpu_out_predictions, model, 0);
+  float abs_tolerance = 0.001;
+  for (int i = 0; i < gpu_out_predictions.size(); i++) {
+    ASSERT_LT(std::abs(gpu_out_predictions[i] - cpu_out_predictions[i]),
+              abs_tolerance);
+  }
+
+  // Test predict instance
+  auto batch = dmat->RowIterator()->Value();
+  for (int i = 0; i < batch.size; i++) {
+    std::vector<float> gpu_instance_out_predictions;
+    std::vector<float> cpu_instance_out_predictions;
+    cpu_predictor->PredictInstance(batch[i], &cpu_instance_out_predictions,
+                                   model);
+    gpu_predictor->PredictInstance(batch[i], &gpu_instance_out_predictions,
+                                   model);
+    ASSERT_EQ(gpu_instance_out_predictions[0], cpu_instance_out_predictions[0]);
+  }
+
+  // Test predict leaf
+  std::vector<float> gpu_leaf_out_predictions;
+  std::vector<float> cpu_leaf_out_predictions;
+  cpu_predictor->PredictLeaf(dmat.get(), &cpu_leaf_out_predictions, model);
+  gpu_predictor->PredictLeaf(dmat.get(), &gpu_leaf_out_predictions, model);
+  for (int i = 0; i < gpu_leaf_out_predictions.size(); i++) {
+    ASSERT_EQ(gpu_leaf_out_predictions[i], cpu_leaf_out_predictions[i]);
+  }
+
+  // Test predict contribution
+  std::vector<float> gpu_out_contribution;
+  std::vector<float> cpu_out_contribution;
+  cpu_predictor->PredictContribution(dmat.get(), &cpu_out_contribution, model);
+  gpu_predictor->PredictContribution(dmat.get(), &gpu_out_contribution, model);
+  for (int i = 0; i < gpu_out_contribution.size(); i++) {
+    ASSERT_EQ(gpu_out_contribution[i], cpu_out_contribution[i]);
+  }
+}
+}  // namespace predictor
+}  // namespace xgboost

plugin/updater_gpu/test/python/test_large.py

@@ -109,6 +109,4 @@ class TestGPU(unittest.TestCase):
                       evals_result=ag_res3)
             print("Time to Train: %s seconds" % (str(time.time() - tmp)))
 
-
-    
     

plugin/updater_gpu/test/python/test_prediction.py

@@ -0,0 +1,37 @@
+from __future__ import print_function
+#pylint: skip-file
+import sys
+sys.path.append("../../tests/python")
+import xgboost as xgb
+import testing as tm
+import numpy as np
+import unittest
+
+rng = np.random.RandomState(1994)
+
+
+class TestGPUPredict (unittest.TestCase):
+    def test_predict(self):
+        iterations = 1
+        np.random.seed(1)
+        test_num_rows = [10,1000,5000]
+        test_num_cols = [10,50,500]
+        for num_rows in test_num_rows:
+            for num_cols in test_num_cols:
+                dm = xgb.DMatrix(np.random.randn(num_rows, num_cols), label=[0, 1] * int(num_rows/2))
+                watchlist = [(dm, 'train')]
+                res = {}
+                param = {
+                    "objective":"binary:logistic",
+                    "predictor":"gpu_predictor",
+                    'eval_metric': 'auc',
+                }
+                bst = xgb.train(param, dm,iterations,evals=watchlist, evals_result=res)
+                assert self.non_decreasing(res["train"]["auc"])
+                gpu_pred = bst.predict(dm, output_margin=True)
+                bst.set_param({"predictor":"cpu_predictor"})
+                cpu_pred = bst.predict(dm, output_margin=True)
+                np.testing.assert_allclose(cpu_pred, gpu_pred, rtol=1e-5)
+
+    def non_decreasing(self, L):
+        return all((x - y) < 0.001 for x, y in zip(L, L[1:]))