scikit-learn-intelex 2025.7.0__py39-none-win_amd64.whl → 2025.9.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -17,28 +17,27 @@
 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"]
 )
@@ -113,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],
         }
 
@@ -139,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(
@@ -154,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:
@@ -184,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
@@ -225,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
 
@@ -265,6 +280,8 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         self : IncrementalRidge
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
 
         dispatch(
             self,
@@ -301,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,
@@ -350,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.7.0.data → scikit_learn_intelex-2025.9.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.7.0.data → scikit_learn_intelex-2025.9.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
 
@@ -61,44 +62,86 @@ if daal_check_version((2024, "P", 1)):
                 **_sklearn_LogisticRegression._parameter_constraints
             }
 
-        def __init__(
-            self,
-            penalty="l2",
-            *,
-            dual=False,
-            tol=1e-4,
-            C=1.0,
-            fit_intercept=True,
-            intercept_scaling=1,
-            class_weight=None,
-            random_state=None,
-            solver="lbfgs",
-            max_iter=100,
-            multi_class="deprecated" if sklearn_check_version("1.5") else "auto",
-            verbose=0,
-            warm_start=False,
-            n_jobs=None,
-            l1_ratio=None,
-        ):
-            super().__init__(
-                penalty=penalty,
-                dual=dual,
-                tol=tol,
-                C=C,
-                fit_intercept=fit_intercept,
-                intercept_scaling=intercept_scaling,
-                class_weight=class_weight,
-                random_state=random_state,
-                solver=solver,
-                max_iter=max_iter,
-                multi_class=multi_class,
-                verbose=verbose,
-                warm_start=warm_start,
-                n_jobs=n_jobs,
-                l1_ratio=l1_ratio,
-            )
+        if sklearn_check_version("1.8"):
+
+            def __init__(
+                self,
+                penalty="l2",
+                *,
+                dual=False,
+                tol=1e-4,
+                C=1.0,
+                fit_intercept=True,
+                intercept_scaling=1,
+                class_weight=None,
+                random_state=None,
+                solver="lbfgs",
+                max_iter=100,
+                verbose=0,
+                warm_start=False,
+                n_jobs=None,
+                l1_ratio=None,
+            ):
+                super().__init__(
+                    penalty=penalty,
+                    dual=dual,
+                    tol=tol,
+                    C=C,
+                    fit_intercept=fit_intercept,
+                    intercept_scaling=intercept_scaling,
+                    class_weight=class_weight,
+                    random_state=random_state,
+                    solver=solver,
+                    max_iter=max_iter,
+                    verbose=verbose,
+                    warm_start=warm_start,
+                    n_jobs=n_jobs,
+                    l1_ratio=l1_ratio,
+                )
+
+        else:
+
+            def __init__(
+                self,
+                penalty="l2",
+                *,
+                dual=False,
+                tol=1e-4,
+                C=1.0,
+                fit_intercept=True,
+                intercept_scaling=1,
+                class_weight=None,
+                random_state=None,
+                solver="lbfgs",
+                max_iter=100,
+                multi_class="deprecated" if sklearn_check_version("1.5") else "auto",
+                verbose=0,
+                warm_start=False,
+                n_jobs=None,
+                l1_ratio=None,
+            ):
+                super().__init__(
+                    penalty=penalty,
+                    dual=dual,
+                    tol=tol,
+                    C=C,
+                    fit_intercept=fit_intercept,
+                    intercept_scaling=intercept_scaling,
+                    class_weight=class_weight,
+                    random_state=random_state,
+                    solver=solver,
+                    max_iter=max_iter,
+                    multi_class=multi_class,
+                    verbose=verbose,
+                    warm_start=warm_start,
+                    n_jobs=n_jobs,
+                    l1_ratio=l1_ratio,
+                )
 
         _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")
@@ -163,6 +206,19 @@ if daal_check_version((2024, "P", 1)):
                 X,
             )
 
+        @wrap_output_data
+        def decision_function(self, X):
+            check_is_fitted(self)
+            return dispatch(
+                self,
+                "decision_function",
+                {
+                    "onedal": self.__class__._onedal_decision_function,
+                    "sklearn": _sklearn_LogisticRegression.decision_function,
+                },
+                X,
+            )
+
         @wrap_output_data
         def score(self, X, y, sample_weight=None):
             check_is_fitted(self)
@@ -209,6 +265,10 @@ 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."),
+                    (
+                        sklearn_check_version("1.8") or self.multi_class != "multinomial",
+                        "multi_class='multinomial is not supported.",
+                    ),
                     (
                         not self.l1_ratio,
                         "l1 ratio is not supported.",
@@ -228,6 +288,7 @@ if daal_check_version((2024, "P", 1)):
                 "predict",
                 "predict_proba",
                 "predict_log_proba",
+                "decision_function",
                 "score",
             ]
 
@@ -241,7 +302,8 @@ if daal_check_version((2024, "P", 1)):
                 [
                     (n_samples > 0, "Number of samples is less than 1."),
                     (
-                        (not any([issparse(i) for i in data])) or _sparsity_enabled,
+                        (_sparsity_enabled and method_name != "decision_function")
+                        or (not any([issparse(i) for i in data])),
                         "Sparse input is not supported.",
                     ),
                     (
@@ -256,7 +318,13 @@ if daal_check_version((2024, "P", 1)):
         def _onedal_gpu_supported(self, method_name, *data):
             if method_name == "fit":
                 return self._onedal_gpu_fit_supported(method_name, *data)
-            if method_name in ["predict", "predict_proba", "predict_log_proba", "score"]:
+            if method_name in [
+                "predict",
+                "predict_proba",
+                "predict_log_proba",
+                "decision_function",
+                "score",
+            ]:
                 return self._onedal_gpu_predict_supported(method_name, *data)
             raise RuntimeError(
                 f"Unknown method {method_name} in {self.__class__.__name__}"
@@ -360,10 +428,26 @@ if daal_check_version((2024, "P", 1)):
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_log_proba(X, queue=queue)
 
+        def _onedal_decision_function(self, X, queue=None):
+            if queue is None or queue.sycl_device.is_cpu:
+                return super().decision_function(X)
+            X = validate_data(
+                self,
+                X,
+                reset=False,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
+
+            assert hasattr(self, "_onedal_estimator")
+            return self._onedal_estimator.decision_function(X, queue=queue)
+
         fit.__doc__ = _sklearn_LogisticRegression.fit.__doc__
         predict.__doc__ = _sklearn_LogisticRegression.predict.__doc__
         predict_proba.__doc__ = _sklearn_LogisticRegression.predict_proba.__doc__
         predict_log_proba.__doc__ = _sklearn_LogisticRegression.predict_log_proba.__doc__
+        decision_function.__doc__ = _sklearn_LogisticRegression.decision_function.__doc__
         score.__doc__ = _sklearn_LogisticRegression.score.__doc__
 
 else: