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

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -19,7 +19,7 @@ import numpy as np
 from daal4py.sklearn._utils import get_dtype
 
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_X_y, _num_features
 from .linear_model import BaseLinearRegression
 
@@ -47,10 +47,22 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self._reset()
 
     def _reset(self):
+        self._need_to_finalize = False
         self._partial_result = self._get_backend(
             "linear_model", "regression", "partial_train_result"
         )
 
+    def __getstate__(self):
+        # Since finalize_fit can't be dispatched without directly provided queue
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
+
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for linear regression
@@ -77,20 +89,19 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self._queue = queue
         policy = self._get_policy(queue, X)
 
-        X, y = _convert_to_supported(policy, X, y)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(self._dtype)
-
-        y = np.asarray(y, dtype=self._dtype)
-
         X, y = _check_X_y(
             X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
         )
+        y = np.asarray(y, dtype=X.dtype)
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
-        X_table, y_table = to_table(X, y)
+
+        X_table, y_table = to_table(X, y, queue=queue)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = X_table.dtype
+            self._params = self._get_onedal_params(self._dtype)
+
         hparams = get_hyperparameters("linear_regression", "train")
         if hparams is not None and not hparams.is_default:
             self._partial_result = module.partial_train(
@@ -106,6 +117,9 @@ class IncrementalLinearRegression(BaseLinearRegression):
                 policy, self._params, self._partial_result, X_table, y_table
             )
 
+        self._need_to_finalize = True
+        return self
+
     def finalize_fit(self, queue=None):
         """
         Finalizes linear regression computation and obtains coefficients
@@ -122,27 +136,30 @@ class IncrementalLinearRegression(BaseLinearRegression):
             Returns the instance itself.
         """
 
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-
-        module = self._get_backend("linear_model", "regression")
-        hparams = get_hyperparameters("linear_regression", "train")
-        if hparams is not None and not hparams.is_default:
-            result = module.finalize_train(
-                policy, self._params, hparams.backend, self._partial_result
+        if self._need_to_finalize:
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+
+            module = self._get_backend("linear_model", "regression")
+            hparams = get_hyperparameters("linear_regression", "train")
+            if hparams is not None and not hparams.is_default:
+                result = module.finalize_train(
+                    policy, self._params, hparams.backend, self._partial_result
+                )
+            else:
+                result = module.finalize_train(policy, self._params, self._partial_result)
+
+            self._onedal_model = result.model
+
+            packed_coefficients = from_table(result.model.packed_coefficients)
+            self.coef_, self.intercept_ = (
+                packed_coefficients[:, 1:].squeeze(),
+                packed_coefficients[:, 0].squeeze(),
             )
-        else:
-            result = module.finalize_train(policy, self._params, self._partial_result)
 
-        self._onedal_model = result.model
-
-        packed_coefficients = from_table(result.model.packed_coefficients)
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:].squeeze(),
-            packed_coefficients[:, 0].squeeze(),
-        )
+            self._need_to_finalize = False
 
         return self
 
@@ -171,15 +188,26 @@ class IncrementalRidge(BaseLinearRegression):
     """
 
     def __init__(self, alpha=1.0, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
-        module = self._get_backend("linear_model", "regression")
         super().__init__(
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
         )
-        self._partial_result = module.partial_train_result()
+        self._reset()
 
     def _reset(self):
         module = self._get_backend("linear_model", "regression")
         self._partial_result = module.partial_train_result()
+        self._need_to_finalize = False
+
+    def __getstate__(self):
+        # Since finalize_fit can't be dispatched without directly provided queue
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
 
     def partial_fit(self, X, y, queue=None):
         """
@@ -207,24 +235,26 @@ class IncrementalRidge(BaseLinearRegression):
         self._queue = queue
         policy = self._get_policy(queue, X)
 
-        X, y = _convert_to_supported(policy, X, y)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(self._dtype)
-
-        y = np.asarray(y, dtype=self._dtype)
-
         X, y = _check_X_y(
             X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
         )
+        y = np.asarray(y, dtype=X.dtype)
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
-        X_table, y_table = to_table(X, y)
+
+        X_table, y_table = to_table(X, y, queue=queue)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = X_table.dtype
+            self._params = self._get_onedal_params(self._dtype)
+
         self._partial_result = module.partial_train(
             policy, self._params, self._partial_result, X_table, y_table
         )
 
