scikit-learn-intelex 2024.2.0__py310-none-win_amd64.whl → 2024.3.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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."),
                 ]
             )
 

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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)

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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
 

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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__

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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__

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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__

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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__

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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)

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/preview/__init__.py

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

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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:

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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,

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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(

scikit_learn_intelex-2024.3.0.data/data/Lib/site-packages/sklearnex/tests/_utils.py

@@ -0,0 +1,155 @@
+# ==============================================================================
+# 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 inspect import isclass
+
+import numpy as np
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    ClusterMixin,
+    OutlierMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.datasets import load_diabetes, load_iris
+from sklearn.neighbors._base import KNeighborsMixin
+
+from onedal.tests.utils._dataframes_support import _convert_to_dataframe
+from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
+from sklearnex.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearnex.svm import SVC, NuSVC
+
+
+def _load_all_models(with_sklearnex=True, estimator=True):
+    # insure that patch state is correct as dictated by patch_sklearn boolean
+    # and return it to the previous state no matter what occurs.
+    already_patched_map = sklearn_is_patched(return_map=True)
+    already_patched = any(already_patched_map.values())
+    try:
+        if with_sklearnex:
+            patch_sklearn()
+        elif already_patched:
+            unpatch_sklearn()
+
+        models = {}
+        for patch_infos in get_patch_map().values():
+            candidate = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
+            if candidate is not None and isclass(candidate) == estimator:
+                if not estimator or issubclass(candidate, BaseEstimator):
+                    models[patch_infos[0][0][1]] = candidate
+    finally:
+        if with_sklearnex:
+            unpatch_sklearn()
+        # both branches are now in an unpatched state, repatch as necessary
+        if already_patched:
+            patch_sklearn(name=[i for i in already_patched_map if already_patched_map[i]])
+
+    return models
+
+
+PATCHED_MODELS = _load_all_models(with_sklearnex=True)
+UNPATCHED_MODELS = _load_all_models(with_sklearnex=False)
+
+PATCHED_FUNCTIONS = _load_all_models(with_sklearnex=True, estimator=False)
+UNPATCHED_FUNCTIONS = _load_all_models(with_sklearnex=False, estimator=False)
+
+mixin_map = [
+    [
+        ClassifierMixin,
+        ["decision_function", "predict", "predict_proba", "predict_log_proba", "score"],
+        "classification",
+    ],
+    [RegressorMixin, ["predict", "score"], "regression"],
+    [ClusterMixin, ["fit_predict"], "classification"],
+    [TransformerMixin, ["fit_transform", "transform", "score"], "classification"],
+    [OutlierMixin, ["fit_predict", "predict"], "classification"],
+    [KNeighborsMixin, ["kneighbors"], None],
+]
+
+
+SPECIAL_INSTANCES = {
+    str(i): i
+    for i in [
+        LocalOutlierFactor(novelty=True),
+        SVC(probability=True),
+        NuSVC(probability=True),
+        KNeighborsClassifier(algorithm="brute"),
+        KNeighborsRegressor(algorithm="brute"),
+        NearestNeighbors(algorithm="brute"),
+    ]
+}
+
+
+def gen_models_info(algorithms):
+    output = []
+    for i in algorithms:
+        # split handles SPECIAL_INSTANCES or custom inputs
+        # custom sklearn inputs must be a dict of estimators
+        # with keys set by the __str__ method
+        est = PATCHED_MODELS[i.split("(")[0]]
+
+        methods = set()
+        candidates = set(
+            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
+        )
+
+        for mixin, method, _ in mixin_map:
+            if issubclass(est, mixin):
+                methods |= candidates & set(method)
+
+        output += [[i, j] for j in methods]
+    return output
+
+
+def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
+    dataset = None
+    name = estimator.__class__.__name__
+    est = PATCHED_MODELS[name]
+    for mixin, _, data in mixin_map:
+        if issubclass(est, mixin) and data is not None:
+            dataset = data
+    # load data
+    if dataset == "classification" or dataset is None:
+        X, y = load_iris(return_X_y=True)
+    elif dataset == "regression":
+        X, y = load_diabetes(return_X_y=True)
+    else:
+        raise ValueError("Unknown dataset type")
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    return X, y
+
+
+DTYPES = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]