scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -14,10 +14,13 @@
 # limitations under the License.
 # ==============================================================================
 
+from functools import wraps
+
 import numpy as np
 from sklearn.exceptions import NotFittedError
 from sklearn.metrics import accuracy_score
 from sklearn.svm import NuSVC as _sklearn_NuSVC
+from sklearn.utils.metaestimators import available_if
 from sklearn.utils.validation import (
     _deprecate_positional_args,
     check_array,
@@ -26,21 +29,13 @@ from sklearn.utils.validation import (
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from onedal.svm import NuSVC as onedal_NuSVC
 
 from .._device_offload import dispatch, wrap_output_data
 from ..utils._array_api import get_namespace
+from ..utils.validation import validate_data
 from ._common import BaseSVC
 
-if sklearn_check_version("1.0"):
-    from sklearn.utils.metaestimators import available_if
-
-from onedal.svm import NuSVC as onedal_NuSVC
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseSVC._validate_data
-
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
@@ -145,99 +140,27 @@ class NuSVC(_sklearn_NuSVC, BaseSVC):
             sample_weight=sample_weight,
         )
 
-    if sklearn_check_version("1.0"):
-
-        @available_if(_sklearn_NuSVC._check_proba)
-        def predict_proba(self, X):
-            """
-            Compute probabilities of possible outcomes for samples in X.
-
-            The model need to have probability information computed at training
-            time: fit with attribute `probability` set to True.
-
-            Parameters
-            ----------
-            X : array-like of shape (n_samples, n_features)
-                For kernel="precomputed", the expected shape of X is
-                (n_samples_test, n_samples_train).
-
-            Returns
-            -------
-            T : ndarray of shape (n_samples, n_classes)
-                Returns the probability of the sample for each class in
-                the model. The columns correspond to the classes in sorted
-                order, as they appear in the attribute :term:`classes_`.
-
-            Notes
-            -----
-            The probability model is created using cross validation, so
-            the results can be slightly different than those obtained by
-            predict. Also, it will produce meaningless results on very small
-            datasets.
-            """
-            check_is_fitted(self)
-            return self._predict_proba(X)
-
-        @available_if(_sklearn_NuSVC._check_proba)
-        def predict_log_proba(self, X):
-            """Compute log probabilities of possible outcomes for samples in X.
-
-            The model need to have probability information computed at training
-            time: fit with attribute `probability` set to True.
-
-            Parameters
-            ----------
-            X : array-like of shape (n_samples, n_features) or \
-                    (n_samples_test, n_samples_train)
-                For kernel="precomputed", the expected shape of X is
-                (n_samples_test, n_samples_train).
-
-            Returns
-            -------
-            T : ndarray of shape (n_samples, n_classes)
-                Returns the log-probabilities of the sample for each class in
-                the model. The columns correspond to the classes in sorted
-                order, as they appear in the attribute :term:`classes_`.
-
-            Notes
-            -----
-            The probability model is created using cross validation, so
-            the results can be slightly different than those obtained by
-            predict. Also, it will produce meaningless results on very small
-            datasets.
-            """
-            xp, _ = get_namespace(X)
-
-            return xp.log(self.predict_proba(X))
-
-    else:
-
-        @property
-        def predict_proba(self):
-            self._check_proba()
-            check_is_fitted(self)
-            return self._predict_proba
-
-        def _predict_log_proba(self, X):
-            xp, _ = get_namespace(X)
-            return xp.log(self.predict_proba(X))
-
-        predict_proba.__doc__ = _sklearn_NuSVC.predict_proba.__doc__
+    @available_if(_sklearn_NuSVC._check_proba)
+    @wraps(_sklearn_NuSVC.predict_proba, assigned=["__doc__"])
+    def predict_proba(self, X):
+        check_is_fitted(self)
+        return self._predict_proba(X)
+
+    @available_if(_sklearn_NuSVC._check_proba)
+    @wraps(_sklearn_NuSVC.predict_log_proba, assigned=["__doc__"])
+    def predict_log_proba(self, X):
+        xp, _ = get_namespace(X)
+
+        return xp.log(self.predict_proba(X))
 
     @wrap_output_data
     def _predict_proba(self, X):
-        sklearn_pred_proba = (
-            _sklearn_NuSVC.predict_proba
-            if sklearn_check_version("1.0")
-            else _sklearn_NuSVC._predict_proba
-        )
-
         return dispatch(
             self,
             "predict_proba",
             {
                 "onedal": self.__class__._onedal_predict_proba,
-                "sklearn": sklearn_pred_proba,
+                "sklearn": _sklearn_NuSVC.predict_proba,
             },
             X,
         )
@@ -306,23 +229,15 @@ class NuSVC(_sklearn_NuSVC, BaseSVC):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                ensure_2d=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            ensure_2d=False,
+            accept_sparse="csr",
+            reset=False,
+        )
 
         return self._onedal_estimator.predict(X, queue=queue)
 
@@ -341,22 +256,14 @@ class NuSVC(_sklearn_NuSVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
 
         return self._onedal_estimator.decision_function(X, queue=queue)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -27,13 +27,9 @@ from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import NuSVR as onedal_NuSVR
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import validate_data
 from ._common import BaseSVR
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseSVR._validate_data
-
 
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
 class NuSVR(_sklearn_NuSVR, BaseSVR):
@@ -147,22 +143,14 @@ class NuSVR(_sklearn_NuSVR, BaseSVR):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
         return self._onedal_estimator.predict(X, queue=queue)
 
     fit.__doc__ = _sklearn_NuSVR.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -14,11 +14,14 @@
 # limitations under the License.
 # ==============================================================================
 
+from functools import wraps
+
 import numpy as np
 from scipy import sparse as sp
 from sklearn.exceptions import NotFittedError
 from sklearn.metrics import accuracy_score
 from sklearn.svm import SVC as _sklearn_SVC
+from sklearn.utils.metaestimators import available_if
 from sklearn.utils.validation import (
     _deprecate_positional_args,
     check_array,
@@ -27,22 +30,14 @@ from sklearn.utils.validation import (
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from onedal.svm import SVC as onedal_SVC
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
 from ..utils._array_api import get_namespace
+from ..utils.validation import validate_data
 from ._common import BaseSVC
 
-if sklearn_check_version("1.0"):
-    from sklearn.utils.metaestimators import available_if
-
-from onedal.svm import SVC as onedal_SVC
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseSVC._validate_data
-
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
@@ -147,99 +142,27 @@ class SVC(_sklearn_SVC, BaseSVC):
             sample_weight=sample_weight,
         )
 
-    if sklearn_check_version("1.0"):
-
-        @available_if(_sklearn_SVC._check_proba)
-        def predict_proba(self, X):
-            """
-            Compute probabilities of possible outcomes for samples in X.
-
-            The model need to have probability information computed at training
-            time: fit with attribute `probability` set to True.
-
-            Parameters
-            ----------
-            X : array-like of shape (n_samples, n_features)
-                For kernel="precomputed", the expected shape of X is
-                (n_samples_test, n_samples_train).
-
-            Returns
-            -------
-            T : ndarray of shape (n_samples, n_classes)
-                Returns the probability of the sample for each class in
-                the model. The columns correspond to the classes in sorted
-                order, as they appear in the attribute :term:`classes_`.
-
-            Notes
-            -----
-            The probability model is created using cross validation, so
-            the results can be slightly different than those obtained by
-            predict. Also, it will produce meaningless results on very small
-            datasets.
-            """
-            check_is_fitted(self)
-            return self._predict_proba(X)
-
-        @available_if(_sklearn_SVC._check_proba)
-        def predict_log_proba(self, X):
-            """Compute log probabilities of possible outcomes for samples in X.
-
-            The model need to have probability information computed at training
-            time: fit with attribute `probability` set to True.
-
-            Parameters
-            ----------
-            X : array-like of shape (n_samples, n_features) or \
-                    (n_samples_test, n_samples_train)
-                For kernel="precomputed", the expected shape of X is
-                (n_samples_test, n_samples_train).
-
-            Returns
-            -------
-            T : ndarray of shape (n_samples, n_classes)
-                Returns the log-probabilities of the sample for each class in
-                the model. The columns correspond to the classes in sorted
-                order, as they appear in the attribute :term:`classes_`.
-
-            Notes
-            -----
-            The probability model is created using cross validation, so
-            the results can be slightly different than those obtained by
-            predict. Also, it will produce meaningless results on very small
-            datasets.
-            """
-            xp, _ = get_namespace(X)
-
-            return xp.log(self.predict_proba(X))
-
-    else:
-
-        @property
-        def predict_proba(self):
-            self._check_proba()
-            check_is_fitted(self)
-            return self._predict_proba
+    @available_if(_sklearn_SVC._check_proba)
+    @wraps(_sklearn_SVC.predict_proba, assigned=["__doc__"])
+    def predict_proba(self, X):
+        check_is_fitted(self)
+        return self._predict_proba(X)
 
-        def _predict_log_proba(self, X):
-            xp, _ = get_namespace(X)
-            return xp.log(self.predict_proba(X))
+    @available_if(_sklearn_SVC._check_proba)
+    @wraps(_sklearn_SVC.predict_log_proba, assigned=["__doc__"])
+    def predict_log_proba(self, X):
+        xp, _ = get_namespace(X)
 
-        predict_proba.__doc__ = _sklearn_SVC.predict_proba.__doc__
+        return xp.log(self.predict_proba(X))
 
     @wrap_output_data
     def _predict_proba(self, X):
-        sklearn_pred_proba = (
-            _sklearn_SVC.predict_proba
-            if sklearn_check_version("1.0")
-            else _sklearn_SVC._predict_proba
-        )
-
         return dispatch(
             self,
             "predict_proba",
             {
                 "onedal": self.__class__._onedal_predict_proba,
-                "sklearn": sklearn_pred_proba,
+                "sklearn": _sklearn_SVC.predict_proba,
             },
             X,
         )
@@ -336,23 +259,15 @@ class SVC(_sklearn_SVC, BaseSVC):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                ensure_2d=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            ensure_2d=False,
+            accept_sparse="csr",
+            reset=False,
+        )
         return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_predict_proba(self, X, queue=None):
@@ -370,22 +285,14 @@ class SVC(_sklearn_SVC, BaseSVC):
             return self.clf_prob.predict_proba(X)
 
     def _onedal_decision_function(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
         return self._onedal_estimator.decision_function(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/svm/svr.py

@@ -23,13 +23,9 @@ from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import SVR as onedal_SVR
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import validate_data
 from ._common import BaseSVR
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseSVR._validate_data
-
 
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
 class SVR(_sklearn_SVR, BaseSVR):
@@ -144,22 +140,14 @@ class SVR(_sklearn_SVR, BaseSVR):
         self._save_attributes()
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+            reset=False,
+        )
         return self._onedal_estimator.predict(X, queue=queue)
 
     fit.__doc__ = _sklearn_SVR.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -406,22 +406,36 @@ def estimator_trace(estimator, method, cache, isolated_trace):
 
 
 def call_validate_data(text, estimator, method):
-    """test that the sklearn function/attribute validate_data is
+    """test that both sklearnex wrapper for validate_data and
+    original sklearn function/method validate_data are
     called once before offloading to oneDAL in sklearnex"""
     try:
         # get last to_table call showing end of oneDAL input portion of code
         idx = len(text["funcs"]) - 1 - text["funcs"][::-1].index("to_table")
-        validfuncs = text["funcs"][:idx]
+        valid_funcs = text["funcs"][:idx]
+        valid_modules = text["modules"][:idx]
     except ValueError:
         pytest.skip("onedal backend not used in this function")
 
-    validate_data = "validate_data" if sklearn_check_version("1.6") else "_validate_data"
+    validate_data_calls = []
+    for func, module in zip(valid_funcs, valid_modules):
+        if func.endswith("validate_data"):
+            validate_data_calls.append({module, func})
 
     assert (
-        validfuncs.count(validate_data) == 1
-    ), f"sklearn's {validate_data} should be called"
+        len(validate_data_calls) == 2
+    ), "validate_data should be called two times: once for sklearn and once for sklearnex"
+    assert validate_data_calls[0] == {
+        "sklearnex.utils.validation",
+        "validate_data",
+    }, "sklearnex's validate_data should be called first"
+    assert (
+        (validate_data_calls[1] == {"sklearn.utils.validation", "validate_data"})
+        if sklearn_check_version("1.6")
+        else (validate_data_calls[1] == {"sklearn.base", "_validate_data"})
+    ), "sklearn's validate_data should be called second"
     assert (
-        validfuncs.count("_check_feature_names") == 1
+        valid_funcs.count("_check_feature_names") == 1
     ), "estimator should check feature names in validate_data"
 
 
@@ -467,11 +481,12 @@ def fit_check_before_support_check(text, estimator, method):
         pytest.skip(f"fitting occurs in {estimator}.{method}")
 
 
-DESIGN_RULES = [n_jobs_check, runtime_property_check, fit_check_before_support_check]
-
-
-if sklearn_check_version("1.0"):
-    DESIGN_RULES += [call_validate_data]
+DESIGN_RULES = [
+    n_jobs_check,
+    runtime_property_check,
+    fit_check_before_support_check,
+    call_validate_data,
+]
 
 
 @pytest.mark.parametrize("design_pattern", DESIGN_RULES)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -18,7 +18,6 @@ import gc
 import logging
 import os
 import tracemalloc
-import types
 import warnings
 from inspect import isclass
 
@@ -29,12 +28,13 @@ from sklearn.base import BaseEstimator, clone
 from sklearn.datasets import make_classification
 from sklearn.model_selection import KFold
 
-from onedal import _is_dpc_backend
+from onedal import _default_backend as backend
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
 from onedal.tests.utils._device_selection import get_queues, is_dpctl_device_available
+from onedal.utils._array_api import _get_sycl_namespace
 from onedal.utils._dpep_helpers import dpctl_available, dpnp_available
 from sklearnex import config_context
 from sklearnex.tests.utils import (
@@ -43,7 +43,6 @@ from sklearnex.tests.utils import (
     SPECIAL_INSTANCES,
     DummyEstimator,
 )
-from sklearnex.utils._array_api import get_namespace
 
 if dpctl_available:
     from dpctl.tensor import usm_ndarray
@@ -51,9 +50,6 @@ if dpctl_available:
 if dpnp_available:
     import dpnp
 
-if _is_dpc_backend:
-    from onedal import _backend
-
 
 CPU_SKIP_LIST = (
     "TSNE",  # too slow for using in testing on common data size
@@ -149,25 +145,22 @@ def gen_clsf_data(n_samples, n_features, dtype=None):
 
 
 def get_traced_memory(queue=None):
-    if _is_dpc_backend and queue and queue.sycl_device.is_gpu:
-        return _backend.get_used_memory(queue)
+    if backend.is_dpc and queue and queue.sycl_device.is_gpu:
+        return backend.get_used_memory(queue)
     else:
         return tracemalloc.get_traced_memory()[0]
 
 
 def take(x, index, axis=0, queue=None):
-    xp, array_api = get_namespace(x)
-    if (
-        dpnp_available
-        and isinstance(x, dpnp.ndarray)
-        or dpctl_available
-        and isinstance(x, usm_ndarray)
-    ):
+    sycl_usm, xp, _ = _get_sycl_namespace(x)
+    if sycl_usm:
         # Using the same sycl queue for dpnp.ndarray or usm_ndarray.
         return xp.take(
             x, xp.asarray(index, usm_type="device", sycl_queue=x.sycl_queue), axis=axis
         )
-    elif array_api:
+    elif hasattr(x, "__array_namespace__"):
+        # check explicitly instead of sklearn's `get_namespace` as array_api is off by default
+        xp = x.__array_namespace__()
         return xp.take(x, xp.asarray(index, device=x.device), axis=axis)
     else:
         return x.take(index, axis=axis)
@@ -319,12 +312,8 @@ def test_gpu_memory_leaks(estimator, queue, order, data_shape):
         _kfold_function_template(GPU_ESTIMATORS[estimator], None, data_shape, queue, func)
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend,
-    reason="__sycl_usm_array_interface__ support requires DPC backend.",
-)
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
@@ -332,8 +321,12 @@ def test_gpu_memory_leaks(estimator, queue, order, data_shape):
 def test_table_conversions_memory_leaks(dataframe, queue, order, data_shape, dtype):
     func = ORDER_DICT[order]
 
-    if queue.sycl_device.is_gpu and (
-        os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_device_available("gpu")
+    if (
+        queue
+        and queue.sycl_device.is_gpu
+        and (
+            os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_device_available("gpu")
+        )
     ):
         pytest.skip("SYCL device memory leak check requires the level zero sysman")