+        self._need_to_finalize = True
+        return self
+
     def finalize_fit(self, queue=None):
         """
         Finalizes ridge regression computation and obtains coefficients
@@ -240,19 +270,23 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-        result = module.finalize_train(policy, self._params, self._partial_result)
 
-        self._onedal_model = result.model
+        if self._need_to_finalize:
+            module = self._get_backend("linear_model", "regression")
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+            result = module.finalize_train(policy, self._params, self._partial_result)
 
-        packed_coefficients = from_table(result.model.packed_coefficients)
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:].squeeze(),
-            packed_coefficients[:, 0].squeeze(),
-        )
+            self._onedal_model = result.model
+
+            packed_coefficients = from_table(result.model.packed_coefficients)
+            self.coef_, self.intercept_ = (
+                packed_coefficients[:, 1:].squeeze(),
+                packed_coefficients[:, 0].squeeze(),
+            )
+
+            self._need_to_finalize = False
 
         return self

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

@@ -24,7 +24,7 @@ from daal4py.sklearn._utils import daal_check_version, get_dtype, make2d
 from ..common._base import BaseEstimator
 from ..common._estimator_checks import _check_is_fitted
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array, _check_n_features, _check_X_y, _num_features
 
 
@@ -43,7 +43,7 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
     def _get_onedal_params(self, dtype=np.float32):
         intercept = "intercept|" if self.fit_intercept else ""
         params = {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "method": self.algorithm,
             "intercept": self.fit_intercept,
             "result_option": (intercept + "coefficients"),
@@ -91,9 +91,9 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
         if self.fit_intercept:
             packed_coefficients[:, 0][:, np.newaxis] = intercept
 
-        packed_coefficients = _convert_to_supported(policy, packed_coefficients)
-
-        model.packed_coefficients = to_table(packed_coefficients)
+        model.packed_coefficients = to_table(
+            packed_coefficients, queue=getattr(policy, "_queue", None)
+        )
 
         self._onedal_model = model
 
@@ -131,11 +131,9 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
         else:
             model = self._create_model(policy)
 
-        X = make2d(X)
-        X = _convert_to_supported(policy, X)
-        params = self._get_onedal_params(get_dtype(X))
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table.dtype)
 
-        X_table = to_table(X)
         result = module.infer(policy, params, model, X_table)
         y = from_table(result.responses)
 
@@ -211,9 +209,8 @@ class LinearRegression(BaseLinearRegression):
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(get_dtype(X))
-        X_table, y_table = to_table(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        params = self._get_onedal_params(X_table.dtype)
 
         hparams = get_hyperparameters("linear_regression", "train")
         if hparams is not None and not hparams.is_default:
@@ -293,15 +290,15 @@ class Ridge(BaseLinearRegression):
         """
         module = self._get_backend("linear_model", "regression")
 
-        X = _check_array(
-            X,
-            dtype=[np.float64, np.float32],
-            force_all_finite=False,
-            ensure_2d=False,
-            copy=self.copy_X,
-        )
+        if not isinstance(X, np.ndarray):
+            X = np.asarray(X)
 
-        y = np.asarray(y).astype(dtype=get_dtype(X))
+        dtype = get_dtype(X)
+        if dtype not in [np.float32, np.float64]:
+            dtype = np.float64
+            X = X.astype(dtype, copy=self.copy_X)
+
+        y = np.asarray(y).astype(dtype=dtype)
 
         X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
 
