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/ensemble/_forest.py

@@ -20,13 +20,13 @@ from abc import ABC
 
 import numpy as np
 from scipy import sparse as sp
-from sklearn.base import clone
-from sklearn.ensemble import ExtraTreesClassifier as sklearn_ExtraTreesClassifier
-from sklearn.ensemble import ExtraTreesRegressor as sklearn_ExtraTreesRegressor
-from sklearn.ensemble import RandomForestClassifier as sklearn_RandomForestClassifier
-from sklearn.ensemble import RandomForestRegressor as sklearn_RandomForestRegressor
-from sklearn.ensemble._forest import ForestClassifier as sklearn_ForestClassifier
-from sklearn.ensemble._forest import ForestRegressor as sklearn_ForestRegressor
+from sklearn.base import BaseEstimator, clone
+from sklearn.ensemble import ExtraTreesClassifier as _sklearn_ExtraTreesClassifier
+from sklearn.ensemble import ExtraTreesRegressor as _sklearn_ExtraTreesRegressor
+from sklearn.ensemble import RandomForestClassifier as _sklearn_RandomForestClassifier
+from sklearn.ensemble import RandomForestRegressor as _sklearn_RandomForestRegressor
+from sklearn.ensemble._forest import ForestClassifier as _sklearn_ForestClassifier
+from sklearn.ensemble._forest import ForestRegressor as _sklearn_ForestRegressor
 from sklearn.ensemble._forest import _get_n_samples_bootstrap
 from sklearn.exceptions import DataConversionWarning
 from sklearn.metrics import accuracy_score, r2_score
@@ -57,6 +57,8 @@ from onedal.ensemble import RandomForestClassifier as onedal_RandomForestClassif
 from onedal.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 from onedal.primitives import get_tree_state_cls, get_tree_state_reg
 from onedal.utils import _num_features, _num_samples
+from sklearnex import get_hyperparameters
+from sklearnex._utils import register_hyperparameters
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
@@ -67,12 +69,18 @@ if sklearn_check_version("1.2"):
 if sklearn_check_version("1.4"):
     from daal4py.sklearn.utils import _assert_all_finite
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 
 class BaseForest(ABC):
     _onedal_factory = None
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        X, y = self._validate_data(
+        X, y = validate_data(
+            self,
             X,
             y,
             multi_output=True,
@@ -394,7 +402,7 @@ class BaseForest(ABC):
             self.estimator = estimator
 
 
-class ForestClassifier(sklearn_ForestClassifier, BaseForest):
+class ForestClassifier(_sklearn_ForestClassifier, BaseForest):
     # Surprisingly, even though scikit-learn warns against using
     # their ForestClassifier directly, it actually has a more stable
     # API than the user-facing objects (over time). If they change it
@@ -458,7 +466,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_ForestClassifier.fit,
+                "sklearn": _sklearn_ForestClassifier.fit,
             },
             X,
             y,
@@ -592,12 +600,13 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
 
     @wrap_output_data
     def predict(self, X):
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_ForestClassifier.predict,
+                "sklearn": _sklearn_ForestClassifier.predict,
             },
             X,
         )
@@ -607,27 +616,13 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
         # TODO:
         # _check_proba()
         # self._check_proba()
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
-        if hasattr(self, "n_features_in_"):
-            try:
-                num_features = _num_features(X)
-            except TypeError:
-                num_features = _num_samples(X)
-            if num_features != self.n_features_in_:
-                raise ValueError(
-                    (
-                        f"X has {num_features} features, "
-                        f"but {self.__class__.__name__} is expecting "
-                        f"{self.n_features_in_} features as input"
-                    )
-                )
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict_proba",
             {
                 "onedal": self.__class__._onedal_predict_proba,
-                "sklearn": sklearn_ForestClassifier.predict_proba,
+                "sklearn": _sklearn_ForestClassifier.predict_proba,
             },
             X,
         )
@@ -647,23 +642,24 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
 
     @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_ForestClassifier.score,
+                "sklearn": _sklearn_ForestClassifier.score,
             },
             X,
             y,
             sample_weight=sample_weight,
         )
 
-    fit.__doc__ = sklearn_ForestClassifier.fit.__doc__
-    predict.__doc__ = sklearn_ForestClassifier.predict.__doc__
-    predict_proba.__doc__ = sklearn_ForestClassifier.predict_proba.__doc__
-    predict_log_proba.__doc__ = sklearn_ForestClassifier.predict_log_proba.__doc__
-    score.__doc__ = sklearn_ForestClassifier.score.__doc__
+    fit.__doc__ = _sklearn_ForestClassifier.fit.__doc__
+    predict.__doc__ = _sklearn_ForestClassifier.predict.__doc__
+    predict_proba.__doc__ = _sklearn_ForestClassifier.predict_proba.__doc__
+    predict_log_proba.__doc__ = _sklearn_ForestClassifier.predict_log_proba.__doc__
+    score.__doc__ = _sklearn_ForestClassifier.score.__doc__
 
     def _onedal_cpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -794,10 +790,10 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
         return patching_status
 
     def _onedal_predict(self, X, queue=None):
-        check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[np.float64, np.float32],
                 force_all_finite=False,
@@ -810,16 +806,29 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
                 dtype=[np.float64, np.float32],
                 force_all_finite=False,
             )  # Warning, order of dtype matters
+            if hasattr(self, "n_features_in_"):
+                try:
+                    num_features = _num_features(X)
+                except TypeError:
+                    num_features = _num_samples(X)
+                if num_features != self.n_features_in_:
+                    raise ValueError(
+                        (
+                            f"X has {num_features} features, "
+                            f"but {self.__class__.__name__} is expecting "
+                            f"{self.n_features_in_} features as input"
+                        )
+                    )
             self._check_n_features(X, reset=False)
 
         res = self._onedal_estimator.predict(X, queue=queue)
         return np.take(self.classes_, res.ravel().astype(np.int64, casting="unsafe"))
 
     def _onedal_predict_proba(self, X, queue=None):
-        check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[np.float64, np.float32],
                 force_all_finite=False,
@@ -842,7 +851,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
         )
 
 
-class ForestRegressor(sklearn_ForestRegressor, BaseForest):
+class ForestRegressor(_sklearn_ForestRegressor, BaseForest):
     _err = "out_of_bag_error_r2|out_of_bag_error_prediction"
     _get_tree_state = staticmethod(get_tree_state_reg)
 
@@ -1123,7 +1132,8 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
         check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[np.float64, np.float32],
                 force_all_finite=False,
@@ -1148,7 +1158,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_ForestRegressor.fit,
+                "sklearn": _sklearn_ForestRegressor.fit,
             },
             X,
             y,
@@ -1158,43 +1168,46 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
 
     @wrap_output_data
     def predict(self, X):
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_ForestRegressor.predict,
+                "sklearn": _sklearn_ForestRegressor.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_ForestRegressor.score,
+                "sklearn": _sklearn_ForestRegressor.score,
             },
             X,
             y,
             sample_weight=sample_weight,
         )
 
-    fit.__doc__ = sklearn_ForestRegressor.fit.__doc__
-    predict.__doc__ = sklearn_ForestRegressor.predict.__doc__
-    score.__doc__ = sklearn_ForestRegressor.score.__doc__
+    fit.__doc__ = _sklearn_ForestRegressor.fit.__doc__
+    predict.__doc__ = _sklearn_ForestRegressor.predict.__doc__
+    score.__doc__ = _sklearn_ForestRegressor.score.__doc__
 
 
+@register_hyperparameters({"infer": get_hyperparameters("decision_forest", "infer")})
 @control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])
 class RandomForestClassifier(ForestClassifier):
