scikit-learn-intelex 2024.0.1__py312-none-manylinux1_x86_64.whl → 2024.2.0__py312-none-manylinux1_x86_64.whl

sklearnex/preview/decomposition/pca.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # ===============================================================================
 # Copyright 2023 Intel Corporation
 #
@@ -24,11 +23,12 @@ from sklearn.base import BaseEstimator
 from sklearn.utils.extmath import stable_cumsum
 from sklearn.utils.validation import check_array, check_is_fitted
 
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.utils import _check_array
 
 from ..._device_offload import dispatch
-from ..._utils import PatchingConditionsChain
+from ..._utils import PatchingConditionsChain, register_hyperparameters
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
@@ -39,10 +39,15 @@ else:
 
 from sklearn.decomposition import PCA as sklearn_PCA
 
+from onedal.common.hyperparameters import get_hyperparameters
 from onedal.decomposition import PCA as onedal_PCA
 
 
+@register_hyperparameters({"fit": get_hyperparameters("covariance", "compute")})
+@control_n_jobs(decorated_methods=["fit", "transform"])
 class PCA(sklearn_PCA):
+    __doc__ = sklearn_PCA.__doc__
+
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_PCA._parameter_constraints}
 
@@ -99,23 +104,22 @@ class PCA(sklearn_PCA):
                 min_val=1,
                 target_type=numbers.Integral,
             )
-        self._fit(X)
-        return self
-
-    def _fit(self, X):
-        if issparse(X):
-            raise TypeError(
-                "PCA does not support sparse input. See "
-                "TruncatedSVD for a possible alternative."
-            )
 
         if sklearn_check_version("0.23"):
             X = self._validate_data(
-                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
+                X,
+                dtype=[np.float64, np.float32],
+                ensure_2d=True,
+                copy=False,
+                accept_sparse=True,
             )
         else:
             X = _check_array(
-                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
+                X,
+                dtype=[np.float64, np.float32],
+                ensure_2d=True,
+                copy=False,
+                accept_sparse=True,
             )
 
         n_samples, n_features = X.shape
@@ -132,7 +136,7 @@ class PCA(sklearn_PCA):
         self._validate_n_components(n_components, n_samples, n_features, n_sf_min)
 
         self._fit_svd_solver = self.svd_solver
-        shape_good_for_daal = X.shape[1] / X.shape[0] < 2
+
         if self._fit_svd_solver == "auto":
             if sklearn_check_version("1.1"):
                 if max(X.shape) <= 500 or n_components == "mle":
@@ -164,37 +168,21 @@ class PCA(sklearn_PCA):
                     else:
                         self._fit_svd_solver = "full"
 
-        if not shape_good_for_daal or self._fit_svd_solver != "full":
-            if sklearn_check_version("0.23"):
-                X = self._validate_data(X, copy=self.copy)
-            else:
-                X = check_array(X, copy=self.copy)
-
-        # Call different fits for either full or truncated SVD
-        if shape_good_for_daal and self._fit_svd_solver == "full":
-            return dispatch(
-                self,
-                "fit",
-                {
-                    "onedal": self.__class__._onedal_fit,
-                    "sklearn": sklearn_PCA._fit_full,
-                },
-                X,
-            )
-        elif not shape_good_for_daal and self._fit_svd_solver == "full":
-            return sklearn_PCA._fit_full(self, X, n_components)
-        elif self._fit_svd_solver in ["arpack", "randomized"]:
-            return sklearn_PCA._fit_truncated(
-                self,
-                X,
-                n_components,
-                self._fit_svd_solver,
-            )
-        else:
-            raise ValueError("Unrecognized svd_solver='{0}'".format(self._fit_svd_solver))
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_PCA.fit,
+            },
+            X,
+        )
+        return self
 
     def _onedal_supported(self, method_name, *data):
         class_name = self.__class__.__name__
+        X = data[0]
+
         if method_name == "fit":
             patching_status = PatchingConditionsChain(
                 f"sklearn.decomposition.{class_name}.{method_name}"
@@ -206,6 +194,12 @@ class PCA(sklearn_PCA):
                         f"'{self._fit_svd_solver}' SVD solver is not supported. "
                         "Only 'full' solver is supported.",
                     ),
+                    (not issparse(X), "oneDAL PCA does not support sparse inputs"),
+                    (
+                        X.shape[1] / X.shape[0] < 2,
+                        "The shape of X does not satisfy oneDAL requirements: "
+                        "number of features / number of samples >= 2",
+                    ),
                 ]
             )
             return patching_status
