Use runs-on GPU runners for CI (#212)

* Use runs-on GPU runners for CI

Replace self-hosted GPU runners with runs-on g4dn.xlarge spot instances,
matching the approach in mlverse/torch#1439. Also modernizes the workflow:

- Action versions: checkout@v4, setup-python@v5, setup-r@v2, etc.
- Fix deprecated ::set-output → $GITHUB_OUTPUT
- Container: ubuntu18.04 → ubuntu20.04 (18.04 is EOL)
- Add --runtime=nvidia to container options
- Add concurrency groups with cancel-in-progress
- Simplify matrix to single config (CUDA 11.2.1, cuML 21.12, R release)
- Drop ASAN matrix dimension

* Revert container to ubuntu18.04 for CUDA 11.2 compatibility

* Use CUDA 11.2.2 container (11.2.1 removed from Docker Hub)

* Bump container to ubuntu20.04 (18.04 glibc too old for Node 20 actions)

* Split CI into build-image (free runner) and test-gpu (GPU runner)

- Build Docker image with cuda.ml pre-installed on ubuntu-latest (free)
- Run tests on runs-on g4dn.xlarge GPU runner using the pre-built image
- Add .github/docker/Dockerfile following the same pattern as mlverse/torch
- Make CMAKE_CUDA_ARCHITECTURES configurable via env var (defaults to NATIVE)
  so cross-compilation works on runners without a GPU (targets T4 = SM 75)
- Remove miniconda install (no longer needed for reticulate tests)

* Fix sklearn install: use scikit-learn package name and py_require()

The 'sklearn' PyPI package is deprecated in favor of 'scikit-learn'.
Also switch from py_install() to py_require() which is the modern
reticulate API for declaring Python dependencies.

* Fix configure warnings: normalizePath ordering and cmake unused variable

- Move download_libcuml() before normalizePath() so the directory exists
- Reference CUML_STUB_HEADERS_DIR in both Treelite found/not-found branches
  so cmake doesn't warn about unused variable

* Fix TSVD tests for SVD sign ambiguity between cuML and sklearn

SVD components are only defined up to sign, so different implementations
can produce sign-flipped vectors that are mathematically equivalent.
Align signs before comparing components and transformed data.

* Fix sklearn max_iter type: use integer (10000L) not float (10000.0)

Modern sklearn strictly validates that max_iter is an int. R's default
numeric type is double, which reticulate passes as a Python float.
Using 10000L ensures it's passed as a Python int.

* Add CRAN-like check job (no CUDA, stub headers, ubuntu-latest)

Runs R CMD check --as-cran on ubuntu-latest with R release and devel.
No nvcc/CUDA available, so the package builds with stub headers — matching
what CRAN would see.

* Update roxygen

* export S3 methods

* roxygen updates

* Fix CRAN check: escape Rd braces, skip tests without cuML

- Escape literal braces in roxygen comments across R source files and
  templates (e.g. {cuda.ml} -> \{cuda.ml\}, {"opt1",...} -> \{"opt1",...\})
- Regenerate all affected Rd files via devtools::document()
- Skip test_check() when cuML is not linked (CRAN-like environments)
- Use R CMD check directly in CRAN job (avoids rcmdcheck NOT_CRAN=true)

* Fix examples brace escaping and register S3 methods

- Revert brace escaping inside @examples blocks (R code, not Rd markup)
- Define cuda_ml_can_predict_class_probabilities methods as proper
  functions so roxygen registers them as S3method() in NAMESPACE

* Add RAPIDS cuML 26.04 + CUDA 12 support

Build infrastructure:
- Dockerfile: CUDA 12.8.1 + Ubuntu 22.04 base image
- libcuml_versions.R: add 26.04 entry pointing to PyPI libcuml-cu12 wheel
- cuml.R: handle pip wheel extraction (lib64/ layout, .whl extension)
- configure.R: handle lib64/ vs lib/ for pip wheels
- CMakeLists.txt.in: C++17, rapids-cmake branch-26.04
- Workflow: target cuML 26.04

C++ API changes for cuML 26.04:
- svm_serde.h: namespace alias MLCommon::Matrix -> ML::matrix for
  KernelParams and KernelType (header renamed kernelparams.h ->
  kernel_params.hpp)
- fil.cu, fil_utils.h, fil_utils.cu: disable FIL on 26.04 with stubs
  (fil.h replaced by modular headers; full adaptation TODO)
- random_projection.cu: disable on 26.04 with stubs (C++ API removed)
- knn.cu: disable on 26.04 with stubs (raft::spatial::knn types removed)
- random_forest_classifier.cu, random_forest_regressor.cu: guard FIL
  prediction paths for 26.04

Backward compatible: cuML 21.x with CUDA 11 still works.

* Test both cuML 21.12 and 26.04 in CI

- Dockerfile: accept CUDA_IMAGE as build arg for different base images
- Workflow: matrix over cuML 21.12 (CUDA 11.2) and 26.04 (CUDA 12.8)
- Each version gets its own build-image and test-gpu job

* Fix rapids-cmake version and lib symlink for dual cuML support

- CMakeLists.txt.in: template RAPIDS_CMAKE_TAG and CMAKE_CXX_STANDARD
  so they adapt to the cuML version being built against
- configure.R: set rapids-cmake tag (v26.04.00 for 26.x, branch-21.10
  for 21.x) and C++ standard (17 for 26.x, 14 for 21.x)
- cuml.R: don't create premature lib symlink in download_libcuml()

* Derive rapids-cmake tag from cuML version instead of hardcoding

Use vYY.MM.00 for cuML >= 23.02 (stable tags), vYY.MM.00a for older
versions (only alpha tags available).

* Require cmake 3.30.4+ for cuML 26.04 (auto-downloaded if missing)

rapids-cmake v26.04 needs cmake >= 3.30.4. The existing auto-download
logic handles this, but the min version threshold was hardcoded to 3.21.1.
Now it's 3.30.4 for cuML >= 23.02, 3.21.1 for older versions.

* Fix cuML 26.04 build: raft/rmm deps, static_assert, device_allocator

- Download libraft-cu12 and librmm-cu12 wheels alongside libcuml-cu12
  (cuml headers include raft/rmm headers which are in separate packages)
- Merge raft/rmm headers into libcuml/include/ during download
- Remove static_assert(CUML_VERSION_MAJOR == 21) — allow 26+
- Guard raft::mr::device::allocator (removed in raft 26.x) with version
  conditionals in device_allocator.cu/.h and stream_allocator.cu
- Use raft/core/handle.hpp instead of raft/handle.hpp for v26+

* Resolve cuML PyPI deps dynamically instead of hardcoding URLs

- Add tools/config/utils/pypi.R with resolve_native_deps() that walks
  the PyPI dependency tree for a package and returns download URLs for
  all native C++ dependencies (libraft, librmm, rapids-logger, cccl, etc.)
- libcuml_versions.R: cuML 26.04 entry is now just "libcuml-cu12"
  (the PyPI package name), not a hardcoded URL
- cuml.R: download_libcuml() detects PyPI package names vs direct URLs,
  resolves the full dep tree, downloads all wheels, and merges their
  include/ directories into libcuml/include/
- configure.R: load pypi.R utility
- Uses jsonlite for PyPI JSON API parsing

* Download CCCL 3.3 headers for cuML 26.04 builds

RMM 26.04 headers require CCCL >= 3.3 at compile time, but CCCL is not
a pip dependency (it's normally bundled with the CUDA toolkit). CUDA 12.x
ships CCCL 2.x which is too old. Download CCCL v3.3.0 from GitHub
releases (header-only, ~2MB) and merge into libcuml/include/.

Also handle pip wheels that extract to nested dirs like
nvidia/<subpackage>/include/.

* Put CUML_INCLUDE_DIR before CUDA toolkit includes

CCCL 3.3 headers (bundled in libcuml/include/) must take precedence
over the CUDA 12 toolkit's older CCCL 2.x headers. Swap include order
so cuml/raft/rmm/cccl headers are found first.

* Fix CCCL compat, pinned_allocator removal, and raft handle API

- Use RAPIDS-pinned CCCL commit (CUDA 12 compatible) instead of v3.3.0
  release tag which includes CUDA 13-only code
- pinned_host_vector.h: guard thrust::cuda::experimental::pinned_allocator
  (removed in CCCL 3.x); use plain host_vector on v26+
- handle_utils.cu: raft::handle_t no longer has set_stream(); reconstruct
  with stream_view via constructor on v26+

* Switch to cuML 25.12 (no CCCL 3.x requirement)

cuML 26.04's rmm headers require CCCL >= 3.3 which conflicts with
CUDA 12.x toolkit's CCCL 2.x. cuML 25.12 vendors its own CCCL in
librmm/include/rapids/ and has no CCCL version check — clean CUDA 12
compatibility.

- Target cuML 25.12 instead of 26.04
- Version guards: >= 26 -> >= 25 (same API changes apply)
- Re-enable KNN (knn.hpp exists in 25.12 with same API)
- Remove CCCL GitHub download (not needed)
- Update PyPI resolver to handle version pins (==25.12.*)

* Define LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE for RMM

RMM headers require this define (normally set automatically by RMM's
cmake config, but we're using headers directly from the pip wheel).

* Revert cuML 25.x/26.x support (CCCL 3.x incompatible with CUDA 12)

All RAPIDS 25.x+ pip wheels require CCCL 3.x headers which are
incompatible with CUDA 12's bundled CCCL 2.x. No version of
libcuml-cu12 can be compiled against a stock CUDA 12 toolkit.

Revert to cuML 21.12 as the default for now. Supporting newer cuML
will require either CUDA 13 or a custom build environment.

---------

Co-authored-by: Tomasz Kalinowski <kalinowskit@gmail.com>

Author: dfalbel

.Rbuildignore

@@ -31,3 +31,6 @@
 ^libcuml/*
 ^\.github$
 ^\.lsan-suppressions\.txt$
+^\.positai$
+^\.claude$
+^\.codex$

.github/docker/Dockerfile

@@ -0,0 +1,53 @@
+FROM nvidia/cuda:11.2.2-devel-ubuntu20.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# System dependencies
+RUN apt-get update -y && apt-get install -y \
+    sudo software-properties-common dialog apt-utils \
+    tzdata locales curl wget git \
+    libcurl4-openssl-dev libssl-dev libxml2-dev \
+    libfontconfig1-dev libfreetype6-dev libpng-dev \
+    libharfbuzz-dev libfribidi-dev libtiff5-dev libjpeg-dev \
+    make gcc g++ pandoc python3 python3-pip
+
+# Install R via rig
+RUN curl -L https://rig.r-pkg.org/deb/rig.gpg -o /etc/apt/trusted.gpg.d/rig.gpg \
+    && echo "deb http://rig.r-pkg.org/deb rig main" > /etc/apt/sources.list.d/rig.list \
+    && apt-get update \
+    && apt-get install -y r-rig \
+    && rig add release \
+    && rig default release \
+    && rm -rf /var/lib/apt/lists/*
+
+# Use a fixed library path (not HOME-dependent) so packages are found
+# regardless of what HOME is set to at runtime (GitHub Actions sets HOME=/github/home)
+ENV R_LIBS_USER=/opt/R/library
+RUN mkdir -p /opt/R/library
+
+# Parallel compilation
+RUN echo "MAKEFLAGS=-j$(nproc)" >> "$(R RHOME)/etc/Renviron.site"
+
+# Copy source
+COPY . /build
+
+ARG CUML_VERSION=21.12
+ENV CUML_VERSION=${CUML_VERSION}
+
+# Cross-compile for T4 GPU (compute capability 7.5) since build runner has no GPU
+ARG CMAKE_CUDA_ARCHITECTURES=75
+ENV CMAKE_CUDA_ARCHITECTURES=${CMAKE_CUDA_ARCHITECTURES}
+
+ENV NOT_CRAN=true
+
+# Install R dependencies
+RUN Rscript -e "\
+    install.packages('pak', repos = 'https://r-lib.github.io/p/pak/devel/'); \
+    pak::local_install_deps('/build', dependencies = TRUE)" \
+    && rm -rf /tmp/* /root/.cache
+
+# Install cuda.ml with tests
+RUN R CMD INSTALL --install-tests /build
+
+# Clean up
+RUN rm -rf /tmp/* /build

.github/workflows/R-CMD-check.yaml

@@ -1,5 +1,3 @@
-# Workflow derived from https://github.com/r-lib/actions/tree/master/examples
-# Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help
 on:
   push:
     branches: [main]
@@ -9,117 +7,99 @@ on:
 name: R-CMD-check
 
 jobs:
-  R-CMD-check:
-
+  check-cran:
     strategy:
       fail-fast: false
       matrix:
-        cuda: ['11.2.1']
-        cuml: ['21.08', '21.10', '21.12']
         r: ['release', 'devel']
-        asan: ['false', 'true']
-
-    runs-on: ['self-hosted', 'gpu']
-    container:
-      image: nvidia/cuda:${{ matrix.cuda }}-devel-ubuntu18.04
-      options: --gpus all
 
-    name: 'R: ${{ matrix.r }}, CUDA: ${{ matrix.cuda }}, CUML: ${{ matrix.cuml }}, ASAN: ${{ matrix.asan }}'
+    runs-on: ubuntu-latest
+    name: 'CRAN (R: ${{ matrix.r }})'
 
     env:
-      NOT_CRAN: true
       GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
       R_KEEP_PKG_SOURCE: yes
-      CUML_VERSION: ${{ matrix.cuml }}
-      CUML4R_ENABLE_ASAN: ${{ matrix.asan }}
-      DEBIAN_FRONTEND: 'noninteractive'
 
     steps:
-      - run: |
-          apt-get update -y
-          apt-get install -y sudo software-properties-common dialog apt-utils tzdata
-          if [[ $CUML4R_ENABLE_ASAN == 'true' ]]; then
-            apt-get install -y libasan5
-          fi
-        shell: bash
-
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-      - uses: r-lib/actions/setup-pandoc@v1
+      - uses: r-lib/actions/setup-pandoc@v2
 
-      - uses: actions/setup-python@v2
-        with:
-          python-version: '3.x'
-          architecture: 'x64'
-
-      - uses: r-lib/actions/setup-r@master
+      - uses: r-lib/actions/setup-r@v2
         with:
           r-version: ${{ matrix.r }}
-          http-user-agent: ${{ matrix.config.http-user-agent }}
           use-public-rspm: true
 
-      - uses: r-lib/actions/setup-r-dependencies@v1
+      - uses: r-lib/actions/setup-r-dependencies@v2
         with:
-          extra-packages: rcmdcheck
+          needs: check
+
+      - name: Build
+        run: R CMD build .
+
+      - name: Check
+        run: R CMD check --no-manual --as-cran cuda.ml_*.tar.gz
+        env:
+          _R_CHECK_CRAN_INCOMING_: false
+
+  build-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    timeout-minutes: 120
+    outputs:
+      image: ghcr.io/${{ github.repository }}-ci:${{ github.sha }}
+    steps:
+      - uses: actions/checkout@v4
 
-      - name: Build {cuda.ml}
-        id: build-pkg
-        run: |
-          cd ..
-          ls -a
-          rm -v cuda.ml_*.tar.gz
-          R CMD build cuda.ml
-          ls -a
-          echo "::set-output name=pkg-dir::$(pwd)"
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: .github/docker/Dockerfile
+          push: true
+          tags: ghcr.io/${{ github.repository }}-ci:${{ github.sha }}
+          build-args: |
+            CUML_VERSION=21.12
+            CMAKE_CUDA_ARCHITECTURES=75
+
+  test-gpu:
+    needs: build-image
+    if: ${{ always() && needs.build-image.result == 'success' }}
+    concurrency:
+      group: gpu-tests
+    runs-on:
+      - "runs-on=${{ github.run_id }}/family=g4dn.xlarge/image=ubuntu24-gpu-x64/spot=true"
+    container:
+      image: ${{ needs.build-image.outputs.image }}
+      credentials:
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+      options: --gpus all --runtime=nvidia
+    timeout-minutes: 60
+    env:
+      NOT_CRAN: true
 
-      - run: cp -v cuda.ml/.lsan-suppressions.txt /tmp
-        working-directory: ${{ steps.build-pkg.outputs.pkg-dir }}
+    steps:
+      - name: Verify GPU access
+        run: nvidia-smi
 
-      - name: Check {cuda.ml} package
-        run: |
-          print(list.files("."))
-          pkg <- list.files(".", pattern = "cuda\\.ml_.*\\.tar\\.gz")
-          stopifnot(length(pkg) == 1)
-
-          reticulate::install_miniconda(force = TRUE)
-
-          rcmdcheck_env <- (
-            if (identical(Sys.getenv("CUML4R_ENABLE_ASAN"), "true")) {
-              c(
-                LD_PRELOAD = "/usr/lib/x86_64-linux-gnu/libasan.so.5",
-                ASAN_OPTIONS = "halt_on_error=0,new_delete_type_mismatch=0,alloc_dealloc_mismatch=0,protect_shadow_gap=0",
-                LSAN_OPTIONS = "suppressions=/tmp/.lsan-suppressions.txt"
-              )
-            } else {
-              character()
-            }
-          )
-          rcmdcheck::rcmdcheck(
-            path = pkg[[1]],
-            args = c("--no-manual", "--as-cran"),
-            check_dir="check",
-            env = rcmdcheck_env
-          )
-        shell: Rscript {0}
-        working-directory: ${{ steps.build-pkg.outputs.pkg-dir }}
-
-      - name: Show testthat output
-        if: ${{ always() }}
+      - name: Session info
         run: |
-          find check -name 'testthat.Rout*' -type f -exec cat '{}' \; || :
-        shell: bash
-        working-directory: ${{ steps.build-pkg.outputs.pkg-dir }}
+          Rscript -e "sessionInfo()"
+          Rscript -e "library(cuda.ml)"
 
-      - name: Check for sanitizer error(s)
-        if: ${{ always() }}
+      - name: Run tests
         run: |
-          ! find check -name 'testthat.Rout*' -type f -exec egrep -C 50 'ERROR: .*Sanitizer:' '{}' +
-        shell: bash
-        working-directory: ${{ steps.build-pkg.outputs.pkg-dir }}
-
-      - name: Upload check results
-        if: ${{ failure() }}
-        uses: actions/upload-artifact@main
-        with:
-          name: ${{ runner.os }}-r${{ matrix.r }}-results
-          path: ${{ steps.build-pkg.outputs.pkg-dir }}/check
+          Rscript -e "testthat::test_package('cuda.ml', reporter = 'progress')"

.gitignore

@@ -12,3 +12,5 @@ cuda.ml.Rcheck
 *.cmake
 *.a
 00check.log
+.positai
+.codex

DESCRIPTION

@@ -45,7 +45,7 @@ Suggests:
     xgboost
 LinkingTo: Rcpp
 Encoding: UTF-8
-RoxygenNote: 7.1.2
+RoxygenNote: 7.3.3
 OS_type: unix
 SystemRequirements: RAPIDS cuML (see https://rapids.ai/start.html)
 NeedsCompilation: yes

NAMESPACE

@@ -1,12 +1,24 @@
 # Generated by roxygen2: do not edit by hand
 
+S3method(cuda_ml_can_predict_class_probabilities,cuda_ml_fil)
+S3method(cuda_ml_can_predict_class_probabilities,cuda_ml_knn)
 S3method(cuda_ml_can_predict_class_probabilities,cuda_ml_model)
+S3method(cuda_ml_can_predict_class_probabilities,cuda_ml_rand_forest)
 S3method(cuda_ml_can_predict_class_probabilities,default)
 S3method(cuda_ml_elastic_net,data.frame)
 S3method(cuda_ml_elastic_net,default)
 S3method(cuda_ml_elastic_net,formula)
 S3method(cuda_ml_elastic_net,matrix)
 S3method(cuda_ml_elastic_net,recipe)
+S3method(cuda_ml_get_state,cuda_ml_model)
+S3method(cuda_ml_get_state,cuda_ml_pca)
+S3method(cuda_ml_get_state,cuda_ml_rand_forest)
+S3method(cuda_ml_get_state,cuda_ml_rand_proj_model)
+S3method(cuda_ml_get_state,cuda_ml_svc)
+S3method(cuda_ml_get_state,cuda_ml_svc_ovr)
+S3method(cuda_ml_get_state,cuda_ml_svr)
+S3method(cuda_ml_get_state,cuda_ml_umap)
+S3method(cuda_ml_get_state,default)
 S3method(cuda_ml_inverse_transform,cuda_ml_pca)
 S3method(cuda_ml_inverse_transform,cuda_ml_tsvd)
 S3method(cuda_ml_is_classifier,cuda_ml_model)
@@ -43,6 +55,15 @@ S3method(cuda_ml_ridge,matrix)
 S3method(cuda_ml_ridge,recipe)
 S3method(cuda_ml_serialize,cuda_ml_model)
 S3method(cuda_ml_serialize,default)
+S3method(cuda_ml_set_state,cuda_ml_model_state)
+S3method(cuda_ml_set_state,cuda_ml_pca_model_state)
+S3method(cuda_ml_set_state,cuda_ml_rand_forest_model_state)
+S3method(cuda_ml_set_state,cuda_ml_rand_proj_model_state)
+S3method(cuda_ml_set_state,cuda_ml_svc_model_state)
+S3method(cuda_ml_set_state,cuda_ml_svc_ovr_model_state)
+S3method(cuda_ml_set_state,cuda_ml_svr_model_state)
+S3method(cuda_ml_set_state,cuda_ml_umap_model_state)
+S3method(cuda_ml_set_state,default)
 S3method(cuda_ml_sgd,data.frame)
 S3method(cuda_ml_sgd,default)
 S3method(cuda_ml_sgd,formula)

R/agglomerative.R

@@ -18,10 +18,10 @@ agglomerative_clustering_match_metric <- function(metric = c("euclidean", "l1",
 #' @template model-with-numeric-input
 #' @param n_clusters The number of clusters to find. Default: 2L.
 #' @param metric Metric used for linkage computation. Must be one of
-#'   {"euclidean", "l1", "l2", "manhattan", "cosine"}. If connectivity is
+#'   \{"euclidean", "l1", "l2", "manhattan", "cosine"\}. If connectivity is
 #'   "knn" then only "euclidean" is accepted. Default: "euclidean".
 #' @param connectivity The type of connectivity matrix to compute. Must be one
-#'   of {"pairwise", "knn"}. Default: "pairwise".
+#'   of \{"pairwise", "knn"\}. Default: "pairwise".
 #'     - 'pairwise' will compute the entire fully-connected graph of pairwise
 #'        distances between each set of points. This is the fastest to compute
 #'        and can be very fast for smaller datasets but requires O(n^2) space.

R/cuml_utils.R

@@ -1,7 +1,7 @@
-#' Determine whether {cuda.ml} was linked to a valid version of the RAPIDS cuML
+#' Determine whether \{cuda.ml\} was linked to a valid version of the RAPIDS cuML
 #' shared library.
 #'
-#' @return A logical value indicating whether the current installation {cuda.ml}
+#' @return A logical value indicating whether the current installation \{cuda.ml\}
 #'   was linked to a valid version of the RAPIDS cuML shared library.
 #'
 #' @examples
@@ -17,11 +17,11 @@
 #' @export
 has_cuML <- .has_cuML
 
-#' Get the major version of the RAPIDS cuML shared library {cuda.ml} was linked
+#' Get the major version of the RAPIDS cuML shared library \{cuda.ml\} was linked
 #' to.
 #'
-#' @return The major version of the RAPIDS cuML shared library {cuda.ml} was
-#' linked to in a character vector, or \code{NA_character_} if {cuda.ml} was not
+#' @return The major version of the RAPIDS cuML shared library \{cuda.ml\} was
+#' linked to in a character vector, or \code{NA_character_} if \{cuda.ml\} was not
 #' linked to any version of RAPIDS cuML.
 #'
 #' @examples
@@ -32,11 +32,11 @@ has_cuML <- .has_cuML
 #' @export
 cuML_major_version <- .cuML_major_version
 
-#' Get the minor version of the RAPIDS cuML shared library {cuda.ml} was linked
+#' Get the minor version of the RAPIDS cuML shared library \{cuda.ml\} was linked
 #' to.
 #'
-#' @return The minor version of the RAPIDS cuML shared library {cuda.ml} was
-#' linked to in a character vector, or \code{NA_character_} if {cuda.ml} was not
+#' @return The minor version of the RAPIDS cuML shared library \{cuda.ml\} was
+#' linked to in a character vector, or \code{NA_character_} if \{cuda.ml\} was not
 #' linked to any version of RAPIDS cuML.
 #'
 #' @examples

R/fil.R

@@ -1,11 +1,11 @@
 #' Determine whether Forest Inference Library (FIL) functionalities are enabled
-#' in the current installation of {cuda.ml}.
+#' in the current installation of \{cuda.ml\}.
 #'
 #' CuML Forest Inference Library (FIL) functionalities (see
 #' https://github.com/rapidsai/cuml/tree/main/python/cuml/fil#readme) will
 #' require Treelite C API. If you need FIL to run tree-based model ensemble on
 #' GPU, and \code{fil_enabled()} returns FALSE, then please consider installing
-#' Treelite and then re-installing {cuda.ml}.
+#' Treelite and then re-installing \{cuda.ml\}.
 #'
 #' @return A logical value indicating whether the Forest Inference Library (FIL)
 #'   functionalities are enabled.
@@ -62,9 +62,9 @@ file_match_storage_type <- function(storage_type = c("auto", "dense", "sparse"))
 #'
 #' @param filename Path to the saved model file.
 #' @param mode Type of task to be performed by the model. Must be one of
-#'   {"classification", "regression"}.
+#'   \{"classification", "regression"\}.
 #' @param model_type Format of the saved model file. Notice if \code{filename}
-#'   ends with ".json" and \code{model_type} is "xgboost", then {cuda.ml} will
+#'   ends with ".json" and \code{model_type} is "xgboost", then \{cuda.ml\} will
 #'   assume the model file is in XGBoost JSON (instead of binary) format.
 #'   Default: "xgboost".
 #' @param algo Type of the algorithm for inference, must be one of the