scikit-learn-intelex 2025.6.1__py39-none-win_amd64.whl → 2025.8.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -17,35 +17,35 @@
 import numbers
 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
+from sklearn.utils.validation import check_is_fitted
 
 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 daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.linear_model import IncrementalRidge as onedal_IncrementalRidge
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, _add_inc_serialization_note
 from ..base import oneDALEstimator
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import validate_data
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._param_validation import Interval
 
 
+@enable_array_api("1.5")  # validate_data y_numeric requires sklearn >=1.5
 @control_n_jobs(
     decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
 class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator):
     """
     Incremental estimator for Ridge Regression.
-    Allows to train Ridge Regression if data is splitted into batches.
+
+    Allows to train Ridge Regression if data is split into batches.
 
     Parameters
     ----------
@@ -96,6 +96,10 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
     batch_size_ : int
         Inferred batch size from ``batch_size``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
     """
 
@@ -108,7 +112,7 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
             "fit_intercept": ["boolean"],
             "alpha": [Interval(numbers.Real, 0, None, closed="left")],
             "copy_X": ["boolean"],
-            "n_jobs": [Interval(numbers.Integral, -1, None, closed="left"), None],
+            "n_jobs": [numbers.Integral, None],
             "batch_size": [Interval(numbers.Integral, 1, None, closed="left"), None],
         }
 
@@ -134,12 +138,20 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        X = validate_data(self, X, accept_sparse=False, reset=False)
+        xp, _ = get_namespace(X)
+
+        X = validate_data(
+            self, X, accept_sparse=False, dtype=[xp.float64, xp.float32], reset=False
+        )
 
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
             self._onedal_finalize_fit()
