scikit-learn-intelex 2025.7.0__py310-none-win_amd64.whl → 2025.8.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -17,11 +17,10 @@
 import numbers
 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 import gen_batches
 from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
@@ -31,13 +30,6 @@ from onedal.linear_model import (
 )
 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
-
-from onedal.common.hyperparameters import get_hyperparameters
-
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import (
     PatchingConditionsChain,
@@ -45,12 +37,18 @@ from .._utils import (
     register_hyperparameters,
 )
 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
 @register_hyperparameters(
     {
-        "fit": get_hyperparameters("linear_regression", "train"),
-        "partial_fit": get_hyperparameters("linear_regression", "train"),
+        "fit": ("linear_regression", "train"),
+        "partial_fit": ("linear_regression", "train"),
     }
 )
 @control_n_jobs(
@@ -144,7 +142,7 @@ class IncrementalLinearRegression(
         _parameter_constraints: dict = {
             "fit_intercept": ["boolean"],
             "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],
         }
 
@@ -164,14 +162,16 @@ class IncrementalLinearRegression(
     _onedal_gpu_supported = _onedal_supported
 
     def _onedal_predict(self, X, queue=None):
-        if get_config()["use_raw_input"] is False:
+        if not get_config()["use_raw_input"]:
             if sklearn_check_version("1.2"):
                 self._validate_params()
 
+            xp, _ = get_namespace(X)
+
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 copy=self.copy_X,
                 reset=False,
             )
@@ -179,7 +179,11 @@ class IncrementalLinearRegression(
         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(
@@ -189,22 +193,17 @@ class IncrementalLinearRegression(
     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()
-
-        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 check_input and not get_config()["use_raw_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:
@@ -234,20 +233,29 @@ class IncrementalLinearRegression(
         assert hasattr(self, "_onedal_estimator")
         self._onedal_validate_underdetermined(self.n_samples_seen_, self.n_features_in_)
         self._onedal_estimator.finalize_fit()
+
+        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 get_config()["use_raw_input"] is False:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
+        if not get_config()["use_raw_input"]:
+            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
@@ -264,7 +272,7 @@ class IncrementalLinearRegression(
             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)
 
         # finite check occurs on onedal side
@@ -278,44 +286,6 @@ class IncrementalLinearRegression(
         self._onedal_finalize_fit()
         return self
 
-    @property
-    def intercept_(self):
-        if hasattr(self, "_onedal_estimator"):
-            if self._need_to_finalize:
-                self._onedal_finalize_fit()
-
-            return self._onedal_estimator.intercept_
-        else:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute 'intercept_'"
-            )
-
-    @intercept_.setter
-    def intercept_(self, value):
-        self.__dict__["intercept_"] = value
-        if hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator.intercept_ = value
-            del self._onedal_estimator._onedal_model
-
-    @property
-    def coef_(self):
-        if hasattr(self, "_onedal_estimator"):
-            if self._need_to_finalize:
-                self._onedal_finalize_fit()
-
-            return self._onedal_estimator.coef_
-        else:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute 'coef_'"
-            )
-
-    @coef_.setter
-    def coef_(self, value):
-        self.__dict__["coef_"] = value
-        if hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator.coef_ = value
-            del self._onedal_estimator._onedal_model
-
     def partial_fit(self, X, y, check_input=True):
         """
         Incremental fit with X and y. X and y are processed as a single batch.
@@ -338,6 +308,8 @@ class IncrementalLinearRegression(
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
 
         dispatch(
             self,
@@ -374,6 +346,8 @@ class IncrementalLinearRegression(
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
 
         dispatch(
             self,
@@ -415,5 +389,39 @@ class IncrementalLinearRegression(
             sample_weight=sample_weight,
         )
 
+    @property
+    def coef_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._coef_
+
+    @coef_.setter
+    def coef_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.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_
+
+    @intercept_.setter
+    def intercept_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.intercept_ = value
+            self._onedal_estimator._onedal_model = None
+        self._intercept_ = value
+
+    @intercept_.deleter
+    def intercept_(self):
+        del self._intercept_
+
     score.__doc__ = _sklearn_LinearRegression.score.__doc__
     predict.__doc__ = _sklearn_LinearRegression.predict.__doc__

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.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.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__