scikit-learn-intelex 2024.2.0__py38-none-manylinux1_x86_64.whl → 2024.3.0__py38-none-manylinux1_x86_64.whl

sklearnex/dispatcher.py

@@ -1,5 +1,6 @@
 # ==============================================================================
 # Copyright 2021 Intel Corporation
+# Copyright 2024 Fujitsu Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,7 +23,7 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
 
 def _is_new_patching_available():
-    return os.environ.get("OFF_ONEDAL_IFACE") is None and daal_check_version(
+    return os.environ.get("OFF_ONEDAL_IFACE", "0") == "0" and daal_check_version(
         (2021, "P", 300)
     )
 
@@ -32,16 +33,66 @@ def _is_preview_enabled():
 
 
 @lru_cache(maxsize=None)
-def get_patch_map():
+def get_patch_map_core(preview=False):
+    if preview:
+        # use recursion to guarantee that state of preview
+        # and non-preview maps are done at the same time.
+        # The two lru_cache dicts are actually one underneath.
+        # Preview is always secondary. Both sklearnex patch
+        # maps are referring to the daal4py dict unless the
+        # key has been replaced. Use with caution.
+        mapping = get_patch_map_core().copy()
+
+        if _is_new_patching_available():
+            import sklearn.covariance as covariance_module
+
+            # Preview classes for patching
+            from .preview.cluster import KMeans as KMeans_sklearnex
+            from .preview.covariance import (
+                EmpiricalCovariance as EmpiricalCovariance_sklearnex,
+            )
+
+            # Since the state of the lru_cache without preview cannot be
+            # guaranteed to not have already enabled sklearnex algorithms
+            # when preview is used, setting the mapping element[1] to None
+            # should NOT be done. This may lose track of the unpatched
+            # sklearn estimator or function.
+            # KMeans
+            cluster_module, _, _ = mapping["kmeans"][0][0]
+            sklearn_obj = mapping["kmeans"][0][1]
+            mapping.pop("kmeans")
+            mapping["kmeans"] = [
+                [(cluster_module, "kmeans", KMeans_sklearnex), sklearn_obj]
+            ]
+
+            # Covariance
+            mapping["empiricalcovariance"] = [
+                [
+                    (
+                        covariance_module,
+                        "EmpiricalCovariance",
+                        EmpiricalCovariance_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+        return mapping
+
     from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms
 
+    # NOTE: this is a shallow copy of a dict, modification is dangerous
     mapping = _get_map_of_algorithms().copy()
 
+    # NOTE: Use of daal4py _get_map_of_algorithms and
+    # get_patch_map/get_patch_map_core should not be used concurrently.
+    # The setting of elements to None below may cause loss of state
+    # when interacting with sklearn. A dictionary key must not be
+    # modified but totally replaced, otherwise it will cause chaos.
+    # Hence why pop is being used.
     if _is_new_patching_available():
         # Scikit-learn* modules
         import sklearn as base_module
         import sklearn.cluster as cluster_module
-        import sklearn.covariance as covariance_module
         import sklearn.decomposition as decomposition_module
         import sklearn.ensemble as ensemble_module
         import sklearn.linear_model as linear_model_module
@@ -64,6 +115,7 @@ def get_patch_map():
             from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
 
         from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .decomposition import PCA as PCA_sklearnex
         from .ensemble import ExtraTreesClassifier as ExtraTreesClassifier_sklearnex
         from .ensemble import ExtraTreesRegressor as ExtraTreesRegressor_sklearnex
         from .ensemble import RandomForestClassifier as RandomForestClassifier_sklearnex
@@ -74,53 +126,19 @@ def get_patch_map():
         from .neighbors import KNeighborsRegressor as KNeighborsRegressor_sklearnex
         from .neighbors import LocalOutlierFactor as LocalOutlierFactor_sklearnex
         from .neighbors import NearestNeighbors as NearestNeighbors_sklearnex
-
-        # Preview classes for patching
-        from .preview.cluster import KMeans as KMeans_sklearnex
-        from .preview.covariance import (
-            EmpiricalCovariance as EmpiricalCovariance_sklearnex,
-        )
-        from .preview.decomposition import PCA as PCA_sklearnex
         from .svm import SVC as SVC_sklearnex
         from .svm import SVR as SVR_sklearnex
         from .svm import NuSVC as NuSVC_sklearnex
         from .svm import NuSVR as NuSVR_sklearnex
 
-        # Patch for mapping
-        if _is_preview_enabled():
-            # PCA
-            mapping.pop("pca")
-            mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
-
-            # KMeans
-            mapping.pop("kmeans")
-            mapping["kmeans"] = [
-                [
-                    (
-                        cluster_module,
-                        "KMeans",
-                        KMeans_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-
-            # Covariance
-            mapping["empiricalcovariance"] = [
-                [
-                    (
-                        covariance_module,
-                        "EmpiricalCovariance",
-                        EmpiricalCovariance_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-
         # DBSCAN
         mapping.pop("dbscan")
         mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
 
+        # PCA
+        mapping.pop("pca")
+        mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
+
         # SVM
         mapping.pop("svm")
         mapping.pop("svc")
@@ -276,6 +294,19 @@ def get_patch_map():
     return mapping
 
 
+# This is necessary to properly cache the patch_map when
+# using preview.
+def get_patch_map():
+    preview = _is_preview_enabled()
+    return get_patch_map_core(preview=preview)
+
+
+get_patch_map.cache_clear = get_patch_map_core.cache_clear
+
+
+get_patch_map.cache_info = get_patch_map_core.cache_info
+
+
 def get_patch_names():
     return list(get_patch_map().keys())
 

sklearnex/ensemble/_forest.py

@@ -453,14 +453,12 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
 
         # The estimator is checked against the class attribute for conformance.
         # This should only trigger if the user uses this class directly.
-        if (
-            self.estimator.__class__ == DecisionTreeClassifier
-            and self._onedal_factory != onedal_RandomForestClassifier
+        if self.estimator.__class__ == DecisionTreeClassifier and not issubclass(
+            self._onedal_factory, onedal_RandomForestClassifier
         ):
             self._onedal_factory = onedal_RandomForestClassifier
-        elif (
-            self.estimator.__class__ == ExtraTreeClassifier
-            and self._onedal_factory != onedal_ExtraTreesClassifier
+        elif self.estimator.__class__ == ExtraTreeClassifier and not issubclass(
+            self._onedal_factory, onedal_ExtraTreesClassifier
         ):
             self._onedal_factory = onedal_ExtraTreesClassifier
 
@@ -747,7 +745,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
                         or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
-                    (sample_weight is not None, "sample_weight is not supported."),
+                    (sample_weight is None, "sample_weight is not supported."),
                 ]
             )
 
@@ -843,14 +841,12 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
 
         # The splitter is checked against the class attribute for conformance
         # This should only trigger if the user uses this class directly.
-        if (
-            self.estimator.__class__ == DecisionTreeRegressor
-            and self._onedal_factory != onedal_RandomForestRegressor
+        if self.estimator.__class__ == DecisionTreeRegressor and not issubclass(
+            self._onedal_factory, onedal_RandomForestRegressor
         ):
             self._onedal_factory = onedal_RandomForestRegressor
-        elif (
-            self.estimator.__class__ == ExtraTreeRegressor
-            and self._onedal_factory != onedal_ExtraTreesRegressor
+        elif self.estimator.__class__ == ExtraTreeRegressor and not issubclass(
+            self._onedal_factory, onedal_ExtraTreesRegressor
         ):
             self._onedal_factory = onedal_ExtraTreesRegressor
 
@@ -1056,7 +1052,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
                         or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
-                    (sample_weight is not None, "sample_weight is not supported."),
+                    (sample_weight is None, "sample_weight is not supported."),
                 ]
             )
 

sklearnex/ensemble/tests/test_forest.py

@@ -45,11 +45,7 @@ def test_sklearnex_import_rf_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_rf_regression(dataframe, queue):
     from sklearnex.ensemble import RandomForestRegressor
 
@@ -59,17 +55,17 @@ def test_sklearnex_import_rf_regression(dataframe, queue):
     rf = RandomForestRegressor(max_depth=2, random_state=0).fit(X, y)
     assert "sklearnex" in rf.__module__
     pred = _as_numpy(rf.predict([[0, 0, 0, 0]]))
-    if daal_check_version((2024, "P", 0)):
-        assert_allclose([-6.971], pred, atol=1e-2)
+
+    if queue is not None and queue.sycl_device.is_gpu:
+        assert_allclose([-0.011208], pred, atol=1e-2)
     else:
-        assert_allclose([-6.839], pred, atol=1e-2)
+        if daal_check_version((2024, "P", 0)):
+            assert_allclose([-6.971], pred, atol=1e-2)
+        else:
+            assert_allclose([-6.839], pred, atol=1e-2)
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_classifier(dataframe, queue):
     from sklearnex.ensemble import ExtraTreesClassifier
 
@@ -90,11 +86,7 @@ def test_sklearnex_import_et_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-# TODO:
-# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_regression(dataframe, queue):
     from sklearnex.ensemble import ExtraTreesRegressor
 
@@ -114,4 +106,8 @@ def test_sklearnex_import_et_regression(dataframe, queue):
             ]
         )
     )
-    assert_allclose([0.445], pred, atol=1e-2)
+
+    if queue is not None and queue.sycl_device.is_gpu:
+        assert_allclose([1.909769], pred, atol=1e-2)
+    else:
+        assert_allclose([0.445], pred, atol=1e-2)

sklearnex/linear_model/logistic_regression.py

@@ -185,7 +185,10 @@ if daal_check_version((2024, "P", 1)):
                 [
                     (self.penalty == "l2", "Only l2 penalty is supported."),
                     (self.dual == False, "dual=True is not supported."),
-                    (self.intercept_scaling == 1, "Intercept scaling is not supported."),
+                    (
+                        self.intercept_scaling == 1,
+                        "Intercept scaling is not supported.",
+                    ),
                     (self.class_weight is None, "Class weight is not supported"),
                     (self.solver == "newton-cg", "Only newton-cg solver is supported."),
                     (
@@ -230,7 +233,10 @@ if daal_check_version((2024, "P", 1)):
                     (n_samples > 0, "Number of samples is less than 1."),
                     (not issparse(*data), "Sparse input is not supported."),
                     (not model_is_sparse, "Sparse coefficients are not supported."),
-                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."),
+                    (
+                        hasattr(self, "_onedal_estimator"),
+                        "oneDAL model was not trained.",
+                    ),
                 ]
             )
             if not dal_ready:
@@ -324,6 +330,11 @@ if daal_check_version((2024, "P", 1)):
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_log_proba(X, queue=queue)
 
+        fit.__doc__ = sklearn_LogisticRegression.fit.__doc__
+        predict.__doc__ = sklearn_LogisticRegression.predict.__doc__
+        predict_proba.__doc__ = sklearn_LogisticRegression.predict_proba.__doc__
+        predict_log_proba.__doc__ = sklearn_LogisticRegression.predict_log_proba.__doc__
+
 else:
     LogisticRegression = LogisticRegression_daal4py
 

sklearnex/linear_model/tests/test_logreg.py

@@ -14,9 +14,7 @@
 # limitations under the License.
 # ===============================================================================
 
-import numpy as np
 import pytest
-from numpy.testing import assert_allclose
 from sklearn.datasets import load_breast_cancer, load_iris
 from sklearn.metrics import accuracy_score
 from sklearn.model_selection import train_test_split

sklearnex/neighbors/_lof.py

@@ -137,11 +137,50 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, sklearn_LocalOutlierFactor):
     @available_if(sklearn_LocalOutlierFactor._check_novelty_fit_predict)
     @wrap_output_data
     def fit_predict(self, X, y=None):
+        """Fit the model to the training set X and return the labels.
+
+        **Not available for novelty detection (when novelty is set to True).**
+        Label is 1 for an inlier and -1 for an outlier according to the LOF
+        score and the contamination parameter.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features), default=None
+            The query sample or samples to compute the Local Outlier Factor
+            w.r.t. the training samples.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        is_inlier : ndarray of shape (n_samples,)
+            Returns -1 for anomalies/outliers and 1 for inliers.
+        """
         return self.fit(X)._predict()
 
     @available_if(sklearn_LocalOutlierFactor._check_novelty_predict)
     @wrap_output_data
     def predict(self, X=None):
+        """Predict the labels (1 inlier, -1 outlier) of X according to LOF.
+
+        **Only available for novelty detection (when novelty is set to True).**
+        This method allows to generalize prediction to *new observations* (not
+        in the training set). Note that the result of ``clf.fit(X)`` then
+        ``clf.predict(X)`` with ``novelty=True`` may differ from the result
+        obtained by ``clf.fit_predict(X)`` with ``novelty=False``.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The query sample or samples to compute the Local Outlier Factor
+            w.r.t. the training samples.
+
+        Returns
+        -------
+        is_inlier : ndarray of shape (n_samples,)
+            Returns -1 for anomalies/outliers and +1 for inliers.
+        """
         return self._predict(X)
 
     @wrap_output_data
@@ -162,6 +201,4 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, sklearn_LocalOutlierFactor):
         )
 
     fit.__doc__ = sklearn_LocalOutlierFactor.fit.__doc__
-    fit_predict.__doc__ = sklearn_LocalOutlierFactor.fit_predict.__doc__
-    predict.__doc__ = sklearn_LocalOutlierFactor.predict.__doc__
     kneighbors.__doc__ = sklearn_LocalOutlierFactor.kneighbors.__doc__

sklearnex/neighbors/knn_classification.py

@@ -14,20 +14,12 @@
 # limitations under the License.
 # ===============================================================================
 
-import warnings
-
-from sklearn.neighbors._ball_tree import BallTree
-from sklearn.neighbors._base import NeighborsBase as sklearn_NeighborsBase
-from sklearn.neighbors._kd_tree import KDTree
-
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 
 if not sklearn_check_version("1.2"):
     from sklearn.neighbors._base import _check_weights
 
-import numpy as np
-from sklearn.neighbors._base import VALID_METRICS
 from sklearn.neighbors._classification import (
     KNeighborsClassifier as sklearn_KNeighborsClassifier,
 )
@@ -35,7 +27,6 @@ from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestN
 from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
 
 from onedal.neighbors import KNeighborsClassifier as onedal_KNeighborsClassifier
-from onedal.utils import _check_array, _num_features, _num_samples
 
 from .._device_offload import dispatch, wrap_output_data
 from .common import KNeighborsDispatchingBase
@@ -143,6 +134,7 @@ else:
 
 @control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "kneighbors"])
 class KNeighborsClassifier(KNeighborsClassifier_, KNeighborsDispatchingBase):
+    __doc__ = sklearn_KNeighborsClassifier.__doc__
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**KNeighborsClassifier_._parameter_constraints}
 
@@ -330,3 +322,9 @@ class KNeighborsClassifier(KNeighborsClassifier_, KNeighborsDispatchingBase):
         self._fit_method = self._onedal_estimator._fit_method
         self.outputs_2d_ = self._onedal_estimator.outputs_2d_
         self._tree = self._onedal_estimator._tree
+
+    fit.__doc__ = sklearn_KNeighborsClassifier.fit.__doc__
+    predict.__doc__ = sklearn_KNeighborsClassifier.predict.__doc__
+    predict_proba.__doc__ = sklearn_KNeighborsClassifier.predict_proba.__doc__
+    kneighbors.__doc__ = sklearn_KNeighborsClassifier.kneighbors.__doc__
+    radius_neighbors.__doc__ = sklearn_NearestNeighbors.radius_neighbors.__doc__

sklearnex/neighbors/knn_regression.py

@@ -14,20 +14,12 @@
 # limitations under the License.
 # ==============================================================================
 
-import warnings
-
-from sklearn.neighbors._ball_tree import BallTree
-from sklearn.neighbors._base import NeighborsBase as sklearn_NeighborsBase
-from sklearn.neighbors._kd_tree import KDTree
-
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 
 if not sklearn_check_version("1.2"):
     from sklearn.neighbors._base import _check_weights
 
-import numpy as np
-from sklearn.neighbors._base import VALID_METRICS
 from sklearn.neighbors._regression import (
     KNeighborsRegressor as sklearn_KNeighborsRegressor,
 )
@@ -35,7 +27,6 @@ from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestN
 from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
 
 from onedal.neighbors import KNeighborsRegressor as onedal_KNeighborsRegressor
-from onedal.utils import _check_array, _num_features, _num_samples
 
 from .._device_offload import dispatch, wrap_output_data
 from .common import KNeighborsDispatchingBase
@@ -139,6 +130,7 @@ else:
 
 @control_n_jobs(decorated_methods=["fit", "predict", "kneighbors"])
 class KNeighborsRegressor(KNeighborsRegressor_, KNeighborsDispatchingBase):
+    __doc__ = sklearn_KNeighborsRegressor.__doc__
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**KNeighborsRegressor_._parameter_constraints}
 
@@ -306,3 +298,8 @@ class KNeighborsRegressor(KNeighborsRegressor_, KNeighborsDispatchingBase):
         self._y = self._onedal_estimator._y
         self._fit_method = self._onedal_estimator._fit_method
         self._tree = self._onedal_estimator._tree
+
+    fit.__doc__ = sklearn_KNeighborsRegressor.__doc__
+    predict.__doc__ = sklearn_KNeighborsRegressor.predict.__doc__
+    kneighbors.__doc__ = sklearn_KNeighborsRegressor.kneighbors.__doc__
+    radius_neighbors.__doc__ = sklearn_NearestNeighbors.radius_neighbors.__doc__

sklearnex/neighbors/knn_unsupervised.py

@@ -19,21 +19,13 @@ try:
 except ImportError:
     from distutils.version import LooseVersion as Version
 
-import warnings
-
-import numpy as np
 from sklearn import __version__ as sklearn_version
-from sklearn.neighbors._ball_tree import BallTree
-from sklearn.neighbors._base import VALID_METRICS
-from sklearn.neighbors._base import NeighborsBase as sklearn_NeighborsBase
-from sklearn.neighbors._kd_tree import KDTree
 from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestNeighbors
 from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.neighbors import NearestNeighbors as onedal_NearestNeighbors
-from onedal.utils import _check_array, _num_features, _num_samples
 
 from .._device_offload import dispatch, wrap_output_data
 from .common import KNeighborsDispatchingBase
@@ -98,6 +90,7 @@ else:
 
 @control_n_jobs(decorated_methods=["fit", "kneighbors"])
 class NearestNeighbors(NearestNeighbors_, KNeighborsDispatchingBase):
+    __doc__ = sklearn_NearestNeighbors.__doc__
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**NearestNeighbors_._parameter_constraints}
 
@@ -219,3 +212,7 @@ class NearestNeighbors(NearestNeighbors_, KNeighborsDispatchingBase):
         self._fit_X = self._onedal_estimator._fit_X
         self._fit_method = self._onedal_estimator._fit_method
         self._tree = self._onedal_estimator._tree
+
+    fit.__doc__ = sklearn_NearestNeighbors.__doc__
+    kneighbors.__doc__ = sklearn_NearestNeighbors.kneighbors.__doc__
+    radius_neighbors.__doc__ = sklearn_NearestNeighbors.radius_neighbors.__doc__

sklearnex/neighbors/tests/test_neighbors.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 # ===============================================================================
 
-import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
@@ -33,7 +32,6 @@ from sklearnex.neighbors import (
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_knn_classifier(dataframe, queue):
-
     X = _convert_to_dataframe([[0], [1], [2], [3]], sycl_queue=queue, target_df=dataframe)
     y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
     neigh = KNeighborsClassifier(n_neighbors=3).fit(X, y)
@@ -45,7 +43,6 @@ def test_sklearnex_import_knn_classifier(dataframe, queue):
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_knn_regression(dataframe, queue):
-
     X = _convert_to_dataframe([[0], [1], [2], [3]], sycl_queue=queue, target_df=dataframe)
     y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
     neigh = KNeighborsRegressor(n_neighbors=2).fit(X, y)
@@ -61,7 +58,6 @@ def test_sklearnex_import_knn_regression(dataframe, queue):
     [LocalOutlierFactor, NearestNeighbors],
 )
 def test_sklearnex_kneighbors(estimator, dataframe, queue):
