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

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/glob/__main__.py

@@ -30,7 +30,7 @@ def _main():
     parser = argparse.ArgumentParser(
         prog="python -m sklearnex.glob",
         description="""
-            Patch all your Scikit-learn applications using Intel(R) Extension for
+            Patch all your Scikit-learn applications using Extension for
             scikit-learn.""",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/glob/dispatcher.py

@@ -70,7 +70,7 @@ def patch_sklearn_global(name=None, verbose=True):
         distributor_file.write(lines + "\n" + get_patch_str(name, verbose) + "\n")
         print(
             "Scikit-learn was successfully globally patched"
-            " by Intel(R) Extension for Scikit-learn"
+            " by Extension for Scikit-learn"
         )
         return
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/coordinate_descent.py

@@ -14,17 +14,29 @@
 # limitations under the License.
 # ===============================================================================
 
+from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.linear_model import ElasticNet, Lasso
 from onedal._device_offload import support_input_format
 
+from ..base import oneDALEstimator
+
 # Note: `sklearnex.linear_model.ElasticNet` only has functional
 # sycl GPU support. No GPU device will be offloaded.
-ElasticNet.fit = support_input_format(queue_param=False)(ElasticNet.fit)
-ElasticNet.predict = support_input_format(queue_param=False)(ElasticNet.predict)
-ElasticNet.score = support_input_format(queue_param=False)(ElasticNet.score)
+ElasticNet.fit = support_input_format(ElasticNet.fit)
+ElasticNet.predict = support_input_format(ElasticNet.predict)
+ElasticNet.score = support_input_format(ElasticNet.score)
+if sklearn_check_version("1.4"):
+    ElasticNet._doc_link_module = "daal4py"
+    ElasticNet._doc_link_url_param_generator = (
+        oneDALEstimator._doc_link_url_param_generator
+    )
+
 
 # Note: `sklearnex.linear_model.Lasso` only has functional
 # sycl GPU support. No GPU device will be offloaded.
-Lasso.fit = support_input_format(queue_param=False)(Lasso.fit)
-Lasso.predict = support_input_format(queue_param=False)(Lasso.predict)
-Lasso.score = support_input_format(queue_param=False)(Lasso.score)
+Lasso.fit = support_input_format(Lasso.fit)
+Lasso.predict = support_input_format(Lasso.predict)
+Lasso.score = support_input_format(Lasso.score)
+if sklearn_check_version("1.4"):
+    Lasso._doc_link_module = "daal4py"
+    Lasso._doc_link_url_param_generator = oneDALEstimator._doc_link_url_param_generator

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -19,6 +19,7 @@ import warnings
 
 import numpy as np
 from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
+from sklearn.linear_model import LinearRegression as _sklearn_LinearRegression
 from sklearn.metrics import r2_score
 from sklearn.utils import check_array, gen_batches
 from sklearn.utils.validation import check_is_fitted
@@ -28,19 +29,22 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.linear_model import (
     IncrementalLinearRegression as onedal_IncrementalLinearRegression,
 )
+from sklearnex._config import get_config
+
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
-
 from onedal.common.hyperparameters import get_hyperparameters
 
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import IntelEstimator, PatchingConditionsChain, register_hyperparameters
+from .._utils import (
+    PatchingConditionsChain,
+    _add_inc_serialization_note,
+    register_hyperparameters,
+)
+from ..base import oneDALEstimator
 
 
 @register_hyperparameters(
@@ -53,7 +57,7 @@ from .._utils import IntelEstimator, PatchingConditionsChain, register_hyperpara
     decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
 class IncrementalLinearRegression(
-    IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEstimator
+    MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator
 ):
     """
     Trains a linear regression model, allows for computation if the data are split into
@@ -103,12 +107,7 @@ class IncrementalLinearRegression(
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
-    Note
-    ----
-    Serializing instances of this class will trigger a forced finalization of calculations.
-    Since finalize_fit can't be dispatched without directly provided queue
-    and the dispatching policy can't be serialized, the computation is finalized
-    during serialization call and the policy is not saved in serialized data.
+    %incremental_serialization_note%
 
     Examples
     --------
@@ -130,6 +129,8 @@ class IncrementalLinearRegression(
     np.array(0.)
     """
 
+    __doc__ = _add_inc_serialization_note(__doc__)
+
     _onedal_incremental_linear = staticmethod(onedal_IncrementalLinearRegression)
 
     if sklearn_check_version("1.2"):
@@ -156,10 +157,10 @@ class IncrementalLinearRegression(
     _onedal_gpu_supported = _onedal_supported
 
     def _onedal_predict(self, X, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
+        if get_config()["use_raw_input"] is False:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
 
-        if sklearn_check_version("1.0"):
             X = validate_data(
                 self,
                 X,
@@ -167,12 +168,6 @@ class IncrementalLinearRegression(
                 copy=self.copy_X,
                 reset=False,
             )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                copy=self.copy_X,
-            )
 
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
@@ -190,32 +185,20 @@ class IncrementalLinearRegression(
         if sklearn_check_version("1.2"):
             self._validate_params()
 
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        # never check input when using raw input
+        check_input &= use_raw_input is False
         if check_input:
-            if sklearn_check_version("1.0"):
-                X, y = validate_data(
-                    self,
-                    X,
-                    y,
-                    dtype=[np.float64, np.float32],
-                    reset=first_pass,
-                    copy=self.copy_X,
-                    multi_output=True,
-                    force_all_finite=False,
-                )
-            else:
-                X = check_array(
-                    X,
-                    dtype=[np.float64, np.float32],
-                    copy=self.copy_X,
-                    force_all_finite=False,
-                )
-                y = check_array(
-                    y,
-                    dtype=[np.float64, np.float32],
-                    copy=False,
-                    ensure_2d=False,
-                    force_all_finite=False,
-                )
+            X, y = validate_data(
+                self,
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                reset=first_pass,
+                copy=self.copy_X,
+                multi_output=True,
+                ensure_all_finite=False,
+            )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -240,17 +223,16 @@ class IncrementalLinearRegression(
             if is_underdetermined:
                 raise ValueError("Not enough samples for oneDAL")
 
-    def _onedal_finalize_fit(self, queue=None):
+    def _onedal_finalize_fit(self):
         assert hasattr(self, "_onedal_estimator")
         self._onedal_validate_underdetermined(self.n_samples_seen_, self.n_features_in_)
-        self._onedal_estimator.finalize_fit(queue=queue)
+        self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, y, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
-        if sklearn_check_version("1.0"):
+        if get_config()["use_raw_input"] is False:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
             X, y = validate_data(
                 self,
                 X,
@@ -260,18 +242,6 @@ class IncrementalLinearRegression(
                 multi_output=True,
                 ensure_2d=True,
             )
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                copy=self.copy_X,
-            )
-            y = check_array(
-                y,
-                dtype=[np.float64, np.float32],
-                copy=False,
-                ensure_2d=False,
-            )
 
         n_samples, n_features = X.shape
 
@@ -290,9 +260,6 @@ class IncrementalLinearRegression(
             X_batch, y_batch = X[batch], y[batch]
             self._onedal_partial_fit(X_batch, y_batch, check_input=False, queue=queue)
 
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
         # finite check occurs on onedal side
         self.n_features_in_ = n_features
 
@@ -301,7 +268,7 @@ class IncrementalLinearRegression(
                 "Only one sample available. You may want to reshape your data array"
             )
 
-        self._onedal_finalize_fit(queue=queue)
+        self._onedal_finalize_fit()
         return self
 
     @property
@@ -359,7 +326,7 @@ class IncrementalLinearRegression(
 
         Returns
         -------
-        self : object
+        self : IncrementalLinearRegression
             Returns the instance itself.
         """
 
@@ -395,7 +362,7 @@ class IncrementalLinearRegression(
 
         Returns
         -------
-        self : object
+        self : IncrementalLinearRegression
             Returns the instance itself.
         """
 
@@ -413,22 +380,6 @@ class IncrementalLinearRegression(
 
     @wrap_output_data
     def predict(self, X, y=None):
-        """
-        Predict using the linear model.
-
-        Parameters
-        ----------
-        X : array-like or sparse matrix, shape (n_samples, n_features)
-            Samples.
-
-        y : Ignored
-            Not used, present for API consistency by convention.
-
-        Returns
-        -------
-        C : array, shape (n_samples, n_targets)
-            Returns predicted values.
-        """
         check_is_fitted(self)
         return dispatch(
             self,
@@ -442,45 +393,6 @@ class IncrementalLinearRegression(
 
     @wrap_output_data
     def score(self, X, y, sample_weight=None):
-        """Return the coefficient of determination of the prediction.
-
-        The coefficient of determination :math:`R^2` is defined as
-        :math:`(1 - \\frac{u}{v})`, where :math:`u` is the residual
-        sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
-        is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
-        The best possible score is 1.0 and it can be negative (because the
-        model can be arbitrarily worse). A constant model that always predicts
-        the expected value of `y`, disregarding the input features, would get
-        a :math:`R^2` score of 0.0.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Test samples. For some estimators this may be a precomputed
-            kernel matrix or a list of generic objects instead with shape
-            ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
-            is the number of samples used in the fitting for the estimator.
-
-        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
-            True values for `X`.
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Sample weights.
-
-        Returns
-        -------
-        score : float
-            :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
-
-        Notes
-        -----
-        The :math:`R^2` score used when calling ``score`` on a regressor uses
-        ``multioutput='uniform_average'`` from version 0.23 to keep consistent
-        with default value of :func:`~sklearn.metrics.r2_score`.
-        This influences the ``score`` method of all the multioutput
-        regressors (except for
-        :class:`~sklearn.multioutput.MultiOutputRegressor`).
-        """
         check_is_fitted(self)
         return dispatch(
             self,
@@ -493,3 +405,6 @@ class IncrementalLinearRegression(
             y,
             sample_weight=sample_weight,
         )
+
+    score.__doc__ = _sklearn_LinearRegression.score.__doc__
+    predict.__doc__ = _sklearn_LinearRegression.predict.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -19,6 +19,7 @@ import warnings
 
 import numpy as np
 from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
+from sklearn.linear_model import Ridge as _sklearn_Ridge
 from sklearn.metrics import r2_score
 from sklearn.utils import gen_batches
 from sklearn.utils.validation import check_is_fitted, check_X_y
@@ -26,24 +27,22 @@ from sklearn.utils.validation import check_is_fitted, check_X_y
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn.utils.validation import sklearn_check_version
 
+from ..utils.validation import validate_data
+
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
 from onedal.linear_model import IncrementalRidge as onedal_IncrementalRidge
 
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import IntelEstimator, PatchingConditionsChain
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
+from .._utils import PatchingConditionsChain, _add_inc_serialization_note
+from ..base import oneDALEstimator
 
 
 @control_n_jobs(
     decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
-class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEstimator):
+class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator):
     """
     Incremental estimator for Ridge Regression.
     Allows to train Ridge Regression if data is splitted into batches.
@@ -97,14 +96,11 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
     batch_size_ : int
         Inferred batch size from ``batch_size``.
 
-    Note
-    ----
-    Serializing instances of this class will trigger a forced finalization of calculations.
-    Since finalize_fit can't be dispatched without directly provided queue
-    and the dispatching policy can't be serialized, the computation is finalized
-    during serialization call and the policy is not saved in serialized data.
+    %incremental_serialization_note%
     """
 
+    __doc__ = _add_inc_serialization_note(__doc__)
+
     _onedal_incremental_ridge = staticmethod(onedal_IncrementalRidge)
 
     if sklearn_check_version("1.2"):
@@ -138,13 +134,12 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        if sklearn_check_version("1.0"):
-            X = validate_data(self, X, accept_sparse=False, reset=False)
+        X = validate_data(self, X, accept_sparse=False, reset=False)
 
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
             self._onedal_finalize_fit()
-        return self._onedal_estimator.predict(X, queue)
+        return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
         return r2_score(
@@ -158,19 +153,16 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
             self._validate_params()
 
         if check_input:
-            if sklearn_check_version("1.0"):
-                X, y = validate_data(
-                    self,
-                    X,
-                    y,
-                    dtype=[np.float64, np.float32],
-                    reset=first_pass,
-                    copy=self.copy_X,
-                    multi_output=True,
-                    force_all_finite=False,
-                )
-            else:
-                check_X_y(X, y, multi_output=True, y_numeric=True)
+            X, y = validate_data(
+                self,
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                reset=first_pass,
+                copy=self.copy_X,
+                multi_output=True,
+                ensure_all_finite=False,
+            )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -184,7 +176,7 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
         }
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_ridge(**onedal_params)
-        self._onedal_estimator.partial_fit(X, y, queue)
+        self._onedal_estimator.partial_fit(X, y, queue=queue)
         self._need_to_finalize = True
 
     def _onedal_finalize_fit(self):
@@ -202,18 +194,15 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        if sklearn_check_version("1.0"):
-            X, y = validate_data(
-                self,
-                X,
-                y,
-                dtype=[np.float64, np.float32],
-                copy=self.copy_X,
-                multi_output=True,
-                ensure_2d=True,
-            )
-        else:
-            check_X_y(X, y, multi_output=True, y_numeric=True)
+        X, y = validate_data(
+            self,
+            X,
+            y,
+            dtype=[np.float64, np.float32],
+            copy=self.copy_X,
+            multi_output=True,
+            ensure_2d=True,
+        )
 
         n_samples, n_features = X.shape
 
@@ -266,7 +255,7 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
 
         Returns
         -------
-        self : object
+        self : IncrementalRidge
             Returns the instance itself.
         """
 
@@ -285,7 +274,7 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
 
     def fit(self, X, y):
         """
-        Fit the model with X and y, using minibatches of size batch_size.
+        Fit the model with X and y, using minibatches of size ``batch_size``.
 
         Parameters
         ----------
@@ -302,7 +291,7 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
 
         Returns
         -------
-        self : object
+        self : IncrementalRidge
             Returns the instance itself.
         """
 
@@ -320,19 +309,6 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
 
     @wrap_output_data
     def predict(self, X, y=None):
-        """
-        Predict using the linear model.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            Samples.
-
-        Returns
-        -------
-        array, shape (n_samples,) or (n_samples, n_targets)
-            Returns predicted values.
-        """
         check_is_fitted(
             self,
             msg=f"This {self.__class__.__name__} instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.",
@@ -350,33 +326,6 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
 
     @wrap_output_data
     def score(self, X, y, sample_weight=None):
-        """
-        Return the coefficient of determination R^2 of the prediction.
-
-        The coefficient R^2 is defined as (1 - u/v), where u is the residual
-        sum of squares ((y_true - y_pred) ** 2).sum() and v is the total sum
-        of squares ((y_true - y_true.mean()) ** 2).sum().
-        The best possible score is 1.0 and it can be negative (because the
-        model can be arbitrarily worse). A constant model that always
-        predicts the expected value of y, disregarding the input features,
-        would get a R^2 score of 0.0.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            Test samples.
-
-        y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            True values for X.
-
-        sample_weight : array-like of shape (n_samples,), default=None
-            Sample weights.
-
-        Returns
-        -------
-        score : float
-            R^2 of self.predict(X) wrt. y.
-        """
         check_is_fitted(
             self,
             msg=f"This {self.__class__.__name__} instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.",
@@ -394,6 +343,9 @@ class IncrementalRidge(IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEst
             sample_weight=sample_weight,
         )
 
+    score.__doc__ = _sklearn_Ridge.score.__doc__
+    predict.__doc__ = _sklearn_Ridge.predict.__doc__
+
     @property
     def coef_(self):
         if hasattr(self, "_onedal_estimator") and self._need_to_finalize: