Estimators adaptation toward CPU/GPU interoperability

python/cuml/common/array_descriptor.py

@@ -54,8 +54,14 @@ class CumlArrayDescriptor():
     Python descriptor object to control getting/setting `CumlArray` attributes
     on `Base` objects. See the Estimator Guide for an in depth guide.
     """
+    def __init__(self, order='K'):
+        # order corresponds to the order that the CumlArray attribute
+        # should be in to work with the C++ algorithms.
+        self.order = order
+
     def __set_name__(self, owner, name):
         self.name = name
+        setattr(owner, name + '_order', self.order)
 
     def _get_meta(self,
                   instance,

python/cuml/common/input_utils.py

@@ -535,7 +535,7 @@ def input_to_host_array(X,
 
     if isinstance(X, (int, float, complex, bool, str,
                       type(None), dict, set, list, tuple)):
-        return X
+        return (X,)
 
     if isinstance(X, np.ndarray):
         if len(X.shape) > 1:

python/cuml/common/mixins.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021, NVIDIA CORPORATION.
+# Copyright (c) 2021-2022, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -214,6 +214,33 @@ def score(self, X, y, **kwargs):
         preds = self.predict(X, **kwargs)
         return r2_score(y, preds, handle=handle)
 
+    # TODO : remove score function duplicate
+    # once updated CPU/GPU interoperability class is ready
+    @generate_docstring(
+        return_values={
+            'name': 'score',
+            'type': 'float',
+            'description': 'R^2 of self.predict(X) '
+                           'wrt. y.'
+        })
+    @cuml.internals.api_base_return_any_skipall
+    def _score(self, X, y, **kwargs):
+        """
+        Scoring function for regression estimators
+
+        Returns the coefficient of determination R^2 of the prediction.
+
+        """
+        from cuml.metrics.regression import r2_score
+
+        if hasattr(self, 'handle'):
+            handle = self.handle
+        else:
+            handle = None
+
+        preds = self._predict(X, **kwargs)
+        return r2_score(y, preds, handle=handle)
+
     @staticmethod
     def _more_static_tags():
         return {
@@ -253,6 +280,33 @@ def score(self, X, y, **kwargs):
         preds = self.predict(X, **kwargs)
         return accuracy_score(y, preds, handle=handle)
 
+    # TODO : remove score function duplicate
+    # once updated CPU/GPU interoperability class is ready
+    @generate_docstring(
+        return_values={
+            'name':
+                'score',
+            'type':
+                'float',
+            'description': ('Accuracy of self.predict(X) wrt. y '
+                            '(fraction where y == pred_y)')
+        })
+    @cuml.internals.api_base_return_any_skipall
+    def _score(self, X, y, **kwargs):
+        """
+        Scoring function for classifier estimators based on mean accuracy.
+
+        """
+        from cuml.metrics.accuracy import accuracy_score
+
+        if hasattr(self, 'handle'):
+            handle = self.handle
+        else:
+            handle = None
+
+        preds = self._predict(X, **kwargs)
+        return accuracy_score(y, preds, handle=handle)
+
     @staticmethod
     def _more_static_tags():
         return {

python/cuml/dask/common/base.py

@@ -23,7 +23,6 @@
 from cuml.dask.common.utils import get_client
 
 from cuml.common.base import Base
-from cuml.experimental.common.base import Base as experimentalBase
 from cuml.common.array import CumlArray
 from cuml.dask.common.utils import wait_and_raise_from_futures
 from raft_dask.common.comms import Comms
@@ -129,7 +128,7 @@ def _check_internal_model(model):
             if model.type is None:
                 wait_and_raise_from_futures([model])
 
-            if not issubclass(model.type, (Base, experimentalBase)):
+            if not issubclass(model.type, Base):
                 raise ValueError("Dask Future expected to contain cuml.Base "
                                  "but found %s instead." % model.type)
 

python/cuml/decomposition/base_mg.pyx

@@ -67,9 +67,9 @@ class BaseDecompositionMG(object):
         self._set_n_features_in(n_cols)
 
         if self.n_components is None:
-            self._n_components = min(total_rows, n_cols)
+            self.n_components_ = min(total_rows, n_cols)
         else:
-            self._n_components = self.n_components
+            self.n_components_ = self.n_components
 
         X_arys = []
         for i in range(len(X)):
@@ -102,11 +102,11 @@ class BaseDecompositionMG(object):
             trans_arg = opg.build_data_t(trans_arys)
 
             trans_part_desc = opg.build_part_descriptor(total_rows,
-                                                        self._n_components,
+                                                        self.n_components_,
                                                         rank_to_sizes,
                                                         rank)
 
-        self._initialize_arrays(self._n_components, total_rows, n_cols)
+        self._initialize_arrays(self.n_components_, total_rows, n_cols)
         decomp_params = self._build_params(total_rows, n_cols)
 
         if _transform:

python/cuml/decomposition/incremental_pca.py

@@ -349,7 +349,7 @@ def partial_fit(self, X, y=None, check_input=True) -> "IncrementalPCA":
         explained_variance = S ** 2 / (n_total_samples - 1)
         explained_variance_ratio = S ** 2 / cp.sum(col_var * n_total_samples)
 
-        self.n_rows = n_total_samples
+        self.n_samples_ = n_total_samples
         self.n_samples_seen_ = n_total_samples
         self.components_ = V[:self.n_components_]
         self.singular_values_ = S[:self.n_components_]