Multiple CPU interop fixes for serialization and cloning

python/cuml/cuml/cluster/hdbscan/hdbscan.pyx

@@ -771,7 +771,7 @@ class HDBSCAN(UniversalBase, ClusterMixin, CMajorInputTagMixin):
         """
         Fit HDBSCAN model from features.
         """
-
+        self._all_finite = True
         X_m, n_rows, n_cols, self.dtype = \
             input_to_cuml_array(X, order='C',
                                 check_dtype=[np.float32],
@@ -1163,7 +1163,7 @@ class HDBSCAN(UniversalBase, ClusterMixin, CMajorInputTagMixin):
     def get_attr_names(self):
         attr_names = ['labels_', 'probabilities_', 'cluster_persistence_',
                       'condensed_tree_', 'single_linkage_tree_',
-                      'outlier_scores_']
+                      'outlier_scores_', '_all_finite']
         if self.gen_min_span_tree:
             attr_names = attr_names + ['minimum_spanning_tree_']
         if self.prediction_data:

python/cuml/cuml/experimental/accel/estimator_proxy.py

@@ -207,14 +207,29 @@ def __init__(self, *args, **kwargs):
             self._cpu_model_class = (
                 original_class_a  # Store a reference to the original class
             )
+            signature = inspect.signature(self._cpu_model_class.__init__)
+
+            # Keep the original passed hyperparameters so that we know what
+            # to use in get_params, and also can do later conversions if we
+            # need.
+            self._cpu_hyperparams_dict = {
+                name: param.default
+                for name, param in signature.parameters.items()
+                if name != "self"
+            }
+            self._cpu_hyperparams_dict.update(kwargs)
+
             kwargs, self._gpuaccel = self._hyperparam_translator(**kwargs)
             super().__init__(*args, **kwargs)
 
-            self._cpu_hyperparams = list(
-                inspect.signature(
-                    self._cpu_model_class.__init__
-                ).parameters.keys()
-            )
+            # _cpu_hyperparams is expected to be a list in the UniversalBase
+            # methods.
+            self._cpu_hyperparams = list(self._cpu_hyperparams_dict.keys())
+
+            # Importing and building the model here ensures a more uniform
+            # behavior of when do we import CPU classes.
+            self.import_cpu_model()
+            self.build_cpu_model()
 
         def __repr__(self):
             """
@@ -226,7 +241,10 @@ def __repr__(self):
                 A string representation indicating that this is a wrapped
                  version of the original CPU-based estimator.
             """
-            return f"wrapped {self._cpu_model_class}"
+            self.import_cpu_model()
+            self.build_cpu_model()
+            self.gpu_to_cpu()
+            return self._cpu_model.__repr__()
 
         def __str__(self):
             """
@@ -238,7 +256,10 @@ def __str__(self):
                 A string representation indicating that this is a wrapped
                  version of the original CPU-based estimator.
             """
-            return f"ProxyEstimator of {self._cpu_model_class}"
+            self.import_cpu_model()
+            self.build_cpu_model()
+            self.gpu_to_cpu()
+            return self._cpu_model.__str__()
 
         def __getstate__(self):
             """

python/cuml/cuml/internals/base.pyx

@@ -889,6 +889,12 @@ class UniversalBase(Base):
             # that are not in the cuML estimator in the host estimator
             if GlobalSettings().accelerator_active or self._experimental_dispatching:
 
+                # we don't want to special sklearn dispatch cloning function
+                # so that cloning works with this class as a regular estimator
+                # without __sklearn_clone__
+                if attr == "__sklearn_clone__":
+                    raise ex
+
                 self.import_cpu_model()
                 if hasattr(self._cpu_model_class, attr):
 
@@ -988,3 +994,27 @@ class UniversalBase(Base):
         estimator.output_mem_type = MemoryType.host
 
         return estimator
+
+    def get_params(self, deep=True):
+        """
+        If accelerator is active, we return the params of the CPU estimator
+        being helf by the class, otherwise we just call the regular
+        get_params of the Base class.
+        """
+        if GlobalSettings().accelerator_active or self._experimental_dispatching:
+            return self._cpu_hyperparams_dict
+        else:
+            return super().get_params(deep=deep)
+
+    def set_params(self, **params):
+        """
+        For setting parameters, when the accelerator is active, we translate
+        the parameters to set the GPU params, and also update the
+        params of the CPU class. Otherwise dispatching to the CPU class after
+        updating params of the GPU estimator will dispatch to an estimator
+        with outdated params.
+        """
+        self._cpu_hyperparams_dict.update(params)
+        params, gpuaccel = super._hyperparam_translator(params)
+        super().set_params(params)
+        return self