-    __doc__ = sklearn_RandomForestClassifier.__doc__
+    __doc__ = _sklearn_RandomForestClassifier.__doc__
     _onedal_factory = onedal_RandomForestClassifier
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_RandomForestClassifier._parameter_constraints,
+            **_sklearn_RandomForestClassifier._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
@@ -1397,14 +1410,14 @@ class RandomForestClassifier(ForestClassifier):
             self.min_bin_size = min_bin_size
 
 
-@control_n_jobs(decorated_methods=["fit", "predict"])
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
 class RandomForestRegressor(ForestRegressor):
-    __doc__ = sklearn_RandomForestRegressor.__doc__
+    __doc__ = _sklearn_RandomForestRegressor.__doc__
     _onedal_factory = onedal_RandomForestRegressor
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_RandomForestRegressor._parameter_constraints,
+            **_sklearn_RandomForestRegressor._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
@@ -1600,12 +1613,12 @@ class RandomForestRegressor(ForestRegressor):
 
 @control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])
 class ExtraTreesClassifier(ForestClassifier):
-    __doc__ = sklearn_ExtraTreesClassifier.__doc__
+    __doc__ = _sklearn_ExtraTreesClassifier.__doc__
     _onedal_factory = onedal_ExtraTreesClassifier
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_ExtraTreesClassifier._parameter_constraints,
+            **_sklearn_ExtraTreesClassifier._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
@@ -1808,14 +1821,14 @@ class ExtraTreesClassifier(ForestClassifier):
             self.min_bin_size = min_bin_size
 
 
-@control_n_jobs(decorated_methods=["fit", "predict"])
+@control_n_jobs(decorated_methods=["fit", "predict", "score"])
 class ExtraTreesRegressor(ForestRegressor):
-    __doc__ = sklearn_ExtraTreesRegressor.__doc__
+    __doc__ = _sklearn_ExtraTreesRegressor.__doc__
     _onedal_factory = onedal_ExtraTreesRegressor
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_ExtraTreesRegressor._parameter_constraints,
+            **_sklearn_ExtraTreesRegressor._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
@@ -2010,7 +2023,7 @@ class ExtraTreesRegressor(ForestRegressor):
 
 
 # Allow for isinstance calls without inheritance changes using ABCMeta
-sklearn_RandomForestClassifier.register(RandomForestClassifier)
-sklearn_RandomForestRegressor.register(RandomForestRegressor)
-sklearn_ExtraTreesClassifier.register(ExtraTreesClassifier)
-sklearn_ExtraTreesRegressor.register(ExtraTreesRegressor)
+_sklearn_RandomForestClassifier.register(RandomForestClassifier)
+_sklearn_RandomForestRegressor.register(RandomForestRegressor)
+_sklearn_ExtraTreesClassifier.register(ExtraTreesClassifier)
+_sklearn_ExtraTreesRegressor.register(ExtraTreesRegressor)

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/ensemble/tests/test_forest.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 # ===============================================================================
 
-import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 from sklearn.datasets import make_classification, make_regression
@@ -26,9 +25,19 @@ from onedal.tests.utils._dataframes_support import (
     get_dataframes_and_queues,
 )
 
+hparam_values = [
+    (None, None, None, None),
+    (8, 100, 32, 0.3),
+    (16, 100, 32, 0.3),
+    (32, 100, 32, 0.3),
+    (64, 10, 32, 0.1),
+    (128, 100, 1000, 1.0),
+]
 
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import_rf_classifier(dataframe, queue):
+
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("block, trees, rows, scale", hparam_values)
+def test_sklearnex_import_rf_classifier(dataframe, queue, block, trees, rows, scale):
     from sklearnex.ensemble import RandomForestClassifier
 
     X, y = make_classification(
@@ -42,14 +51,20 @@ def test_sklearnex_import_rf_classifier(dataframe, queue):
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
     rf = RandomForestClassifier(max_depth=2, random_state=0).fit(X, y)
+    hparams = RandomForestClassifier.get_hyperparameters("infer")
+    if hparams and block is not None:
+        hparams.block_size = block
+        hparams.min_trees_for_threading = trees
+        hparams.min_number_of_rows_for_vect_seq_compute = rows
+        hparams.scale_factor_for_vect_parallel_compute = scale
     assert "sklearnex" in rf.__module__
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_rf_regression(dataframe, queue):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("RF regressor predict for the GPU sycl_queue is buggy.")
+    if (not daal_check_version((2025, "P", 200))) and queue and queue.sycl_device.is_gpu:
+        pytest.skip("Skipping due to bug in histogram merges fixed in 2025.2.")
     from sklearnex.ensemble import RandomForestRegressor
 
     X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)
