scikit-learn-intelex 2025.1.0__py310-none-win_amd64.whl → 2025.2.0__py310-none-win_amd64.whl

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

@@ -51,7 +51,7 @@ def test_sklearnex_import_rf_classifier(dataframe, queue, block, trees, rows, sc
     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 = rf.get_hyperparameters("infer")
+    hparams = RandomForestClassifier.get_hyperparameters("infer")
     if hparams and block is not None:
         hparams.block_size = block
         hparams.min_trees_for_threading = trees
@@ -63,8 +63,8 @@ def test_sklearnex_import_rf_classifier(dataframe, queue, block, trees, rows, sc
 
 @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)
@@ -74,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(
@@ -108,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)
@@ -129,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.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -24,7 +24,7 @@ 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,
 )
@@ -63,9 +63,9 @@ class IncrementalLinearRegression(
     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.
@@ -103,6 +103,13 @@ class IncrementalLinearRegression(
     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
@@ -221,13 +228,21 @@ class IncrementalLinearRegression(
         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
 
@@ -260,9 +275,7 @@ class IncrementalLinearRegression(
 
         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

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

@@ -96,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)

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

@@ -148,7 +148,7 @@ class LinearRegression(_sklearn_LinearRegression):
             f"sklearn.linear_model.{self.__class__.__name__}.{method_name}"
         )
 
-        if method_name == "fit":
+        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))

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

@@ -48,7 +48,7 @@ if daal_check_version((2024, "P", 1)):
     _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_
@@ -275,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,
@@ -309,12 +309,13 @@ if daal_check_version((2024, "P", 1)):
                     dtype=[np.float64, np.float32],
                 )
 
-            self._initialize_onedal_estimator()
-            if get_config()["allow_sklearn_after_onedal"]:
-                try:
-                    self._onedal_estimator.fit(X, y, queue=queue)
-                    self._save_attributes()
-                except RuntimeError:
+            self._onedal_gpu_initialize_estimator()
+            try:
+                self._onedal_estimator.fit(X, y, queue=queue)
+                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")
@@ -322,9 +323,8 @@ if daal_check_version((2024, "P", 1)):
 
                     del self._onedal_estimator
                     super().fit(X, y)
-            else:
-                self._onedal_estimator.fit(X, y, queue=queue)
-                self._save_attributes()
+                else:
+                    raise err
 
         def _onedal_predict(self, X, queue=None):
             if queue is None or queue.sycl_device.is_cpu: