Some fixups from the sklearn test suite

- Support `__sklearn_is_fitted__` since the default `check_is_fitted`
  doesn't work for `ProxyBase`.
- Oops, `LinearRegression` _can_ be multi-target. Fix the `InteropMixin`
  implementations as needed.

Author: jcrist

python/cuml/cuml/accel/estimator_proxy.py

@@ -297,6 +297,10 @@ def set_params(self, **kwargs):
     def __sklearn_tags__(self):
         return self._cpu.__sklearn_tags__()
 
+    def __sklearn_is_fitted__(self):
+        model = self._cpu if self._gpu is None else self._gpu
+        return getattr(model, "n_features_in_", None) is not None
+
     def __sklearn_clone__(self):
         cls = type(self)
         out = cls.__new__(cls)

python/cuml/cuml/internals/interop.py

@@ -18,6 +18,8 @@
 from importlib import import_module
 from typing import Any
 
+import numpy as np
+
 from cuml.internals.device_type import DeviceType
 from cuml.internals.global_settings import GlobalSettings
 from cuml.internals.mem_type import MemoryType
@@ -28,6 +30,7 @@
     "UnsupportedOnCPU",
     "InteropMixin",
     "warn_legacy_device_interop",
+    "to_cpu",
     "to_gpu",
 )
 
@@ -63,15 +66,24 @@ def inner(self, *args, **kwargs):
 
 
 def to_gpu(x, order="K"):
-    """Coerce `x` to the equivalent GPU type."""
-    # Ideally we'd get rid of this helper eventually, using it for now to reduce typing
+    """Coerce `x` to the equivalent gpu type."""
     from cuml.internals.input_utils import input_to_cuml_array
 
+    if np.isscalar(x):
+        # cuml typically expects scalars on host
+        return x
     return input_to_cuml_array(
         x, order=order, convert_to_mem_type=MemoryType.device
     )[0]
 
 
+def to_cpu(x):
+    """Coerce `x` to the equivalent cpu type."""
+    if np.isscalar(x):
+        return x
+    return x.to_output("numpy")
+
+
 class UnsupportedOnGPU(ValueError):
     """An exception raised when a conversion of a CPU to a GPU estimator isn't supported"""
 

python/cuml/cuml/linear_model/elastic_net.pyx

@@ -18,8 +18,6 @@
 
 from inspect import signature
 
-import numpy as np
-
 from cuml.common import input_to_cuml_array
 from cuml.common.array_descriptor import CumlArrayDescriptor
 from cuml.common.doc_utils import generate_docstring
@@ -28,6 +26,7 @@ from cuml.internals.base import Base
 from cuml.internals.interop import (
     InteropMixin,
     UnsupportedOnGPU,
+    to_cpu,
     to_gpu,
     warn_legacy_device_interop,
 )
@@ -210,15 +209,15 @@ class ElasticNet(Base,
 
     def _attrs_from_cpu(self, model):
         return {
-            "intercept_": float(model.intercept_),
+            "intercept_": to_gpu(model.intercept_, order="F"),
             "coef_": to_gpu(model.coef_, order="F"),
             **super()._attrs_from_cpu(model),
         }
 
     def _attrs_to_cpu(self, model):
         return {
-            "intercept_": np.float64(self.intercept_),
-            "coef_": self.coef_.to_output("numpy"),
+            "intercept_": to_cpu(self.intercept_),
+            "coef_": to_cpu(self.coef_),
             **super()._attrs_to_cpu(model),
         }
 

python/cuml/cuml/linear_model/linear_regression.pyx

@@ -30,6 +30,7 @@ from cuml.internals.base import Base
 from cuml.internals.interop import (
     InteropMixin,
     UnsupportedOnGPU,
+    to_cpu,
     to_gpu,
     warn_legacy_device_interop,
 )
@@ -294,15 +295,15 @@ class LinearRegression(Base,
 
     def _attrs_from_cpu(self, model):
         return {
-            "intercept_": float(model.intercept_),
+            "intercept_": to_gpu(model.intercept_, order="F"),
             "coef_": to_gpu(model.coef_, order="F"),
             **super()._attrs_from_cpu(model),
         }
 
     def _attrs_to_cpu(self, model):
         return {
-            "intercept_": np.float64(self.intercept_),
-            "coef_": self.coef_.to_output("numpy"),
+            "intercept_": to_cpu(self.intercept_),
+            "coef_": to_cpu(self.coef_),
             **super()._attrs_to_cpu(model),
         }
 

python/cuml/cuml/linear_model/logistic_regression.pyx

@@ -33,6 +33,7 @@ from cuml.internals.base import Base
 from cuml.internals.input_utils import input_to_cuml_array
 from cuml.internals.interop import (
     InteropMixin,
+    to_cpu,
     to_gpu,
     warn_legacy_device_interop,
 )
@@ -248,8 +249,8 @@ class LogisticRegression(Base,
     def _attrs_to_cpu(self, model):
         return {
             "classes_": self.classes_,
-            "intercept_": self.intercept_.to_output("numpy"),
-            "coef_": self.coef_.to_output("numpy"),
+            "intercept_": to_cpu(self.intercept_),
+            "coef_": to_cpu(self.coef_),
             **super()._attrs_to_cpu(model),
         }
 

python/cuml/cuml_accel_tests/test_estimator_proxy.py

@@ -24,8 +24,9 @@
 import scipy.sparse
 import sklearn
 from packaging.version import Version
-from sklearn.base import is_classifier, is_regressor
+from sklearn.base import check_is_fitted, is_classifier, is_regressor
 from sklearn.datasets import make_classification, make_regression
+from sklearn.exceptions import NotFittedError
 from sklearn.linear_model import (
     ElasticNet,
     LinearRegression,
@@ -395,8 +396,14 @@ def test_unpickle_cuml_not_installed():
 def test_fit_gpu():
     X, y = make_regression(n_samples=10)
     model = LinearRegression()
+
+    # Model isn't fit
+    with pytest.raises(NotFittedError):
+        check_is_fitted(model)
+
     assert model.fit(X, y) is model
     # Fit happened on GPU, attrs kept on GPU
+    check_is_fitted(model)
     assert model._gpu is not None
     assert not hasattr(model._cpu, "n_features_in_")
 
@@ -414,7 +421,8 @@ def test_fit_unsupported_params():
     X, y = make_regression(n_samples=10)
     model = LinearRegression(positive=True)
     assert model.fit(X, y) is model
-    # Fit happened on CPU, attrs kept on GPU
+    # Fit happened on CPU
+    check_is_fitted(model)
     assert model._gpu is None
     assert hasattr(model._cpu, "n_features_in_")
 
@@ -428,7 +436,8 @@ def test_fit_unsupported_args():
     X = scipy.sparse.coo_matrix(X_dense)
     model = LinearRegression(fit_intercept=True)
     assert model.fit(X, y) is model
-    # Fit happened on CPU, attrs kept on GPU
+    # Fit happened on CPU
+    check_is_fitted(model)
     assert model._gpu is None
     assert hasattr(model._cpu, "n_features_in_")