Update algorithm wrappers to latest Scikit-learn changes (#1032)

* Update algorithm wrappers to latest sklearn changes

* PEP8 and lasso fixes

* Fix pca versioning

* Update KMeans versioning

* Rewrite kmeans.fit versions branching

* Fix TSNE perplexity to pass parameter check (perplexity < n_samples)

* Future warnings fix

* Restore auto kmeans algorithm for compatibility with sklearn<1.1

Author: Alexsandruss

daal4py/sklearn/cluster/_dbscan.py

@@ -233,7 +233,7 @@ def fit(self, X, y=None, sample_weight=None):
             Returns a fitted instance of self.
         """
         if self.eps <= 0.0:
-            raise ValueError("eps must be positive.")
+            raise ValueError(f"eps == {self.eps}, must be > 0.0.")
 
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)

daal4py/sklearn/cluster/_k_means_0_23.py

@@ -41,6 +41,10 @@
     PatchingConditionsChain)
 from .._device_offload import support_usm_ndarray
 
+if sklearn_check_version('1.1'):
+    from sklearn.utils.validation import (
+        _check_sample_weight, _is_arraylike_not_scalar)
+
 
 def _validate_center_shape(X, n_centers, centers):
     """Check if centers is compatible with X and n_centers"""
@@ -242,53 +246,82 @@ def _fit(self, X, y=None, sample_weight=None):
         are assigned equal weight (default: None)
 
     """
-    if hasattr(self, 'precompute_distances'):
-        if self.precompute_distances != 'deprecated':
-            if sklearn_check_version('0.24'):
-                warnings.warn("'precompute_distances' was deprecated in version "
-                              "0.23 and will be removed in 1.0 (renaming of 0.25)."
-                              " It has no effect", FutureWarning)
-            elif sklearn_check_version('0.23'):
-                warnings.warn("'precompute_distances' was deprecated in version "
-                              "0.23 and will be removed in 0.25. It has no "
-                              "effect", FutureWarning)
-
-    self._n_threads = None
-    if hasattr(self, 'n_jobs'):
-        if self.n_jobs != 'deprecated':
-            if sklearn_check_version('0.24'):
-                warnings.warn("'n_jobs' was deprecated in version 0.23 and will be"
-                              " removed in 1.0 (renaming of 0.25).", FutureWarning)
-            elif sklearn_check_version('0.23'):
-                warnings.warn("'n_jobs' was deprecated in version 0.23 and will be"
-                              " removed in 0.25.", FutureWarning)
-            self._n_threads = self.n_jobs
-    self._n_threads = _openmp_effective_n_threads(self._n_threads)
-
-    if self.n_init <= 0:
-        raise ValueError(
-            f"n_init should be > 0, got {self.n_init} instead.")
-
-    random_state = check_random_state(self.random_state)
-    if sklearn_check_version("1.0"):
-        self._check_feature_names(X, reset=True)
-
-    if self.max_iter <= 0:
-        raise ValueError(
-            f"max_iter should be > 0, got {self.max_iter} instead.")
+    init = self.init
+    if sklearn_check_version('1.1'):
+        if sklearn_check_version('1.2'):
+            self._validate_params()
+
+        X = self._validate_data(
+            X,
+            accept_sparse="csr",
+            dtype=[np.float64, np.float32],
+            order="C",
+            copy=self.copy_x,
+            accept_large_sparse=False,
+        )
 
-    algorithm = self.algorithm
-    if algorithm == "elkan" and self.n_clusters == 1:
-        warnings.warn("algorithm='elkan' doesn't make sense for a single "
-                      "cluster. Using 'full' instead.", RuntimeWarning)
-        algorithm = "full"
+        if sklearn_check_version('1.2'):
+            self._check_params_vs_input(X)
+        else:
+            self._check_params(X)
 
-    if algorithm == "auto":
-        algorithm = "full" if self.n_clusters == 1 else "elkan"
+        random_state = check_random_state(self.random_state)
+        sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)
+        self._n_threads = _openmp_effective_n_threads()
 
-    if algorithm not in ["full", "elkan"]:
-        raise ValueError("Algorithm must be 'auto', 'full' or 'elkan', got"
-                         " {}".format(str(algorithm)))
+        # Validate init array
+        init_is_array_like = _is_arraylike_not_scalar(init)
+        if init_is_array_like:
+            init = check_array(init, dtype=X.dtype, copy=True, order="C")
+            self._validate_center_shape(X, init)
+    else:
+        if hasattr(self, 'precompute_distances'):
+            if self.precompute_distances != 'deprecated':
+                if sklearn_check_version('0.24'):
+                    warnings.warn("'precompute_distances' was deprecated in version "
+                                  "0.23 and will be removed in 1.0 (renaming of 0.25)."
+                                  " It has no effect", FutureWarning)
+                elif sklearn_check_version('0.23'):
+                    warnings.warn("'precompute_distances' was deprecated in version "
+                                  "0.23 and will be removed in 0.25. It has no "
+                                  "effect", FutureWarning)
+
+        self._n_threads = None
+        if hasattr(self, 'n_jobs'):
+            if self.n_jobs != 'deprecated':
+                if sklearn_check_version('0.24'):
+                    warnings.warn("'n_jobs' was deprecated in version 0.23 and will be"
+                                  " removed in 1.0 (renaming of 0.25).", FutureWarning)
+                elif sklearn_check_version('0.23'):
+                    warnings.warn("'n_jobs' was deprecated in version 0.23 and will be"
+                                  " removed in 0.25.", FutureWarning)
+                self._n_threads = self.n_jobs
+        self._n_threads = _openmp_effective_n_threads(self._n_threads)
+
+        if self.n_init <= 0:
+            raise ValueError(
+                f"n_init should be > 0, got {self.n_init} instead.")
+
+        random_state = check_random_state(self.random_state)
+        if sklearn_check_version("1.0"):
+            self._check_feature_names(X, reset=True)
+
+        if self.max_iter <= 0:
+            raise ValueError(
+                f"max_iter should be > 0, got {self.max_iter} instead.")
+
+        algorithm = self.algorithm
+        if algorithm == "elkan" and self.n_clusters == 1:
+            warnings.warn("algorithm='elkan' doesn't make sense for a single "
+                          "cluster. Using 'full' instead.", RuntimeWarning)
+            algorithm = "full"
+
+        if algorithm == "auto":
+            algorithm = "full" if self.n_clusters == 1 else "elkan"
+
+        if algorithm not in ["full", "elkan"]:
+            raise ValueError("Algorithm must be 'auto', 'full' or 'elkan', got"
+                             " {}".format(str(algorithm)))
 
     X_len = _num_samples(X)
 