@@ -59,19 +74,20 @@ def test_sklearnex_import_rf_regression(dataframe, queue):
     assert "sklearnex" in rf.__module__
     pred = _as_numpy(rf.predict([[0, 0, 0, 0]]))
 
-    if queue is not None and queue.sycl_device.is_gpu:
-        assert_allclose([-0.011208], pred, atol=1e-2)
-    else:
-        if daal_check_version((2024, "P", 0)):
-            assert_allclose([-6.971], pred, atol=1e-2)
-        else:
-            assert_allclose([-6.839], pred, atol=1e-2)
+    # Check that the prediction is within a reasonable range.
+    # 'y' should be in the neighborhood of zero for x=0.
+    assert pred[0] >= -10
+    assert pred[0] <= 10
+
+    # Check that the trees aren't just empty nodes predicting the mean
+    for estimator in rf.estimators_:
+        assert estimator.tree_.children_left.shape[0] > 1
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_classifier(dataframe, queue):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("ET classifier predict for the GPU sycl_queue is buggy.")
+    if (not daal_check_version((2025, "P", 200))) and queue and queue.sycl_device.is_gpu:
+        pytest.skip("Skipping due to bug in histogram merges fixed in 2025.2.")
     from sklearnex.ensemble import ExtraTreesClassifier
 
     X, y = make_classification(
@@ -93,8 +109,8 @@ def test_sklearnex_import_et_classifier(dataframe, queue):
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_regression(dataframe, queue):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("ET regressor predict for the GPU sycl_queue is buggy.")
+    if (not daal_check_version((2025, "P", 200))) and queue and queue.sycl_device.is_gpu:
+        pytest.skip("Skipping due to bug in histogram merges fixed in 2025.2.")
     from sklearnex.ensemble import ExtraTreesRegressor
 
     X, y = make_regression(n_features=1, random_state=0, shuffle=False)
@@ -114,7 +130,11 @@ def test_sklearnex_import_et_regression(dataframe, queue):
         )
     )
 
-    if queue is not None and queue.sycl_device.is_gpu:
-        assert_allclose([1.909769], pred, atol=1e-2)
-    else:
-        assert_allclose([0.445], pred, atol=1e-2)
+    # Check that the prediction is within a reasonable range.
+    # 'y' should be in the neighborhood of zero for x=0.
+    assert pred[0] >= -10
+    assert pred[0] <= 10
+
+    # Check that the trees aren't just empty nodes predicting the mean
+    for estimator in rf.estimators_:
+        assert estimator.tree_.children_left.shape[0] > 1

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

@@ -19,12 +19,12 @@ import warnings
 
 import numpy as np
 from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
-from sklearn.exceptions import NotFittedError
 from sklearn.metrics import r2_score
 from sklearn.utils import check_array, gen_batches
+from sklearn.utils.validation import 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 onedal.linear_model import (
     IncrementalLinearRegression as onedal_IncrementalLinearRegression,
 )
