scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/linear_model/_linear.py

@@ -20,10 +20,9 @@ from sklearn.linear_model import LinearRegression as LinearRegression_original
 from sklearn.utils import check_array
 
 from .._utils import sklearn_check_version
-from ..utils.base import _daal_validate_data
-from ..utils.validation import _daal_check_array
+from ..utils.validation import _daal_check_array, check_feature_names, validate_data
 
-if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+if not sklearn_check_version("1.2"):
     from sklearn.linear_model._base import _deprecate_normalize
 
 import logging
@@ -108,7 +107,7 @@ def _fit_linear(self, X, y, sample_weight=None):
         "y_numeric": True,
         "multi_output": True,
     }
-    X, y = _daal_validate_data(
+    X, y = validate_data(
         self,
         dtype=[np.float64, np.float32],
         **params,
@@ -152,8 +151,7 @@ def _fit_linear(self, X, y, sample_weight=None):
 
 
 def _predict_linear(self, X):
-    if sklearn_check_version("1.0"):
-        self._check_feature_names(X, reset=False)
+    check_feature_names(self, X, reset=False)
     is_df = is_DataFrame(X)
     X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
     X = np.asarray(X) if not sp.issparse(X) and not is_df else X
@@ -224,7 +222,7 @@ class LinearRegression(LinearRegression_original):
         def __init__(
             self,
             fit_intercept=True,
-            normalize="deprecated" if sklearn_check_version("1.0") else False,
+            normalize="deprecated",
             copy_X=True,
             n_jobs=None,
             positive=False,
@@ -238,14 +236,13 @@ class LinearRegression(LinearRegression_original):
             )
 
     def fit(self, X, y, sample_weight=None):
-        if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+        if not sklearn_check_version("1.2"):
             self._normalize = _deprecate_normalize(
                 self.normalize,
                 default=False,
                 estimator_name=self.__class__.__name__,
             )
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
         if sklearn_check_version("1.2"):
             self._validate_params()
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/linear_model/_ridge.py

@@ -33,8 +33,9 @@ from .._utils import (
     make2d,
     sklearn_check_version,
 )
+from ..utils.validation import validate_data
 
-if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+if not sklearn_check_version("1.2"):
     from sklearn.linear_model._base import _deprecate_normalize
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
@@ -103,7 +104,7 @@ def _daal4py_predict(self, X):
 
 
 def _fit_ridge(self, _X, _y, sample_weight=None):
-    if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
+    if not sklearn_check_version("1.2"):
         self._normalize = _deprecate_normalize(
             self.normalize, default=False, estimator_name=self.__class__.__name__
         )
@@ -124,26 +125,16 @@ def _fit_ridge(self, _X, _y, sample_weight=None):
                 include_boundaries="left",
             )
 
-    if sklearn_check_version("1.0"):
-        X, y = self._validate_data(
-            _X,
-            _y,
-            accept_sparse=["csr", "csc", "coo"],
-            dtype=[np.float64, np.float32],
-            multi_output=True,
-            y_numeric=True,
-            ensure_2d=True,
-        )
-    else:
-        X, y = check_X_y(
-            _X,
-            _y,
-            ["csr", "csc", "coo"],
-            dtype=[np.float64, np.float32],
-            multi_output=True,
-            y_numeric=True,
-        )
-        self.n_features_in_ = X.shape[1]
+    X, y = validate_data(
+        self,
+        _X,
+        _y,
+        accept_sparse=["csr", "csc", "coo"],
+        dtype=[np.float64, np.float32],
+        multi_output=True,
+        y_numeric=True,
+        ensure_2d=True,
+    )
 
     self.sample_weight_ = sample_weight
     self.fit_shape_good_for_daal_ = True if X.shape[0] >= X.shape[1] else False
@@ -193,18 +184,14 @@ def _fit_ridge(self, _X, _y, sample_weight=None):
 
 
 def _predict_ridge(self, _X):
-    if sklearn_check_version("1.0"):
-        X = self._validate_data(
-            _X,
-            accept_sparse=["csr", "csc", "coo"],
-            dtype=[np.float64, np.float32],
-            reset=False,
-            ensure_2d=True,
-        )
-    else:
-        X = check_array(
-            _X, accept_sparse=["csr", "csc", "coo"], dtype=[np.float64, np.float32]
-        )
+    X = validate_data(
+        self,
+        _X,
+        accept_sparse=["csr", "csc", "coo"],
+        dtype=[np.float64, np.float32],
+        reset=False,
+        ensure_2d=True,
+    )
     good_shape_for_daal = (
         True if X.ndim <= 1 else True if X.shape[0] >= X.shape[1] else False
     )
@@ -269,7 +256,7 @@ class Ridge(Ridge_original, _BaseRidge):
             self.positive = positive
             self.random_state = random_state
 
-    elif sklearn_check_version("1.0"):
+    else:
 
         def __init__(
             self,
@@ -293,28 +280,6 @@ class Ridge(Ridge_original, _BaseRidge):
             self.positive = positive
             self.random_state = random_state
 
-    else:
-
-        def __init__(
-            self,
-            alpha=1.0,
-            fit_intercept=True,
-            normalize=False,
-            copy_X=True,
-            max_iter=None,
-            tol=1e-3,
-            solver="auto",
-            random_state=None,
-        ):
-            self.alpha = alpha
-            self.fit_intercept = fit_intercept
-            self.normalize = normalize
-            self.copy_X = copy_X
-            self.max_iter = max_iter
-            self.tol = tol
-            self.solver = solver
-            self.random_state = random_state
-
     def fit(self, X, y, sample_weight=None):
         return _fit_ridge(self, X, y, sample_weight=sample_weight)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/linear_model/logistic_path.py

@@ -34,6 +34,7 @@ import daal4py as d4p
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names
 from .logistic_loss import (
     _daal4py_cross_entropy_loss_extra_args,
     _daal4py_grad_,
@@ -793,8 +794,7 @@ def daal4py_fit(self, X, y, sample_weight=None):
 
 def daal4py_predict(self, X, resultsToEvaluate):
     check_is_fitted(self)
-    if sklearn_check_version("1.0"):
-        self._check_feature_names(X, reset=False)
+    check_feature_names(self, X, reset=False)
     X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
     try:
         fptype = getFPType(X)
@@ -1005,8 +1005,7 @@ class LogisticRegression(LogisticRegression_original):
         self.l1_ratio = l1_ratio
 
     def fit(self, X, y, sample_weight=None):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
         if sklearn_check_version("1.2"):
             self._validate_params()
         return daal4py_fit(self, X, y, sample_weight)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/manifold/_t_sne.py

@@ -37,6 +37,7 @@ from daal4py.sklearn._utils import (
 
 from .._n_jobs_support import control_n_jobs
 from ..neighbors import NearestNeighbors
+from ..utils.validation import validate_data
 
 
 @control_n_jobs(decorated_methods=["fit"])
@@ -183,15 +184,19 @@ class TSNE(BaseTSNE):
                     )
 
         if self.method == "barnes_hut":
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 accept_sparse=["csr"],
                 ensure_min_samples=2,
                 dtype=[np.float32, np.float64],
             )
         else:
-            X = self._validate_data(
-                X, accept_sparse=["csr", "csc", "coo"], dtype=[np.float32, np.float64]
+            X = validate_data(
+                self,
+                X,
+                accept_sparse=["csr", "csc", "coo"],
+                dtype=[np.float32, np.float64],
             )
 
         if self.metric == "precomputed":

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/metrics/_pairwise.py

@@ -107,9 +107,14 @@ def _pairwise_distances(
             return _daal4py_correlation_distance_dense(X)
         raise ValueError(f"'{metric}' distance is wrong for daal4py.")
     if metric == "precomputed":
-        X, _ = check_pairwise_arrays(
-            X, Y, precomputed=True, force_all_finite=force_all_finite
-        )
+        if sklearn_check_version("1.6"):
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, force_all_finite=force_all_finite
+            )
         whom = (
             "`pairwise_distances`. Precomputed distance "
             " need to have non-negative values."
@@ -119,9 +124,20 @@ def _pairwise_distances(
     if metric in PAIRWISE_DISTANCE_FUNCTIONS:
         func = PAIRWISE_DISTANCE_FUNCTIONS[metric]
     elif callable(metric):
-        func = partial(
-            _pairwise_callable, metric=metric, force_all_finite=force_all_finite, **kwds
-        )
+        if sklearn_check_version("1.6"):
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                ensure_all_finite=force_all_finite,
+                **kwds,
+            )
+        else:
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                force_all_finite=force_all_finite,
+                **kwds,
+            )
     else:
         if issparse(X) or issparse(Y):
             raise TypeError("scipy distance metrics do not" " support sparse matrices.")
@@ -132,7 +148,14 @@ def _pairwise_distances(
             msg = "Data was converted to boolean for metric %s" % metric
             warnings.warn(msg, DataConversionWarning)
 
-        X, Y = check_pairwise_arrays(X, Y, dtype=dtype, force_all_finite=force_all_finite)
+        if sklearn_check_version("1.6"):
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, force_all_finite=force_all_finite
+            )
 
         # precompute data-derived metric params
         params = _precompute_metric_params(X, Y, metric=metric, **kwds)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/monkeypatch/dispatcher.py

@@ -171,7 +171,7 @@ def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algori
         warnings.warn_explicit(
             "\nScikit-learn patching with daal4py is deprecated "
             "and will be removed in the future.\n"
-            "Use Intel(R) Extension "
+            "Use Extension "
             "for Scikit-learn* module instead "
             "(pip install scikit-learn-intelex).\n"
             "To enable patching, please use one of the "
@@ -187,8 +187,8 @@ def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algori
         )
     if verbose and deprecation and sys.stderr is not None:
         sys.stderr.write(
-            "Intel(R) oneAPI Data Analytics Library solvers for sklearn enabled: "
-            "https://intelpython.github.io/daal4py/sklearn.html\n"
+            "oneAPI Data Analytics Library solvers for sklearn enabled: "
+            "https://uxlfoundation.github.io/scikit-learn-intelex/\n"
         )
 
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_base.py

@@ -40,6 +40,7 @@ from .._utils import (
     getFPType,
     sklearn_check_version,
 )
+from ..utils.validation import check_feature_names, check_n_features, get_requires_y_tag
 
 if not sklearn_check_version("1.2"):
     from sklearn.neighbors._base import _check_weights
@@ -239,10 +240,7 @@ def validate_data(
     estimator, X, y=None, reset=True, validate_separately=False, **check_params
 ):
     if y is None:
-        try:
-            requires_y = estimator._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
+        requires_y = get_requires_y_tag(estimator)
 
         if requires_y:
             raise ValueError(
@@ -265,7 +263,7 @@ def validate_data(
         out = X, y
 
     if check_params.get("ensure_2d", True):
-        estimator._check_n_features(X, reset=reset)
+        check_n_features(estimator, X, reset=reset)
 
     return out
 
@@ -304,15 +302,10 @@ class NeighborsBase(BaseNeighborsBase):
                     stacklevel=2,
                 )
 
-        if (
-            hasattr(self, "weights")
-            and sklearn_check_version("1.0")
-            and not sklearn_check_version("1.2")
-        ):
+        if hasattr(self, "weights") and not sklearn_check_version("1.2"):
             self.weights = _check_weights(self.weights)
 
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
 
         X_incorrect_type = isinstance(
             X, (KDTree, BallTree, NeighborsBase, BaseNeighborsBase)
@@ -322,10 +315,7 @@ class NeighborsBase(BaseNeighborsBase):
         shape = None
         correct_n_classes = True
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
+        requires_y = get_requires_y_tag(self)
 
         if y is not None or requires_y:
             if not X_incorrect_type or y is None:

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_classification.py

@@ -25,6 +25,7 @@ from sklearn.neighbors._classification import (
 from sklearn.utils.validation import check_array
 
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names
 from ._base import KNeighborsMixin, NeighborsBase, parse_auto_method, prediction_algorithm
 
 if not sklearn_check_version("1.2"):
@@ -34,8 +35,7 @@ from sklearn.utils.validation import _deprecate_positional_args
 
 
 def daal4py_classifier_predict(estimator, X, base_predict):
-    if sklearn_check_version("1.0"):
-        estimator._check_feature_names(X, reset=False)
+    check_feature_names(estimator, X, reset=False)
     X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
     daal_model = getattr(estimator, "_daal_model", None)
     n_features = getattr(estimator, "n_features_in_", None)
@@ -119,9 +119,7 @@ class KNeighborsClassifier(KNeighborsMixin, BaseClassifierMixin, NeighborsBase):
             n_jobs=n_jobs,
             **kwargs,
         )
-        self.weights = (
-            weights if sklearn_check_version("1.0") else _check_weights(weights)
-        )
+        self.weights = weights
 
     def fit(self, X, y):
         return NeighborsBase._fit(self, X, y)
@@ -130,8 +128,7 @@ class KNeighborsClassifier(KNeighborsMixin, BaseClassifierMixin, NeighborsBase):
         return daal4py_classifier_predict(self, X, BaseKNeighborsClassifier.predict)
 
     def predict_proba(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return BaseKNeighborsClassifier.predict_proba(self, X)
 
     fit.__doc__ = BaseKNeighborsClassifier.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_regression.py

@@ -20,6 +20,7 @@ from sklearn.base import RegressorMixin
 from sklearn.neighbors._regression import KNeighborsRegressor as BaseKNeighborsRegressor
 
 from .._utils import sklearn_check_version
+from ..utils.validation import check_feature_names
 from ._base import KNeighborsMixin, NeighborsBase
 
 if not sklearn_check_version("1.2"):
@@ -55,9 +56,7 @@ class KNeighborsRegressor(KNeighborsMixin, RegressorMixin, NeighborsBase):
             n_jobs=n_jobs,
             **kwargs,
         )
-        self.weights = (
-            weights if sklearn_check_version("1.0") else _check_weights(weights)
-        )
+        self.weights = weights
 
     def _more_tags(self):
         return BaseKNeighborsRegressor._more_tags(self)
@@ -66,8 +65,7 @@ class KNeighborsRegressor(KNeighborsMixin, RegressorMixin, NeighborsBase):
         return NeighborsBase._fit(self, X, y)
 
     def predict(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return BaseKNeighborsRegressor.predict(self, X)
 
     fit.__doc__ = BaseKNeighborsRegressor.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/svm/svm.py

@@ -35,6 +35,7 @@ from sklearn.utils.validation import (
 import daal4py
 
 from .._utils import PatchingConditionsChain, getFPType, make2d
+from ..utils.validation import validate_data
 
 
 def _get_libsvm_impl():
@@ -421,7 +422,8 @@ def fit(self, X, y, sample_weight=None):
     if callable(self.kernel):
         check_consistent_length(X, y)
     else:
-        X, y = self._validate_data(
+        X, y = validate_data(
+            self,
             X,
             y,
             dtype=np.float64,
@@ -568,7 +570,7 @@ def _daal4py_predict(self, X, is_decision_function=False):
         res = -predictionRes.decisionFunction
 
     if num_classes == 2 and not is_decision_function:
-        # Convert from Intel(R) oneAPI Data Analytics Library format back to
+        # Convert from oneAPI Data Analytics Library format back to
         # original classes
         np.greater(res, 0, out=res)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/utils/base.py

@@ -14,7 +14,12 @@
 # limitations under the License.
 # ==============================================================================
 
-from .validation import _daal_check_array, _daal_check_X_y
+from .validation import (
+    _daal_check_array,
+    _daal_check_X_y,
+    check_n_features,
+    get_requires_y_tag,
+)
 
 
 def _daal_validate_data(
@@ -50,7 +55,7 @@ def _daal_validate_data(
     """
 
     if y is None:
-        if self._get_tags()["requires_y"]:
+        if get_requires_y_tag(self):
             raise ValueError(
                 f"This {self.__class__.__name__} estimator "
                 f"requires y to be passed, but the target y is None."
@@ -71,5 +76,5 @@ def _daal_validate_data(
         out = X, y
 
     if check_params.get("ensure_2d", True):
-        self._check_n_features(X, reset=reset)
+        check_n_features(self, X, reset=reset)
     return out

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/daal4py/sklearn/utils/validation.py

@@ -16,6 +16,7 @@
 
 import warnings
 from contextlib import suppress
+from functools import wraps
 
 import numpy as np
 import scipy.sparse as sp
@@ -49,6 +50,19 @@ from .._utils import (
     sklearn_check_version,
 )
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import (
+        _check_feature_names as _sklearn_check_feature_names,
+    )
+    from sklearn.utils.validation import _check_n_features as _sklearn_check_n_features
+    from sklearn.utils.validation import validate_data as _sklearn_validate_data
+else:
+    from sklearn.base import BaseEstimator
+
+    _sklearn_validate_data = BaseEstimator._validate_data
+    _sklearn_check_feature_names = BaseEstimator._check_feature_names
+    _sklearn_check_n_features = BaseEstimator._check_n_features
+
 
 def _assert_all_finite(
     X, allow_nan=False, msg_dtype=None, estimator_name=None, input_name=""
@@ -394,13 +408,19 @@ def _daal_check_array(
 
     if sp.issparse(array):
         _ensure_no_complex_data(array)
+        kwargs = {
+            "accept_sparse": accept_sparse,
+            "dtype": dtype,
+            "copy": copy,
+            "accept_large_sparse": accept_large_sparse,
+        }
+        if sklearn_check_version("1.6"):
+            kwargs["ensure_all_finite"] = force_all_finite
+        else:
+            kwargs["force_all_finite"] = force_all_finite
         array = _ensure_sparse_format(
             array,
-            accept_sparse=accept_sparse,
-            dtype=dtype,
-            copy=copy,
-            force_all_finite=force_all_finite,
-            accept_large_sparse=accept_large_sparse,
+            **kwargs,
         )
     else:
         # If np.array(..) gives ComplexWarning, then we convert the warning
@@ -694,3 +714,60 @@ def _daal_num_features(X):
         return len(first_sample)
     except Exception as err:
         raise TypeError(message) from err
+
+
+def get_requires_y_tag(estimator):
+    """Gets the value of the 'requires_y' tag from the estimator
+    using correct code path depending on the scikit-learn version."""
+    if sklearn_check_version("1.6"):
+        requires_y = estimator.__sklearn_tags__().target_tags.required
+    else:
+        try:
+            requires_y = estimator._get_tags()["requires_y"]
+        except KeyError:
+            requires_y = False
+    return requires_y
+
+
+def add_dispatcher_docstring(original_function):
+    """Adds a note about the dispatcher function to the docstring of the original function."""
+
+    def wrapper(dispatcher_function):
+        @wraps(
+            original_function,
+            ["__name__", "__doc__", "__annotations__", "__type_params__"],
+        )
+        def new_function(*args, **kwargs):
+            return dispatcher_function(*args, **kwargs)
+
+        new_function.__doc__ = (
+            f"Sklearnex dispatcher for '{original_function.__qualname__}' "
+            f"from '{original_function.__module__}' module supporting "
+            "it's multiple implementations from different scikit-learn versions.\n\n"
+            + original_function.__doc__
+        )
+
+        return new_function
+
+    return wrapper
+
+
+# simplified copy of similar function from sklearnex.utils.validation,
+# ensures that the correct finiteness check argument is used
+@add_dispatcher_docstring(_sklearn_validate_data)
+def validate_data(*args, **kwargs):
+    if not sklearn_check_version("1.6") and "ensure_all_finite" in kwargs:
+        kwargs["force_all_finite"] = kwargs.pop("ensure_all_finite")
+    return _sklearn_validate_data(*args, **kwargs)
+
+
+# dispatcher functions which use correct `check_feature_names`/`check_n_features` import
+# depending on the scikit-learn version
+@add_dispatcher_docstring(_sklearn_check_feature_names)
+def check_feature_names(*args, **kwargs):
+    _sklearn_check_feature_names(*args, **kwargs)
+
+
+@add_dispatcher_docstring(_sklearn_check_n_features)
+def check_n_features(*args, **kwargs):
+    _sklearn_check_n_features(*args, **kwargs)