Accelerate linear model predict on C-ordered inputs (#7329)

This started out as a cleanup PR, but moved to a performance improvement after some benchmarking.

`LinearRegression`, `ElasticNet`, `Lasso`, and `Ridge` all share the same `predict` method. This calculates `X.dot(coef.T) + intercept`.

Previously we used a function from `libcuml` to compute the single target case, and `cupy` to handle the multitarget case.

After some benchmarking, I no longer think using `libcuml` at all here is worth it. It's simpler to always take the `cupy` path, and `cupy` already handles dispatching to cublas appropriately to handle disparate layouts (C vs F).

For F-ordered inputs we see roughly the same performance as before.

For C-ordered inputs, we see anything from mild speedups (150 us now, vs 200 us before) on small data, to up to 10x speedup on larger data (0.75 ms now vs 8.4 ms before). Presumably this is due to avoiding unnecessary copies to force a uniform F order as we did before.

Authors:
  - Jim Crist-Harif (https://github.com/jcrist)

Approvers:
  - Victor Lafargue (https://github.com/viclafargue)
  - Simon Adorf (https://github.com/csadorf)

URL: #7329

Author: jcrist

python/cuml/cuml/linear_model/CMakeLists.txt

@@ -14,7 +14,6 @@
 
 
 set(cython_sources "")
-add_module_gpu_default("base.pyx" ${linearregression_algo} ${elastic_net_algo} ${ridge_algo} ${linear_model_algo})
 add_module_gpu_default("linear_regression.pyx" ${linearregression_algo} ${linear_model_algo})
 add_module_gpu_default("ridge.pyx" ${ridge_algo} ${linear_model_algo})
 

python/cuml/cuml/linear_model/base.py

@@ -0,0 +1,60 @@
+#
+# Copyright (c) 2020-2025, NVIDIA CORPORATION.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import cuml.internals
+from cuml.common.doc_utils import generate_docstring
+from cuml.internals.array import CumlArray
+from cuml.internals.input_utils import input_to_cuml_array
+
+
+class LinearPredictMixin:
+    @generate_docstring(
+        return_values={
+            "name": "preds",
+            "type": "dense",
+            "description": "Predicted values",
+            "shape": "(n_samples, 1)",
+        }
+    )
+    @cuml.internals.api_base_return_array_skipall
+    def predict(self, X, *, convert_dtype=True) -> CumlArray:
+        """
+        Predicts `y` values for `X`.
+        """
+        if getattr(self, "coef_", None) is None:
+            raise ValueError(
+                "LinearModel.predict() cannot be called before fit(). "
+                "Please fit the model first."
+            )
+
+        X = input_to_cuml_array(
+            X,
+            check_dtype=self.coef_.dtype,
+            convert_to_dtype=(self.coef_.dtype if convert_dtype else None),
+            check_cols=self.n_features_in_,
+            order="K",
+        ).array
+        X_cp = X.to_output("cupy")
+
+        coef = self.coef_.to_output("cupy")
+
+        intercept = self.intercept_
+        if isinstance(intercept, CumlArray):
+            intercept = intercept.to_output("cupy")
+
+        out = X_cp @ coef.T
+        out += intercept
+
+        return CumlArray(out, index=X.index)