scikit-learn-intelex 2025.0.1__py312-none-win_amd64.whl → 2025.2.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -34,9 +34,14 @@ from onedal.linear_model import IncrementalRidge as onedal_IncrementalRidge
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 
 @control_n_jobs(
-    decorated_methods=["fit", "partial_fit", "predict", "_onedal_finalize_fit"]
+    decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
 class IncrementalRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
     """
@@ -91,6 +96,13 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
 
     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.
     """
 
     _onedal_incremental_ridge = staticmethod(onedal_IncrementalRidge)
@@ -127,7 +139,7 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
             self._validate_params()
 
         if sklearn_check_version("1.0"):
-            X = self._validate_data(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:
@@ -147,7 +159,8 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
 
         if check_input:
             if sklearn_check_version("1.0"):
-                X, y = self._validate_data(
+                X, y = validate_data(
+                    self,
                     X,
                     y,
                     dtype=[np.float64, np.float32],
@@ -190,7 +203,8 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
             self._validate_params()
 
         if sklearn_check_version("1.0"):
-            X, y = self._validate_data(
+            X, y = validate_data(
+                self,
                 X,
                 y,
                 dtype=[np.float64, np.float32],

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/linear_model/linear.py

@@ -18,13 +18,14 @@ import logging
 from abc import ABC
 
 import numpy as np
-from sklearn.exceptions import NotFittedError
-from sklearn.linear_model import LinearRegression as sklearn_LinearRegression
+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 daal4py.sklearn._n_jobs_support import control_n_jobs
-from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
+from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, get_patch_message, register_hyperparameters
 
@@ -32,20 +33,27 @@ if sklearn_check_version("1.0") and 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_X_y
+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 import _num_features, _num_samples
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = _sklearn_LinearRegression._validate_data
+
 
 @register_hyperparameters({"fit": get_hyperparameters("linear_regression", "train")})
-@control_n_jobs(decorated_methods=["fit", "predict"])
-class LinearRegression(sklearn_LinearRegression):
-    __doc__ = sklearn_LinearRegression.__doc__
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
+class LinearRegression(_sklearn_LinearRegression):
+    __doc__ = _sklearn_LinearRegression.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_LinearRegression._parameter_constraints}
+        _parameter_constraints: dict = {
+            **_sklearn_LinearRegression._parameter_constraints
+        }
 
         def __init__(
             self,
@@ -80,8 +88,6 @@ class LinearRegression(sklearn_LinearRegression):
             )
 
     def fit(self, X, y, sample_weight=None):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
         if sklearn_check_version("1.2"):
             self._validate_params()
 
@@ -95,7 +101,7 @@ class LinearRegression(sklearn_LinearRegression):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_LinearRegression.fit,
+                "sklearn": _sklearn_LinearRegression.fit,
             },
             X,
             y,
@@ -105,48 +111,71 @@ class LinearRegression(sklearn_LinearRegression):
 
     @wrap_output_data
     def predict(self, X):
-
-        if not hasattr(self, "coef_"):
-            msg = (
-                "This %(name)s instance is not fitted yet. Call 'fit' with "
-                "appropriate arguments before using this estimator."
-            )
-            raise NotFittedError(msg % {"name": self.__class__.__name__})
-
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_LinearRegression.predict,
+                "sklearn": _sklearn_LinearRegression.predict,
             },
             X,
         )
 
     @wrap_output_data
     def score(self, X, y, sample_weight=None):
+        check_is_fitted(self)
         return dispatch(
             self,
             "score",
             {
                 "onedal": self.__class__._onedal_score,
-                "sklearn": sklearn_LinearRegression.score,
+                "sklearn": _sklearn_LinearRegression.score,
             },
             X,
             y,
             sample_weight=sample_weight,
         )
 
-    def _onedal_fit_supported(self, method_name, *data):
-        assert method_name == "fit"
-        assert len(data) == 3
-        X, y, sample_weight = data
+    def _onedal_cpu_supported(self, method_name, *data):
+        patching_status = PatchingConditionsChain(
+            f"sklearn.linear_model.{self.__class__.__name__}.{method_name}"
+        )
+        return self._onedal_supported(patching_status, method_name, *data)
 
-        class_name = self.__class__.__name__
+    def _onedal_gpu_supported(self, method_name, *data):
         patching_status = PatchingConditionsChain(
-            f"sklearn.linear_model.{class_name}.fit"
+            f"sklearn.linear_model.{self.__class__.__name__}.{method_name}"
         )
 
+        if method_name == "fit" and not daal_check_version((2025, "P", 200)):
+            n_samples = _num_samples(data[0])
+            n_features = _num_features(data[0], fallback_1d=True)
+            is_underdetermined = n_samples < (n_features + int(self.fit_intercept))
+            patching_status.and_conditions(
+                [
+                    (
+                        not is_underdetermined,
+                        "The shape of X (fitting) does not satisfy oneDAL requirements:"
+                        "Number of features + 1 >= number of samples.",
+                    )
+                ]
+            )
+
+        return self._onedal_supported(patching_status, method_name, *data)
+
+    def _onedal_supported(self, patching_status, method_name, *data):
+        if method_name == "fit":
+            return self._onedal_fit_supported(patching_status, method_name, *data)
+        if method_name in ["predict", "score"]:
+            return self._onedal_predict_supported(patching_status, method_name, *data)
+        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
+
+    def _onedal_fit_supported(self, patching_status, method_name, *data):
+        assert method_name == "fit"
+        assert len(data) == 3
+        X, y, sample_weight = data
+
         normalize_is_set = (
             hasattr(self, "normalize")
             and self.normalize
@@ -157,8 +186,11 @@ class LinearRegression(sklearn_LinearRegression):
         n_samples = _num_samples(X)
         n_features = _num_features(X, fallback_1d=True)
 
-        # Check if equations are well defined
+        # Note: support for some variants was either introduced in oneDAL 2025.1,
+        # or had bugs in some uncommon cases in older versions.
         is_underdetermined = n_samples < (n_features + int(self.fit_intercept))
+        supports_all_variants = daal_check_version((2025, "P", 1))
+        is_multi_output = _num_features(y, fallback_1d=True) > 1
 
         patching_status.and_conditions(
             [
@@ -173,21 +205,20 @@ class LinearRegression(sklearn_LinearRegression):
                     "Forced positive coefficients are not supported.",
                 ),
                 (
-                    not is_underdetermined,
+                    not is_underdetermined or supports_all_variants,
                     "The shape of X (fitting) does not satisfy oneDAL requirements:"
                     "Number of features + 1 >= number of samples.",
                 ),
+                (
+                    not is_multi_output or supports_all_variants,
+                    "Multi-output regression is not supported.",
+                ),
             ]
         )
 
         return patching_status
 
-    def _onedal_predict_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        patching_status = PatchingConditionsChain(
-            f"sklearn.linear_model.{class_name}.predict"
-        )
-
+    def _onedal_predict_supported(self, patching_status, method_name, *data):
         n_samples = _num_samples(data[0])
         model_is_sparse = issparse(self.coef_) or (
             self.fit_intercept and issparse(self.intercept_)
@@ -202,16 +233,6 @@ class LinearRegression(sklearn_LinearRegression):
 
         return patching_status
 
-    def _onedal_supported(self, method_name, *data):
-        if method_name == "fit":
-            return self._onedal_fit_supported(method_name, *data)
-        if method_name in ["predict", "score"]:
-            return self._onedal_predict_supported(method_name, *data)
-        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
-
-    _onedal_gpu_supported = _onedal_supported
-    _onedal_cpu_supported = _onedal_supported
-
     def _initialize_onedal_estimator(self):
         onedal_params = {"fit_intercept": self.fit_intercept, "copy_X": self.copy_X}
         self._onedal_estimator = onedal_LinearRegression(**onedal_params)
@@ -219,16 +240,17 @@ class LinearRegression(sklearn_LinearRegression):
     def _onedal_fit(self, X, y, sample_weight, queue=None):
         assert sample_weight is None
 
+        supports_multi_output = daal_check_version((2025, "P", 1))
         check_params = {
             "X": X,
             "y": y,
             "dtype": [np.float64, np.float32],
             "accept_sparse": ["csr", "csc", "coo"],
             "y_numeric": True,
-            "multi_output": True,
+            "multi_output": supports_multi_output,
         }
-        if sklearn_check_version("1.2"):
-            X, y = self._validate_data(**check_params)
+        if sklearn_check_version("1.0"):
+            X, y = validate_data(self, **check_params)
         else:
             X, y = check_X_y(**check_params)
 
@@ -240,24 +262,31 @@ class LinearRegression(sklearn_LinearRegression):
             )
 
         self._initialize_onedal_estimator()
-        try:
+        # 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:
+                logging.getLogger("sklearnex").info(
+                    f"{self.__class__.__name__}.fit "
+                    + get_patch_message("sklearn_after_onedal")
+                )
+
+                del self._onedal_estimator
+                super().fit(X, y)
+        else:
             self._onedal_estimator.fit(X, y, queue=queue)
             self._save_attributes()
 
-        except RuntimeError:
-            logging.getLogger("sklearnex").info(
-                f"{self.__class__.__name__}.fit "
-                + get_patch_message("sklearn_after_onedal")
-            )
-
-            del self._onedal_estimator
-            super().fit(X, y)
-
     def _onedal_predict(self, X, queue=None):
         if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+            X = validate_data(self, X, accept_sparse=False, reset=False)
+        else:
+            X = check_array(X, accept_sparse=False)
 
-        X = self._validate_data(X, accept_sparse=False, reset=False)
         if not hasattr(self, "_onedal_estimator"):
             self._initialize_onedal_estimator()
             self._onedal_estimator.coef_ = self.coef_
@@ -271,32 +300,42 @@ class LinearRegression(sklearn_LinearRegression):
             y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
         )
 
-    def get_coef_(self):
-        return self.coef_
+    @property
+    def coef_(self):
+        return self._coef_
 
-    def set_coef_(self, value):
-        self.__dict__["coef_"] = value
+    @coef_.setter
+    def coef_(self, value):
+        self._coef_ = value
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.coef_ = value
             del self._onedal_estimator._onedal_model
 
-    def get_intercept_(self):
-        return self.intercept_
+    @coef_.deleter
+    def coef_(self):
+        del self._coef_
 
-    def set_intercept_(self, value):
-        self.__dict__["intercept_"] = value
+    @property
+    def intercept_(self):
+        return self._intercept_
+
+    @intercept_.setter
+    def intercept_(self, value):
+        self._intercept_ = value
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator.intercept_ = value
             del self._onedal_estimator._onedal_model
 
+    @intercept_.deleter
+    def intercept_(self):
+        del self._intercept_
+
     def _save_attributes(self):
-        self.coef_ = property(self.get_coef_, self.set_coef_)
-        self.intercept_ = property(self.get_intercept_, self.set_intercept_)
         self.n_features_in_ = self._onedal_estimator.n_features_in_
         self._sparse = False
-        self.__dict__["coef_"] = self._onedal_estimator.coef_
-        self.__dict__["intercept_"] = self._onedal_estimator.intercept_
+        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__
+    fit.__doc__ = _sklearn_LinearRegression.fit.__doc__
+    predict.__doc__ = _sklearn_LinearRegression.predict.__doc__
+    score.__doc__ = _sklearn_LinearRegression.score.__doc__

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -19,13 +19,13 @@ from abc import ABC
 
 from daal4py.sklearn._utils import daal_check_version
 from daal4py.sklearn.linear_model.logistic_path import (
-    LogisticRegression as LogisticRegression_daal4py,
+    LogisticRegression as _daal4py_LogisticRegression,
 )
 
 if daal_check_version((2024, "P", 1)):
     import numpy as np
     from scipy.sparse import issparse
-    from sklearn.linear_model import LogisticRegression as sklearn_LogisticRegression
+    from sklearn.linear_model import LogisticRegression as _sklearn_LogisticRegression
     from sklearn.metrics import accuracy_score
     from sklearn.utils.multiclass import type_of_target
     from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
@@ -36,13 +36,19 @@ if daal_check_version((2024, "P", 1)):
     from onedal.linear_model import LogisticRegression as onedal_LogisticRegression
     from onedal.utils import _num_samples
 
+    from .._config import get_config
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain, get_patch_message
 
+    if sklearn_check_version("1.6"):
+        from sklearn.utils.validation import validate_data
+    else:
+        validate_data = _sklearn_LogisticRegression._validate_data
+
     _sparsity_enabled = daal_check_version((2024, "P", 700))
 
     class BaseLogisticRegression(ABC):
-        def _save_attributes(self):
+        def _onedal_gpu_save_attributes(self):
             assert hasattr(self, "_onedal_estimator")
             self.classes_ = self._onedal_estimator.classes_
             self.coef_ = self._onedal_estimator.coef_
@@ -59,13 +65,12 @@ if daal_check_version((2024, "P", 1)):
             "score",
         ]
     )