@@ -32,10 +32,15 @@ from onedal.linear_model import (
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 from onedal.common.hyperparameters import get_hyperparameters
 
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import PatchingConditionsChain, register_hyperparameters
+from .._utils import IntelEstimator, PatchingConditionsChain, register_hyperparameters
 
 
 @register_hyperparameters(
@@ -45,9 +50,11 @@ from .._utils import PatchingConditionsChain, register_hyperparameters
     }
 )
 @control_n_jobs(
-    decorated_methods=["fit", "partial_fit", "predict", "_onedal_finalize_fit"]
+    decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
-class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimator):
+class IncrementalLinearRegression(
+    IntelEstimator, MultiOutputMixin, RegressorMixin, BaseEstimator
+):
     """
     Trains a linear regression model, allows for computation if the data are split into
     batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
@@ -56,9 +63,9 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
     Parameters
     ----------
     fit_intercept : bool, default=True
-    Whether to calculate the intercept for this model. If set
-    to False, no intercept will be used in calculations
-    (i.e. data is expected to be centered).
+        Whether to calculate the intercept for this model. If set
+        to False, no intercept will be used in calculations
+        (i.e. data is expected to be centered).
 
     copy_X : bool, default=True
         If True, X will be copied; else, it may be overwritten.
@@ -96,6 +103,13 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Note
+    ----
+    Serializing instances of this class will trigger a forced finalization of calculations.
+    Since finalize_fit can't be dispatched without directly provided queue
+    and the dispatching policy can't be serialized, the computation is finalized
+    during serialization call and the policy is not saved in serialized data.
+
     Examples
     --------
     >>> import numpy as np
@@ -146,7 +160,8 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
             self._validate_params()
 
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[np.float64, np.float32],
                 copy=self.copy_X,
@@ -177,7 +192,8 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
 
         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],
@@ -212,13 +228,21 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         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, queue=None):
         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(queue=queue)
         self._need_to_finalize = False
 
@@ -227,7 +251,8 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
             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],
@@ -250,9 +275,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
 
         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
@@ -281,7 +304,8 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         self._onedal_finalize_fit(queue=queue)
         return self
 
-    def get_intercept_(self):
+    @property
+    def intercept_(self):
         if hasattr(self, "_onedal_estimator"):
             if self._need_to_finalize:
                 self._onedal_finalize_fit()
@@ -292,13 +316,15 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
                 f"'{self.__class__.__name__}' object has no attribute 'intercept_'"
             )
 
-    def set_intercept_(self, value):
+    @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
 
-    def get_coef_(self):
+    @property
+    def coef_(self):
         if hasattr(self, "_onedal_estimator"):
             if self._need_to_finalize:
                 self._onedal_finalize_fit()
@@ -309,15 +335,13 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
                 f"'{self.__class__.__name__}' object has no attribute 'coef_'"
             )
 
-    def set_coef_(self, value):
+    @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
 
-    coef_ = property(get_coef_, set_coef_)
-    intercept_ = property(get_intercept_, set_intercept_)
-
     def partial_fit(self, X, y, check_input=True):
         """
         Incremental fit linear model with X and y. All of X and y is
@@ -405,13 +429,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         C : array, shape (n_samples, n_targets)
             Returns predicted values.
         """
-        if not hasattr(self, "coef_"):
-            msg = (
-                "This %(name)s instance is not fitted yet. Call 'fit' or 'partial_fit' "
-                "with appropriate arguments before using this estimator."
-            )
-            raise NotFittedError(msg % {"name": self.__class__.__name__})
-
+        check_is_fitted(self)
         return dispatch(
             self,
             "predict",
@@ -463,13 +481,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         regressors (except for
         :class:`~sklearn.multioutput.MultiOutputRegressor`).
         """
-        if not hasattr(self, "coef_"):
-            msg = (
-                "This %(name)s instance is not fitted yet. Call 'fit' or 'partial_fit' "
-                "with appropriate arguments before using this estimator."
-            )
-            raise NotFittedError(msg % {"name": self.__class__.__name__})
-
+        check_is_fitted(self)
         return dispatch(
             self,
             "score",