-        return self._onedal_estimator.predict(X, queue=queue)
+        res = self._onedal_estimator.predict(X, queue=queue)
+
+        if res.shape[1] == 1 and self.coef_.ndim == 1:
+            res = xp.reshape(res, (-1,))
+        return res
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
         return r2_score(
@@ -149,19 +161,17 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
     def _onedal_partial_fit(self, X, y, check_input=True, queue=None):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
         if check_input:
+            xp, _ = get_namespace(X, y)
             X, y = validate_data(
                 self,
                 X,
                 y,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
                 copy=self.copy_X,
                 multi_output=True,
-                ensure_all_finite=False,
+                y_numeric=True,
             )
 
         if first_pass:
@@ -179,36 +189,49 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         self._onedal_estimator.partial_fit(X, y, queue=queue)
         self._need_to_finalize = True
 
+    if daal_check_version((2025, "P", 200)):
+
+        def _onedal_validate_underdetermined(self, n_samples, n_features):
+            pass
+
+    else:
+
+        def _onedal_validate_underdetermined(self, n_samples, n_features):
+            is_underdetermined = n_samples < n_features + int(self.fit_intercept)
+            if is_underdetermined:
+                raise ValueError("Not enough samples for oneDAL")
+
     def _onedal_finalize_fit(self):
         assert hasattr(self, "_onedal_estimator")
-        is_underdetermined = self.n_samples_seen_ < self.n_features_in_ + int(
-            self.fit_intercept
-        )
-        if is_underdetermined:
-            raise ValueError("Not enough samples to finalize")
+        self._onedal_validate_underdetermined(self.n_samples_seen_, self.n_features_in_)
         self._onedal_estimator.finalize_fit()
-        self._save_attributes()
+
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+        self._coef_ = self._onedal_estimator.coef_
+        self._intercept_ = self._onedal_estimator.intercept_
+
+        if self._coef_.shape[0] == 1:
+            self._coef_ = self._coef_[0, ...]  # set to 1d
+            self._intercept_ = self._intercept_[0]  # set 1d to scalar
+
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, y, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
+        xp, _ = get_namespace(X, y)
 
         X, y = validate_data(
             self,
             X,
             y,
-            dtype=[np.float64, np.float32],
+            dtype=[xp.float64, xp.float32],
             copy=self.copy_X,
             multi_output=True,
-            ensure_2d=True,
+            y_numeric=True,
         )
 
         n_samples, n_features = X.shape
 
-        is_underdetermined = n_samples < n_features + int(self.fit_intercept)
-        if is_underdetermined:
-            raise ValueError("Not enough samples to run oneDAL backend")
+        self._onedal_validate_underdetermined(n_samples, n_features)
 
         if self.batch_size is None:
             self.batch_size_ = 5 * n_features
@@ -220,12 +243,9 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
             self._onedal_estimator._reset()
 
         for batch in gen_batches(n_samples, self.batch_size_):
-            X_batch, y_batch = X[batch], y[batch]
+            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
 
@@ -240,8 +260,7 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
 
     def partial_fit(self, X, y, check_input=True):
         """
-        Incrementally fits the linear model with X and y. All of X and y is
-        processed as a single batch.
+        Incrementally fits with X and y. X and y are processed as a single batch.
 
         Parameters
         ----------
@@ -253,11 +272,16 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
             Target values, where `n_samples` is the number of samples and
             `n_targets` is the number of targets.
 
+        check_input : bool, default=True
+            Run validate_data on X and y.
+
         Returns
         -------
         self : IncrementalRidge
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
 
         dispatch(
             self,
@@ -280,10 +304,10 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         ----------
         X : array-like of shape (n_samples, n_features)
             Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features. It is necessary for
-            `n_samples` to be not less than `n_features` if `fit_intercept`
-            is False and not less than `n_features` + 1 if `fit_intercept`
-            is True
+            ``n_features`` is the number of features. It is necessary for
+            ``n_samples`` to be not less than ``n_features`` if ``fit_intercept``
+            is False and not less than ``n_features`` + 1 if ``fit_intercept``
+            is True.
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values, where `n_samples` is the number of samples and
@@ -294,6 +318,8 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         self : IncrementalRidge
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
 
         dispatch(
             self,
@@ -343,42 +369,39 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
             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:
             self._onedal_finalize_fit()
-
-        return self._coef
+        return self._coef_
 
     @coef_.setter
     def coef_(self, value):
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.coef_ = value
-            # checking if the model is already fitted and if so, deleting the model
-            if hasattr(self._onedal_estimator, "_onedal_model"):
-                del self._onedal_estimator._onedal_model
-        self._coef = value
+            self._onedal_estimator._onedal_model = None
+        self._coef_ = value
+
+    @coef_.deleter
+    def coef_(self):
+        del self._coef_
 
     @property
     def intercept_(self):
         if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
             self._onedal_finalize_fit()
-
-        return self._intercept
+        return self._intercept_
 
     @intercept_.setter
     def intercept_(self, value):
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.intercept_ = value
-            # checking if the model is already fitted and if so, deleting the model
-            if hasattr(self._onedal_estimator, "_onedal_model"):
-                del self._onedal_estimator._onedal_model
-        self._intercept = value
+            self._onedal_estimator._onedal_model = None
+        self._intercept_ = value
 
-    def _save_attributes(self):
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self._coef = self._onedal_estimator.coef_
-        self._intercept = self._onedal_estimator.intercept_
+    @intercept_.deleter
+    def intercept_(self):
+        del self._intercept_
+
+    score.__doc__ = _sklearn_Ridge.score.__doc__
+    predict.__doc__ = _sklearn_Ridge.predict.__doc__

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/linear_model/linear.py

@@ -16,32 +16,30 @@
 
 import logging
 
-import numpy as np
+from scipy.sparse import issparse
 from sklearn.linear_model import LinearRegression as _sklearn_LinearRegression
 from sklearn.metrics import r2_score
-from sklearn.utils.validation import check_array, check_is_fitted
+from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.common.hyperparameters import get_hyperparameters
+from onedal.linear_model import LinearRegression as onedal_LinearRegression
+from onedal.utils.validation import _num_features, _num_samples
 
 from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, get_patch_message, register_hyperparameters
 from ..base import oneDALEstimator
+from ..utils._array_api import enable_array_api, get_namespace
 from ..utils.validation import validate_data
 
 if not sklearn_check_version("1.2"):
     from sklearn.linear_model._base import _deprecate_normalize
 
-from scipy.sparse import issparse
-from sklearn.utils.validation import check_is_fitted, check_X_y
-
-from onedal.common.hyperparameters import get_hyperparameters
-from onedal.linear_model import LinearRegression as onedal_LinearRegression
-from onedal.utils.validation import _num_features, _num_samples
-
 
-@register_hyperparameters({"fit": get_hyperparameters("linear_regression", "train")})
+@enable_array_api("1.5")  # validate_data y_numeric requires sklearn >=1.5
+@register_hyperparameters({"fit": ("linear_regression", "train")})
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
 class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
     __doc__ = _sklearn_LinearRegression.__doc__
@@ -103,6 +101,8 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
                 positive=positive,
             )
 
+    _onedal_LinearRegression = staticmethod(onedal_LinearRegression)
+
     def fit(self, X, y, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
@@ -251,21 +251,24 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
 
     def _initialize_onedal_estimator(self):
         onedal_params = {"fit_intercept": self.fit_intercept, "copy_X": self.copy_X}
-        self._onedal_estimator = onedal_LinearRegression(**onedal_params)
+        self._onedal_estimator = self._onedal_LinearRegression(**onedal_params)
 
     def _onedal_fit(self, X, y, sample_weight, queue=None):
         assert sample_weight is None
 
-        supports_multi_output = daal_check_version((2025, "P", 1))
-        X, y = validate_data(
-            self,
-            X=X,
-            y=y,
-            dtype=[np.float64, np.float32],
-            accept_sparse=["csr", "csc", "coo"],
-            y_numeric=True,
-            multi_output=supports_multi_output,
-        )
+        xp, _ = get_namespace(X, y)
+
+        if not get_config()["use_raw_input"]:
+            supports_multi_output = daal_check_version((2025, "P", 1))
+            X, y = validate_data(
+                self,
+                X=X,
+                y=y,
+                dtype=[xp.float64, xp.float32],
+                accept_sparse=["csr", "csc", "coo"],
+                y_numeric=True,
+                multi_output=supports_multi_output,
+            )
 
         if not sklearn_check_version("1.2"):
             self._normalize = _deprecate_normalize(
@@ -275,14 +278,22 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
             )
 
         self._initialize_onedal_estimator()
-        # TODO:
-        # impl wrapper/primitive for this case.
-        if get_config()["allow_sklearn_after_onedal"]:
-            try:
-                self._onedal_estimator.fit(X, y, queue=queue)
-                self._save_attributes()
-
-            except RuntimeError:
+
+        try:
+            self._onedal_estimator.fit(X, y, queue=queue)
+
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+            self._sparse = False
+            self._coef_ = self._onedal_estimator.coef_
+            self._intercept_ = self._onedal_estimator.intercept_
+
+            if self._coef_.shape[0] == 1 and y.ndim == 1:
+                self._coef_ = self._coef_[0, ...]  # set to 1d
+                self._intercept_ = self._intercept_[0]  # set 1d to scalar
+
+        except RuntimeError as e:
+            if get_config()["allow_sklearn_after_onedal"]:
+
                 logging.getLogger("sklearnex").info(
                     f"{self.__class__.__name__}.fit "
                     + get_patch_message("sklearn_after_onedal")
@@ -290,12 +301,16 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
 
                 del self._onedal_estimator
                 super().fit(X, y)
-        else:
-            self._onedal_estimator.fit(X, y, queue=queue)
-            self._save_attributes()
+            else:
+                raise e
 
     def _onedal_predict(self, X, queue=None):
-        X = validate_data(self, X, accept_sparse=False, reset=False)
+        xp, _ = get_namespace(X)
+
+        if not get_config()["use_raw_input"]:
+            X = validate_data(
+                self, X, accept_sparse=False, dtype=[xp.float64, xp.float32], reset=False
+            )
 
         if not hasattr(self, "_onedal_estimator"):
             self._initialize_onedal_estimator()
@@ -303,6 +318,9 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
             self._onedal_estimator.intercept_ = self.intercept_
 
         res = self._onedal_estimator.predict(X, queue=queue)
+        if res.shape[1] == 1 and self.coef_.ndim == 1:
+            res = xp.reshape(res, (-1,))
+
         return res
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
@@ -319,7 +337,7 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
         self._coef_ = value
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.coef_ = value
-            del self._onedal_estimator._onedal_model
+            self._onedal_estimator._onedal_model = None
 
     @coef_.deleter
     def coef_(self):
@@ -334,18 +352,12 @@ class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
         self._intercept_ = value
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.intercept_ = value
-            del self._onedal_estimator._onedal_model
+            self._onedal_estimator._onedal_model = None
 
     @intercept_.deleter
     def intercept_(self):
         del self._intercept_
 
-    def _save_attributes(self):
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self._sparse = False
-        self._coef_ = self._onedal_estimator.coef_
-        self._intercept_ = self._onedal_estimator.intercept_
-
     fit.__doc__ = _sklearn_LinearRegression.fit.__doc__
     predict.__doc__ = _sklearn_LinearRegression.predict.__doc__
     score.__doc__ = _sklearn_LinearRegression.score.__doc__

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -33,6 +33,7 @@ if daal_check_version((2024, "P", 1)):
     from daal4py.sklearn._n_jobs_support import control_n_jobs
     from daal4py.sklearn._utils import sklearn_check_version
     from daal4py.sklearn.linear_model.logistic_path import daal4py_fit, daal4py_predict
+    from onedal._device_offload import support_input_format
     from onedal.linear_model import LogisticRegression as onedal_LogisticRegression
     from onedal.utils.validation import _num_samples
 
@@ -99,6 +100,9 @@ if daal_check_version((2024, "P", 1)):
             )
 
         _onedal_cpu_fit = daal4py_fit
+        decision_function = support_input_format(
+            _sklearn_LogisticRegression.decision_function
+        )
 
         def _onedal_gpu_save_attributes(self):
             assert hasattr(self, "_onedal_estimator")
@@ -208,12 +212,15 @@ if daal_check_version((2024, "P", 1)):
                     ),
                     (self.class_weight is None, "Class weight is not supported"),
                     (self.solver == "newton-cg", "Only newton-cg solver is supported."),
+                    (self.warm_start == False, "Warm start is not supported."),
                     (
-                        self.multi_class != "multinomial",
-                        "multi_class parameter is not supported.",
+                        not (self.multi_class == "multinomial"),
+                        "multi_class='multinomial is not supported.",
+                    ),
+                    (
+                        not self.l1_ratio,
+                        "l1 ratio is not supported.",
                     ),
-                    (self.warm_start == False, "Warm start is not supported."),
-                    (self.l1_ratio is None, "l1 ratio is not supported."),
                     (sample_weight is None, "Sample weight is not supported."),
                     (
                         target_type == "binary",