-
     X = [[0, 0, 2], [1, 0, 0], [0, 0, 1]]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     test = _convert_to_dataframe([[0, 0, 1.3]], sycl_queue=queue, target_df=dataframe)
@@ -74,7 +70,6 @@ def test_sklearnex_kneighbors(estimator, dataframe, queue):
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_lof(dataframe, queue):
-
     X = [[7, 7, 7], [1, 0, 0], [0, 0, 1], [0, 0, 1]]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     lof = LocalOutlierFactor(n_neighbors=2)

sklearnex/preview/__init__.py

@@ -14,4 +14,4 @@
 # limitations under the License.
 # ==============================================================================
 
-__all__ = ["cluster", "covariance", "decomposition"]
+__all__ = ["cluster", "covariance"]

sklearnex/spmd/ensemble/forest.py

@@ -14,8 +14,6 @@
 # limitations under the License.
 # ==============================================================================
 
-from abc import ABC
-
 from onedal.spmd.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.spmd.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 
@@ -23,16 +21,9 @@ from ...ensemble import RandomForestClassifier as RandomForestClassifier_Batch
 from ...ensemble import RandomForestRegressor as RandomForestRegressor_Batch
 
 
-class BaseForestSPMD(ABC):
-    def _onedal_classifier(self, **onedal_params):
-        return onedal_RandomForestClassifier(**onedal_params)
-
-    def _onedal_regressor(self, **onedal_params):
-        return onedal_RandomForestRegressor(**onedal_params)
-
-
-class RandomForestClassifier(BaseForestSPMD, RandomForestClassifier_Batch):
+class RandomForestClassifier(RandomForestClassifier_Batch):
     __doc__ = RandomForestClassifier_Batch.__doc__
