Correct computation of metrics in multi-quantile regression. (dmlc#11279)

---------

Co-authored-by: Jiaming Yuan <[email protected]>

Author: t-ens

python-package/xgboost/testing/metrics.py

@@ -78,3 +78,21 @@ def check_quantile_error(tree_method: str) -> None:
     predt = booster.inplace_predict(X)
     loss = mean_pinball_loss(y, predt, alpha=0.3)
     np.testing.assert_allclose(evals_result["Train"]["quantile"][-1], loss)
+
+    alpha = [0.25, 0.5, 0.75]
+    booster = xgb.train(
+        {
+            "tree_method": tree_method,
+            "eval_metric": "quantile",
+            "quantile_alpha": alpha,
+            "objective": "reg:quantileerror",
+        },
+        Xy,
+        evals=[(Xy, "Train")],
+        evals_result=evals_result,
+    )
+    predt = booster.inplace_predict(X)
+    loss = np.mean(
+        [mean_pinball_loss(y, predt[:, i], alpha=alpha[i]) for i in range(3)]
+    )
+    np.testing.assert_allclose(evals_result["Train"]["quantile"][-1], loss)

src/metric/elementwise_metric.cu

@@ -43,15 +43,16 @@ namespace {
  *   applying the weights.  A tuple of {error_i, weight_i} is expected as return.
  */
 template <typename Fn>
-PackedReduceResult Reduce(Context const* ctx, MetaInfo const& info, Fn&& loss) {
+PackedReduceResult Reduce(Context const* ctx, MetaInfo const& info, Fn&& loss,
+                          size_t num_preds = 1) {
   PackedReduceResult result;
   // This function doesn't have sycl-specific implementation yet.
   // For that reason we transfer data to host in case of sycl is used for propper execution.
   auto labels = info.labels.View(ctx->Device().IsSycl() ? DeviceOrd::CPU() : ctx->Device());
   if (ctx->IsCUDA()) {
 #if defined(XGBOOST_USE_CUDA)
     thrust::counting_iterator<size_t> begin(0);
-    thrust::counting_iterator<size_t> end = begin + labels.Size();
+    thrust::counting_iterator<size_t> end = begin + labels.Size() * num_preds;
     result = thrust::transform_reduce(
         ctx->CUDACtx()->CTP(), begin, end,
         [=] XGBOOST_DEVICE(size_t i) {
@@ -76,7 +77,7 @@ PackedReduceResult Reduce(Context const* ctx, MetaInfo const& info, Fn&& loss) {
     // - sqrt(1/w(sum_t0 + sum_t1 + ... + sum_tm))       // multi-target
     // - sqrt(avg_t0) + sqrt(avg_t1) + ... sqrt(avg_tm)  // distributed
 
-    auto size = info.labels.Size();
+    auto size = info.labels.Size() * num_preds;
     auto const kBlockSize = 2048;
     auto n_blocks = size / kBlockSize + 1;
 
@@ -491,7 +492,7 @@ class QuantileError : public MetricNoCache {
           auto l =
               loss(y_predt(sample_id, quantile_id, target_id), y_true(sample_id, target_id)) * w;
           return std::make_tuple(l, w);
-        });
+        }, alpha_.Size());
     std::array<double, 2> dat{result.Residue(), result.Weights()};
     auto rc = collective::GlobalSum(ctx, info, linalg::MakeVec(dat.data(), dat.size()));
     collective::SafeColl(rc);

tests/cpp/metric/test_elementwise_metric.h

@@ -348,6 +348,11 @@ inline void VerifyQuantile(DataSplitMode data_split_mode, DeviceOrd device) {
   std::unique_ptr<Metric> metric{Metric::Create("quantile", &ctx)};
 
   HostDeviceVector<float> predts{0.1f, 0.9f, 0.1f, 0.9f};
+  HostDeviceVector<float> predts_2{0.2f, 0.6f, 0.4f, 0.6f, 0.5f, 1.2f, 0.0f, 0.4f};
+  HostDeviceVector<float> predts_3{0.2f, 0.4f, 0.6f,
+                                   0.4f, 0.5f, 0.6f,
+                                   0.5f, 0.8f, 1.2f,
+                                   0.0f, 0.3f, 0.4f};
   std::vector<float> labels{0.5f, 0.5f, 0.9f, 0.1f};
   std::vector<float> weights{0.2f, 0.4f, 0.6f, 0.8f};
 
@@ -377,5 +382,12 @@ inline void VerifyQuantile(DataSplitMode data_split_mode, DeviceOrd device) {
   EXPECT_NEAR(GetMetricEval(metric.get(), predts, labels, {}, {}, data_split_mode), 0.3f, 0.001f);
   metric->Configure(Args{{"quantile_alpha", "[1.0]"}});
   EXPECT_NEAR(GetMetricEval(metric.get(), predts, labels, {}, {}, data_split_mode), 0.3f, 0.001f);
+
+  metric->Configure(Args{{"quantile_alpha", "[0.2, 0.8]"}});
+  EXPECT_NEAR(GetMetricEval(metric.get(), predts_2, labels, {}, {}, data_split_mode), 0.0425f,
+              0.0001f);
+  metric->Configure(Args{{"quantile_alpha", "[0.2, 0.5, 0.8]"}});
+  EXPECT_NEAR(GetMetricEval(metric.get(), predts_3, labels, {}, {}, data_split_mode), 0.0450f,
+              0.0001f);
 }
 }  // namespace xgboost::metric