[EM] Get quantile cuts from the extmem qdm.

doc/tutorials/external_memory.rst

@@ -206,7 +206,7 @@ in-core training is one additional data read when the data is dense.
 
 To run experiments on these platforms, the open source `NVIDIA Linux driver
 <https://developer.nvidia.com/blog/nvidia-transitions-fully-towards-open-source-gpu-kernel-modules/>`__
-with version ``>=565.47`` is required.
+with version ``>=565.47`` is required, it should come with CTK 12.7 and later versions.
 
 **************
 Best Practices

python-package/xgboost/testing/updater.py

@@ -211,6 +211,7 @@ def check_extmem_qdm(
         cache="cache",
         on_host=on_host,
     )
+
     Xy_it = xgb.ExtMemQuantileDMatrix(it)
     with pytest.raises(ValueError, match="Only the `hist`"):
         booster_it = xgb.train(
@@ -227,12 +228,11 @@ def check_extmem_qdm(
     Xy = xgb.QuantileDMatrix(it)
     booster = xgb.train({"device": device}, Xy, num_boost_round=8)
 
-    if device == "cpu":
-        # Get cuts from ellpack without CPU-GPU interpolation is not yet supported.
-        cut_it = Xy_it.get_quantile_cut()
-        cut = Xy.get_quantile_cut()
-        np.testing.assert_allclose(cut_it[0], cut[0])
-        np.testing.assert_allclose(cut_it[1], cut[1])
+    # Get cuts from ellpack without CPU-GPU interpolation is not yet supported.
+    cut_it = Xy_it.get_quantile_cut()
+    cut = Xy.get_quantile_cut()
+    np.testing.assert_allclose(cut_it[0], cut[0])
+    np.testing.assert_allclose(cut_it[1], cut[1])
 
     predt_it = booster_it.predict(Xy_it)
     predt = booster.predict(Xy)

src/data/extmem_quantile_dmatrix.cc

@@ -58,7 +58,7 @@ ExtMemQuantileDMatrix::~ExtMemQuantileDMatrix() {
 }
 
 BatchSet<ExtSparsePage> ExtMemQuantileDMatrix::GetExtBatches(Context const *, BatchParam const &) {
-  LOG(FATAL) << "Not implemented";
+  LOG(FATAL) << "Not implemented for `ExtMemQuantileDMatrix`.";
   auto begin_iter =
       BatchIterator<ExtSparsePage>(new SimpleBatchIteratorImpl<ExtSparsePage>(nullptr));
   return BatchSet<ExtSparsePage>{begin_iter};
@@ -121,7 +121,8 @@ BatchSet<GHistIndexMatrix> ExtMemQuantileDMatrix::GetGradientIndex(Context const
     CHECK(!detail::RegenGHist(param, batch_)) << error::InconsistentMaxBin();
   }
 
-  CHECK(this->ghist_index_source_);
+  CHECK(this->ghist_index_source_)
+      << "The `ExtMemQuantileDMatrix` is initialized using GPU data, cannot be used for CPU.";
   this->ghist_index_source_->Reset(param);
 
   if (!std::isnan(param.sparse_thresh) &&

src/data/extmem_quantile_dmatrix.cu

@@ -80,7 +80,8 @@ BatchSet<EllpackPage> ExtMemQuantileDMatrix::GetEllpackBatches(Context const *,
 
   std::visit(
       [this, param](auto &&ptr) {
-        CHECK(ptr);
+        CHECK(ptr)
+            << "The `ExtMemQuantileDMatrix` is initialized using CPU data, cannot be used for GPU.";
         ptr->Reset(param);
       },
       this->ellpack_page_source_);

src/data/extmem_quantile_dmatrix.h

@@ -54,7 +54,9 @@ class ExtMemQuantileDMatrix : public QuantileDMatrix {
   [[nodiscard]] bool EllpackExists() const override {
     return std::visit([](auto &&v) { return static_cast<bool>(v); }, ellpack_page_source_);
   }
-  [[nodiscard]] bool GHistIndexExists() const override { return true; }
+  [[nodiscard]] bool GHistIndexExists() const override {
+    return static_cast<bool>(ghist_index_source_);
+  }
 
   [[nodiscard]] BatchSet<ExtSparsePage> GetExtBatches(Context const *ctx,
                                                       BatchParam const &param) override;

src/data/gradient_index.cc

@@ -189,13 +189,13 @@ common::ColumnMatrix const &GHistIndexMatrix::Transpose() const {
 bst_bin_t GHistIndexMatrix::GetGindex(size_t ridx, size_t fidx) const {
   auto begin = RowIdx(ridx);
   if (IsDense()) {
-    return static_cast<bst_bin_t>(index[begin + fidx]);
+    return static_cast<bst_bin_t>(this->index[begin + fidx]);
   }
   auto end = RowIdx(ridx + 1);
   auto const& cut_ptrs = cut.Ptrs();
   auto f_begin = cut_ptrs[fidx];
   auto f_end = cut_ptrs[fidx + 1];
-  return BinarySearchBin(begin, end, index, f_begin, f_end);
+  return BinarySearchBin(begin, end, this->index, f_begin, f_end);
 }
 
 float GHistIndexMatrix::GetFvalue(size_t ridx, size_t fidx, bool is_cat) const {

tests/python-gpu/test_gpu_data_iterator.py

@@ -68,17 +68,35 @@ def test_cpu_data_iterator() -> None:
     strategies.booleans(),
 )
 @settings(deadline=None, max_examples=10, print_blob=True)
+@pytest.mark.filterwarnings("ignore")
 def test_extmem_qdm(
     n_samples_per_batch: int, n_features: int, n_batches: int, on_host: bool
 ) -> None:
     check_extmem_qdm(n_samples_per_batch, n_features, n_batches, "cuda", on_host)
 
 
+@pytest.mark.filterwarnings("ignore")
+def test_invalid_device_extmem_qdm() -> None:
+    it = tm.IteratorForTest(
+        *tm.make_batches(16, 4, 2, use_cupy=False), cache="cache", on_host=True
+    )
+    Xy = xgb.ExtMemQuantileDMatrix(it)
+    with pytest.raises(ValueError, match="cannot be used for GPU"):
+        xgb.train({"device": "cuda"}, Xy)
+
+    it = tm.IteratorForTest(
+        *tm.make_batches(16, 4, 2, use_cupy=True), cache="cache", on_host=True
+    )
+    Xy = xgb.ExtMemQuantileDMatrix(it)
+    with pytest.raises(ValueError, match="cannot be used for CPU"):
+        xgb.train({"device": "cpu"}, Xy)
+
+
 def test_concat_pages() -> None:
     it = tm.IteratorForTest(*tm.make_batches(64, 16, 4, use_cupy=True), cache=None)
     Xy = xgb.ExtMemQuantileDMatrix(it)
     with pytest.raises(ValueError, match="can not be used with concatenated pages"):
-        booster = xgb.train(
+        xgb.train(
             {
                 "device": "cuda",
                 "subsample": 0.5,