+    _onedal_factory = onedal_RandomForestClassifier
 
     def _onedal_cpu_supported(self, method_name, *data):
         # TODO:
@@ -55,8 +46,9 @@ class RandomForestClassifier(BaseForestSPMD, RandomForestClassifier_Batch):
         return ready
 
 
-class RandomForestRegressor(BaseForestSPMD, RandomForestRegressor_Batch):
+class RandomForestRegressor(RandomForestRegressor_Batch):
     __doc__ = RandomForestRegressor_Batch.__doc__
+    _onedal_factory = onedal_RandomForestRegressor
 
     def _onedal_cpu_supported(self, method_name, *data):
         # TODO:

sklearnex/svm/nusvc.py

@@ -198,6 +198,8 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        predict_proba.__doc__ = sklearn_NuSVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         if sklearn_check_version("1.0"):
@@ -232,6 +234,8 @@ class NuSVC(sklearn_NuSVC, BaseSVC):
             X,
         )
 
+    decision_function.__doc__ = sklearn_NuSVC.decision_function.__doc__
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
             "nu": self.nu,

sklearnex/svm/nusvr.py

@@ -36,14 +36,14 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
     def __init__(
         self,
         *,
+        nu=0.5,
+        C=1.0,
         kernel="rbf",
         degree=3,
         gamma="scale",
         coef0=0.0,
-        tol=1e-3,
-        C=1.0,
-        nu=0.5,
         shrinking=True,
+        tol=1e-3,
         cache_size=200,
         verbose=False,
         max_iter=-1,

sklearnex/svm/svc.py

@@ -200,6 +200,8 @@ class SVC(sklearn_SVC, BaseSVC):
             self._check_proba()
             return self._predict_proba
 
+        predict_proba.__doc__ = sklearn_SVC.predict_proba.__doc__
+
     @wrap_output_data
     def _predict_proba(self, X):
         sklearn_pred_proba = (
@@ -232,6 +234,8 @@ class SVC(sklearn_SVC, BaseSVC):
             X,
         )
 
+    decision_function.__doc__ = sklearn_SVC.decision_function.__doc__
+
     def _onedal_gpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
         patching_status = PatchingConditionsChain(