-    class LogisticRegression(sklearn_LogisticRegression, BaseLogisticRegression):
-        __doc__ = sklearn_LogisticRegression.__doc__
-        intercept_, coef_, n_iter_ = None, None, None
+    class LogisticRegression(_sklearn_LogisticRegression, BaseLogisticRegression):
+        __doc__ = _sklearn_LogisticRegression.__doc__
 
         if sklearn_check_version("1.2"):
             _parameter_constraints: dict = {
-                **sklearn_LogisticRegression._parameter_constraints
+                **_sklearn_LogisticRegression._parameter_constraints
             }
 
         def __init__(
@@ -115,7 +120,7 @@ if daal_check_version((2024, "P", 1)):
                 "fit",
                 {
                     "onedal": self.__class__._onedal_fit,
-                    "sklearn": sklearn_LogisticRegression.fit,
+                    "sklearn": _sklearn_LogisticRegression.fit,
                 },
                 X,
                 y,
@@ -125,48 +130,52 @@ if daal_check_version((2024, "P", 1)):
 
         @wrap_output_data
         def predict(self, X):
+            check_is_fitted(self)
             return dispatch(
                 self,
                 "predict",
                 {
                     "onedal": self.__class__._onedal_predict,
-                    "sklearn": sklearn_LogisticRegression.predict,
+                    "sklearn": _sklearn_LogisticRegression.predict,
                 },
                 X,
             )
 
         @wrap_output_data
         def predict_proba(self, X):
+            check_is_fitted(self)
             return dispatch(
                 self,
                 "predict_proba",
                 {
                     "onedal": self.__class__._onedal_predict_proba,
-                    "sklearn": sklearn_LogisticRegression.predict_proba,
+                    "sklearn": _sklearn_LogisticRegression.predict_proba,
                 },
                 X,
             )
 
         @wrap_output_data
         def predict_log_proba(self, X):
+            check_is_fitted(self)
             return dispatch(
                 self,
                 "predict_log_proba",
                 {
                     "onedal": self.__class__._onedal_predict_log_proba,
-                    "sklearn": sklearn_LogisticRegression.predict_log_proba,
+                    "sklearn": _sklearn_LogisticRegression.predict_log_proba,
                 },
                 X,
             )
 
         @wrap_output_data
         def score(self, X, y, sample_weight=None):
+            check_is_fitted(self)
             return dispatch(
                 self,
                 "score",
                 {
                     "onedal": self.__class__._onedal_score,
-                    "sklearn": sklearn_LogisticRegression.score,
+                    "sklearn": _sklearn_LogisticRegression.score,
                 },
                 X,
                 y,
@@ -233,9 +242,6 @@ if daal_check_version((2024, "P", 1)):
             )
 
             n_samples = _num_samples(data[0])
-            model_is_sparse = issparse(self.coef_) or (
-                self.fit_intercept and issparse(self.intercept_)
-            )
             dal_ready = patching_status.and_conditions(
                 [
                     (n_samples > 0, "Number of samples is less than 1."),
@@ -243,7 +249,6 @@ if daal_check_version((2024, "P", 1)):
                         (not any([issparse(i) for i in data])) or _sparsity_enabled,
                         "Sparse input is not supported.",
                     ),
-                    (not model_is_sparse, "Sparse coefficients are not supported."),
                     (
                         hasattr(self, "_onedal_estimator"),
                         "oneDAL model was not trained.",
@@ -270,7 +275,7 @@ if daal_check_version((2024, "P", 1)):
 
             return patching_status
 
-        def _initialize_onedal_estimator(self):
+        def _onedal_gpu_initialize_estimator(self):
             onedal_params = {
                 "tol": self.tol,
                 "C": self.C,
@@ -287,7 +292,8 @@ if daal_check_version((2024, "P", 1)):
             assert sample_weight is None
 
             if sklearn_check_version("1.0"):
-                X, y = self._validate_data(
+                X, y = validate_data(
+                    self,
                     X,
                     y,
                     accept_sparse=_sparsity_enabled,
@@ -303,26 +309,30 @@ if daal_check_version((2024, "P", 1)):
                     dtype=[np.float64, np.float32],
                 )
 
-            self._initialize_onedal_estimator()
+            self._onedal_gpu_initialize_estimator()
             try:
                 self._onedal_estimator.fit(X, y, queue=queue)
-                self._save_attributes()
-            except RuntimeError:
-                logging.getLogger("sklearnex").info(
-                    f"{self.__class__.__name__}.fit "
-                    + get_patch_message("sklearn_after_onedal")
-                )
+                self._onedal_gpu_save_attributes()
+            except RuntimeError as err:
+                if get_config()["allow_sklearn_after_onedal"]:
+
+                    logging.getLogger("sklearnex").info(
+                        f"{self.__class__.__name__}.fit "
+                        + get_patch_message("sklearn_after_onedal")
+                    )
 
-                del self._onedal_estimator
-                super().fit(X, y)
+                    del self._onedal_estimator
+                    super().fit(X, y)
+                else:
+                    raise err
 
         def _onedal_predict(self, X, queue=None):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassLabels")
 
-            check_is_fitted(self)
             if sklearn_check_version("1.0"):
-                X = self._validate_data(
+                X = validate_data(
+                    self,
                     X,
                     reset=False,
                     accept_sparse=_sparsity_enabled,
@@ -344,9 +354,9 @@ if daal_check_version((2024, "P", 1)):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassProbabilities")
 
-            check_is_fitted(self)
             if sklearn_check_version("1.0"):
-                X = self._validate_data(
+                X = validate_data(
+                    self,
                     X,
                     reset=False,
                     accept_sparse=_sparsity_enabled,
@@ -368,9 +378,9 @@ if daal_check_version((2024, "P", 1)):
             if queue is None or queue.sycl_device.is_cpu:
                 return daal4py_predict(self, X, "computeClassLogProbabilities")
 
-            check_is_fitted(self)
             if sklearn_check_version("1.0"):
-                X = self._validate_data(
+                X = validate_data(
+                    self,
                     X,
                     reset=False,
                     accept_sparse=_sparsity_enabled,
@@ -388,14 +398,14 @@ if daal_check_version((2024, "P", 1)):
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_log_proba(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__
-        score.__doc__ = sklearn_LogisticRegression.score.__doc__
+        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__
+        score.__doc__ = _sklearn_LogisticRegression.score.__doc__
 
 else:
-    LogisticRegression = LogisticRegression_daal4py
+    LogisticRegression = _daal4py_LogisticRegression
 
     logging.warning(
         "Sklearnex LogisticRegression requires oneDAL version >= 2024.0.1 "