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

{scikit_learn_intelex-2025.0.1.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.0.1.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.0.1.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])
@@ -91,10 +69,11 @@ def test_full_results(queue, num_blocks, dtype):
     if queue and queue.sycl_device.is_gpu:
         tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
     else:
-        tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-5
-    assert_allclose(coef, model.coef_.T, rtol=tol)
+        tol = 3e-3 if model.coef_.dtype == np.float32 else 1e-5
+    atol = 1e-4 if model.coef_.dtype == np.float32 else 1e-6
+    assert_allclose(coef, model.coef_.T, rtol=tol, atol=atol)
 
-    tol = 2e-3 if model.intercept_.dtype == np.float32 else 1e-5
+    tol = 3e-3 if model.intercept_.dtype == np.float32 else 1e-5
     assert_allclose(intercept, model.intercept_, rtol=tol)
 
     Xt = gen.random(size=(num_samples_test, num_features), dtype=dtype)
@@ -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.0.1.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.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_linear_regression.py

@@ -21,6 +21,7 @@ from sklearn.datasets import load_diabetes
 from sklearn.metrics import mean_squared_error
 from sklearn.model_selection import train_test_split
 
+from daal4py.sklearn._utils import daal_check_version
 from onedal.linear_model import LinearRegression
 from onedal.tests.utils._device_selection import get_queues
 
@@ -147,3 +148,112 @@ 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])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    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])
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ y
+        x = model.coef_
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ y
+        x = np.r_[model.coef_, model.intercept_]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < 1e-6)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    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]
+    y = gen.standard_normal(size=X.shape[0])
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ y
+        x = model.coef_
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ y
+        x = np.r_[model.coef_, model.intercept_]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < 1e-6)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.parametrize("problem_type", ["regular", "overdetermined", "singular"])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    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
+        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))
+    elif problem_type == "singular":
+        X = gen.standard_normal(size=(20, 4))
+        X[:, 3] = X[:, 2]
+    else:
+        X = gen.standard_normal(size=(10, 20))
+    Y = gen.standard_normal(size=(X.shape[0], 3), dtype=dtype)
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, Y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ Y
+        x = model.coef_.T
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ Y
+        x = np.r_[model.coef_.T, model.intercept_.reshape((1, -1))]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < 1e-5)
+
+    pred = model.predict(X, queue=queue)
+    expected_pred = X @ model.coef_.T + model.intercept_.reshape((1, -1))
+    tol = 1e-5 if pred.dtype == np.float32 else 1e-7
+    assert_allclose(pred, expected_pred, rtol=tol)
+
+    # check that it also works when 'y' is a list of lists
+    Y_lists = Y.tolist()
+    model_lists = LinearRegression(fit_intercept=fit_intercept).fit(X, Y_lists)
+    assert_allclose(model.coef_, model_lists.coef_)
+    if fit_intercept:
+        assert_allclose(model.intercept_, model_lists.intercept_)