@@ -309,9 +306,8 @@ class Ridge(BaseLinearRegression):
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(get_dtype(X))
-        X_table, y_table = to_table(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        params = self._get_onedal_params(X.dtype)
 
         result = module.train(policy, params, X_table, y_table)
         self._onedal_model = result.model

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

@@ -24,7 +24,7 @@ from daal4py.sklearn._utils import daal_check_version, get_dtype, make2d
 from ..common._base import BaseEstimator as onedal_BaseEstimator
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import (
     _check_array,
     _check_n_features,
@@ -48,7 +48,7 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
     def _get_onedal_params(self, is_csr, dtype=np.float32):
         intercept = "intercept|" if self.fit_intercept else ""
         return {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "method": "sparse" if is_csr else self.algorithm,
             "intercept": self.fit_intercept,
             "tol": self.tol,
@@ -83,9 +83,8 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
         y = y.astype(dtype=np.int32)
 
         policy = self._get_policy(queue, X, y)
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(is_csr, get_dtype(X))
-        X_table, y_table = to_table(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        params = self._get_onedal_params(is_csr, X_table.dtype)
 
         result = module.train(policy, params, X_table, y_table)
 
@@ -144,9 +143,9 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
         if self.fit_intercept:
             packed_coefficients[:, 0][:, np.newaxis] = intercept
 
-        packed_coefficients = _convert_to_supported(policy, packed_coefficients)
-
-        m.packed_coefficients = to_table(packed_coefficients)
+        m.packed_coefficients = to_table(
+            packed_coefficients, queue=getattr(policy, "_queue", None)
+        )
 
         self._onedal_model = m
 
@@ -175,10 +174,9 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
         else:
             model = self._create_model(module, policy)
 
-        X = _convert_to_supported(policy, X)
-        params = self._get_onedal_params(is_csr, get_dtype(X))
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(is_csr, X.dtype)
 
-        X_table = to_table(X)
         result = module.infer(policy, params, model, X_table)
         return result
 

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_incremental_linear_regression.py

@@ -16,11 +16,12 @@
 
 import numpy as np
 import pytest
-from numpy.testing import assert_allclose, assert_array_equal
+from numpy.testing import assert_allclose
 from sklearn.datasets import load_diabetes
 from sklearn.metrics import mean_squared_error
 from sklearn.model_selection import train_test_split
 
+from onedal.datatypes import from_table
 from onedal.linear_model import IncrementalLinearRegression
 from onedal.tests.utils._device_selection import get_queues
 
@@ -43,29 +44,6 @@ def test_diabetes(queue, dtype):
     assert mean_squared_error(y_test, y_pred) < 2396
 
 
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-@pytest.mark.skip(reason="pickling not implemented for oneDAL entities")
-def test_pickle(queue, dtype):
-    # TODO Implement pickling for oneDAL entities
-    X, y = load_diabetes(return_X_y=True)
-    X, y = X.astype(dtype), y.astype(dtype)
-    model = IncrementalLinearRegression(fit_intercept=True)
-    model.partial_fit(X, y, queue=queue)
-    model.finalize_fit()
-    expected = model.predict(X, queue=queue)
-
-    import pickle
-
-    dump = pickle.dumps(model)
-    model2 = pickle.loads(dump)
-
-    assert isinstance(model2, model.__class__)
-    result = model2.predict(X, queue=queue)
-
-    assert_array_equal(expected, result)
-
-
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("num_blocks", [1, 2, 10])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
@@ -92,7 +70,8 @@ def test_full_results(queue, num_blocks, dtype):
         tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
     else:
         tol = 3e-3 if model.coef_.dtype == np.float32 else 1e-5
-    assert_allclose(coef, model.coef_.T, rtol=tol)
+    atol = 1e-4 if model.coef_.dtype == np.float32 else 1e-6
+    assert_allclose(coef, model.coef_.T, rtol=tol, atol=atol)
 
     tol = 3e-3 if model.intercept_.dtype == np.float32 else 1e-5
     assert_allclose(intercept, model.intercept_, rtol=tol)
@@ -166,3 +145,69 @@ def test_reconstruct_model(queue, dtype):
 
     tol = 1e-5 if res.dtype == np.float32 else 1e-7
     assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.linear_model import IncrementalLinearRegression
+
+    inclr = IncrementalLinearRegression()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inclr)
+    inclr_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    coef = gen.random(size=(1, 10), dtype=dtype).T
+    y = X @ coef
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+    inclr.partial_fit(X_split[0], y_split[0], queue=queue)
+    inclr_loaded.partial_fit(X_split[0], y_split[0], queue=queue)
+
+    # inclr.finalize_fit()
+
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inclr)
+    inclr_loaded = pickle.loads(dump)
+
+    partial_xtx = from_table(inclr._partial_result.partial_xtx)
+    partial_xtx_loaded = from_table(inclr_loaded._partial_result.partial_xtx)
+    assert_allclose(partial_xtx, partial_xtx_loaded)
+
+    partial_xty = from_table(inclr._partial_result.partial_xty)
+    partial_xty_loaded = from_table(inclr_loaded._partial_result.partial_xty)
+    assert_allclose(partial_xty, partial_xty_loaded)
+
+    assert inclr._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert inclr_loaded._need_to_finalize == False
+
+    inclr.partial_fit(X_split[1], y_split[1], queue=queue)
+    inclr_loaded.partial_fit(X_split[1], y_split[1], queue=queue)
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(inclr_loaded)
+    inclr_loaded = pickle.loads(dump)
+
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == False
+
+    inclr.finalize_fit()
+    inclr_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inclr_loaded)
+    inclr_loaded = pickle.loads(dump)
+
+    assert_allclose(inclr.coef_, inclr_loaded.coef_, atol=1e-6)
+    assert_allclose(inclr.intercept_, inclr_loaded.intercept_, atol=1e-6)

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_incremental_ridge_regression.py

@@ -24,6 +24,7 @@ if daal_check_version((2024, "P", 600)):
     from sklearn.metrics import mean_squared_error
     from sklearn.model_selection import train_test_split
 
+    from onedal.datatypes import from_table
     from onedal.linear_model import IncrementalRidge
     from onedal.tests.utils._device_selection import get_queues
 
@@ -105,3 +106,66 @@ if daal_check_version((2024, "P", 600)):
 
         tol = 2e-4 if res.dtype == np.float32 else 1e-7
         assert_allclose(gtr, res, rtol=tol)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_incremental_estimator_pickle(queue, dtype):
+        import pickle
+
+        model = IncrementalRidge()
+
+        # Check that estimator can be serialized without any data.
+        dump = pickle.dumps(model)
+        model_loaded = pickle.loads(dump)
+        seed = 77
+        gen = np.random.default_rng(seed)
+        X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+        X = X.astype(dtype)
+        coef = gen.random(size=(1, 10), dtype=dtype).T
+        y = X @ coef
+        X_split = np.array_split(X, 2)
+        y_split = np.array_split(y, 2)
+        model.partial_fit(X_split[0], y_split[0], queue=queue)
+        model_loaded.partial_fit(X_split[0], y_split[0], queue=queue)
+
+        # model.finalize_fit()
+
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == True
+
+        # Check that estimator can be serialized after partial_fit call.
+        dump = pickle.dumps(model)
+        model_loaded = pickle.loads(dump)
+
+        partial_xtx = from_table(model._partial_result.partial_xtx)
+        partial_xtx_loaded = from_table(model_loaded._partial_result.partial_xtx)
+        assert_allclose(partial_xtx, partial_xtx_loaded)
+
+        partial_xty = from_table(model._partial_result.partial_xty)
+        partial_xty_loaded = from_table(model_loaded._partial_result.partial_xty)
+        assert_allclose(partial_xty, partial_xty_loaded)
+
+        assert model._need_to_finalize == False
+        # Finalize is called during serialization to make sure partial results are finalized correctly.
+        assert model_loaded._need_to_finalize == False
+
+        model.partial_fit(X_split[1], y_split[1], queue=queue)
+        model_loaded.partial_fit(X_split[1], y_split[1], queue=queue)
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == True
+
+        dump = pickle.dumps(model_loaded)
+        model_loaded = pickle.loads(dump)
+
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == False
+
+        model.finalize_fit()
+        model_loaded.finalize_fit()
+
+        # Check that finalized estimator can be serialized.
+        dump = pickle.dumps(model_loaded)
+        model_loaded = pickle.loads(dump)
+
+        assert_allclose(model.coef_, model_loaded.coef_, atol=1e-6)
+        assert_allclose(model.intercept_, model_loaded.intercept_, atol=1e-6)

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_linear_regression.py

@@ -150,7 +150,7 @@ def test_reconstruct_model(queue, dtype):
     assert_allclose(gtr, res, rtol=tol)
 
 
-@pytest.mark.parametrize("queue", get_queues("cpu"))
+@pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("fit_intercept", [False, True])
 @pytest.mark.skipif(
@@ -158,6 +158,8 @@ def test_reconstruct_model(queue, dtype):
     reason="Functionality introduced in later versions",
 )
 def test_overdetermined_system(queue, dtype, fit_intercept):
+    if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
+        pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
     X = gen.standard_normal(size=(10, 20))
     y = gen.standard_normal(size=X.shape[0])
@@ -176,7 +178,7 @@ def test_overdetermined_system(queue, dtype, fit_intercept):
     assert np.all(np.abs(residual) < 1e-6)
 
 
-@pytest.mark.parametrize("queue", get_queues("cpu"))
+@pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("fit_intercept", [False, True])
 @pytest.mark.skipif(
@@ -184,6 +186,8 @@ def test_overdetermined_system(queue, dtype, fit_intercept):
     reason="Functionality introduced in later versions",
 )
 def test_singular_matrix(queue, dtype, fit_intercept):
+    if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
+        pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
     X = gen.standard_normal(size=(20, 4))
     X[:, 2] = X[:, 3]
@@ -212,8 +216,13 @@ def test_singular_matrix(queue, dtype, fit_intercept):
     reason="Functionality introduced in the versions >= 2025.0",
 )
 def test_multioutput_regression(queue, dtype, fit_intercept, problem_type):
-    if problem_type != "regular" and queue and queue.sycl_device.is_gpu:
-        pytest.skip("Not yet implemented on GPU")
+    if (
+        problem_type != "regular"
+        and queue
+        and queue.sycl_device.is_gpu
+        and not daal_check_version((2025, "P", 200))
+    ):
+        pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
     if problem_type == "regular":
         X = gen.standard_normal(size=(20, 5))