@@ -317,8 +350,10 @@ def _fit(self, X, y=None, sample_weight=None):
         self.n_features_in_ = X.shape[1]
         self.cluster_centers_, self.labels_, self.inertia_, self.n_iter_ = \
             _daal4py_k_means_fit(
-                X, self.n_clusters, self.max_iter, self.tol, self.init, self.n_init,
+                X, self.n_clusters, self.max_iter, self.tol, init, self.n_init,
                 self.verbose, random_state)
+        if sklearn_check_version('1.1'):
+            self._n_features_out = self.cluster_centers_.shape[0]
     else:
         super(KMeans, self).fit(X, y=y, sample_weight=sample_weight)
     return self

daal4py/sklearn/decomposition/_pca.py

@@ -52,6 +52,8 @@ def __init__(
         svd_solver='auto',
         tol=0.0,
         iterated_power='auto',
+        n_oversamples=10,
+        power_iteration_normalizer="auto",
         random_state=None
     ):
         self.n_components = n_components
@@ -60,6 +62,8 @@ def __init__(
         self.svd_solver = svd_solver
         self.tol = tol
         self.iterated_power = iterated_power
+        self.n_oversamples = n_oversamples
+        self.power_iteration_normalizer = power_iteration_normalizer
         self.random_state = random_state
 
     def _validate_n_components(self, n_components, n_samples, n_features):
@@ -200,26 +204,37 @@ def _fit(self, X):
         shape_good_for_daal = X.shape[1] / X.shape[0] < 2
 
         if self._fit_svd_solver == 'auto':
-            if n_components == 'mle':
-                self._fit_svd_solver = 'full'
-            else:
-                n, p, k = X.shape[0], X.shape[1], n_components
-                # These coefficients are result of training of Logistic Regression
-                # (max_iter=10000, solver="liblinear", fit_intercept=False)
-                # on different datasets and number of components. X is a dataset with
-                # npk, np^2, and n^2 columns. And y is speedup of patched scikit-learn's
-                # full PCA against stock scikit-learn's randomized PCA.
-                regression_coefs = np.array([
-                    [9.779873e-11, n * p * k],
-                    [-1.122062e-11, n * p * p],
-                    [1.127905e-09, n ** 2],
-                ])
-
-                if n_components >= 1 \
-                        and np.dot(regression_coefs[:, 0], regression_coefs[:, 1]) <= 0:
-                    self._fit_svd_solver = 'randomized'
+            if sklearn_check_version('1.1'):
+                # Small problem or n_components == 'mle', just call full PCA
+                if max(X.shape) <= 500 or n_components == "mle":
+                    self._fit_svd_solver = "full"
+                elif 1 <= n_components < 0.8 * min(X.shape):
+                    self._fit_svd_solver = "randomized"
+                # This is also the case of n_components in (0,1)
                 else:
+                    self._fit_svd_solver = "full"
+            else:
+                if n_components == 'mle':
                     self._fit_svd_solver = 'full'
+                else:
+                    n, p, k = X.shape[0], X.shape[1], n_components
+                    # These coefficients are result of training of Logistic Regression
+                    # (max_iter=10000, solver="liblinear", fit_intercept=False)
+                    # on different datasets and number of components.
+                    # X is a dataset with npk, np^2, and n^2 columns.
+                    # And y is speedup of patched scikit-learn's
+                    # full PCA against stock scikit-learn's randomized PCA.
+                    regression_coefs = np.array([
+                        [9.779873e-11, n * p * k],
+                        [-1.122062e-11, n * p * p],
+                        [1.127905e-09, n ** 2],
+                    ])
+
+                    if n_components >= 1 and np.dot(
+                            regression_coefs[:, 0], regression_coefs[:, 1]) <= 0:
+                        self._fit_svd_solver = 'randomized'
+                    else:
+                        self._fit_svd_solver = 'full'
 
         if not shape_good_for_daal or self._fit_svd_solver != 'full':
             if sklearn_check_version('0.23'):
@@ -346,7 +361,11 @@ def fit_transform(self, X, y=None):
         This method returns a Fortran-ordered array. To convert it to a
         C-ordered array, use 'np.ascontiguousarray'.
         """
-        U, S, _ = self._fit(X)
+
+        if sklearn_check_version('1.2'):
+            self._validate_params()
+
+        U, S, Vt = self._fit(X)
 
         _patching_status = PatchingConditionsChain(
             "sklearn.decomposition.PCA.fit_transform")