@@ -290,7 +284,7 @@ class PCA(sklearn_PCA):
             if self.whiten:
                 X_new /= np.sqrt(self.explained_variance_)
         else:
-            return sklearn_PCA.transform(self, X)
+            return super().transform(X)
         return X_new
 
     def fit_transform(self, X, y=None):
@@ -308,7 +302,7 @@ class PCA(sklearn_PCA):
             Transformed values of X.
         """
         if self.svd_solver in ["randomized", "arpack"]:
-            return sklearn_PCA.fit_transform(self, X)
+            return super().fit_transform(X)
         else:
             self.fit(X)
             if hasattr(self, "_onedal_estimator"):
@@ -317,7 +311,11 @@ class PCA(sklearn_PCA):
                     X_new /= np.sqrt(self.explained_variance_)
                 return X_new
             else:
-                return sklearn_PCA.transform(self, X)
+                return super().transform(X)
+
+    fit.__doc__ = sklearn_PCA.fit.__doc__
+    transform.__doc__ = sklearn_PCA.transform.__doc__
+    fit_transform.__doc__ = sklearn_PCA.fit_transform.__doc__
 
     def _save_attributes(self):
         self.n_samples_ = self._onedal_estimator.n_samples_

sklearnex/preview/decomposition/tests/test_preview_pca.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # ===============================================================================
 # Copyright 2023 Intel Corporation
 #
@@ -19,6 +18,7 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+from daal4py.sklearn._utils import daal_check_version
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -27,12 +27,16 @@ from onedal.tests.utils._dataframes_support import (
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import(dataframe, queue):
+@pytest.mark.parametrize("macro_block", [None, 1024])
+def test_sklearnex_import(dataframe, queue, macro_block):
     from sklearnex.preview.decomposition import PCA
 
     X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    pca = PCA(n_components=2, svd_solver="full").fit(X)
+    pca = PCA(n_components=2, svd_solver="full")
+    if daal_check_version((2024, "P", 0)) and macro_block is not None:
+        pca.get_hyperparameters("fit").cpu_macro_block = macro_block
+    pca.fit(X)
     assert "sklearnex" in pca.__module__
     assert hasattr(pca, "_onedal_estimator")
     assert_allclose(_as_numpy(pca.singular_values_), [6.30061232, 0.54980396])

sklearnex/spmd/__init__.py

@@ -17,6 +17,7 @@
 __all__ = [
     "basic_statistics",
     "cluster",
+    "covariance",
     "decomposition",
     "ensemble",
     "linear_model",

sklearnex/spmd/covariance/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from .covariance import EmpiricalCovariance
+
+__all__ = ["EmpiricalCovariance"]

sklearnex/spmd/covariance/covariance.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal.spmd.covariance import EmpiricalCovariance
+
+# TODO:
+# Currently it uses `onedal` module interface.
+# Add sklearnex dispatching.

sklearnex/spmd/linear_model/__init__.py

@@ -15,5 +15,6 @@
 # ==============================================================================
 
 from .linear_model import LinearRegression
+from .logistic_regression import LogisticRegression
 
-__all__ = ["LinearRegression"]
+__all__ = ["LinearRegression", "LogisticRegression"]

sklearnex/spmd/linear_model/logistic_regression.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal.spmd.linear_model import LogisticRegression
+
+# TODO:
+# Currently it uses `onedal` module interface.
+# Add sklearnex dispatching.

sklearnex/svm/__init__.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # ==============================================================================
 # Copyright 2021 Intel Corporation
 #

sklearnex/svm/nusvc.py

@@ -18,6 +18,7 @@ from sklearn.exceptions import NotFittedError
 from sklearn.svm import NuSVC as sklearn_NuSVC
 from sklearn.utils.validation import _deprecate_positional_args
 
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 
 from .._device_offload import dispatch, wrap_output_data
@@ -29,6 +30,9 @@ if sklearn_check_version("1.0"):
 from onedal.svm import NuSVC as onedal_NuSVC
 
 
+@control_n_jobs(
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+)
 class NuSVC(sklearn_NuSVC, BaseSVC):
     __doc__ = sklearn_NuSVC.__doc__
 

sklearnex/svm/nusvr.py

@@ -17,6 +17,7 @@
 from sklearn.svm import NuSVR as sklearn_NuSVR
 from sklearn.utils.validation import _deprecate_positional_args
 
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import NuSVR as onedal_NuSVR
 
@@ -24,6 +25,7 @@ from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVR
 
 
+@control_n_jobs(decorated_methods=["fit", "predict"])
 class NuSVR(sklearn_NuSVR, BaseSVR):
     __doc__ = sklearn_NuSVR.__doc__
 

sklearnex/svm/svc.py

@@ -20,6 +20,7 @@ from sklearn.exceptions import NotFittedError
 from sklearn.svm import SVC as sklearn_SVC
 from sklearn.utils.validation import _deprecate_positional_args
 
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 
 from .._device_offload import dispatch, wrap_output_data
@@ -32,6 +33,9 @@ if sklearn_check_version("1.0"):
 from onedal.svm import SVC as onedal_SVC
 
 
+@control_n_jobs(
+    decorated_methods=["fit", "predict", "_predict_proba", "decision_function"]
+)
 class SVC(sklearn_SVC, BaseSVC):
     __doc__ = sklearn_SVC.__doc__
 
@@ -235,7 +239,7 @@ class SVC(sklearn_SVC, BaseSVC):
         )
         if len(data) > 1:
             self._class_count = len(np.unique(data[1]))
-        self._is_sparse = sp.isspmatrix(data[0])
+        self._is_sparse = sp.issparse(data[0])
         conditions = [
             (
                 self.kernel in ["linear", "rbf"],

sklearnex/svm/svr.py

@@ -17,6 +17,7 @@
 from sklearn.svm import SVR as sklearn_SVR
 from sklearn.utils.validation import _deprecate_positional_args
 
+from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import SVR as onedal_SVR
 
@@ -24,6 +25,7 @@ from .._device_offload import dispatch, wrap_output_data
 from ._common import BaseSVR
 
 
+@control_n_jobs(decorated_methods=["fit", "predict"])
 class SVR(sklearn_SVR, BaseSVR):
     __doc__ = sklearn_SVR.__doc__
 

sklearnex/svm/tests/test_svm.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # ===============================================================================
 # Copyright 2021 Intel Corporation
 #

sklearnex/tests/test_memory_usage.py

@@ -94,10 +94,7 @@ def remove_duplicated_estimators(estimators_list):
     return estimators_map.values()
 
 
-BANNED_ESTIMATORS = (
-    "LocalOutlierFactor",  # fails on ndarray_c for sklearn > 1.0
-    "TSNE",  # too slow for using in testing on common data size
-)
+BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
 estimators = [
     PreviewPCA,
     TrainTestSplitEstimator,

sklearnex/tests/test_monkeypatch.py

@@ -45,8 +45,12 @@ def test_monkey_patching():
         n = _classes[i][1]
 
         sklearnex.unpatch_sklearn(t)
-        class_module = getattr(p, n).__module__
-        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
+        sklearn_class = getattr(p, n, None)
+        if sklearn_class is not None:
+            sklearn_class = sklearn_class.__module__
+        assert sklearn_class is None or sklearn_class.startswith(
+            "sklearn"
+        ), "Unpatching has completed with error."
 
     sklearnex.unpatch_sklearn()
 
@@ -55,8 +59,12 @@ def test_monkey_patching():
         p = _classes[i][0]
         n = _classes[i][1]
 
-        class_module = getattr(p, n).__module__
-        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
+        sklearn_class = getattr(p, n, None)
+        if sklearn_class is not None:
+            sklearn_class = sklearn_class.__module__
+        assert sklearn_class is None or sklearn_class.startswith(
+            "sklearn"
+        ), "Unpatching has completed with error."
 
     sklearnex.unpatch_sklearn()
 
@@ -85,7 +93,10 @@ def test_patch_by_list_simple():
 
     assert RandomForestRegressor.__module__.startswith("sklearn")
     assert KNeighborsRegressor.__module__.startswith("sklearn")
-    assert LogisticRegression.__module__.startswith("daal4py")
+    if daal_check_version((2024, "P", 1)):
+        assert LogisticRegression.__module__.startswith("sklearnex")
+    else:
+        assert LogisticRegression.__module__.startswith("daal4py")
     assert SVC.__module__.startswith("sklearn")
 
     sklearnex.unpatch_sklearn()
@@ -101,7 +112,10 @@ def test_patch_by_list_many_estimators():
 
     assert RandomForestRegressor.__module__.startswith("sklearn")
     assert KNeighborsRegressor.__module__.startswith("sklearn")
-    assert LogisticRegression.__module__.startswith("daal4py")
+    if daal_check_version((2024, "P", 1)):
+        assert LogisticRegression.__module__.startswith("sklearnex")
+    else:
+        assert LogisticRegression.__module__.startswith("daal4py")
     assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
 
     sklearnex.unpatch_sklearn()
@@ -119,7 +133,10 @@ def test_unpatch_by_list_many_estimators():
     assert KNeighborsRegressor.__module__.startswith(
         "daal4py"
     ) or KNeighborsRegressor.__module__.startswith("sklearnex")
-    assert LogisticRegression.__module__.startswith("daal4py")
+    if daal_check_version((2024, "P", 1)):
+        assert LogisticRegression.__module__.startswith("sklearnex")
+    else:
+        assert LogisticRegression.__module__.startswith("daal4py")
     assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
 
     sklearnex.unpatch_sklearn(["KNeighborsRegressor", "RandomForestRegressor"])
@@ -131,7 +148,11 @@ def test_unpatch_by_list_many_estimators():
 
     assert RandomForestRegressor.__module__.startswith("sklearn")
     assert KNeighborsRegressor.__module__.startswith("sklearn")
-    assert LogisticRegression.__module__.startswith("daal4py")
+    if daal_check_version((2024, "P", 1)):
+        assert LogisticRegression.__module__.startswith("sklearnex")
+    else:
+        assert LogisticRegression.__module__.startswith("daal4py")
+
     assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
 
 
@@ -164,14 +185,22 @@ def test_preview_namespace():
         from sklearn.linear_model import LinearRegression
         from sklearn.svm import SVC
 
-        return LinearRegression(), PCA(), DBSCAN(), SVC(), RandomForestClassifier()
+        return (
+            LinearRegression(),
+            PCA(),
+            DBSCAN(),
+            SVC(),
+            RandomForestClassifier(),
+        )
 
     # BUG: previous patching tests force PCA to be patched with daal4py.
     # This unpatching returns behavior to expected
     sklearnex.unpatch_sklearn()
     # behavior with enabled preview
     sklearnex.patch_sklearn(preview=True)
-    assert sklearnex.dispatcher._is_preview_enabled()
+    from sklearnex.dispatcher import _is_preview_enabled
+
+    assert _is_preview_enabled()
 
     lr, pca, dbscan, svc, rfc = get_estimators()
     assert "sklearnex" in rfc.__module__
@@ -188,21 +217,22 @@ def test_preview_namespace():
 
     # no patching behavior
     lr, pca, dbscan, svc, rfc = get_estimators()
-    assert "sklearn." in lr.__module__
-    assert "sklearn." in pca.__module__
-    assert "sklearn." in dbscan.__module__
-    assert "sklearn." in svc.__module__
-    assert "sklearn." in rfc.__module__
+    assert "sklearn." in lr.__module__ and "daal4py" not in lr.__module__
+    assert "sklearn." in pca.__module__ and "daal4py" not in pca.__module__
+    assert "sklearn." in dbscan.__module__ and "daal4py" not in dbscan.__module__
+    assert "sklearn." in svc.__module__ and "daal4py" not in svc.__module__
+    assert "sklearn." in rfc.__module__ and "daal4py" not in rfc.__module__
 
     # default patching behavior
     sklearnex.patch_sklearn()
-    assert not sklearnex.dispatcher._is_preview_enabled()
+    assert not _is_preview_enabled()
 
     lr, pca, dbscan, svc, rfc = get_estimators()
     if daal_check_version((2023, "P", 100)):
         assert "sklearnex" in lr.__module__
     else:
         assert "daal4py" in lr.__module__
+
     assert "daal4py" in pca.__module__
     assert "sklearnex" in rfc.__module__
     assert "sklearnex" in dbscan.__module__

sklearnex/tests/test_n_jobs_support.py

@@ -0,0 +1,93 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import inspect
+import logging
+from multiprocessing import cpu_count
+
+import pytest
+from sklearn.base import BaseEstimator
+from sklearn.datasets import make_classification
+
+from sklearnex.dispatcher import get_patch_map
+from sklearnex.svm import SVC, NuSVC
+
+ESTIMATORS = set(
+    filter(
+        lambda x: inspect.isclass(x) and issubclass(x, BaseEstimator),
+        [value[0][0][2] for value in get_patch_map().values()],
+    )
+)
+
+X, Y = make_classification(n_samples=40, n_features=4, random_state=42)
+
+
+@pytest.mark.parametrize("estimator_class", ESTIMATORS)
+@pytest.mark.parametrize("n_jobs", [None, -1, 1, 2])
+def test_n_jobs_support(caplog, estimator_class, n_jobs):
+    def check_estimator_doc(estimator):
+        if estimator.__doc__ is not None:
+            assert "n_jobs" in estimator.__doc__
+
+    def check_n_jobs_entry_in_logs(caplog, function_name, n_jobs):
+        for rec in caplog.records:
+            if function_name in rec.message and "threads" in rec.message:
+                expected_n_jobs = n_jobs if n_jobs > 0 else cpu_count() + 1 + n_jobs
+                logging.info(f"{function_name}: setting {expected_n_jobs} threads")
+                if f"{function_name}: setting {expected_n_jobs} threads" in rec.message:
+                    return True
+        # False if n_jobs is set and not found in logs
+        return n_jobs is None
+
+    def check_method(*args, method, caplog):
+        method(*args)
+        assert check_n_jobs_entry_in_logs(caplog, method.__name__, n_jobs)
+
+    def check_methods_decoration(estimator):
+        funcs = {
+            i: getattr(estimator, i)
+            for i in dir(estimator)
+            if hasattr(estimator, i) and callable(getattr(estimator, i))
+        }
+
+        for func_name, func in funcs.items():
+            assert hasattr(func, "__onedal_n_jobs_decorated__") == (
+                func_name in estimator._n_jobs_supported_onedal_methods
+            ), f"{estimator}.{func_name} n_jobs decoration does not match {estimator} n_jobs supported methods"
+
+    caplog.set_level(logging.DEBUG, logger="sklearnex")
+    estimator_kwargs = {"n_jobs": n_jobs}
+    # by default, [Nu]SVC.predict_proba is restricted by @available_if decorator
+    if estimator_class in [SVC, NuSVC]:
+        estimator_kwargs["probability"] = True
+    estimator_instance = estimator_class(**estimator_kwargs)
+    # check `n_jobs` parameter doc entry
+    check_estimator_doc(estimator_class)
+    check_estimator_doc(estimator_instance)
+    # check `n_jobs` log entry for supported methods
+    # `fit` call is required before other methods
+    check_method(X, Y, method=estimator_instance.fit, caplog=caplog)
+    for method_name in estimator_instance._n_jobs_supported_onedal_methods:
+        if method_name == "fit":
+            continue
+        method = getattr(estimator_instance, method_name)
+        if len(inspect.signature(method).parameters) == 0:
+            check_method(method=method, caplog=caplog)
+        else:
+            check_method(X, method=method, caplog=caplog)
+    # check if correct methods were decorated
+    check_methods_decoration(estimator_class)
+    check_methods_decoration(estimator_instance)

sklearnex/tests/test_patching.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+import inspect
 import os
 import pathlib
 import re
@@ -96,15 +97,15 @@ def _load_all_models(patched):
     if patched:
         patch_sklearn()
 
-    models = []
+    models = {}
     for patch_infos in get_patch_map().values():
-        maybe_class = getattr(patch_infos[0][0][0], patch_infos[0][0][1])
+        maybe_class = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
         if (
             maybe_class is not None
             and isclass(maybe_class)
             and issubclass(maybe_class, BaseEstimator)
         ):
-            models.append(maybe_class())
+            models[patch_infos[0][0][1]] = maybe_class
 
     if patched:
         unpatch_sklearn()
@@ -116,7 +117,20 @@ PATCHED_MODELS = _load_all_models(patched=True)
 UNPATCHED_MODELS = _load_all_models(patched=False)
 
 
-@pytest.mark.parametrize(("patched", "unpatched"), zip(PATCHED_MODELS, UNPATCHED_MODELS))
-def test_is_patched_instance(patched, unpatched):
+@pytest.mark.parametrize("estimator", UNPATCHED_MODELS.keys())
+def test_is_patched_instance(estimator):
+    patched = PATCHED_MODELS[estimator]
+    unpatched = UNPATCHED_MODELS[estimator]
     assert is_patched_instance(patched), f"{patched} is a patched instance"
     assert not is_patched_instance(unpatched), f"{unpatched} is an unpatched instance"
+
+
+@pytest.mark.parametrize("member", ["_onedal_cpu_supported", "_onedal_gpu_supported"])
+@pytest.mark.parametrize(
+    "name",
+    [i for i in PATCHED_MODELS.keys() if "sklearnex" in PATCHED_MODELS[i].__module__],
+)
+def test_onedal_supported_member(name, member):
+    patched = PATCHED_MODELS[name]
+    sig = str(inspect.signature(getattr(patched, member)))
+    assert "(self, method_name, *data)" == sig

sklearnex/utils/validation.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # ===============================================================================
 # Copyright 2022 Intel Corporation
 #