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/linear_model/tests/test_incremental_linear.py

@@ -24,6 +24,7 @@ from onedal.tests.utils._dataframes_support import (
     get_dataframes_and_queues,
 )
 from sklearnex.linear_model import IncrementalLinearRegression
+from sklearnex.tests.utils import _IS_INTEL
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
@@ -40,7 +41,7 @@ def test_sklearnex_fit_on_gold_data(dataframe, queue, fit_intercept, macro_block
 
     inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
     if macro_block is not None:
-        hparams = inclin.get_hyperparameters("fit")
+        hparams = IncrementalLinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
     inclin.fit(X_df, y_df)
@@ -48,7 +49,7 @@ def test_sklearnex_fit_on_gold_data(dataframe, queue, fit_intercept, macro_block
     y_pred = inclin.predict(X_df)
     np_y_pred = _as_numpy(y_pred)
 
-    tol = 2e-6 if dtype == np.float32 else 1e-7
+    tol = 5e-5 if dtype == np.float32 else 1e-7
     assert_allclose(inclin.coef_, [1], atol=tol)
     if fit_intercept:
         assert_allclose(inclin.intercept_, [0], atol=tol)
@@ -71,7 +72,7 @@ def test_sklearnex_partial_fit_on_gold_data(
 
     inclin = IncrementalLinearRegression()
     if macro_block is not None:
-        hparams = inclin.get_hyperparameters("fit")
+        hparams = IncrementalLinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
     for i in range(2):
@@ -112,7 +113,7 @@ def test_sklearnex_partial_fit_multitarget_on_gold_data(
 
     inclin = IncrementalLinearRegression()
     if macro_block is not None:
-        hparams = inclin.get_hyperparameters("fit")
+        hparams = IncrementalLinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
     for i in range(2):
@@ -129,7 +130,10 @@ def test_sklearnex_partial_fit_multitarget_on_gold_data(
     np_y_pred = _as_numpy(y_pred)
 
     assert inclin.n_features_in_ == 2
-    tol = 7e-6 if dtype == np.float32 else 1e-7
+    tol = 1e-7
+    if dtype == np.float32:
+        tol = 7e-6 if _IS_INTEL else 2e-5
+
     assert_allclose(inclin.coef_, [1.0, 2.0], atol=tol)
     if fit_intercept:
         assert_allclose(inclin.intercept_, 3.0, atol=tol)
@@ -172,7 +176,7 @@ def test_sklearnex_partial_fit_on_random_data(
 
     inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
     if macro_block is not None:
-        hparams = inclin.get_hyperparameters("fit")
+        hparams = IncrementalLinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
     for i in range(num_blocks):
@@ -201,3 +205,63 @@ def test_sklearnex_partial_fit_on_random_data(
     y_pred = inclin.predict(X_test_df)
 
     assert_allclose(expected_y_pred, _as_numpy(y_pred), atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_incremental_estimatior_pickle(dataframe, queue, fit_intercept, dtype):
+    import pickle
+
+    from sklearnex.linear_model import IncrementalLinearRegression
+
+    inclin = IncrementalLinearRegression()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inclin)
+    inclin_loaded = pickle.loads(dump)
+
+    seed = 77
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=1, dtype=dtype)
+    coef = gen.random(size=(1, 10), dtype=dtype).T
+    X = gen.uniform(low=-0.3, high=+0.7, size=(30, 10))
+    X = X.astype(dtype)
+    if fit_intercept:
+        y = X @ coef + intercept[np.newaxis, :]
+    else:
+        y = X @ coef
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+    X_split_df = _convert_to_dataframe(X_split[0], sycl_queue=queue, target_df=dataframe)
+    y_split_df = _convert_to_dataframe(y_split[0], sycl_queue=queue, target_df=dataframe)
+    inclin.partial_fit(X_split_df, y_split_df)
+    inclin_loaded.partial_fit(X_split_df, y_split_df)
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inclin_loaded)
+    inclin_loaded = pickle.loads(dump)
+
+    assert inclin.batch_size == inclin_loaded.batch_size
+    assert inclin.n_features_in_ == inclin_loaded.n_features_in_
+    assert inclin.n_samples_seen_ == inclin_loaded.n_samples_seen_
+    if hasattr(inclin, "_parameter_constraints"):
+        assert inclin._parameter_constraints == inclin_loaded._parameter_constraints
+    assert inclin.n_jobs == inclin_loaded.n_jobs
+
+    X_split_df = _convert_to_dataframe(X_split[1], sycl_queue=queue, target_df=dataframe)
+    y_split_df = _convert_to_dataframe(y_split[1], sycl_queue=queue, target_df=dataframe)
+    inclin.partial_fit(X_split_df, y_split_df)
+    inclin_loaded.partial_fit(X_split_df, y_split_df)
+    dump = pickle.dumps(inclin)
+    inclin_loaded = pickle.loads(dump)
+
+    assert_allclose(inclin.coef_, inclin_loaded.coef_, atol=1e-6)
+    assert_allclose(inclin.intercept_, inclin_loaded.intercept_, atol=1e-6)
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inclin_loaded)
+    inclin_loaded = pickle.loads(dump)
+
+    assert_allclose(inclin.coef_, inclin_loaded.coef_, atol=1e-6)
+    assert_allclose(inclin.intercept_, inclin_loaded.intercept_, atol=1e-6)

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

@@ -151,3 +151,64 @@ if daal_check_version((2024, "P", 600)):
             y_pred_manual += intercept_manual
 
         assert_allclose(_as_numpy(y_pred), y_pred_manual, rtol=1e-6, atol=1e-6)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_incremental_estimatior_pickle(dataframe, queue, fit_intercept, dtype):
+    import pickle
+
+    from sklearnex.linear_model import IncrementalRidge
+
+    inc_ridge = IncrementalRidge()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inc_ridge)
+    inc_ridge_loaded = pickle.loads(dump)
+
+    seed = 77
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=1, dtype=dtype)
+    coef = gen.random(size=(1, 10), dtype=dtype).T
+    X = gen.uniform(low=-0.3, high=+0.7, size=(30, 10))
+    X = X.astype(dtype)
+    if fit_intercept:
+        y = X @ coef + intercept[np.newaxis, :]
+    else:
+        y = X @ coef
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+    X_split_df = _convert_to_dataframe(X_split[0], sycl_queue=queue, target_df=dataframe)
+    y_split_df = _convert_to_dataframe(y_split[0], sycl_queue=queue, target_df=dataframe)
+    inc_ridge.partial_fit(X_split_df, y_split_df)
+    inc_ridge_loaded.partial_fit(X_split_df, y_split_df)
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inc_ridge_loaded)
+    inc_ridge_loaded = pickle.loads(dump)
+
+    assert inc_ridge.batch_size == inc_ridge_loaded.batch_size
+    assert inc_ridge.n_features_in_ == inc_ridge_loaded.n_features_in_
+    assert inc_ridge.n_samples_seen_ == inc_ridge_loaded.n_samples_seen_
+    assert inc_ridge.alpha == inc_ridge_loaded.alpha
+    if hasattr(inc_ridge, "_parameter_constraints"):
+        assert inc_ridge._parameter_constraints == inc_ridge_loaded._parameter_constraints
+    assert inc_ridge.n_jobs == inc_ridge_loaded.n_jobs
+
+    X_split_df = _convert_to_dataframe(X_split[1], sycl_queue=queue, target_df=dataframe)
+    y_split_df = _convert_to_dataframe(y_split[1], sycl_queue=queue, target_df=dataframe)
+    inc_ridge.partial_fit(X_split_df, y_split_df)
+    inc_ridge_loaded.partial_fit(X_split_df, y_split_df)
+    dump = pickle.dumps(inc_ridge)
+    inc_ridge_loaded = pickle.loads(dump)
+
+    assert_allclose(inc_ridge.coef_, inc_ridge_loaded.coef_, atol=1e-6)
+    assert_allclose(inc_ridge.intercept_, inc_ridge_loaded.intercept_, atol=1e-6)
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inc_ridge_loaded)
+    inc_ridge_loaded = pickle.loads(dump)
+
+    assert_allclose(inc_ridge.coef_, inc_ridge_loaded.coef_, atol=1e-6)
+    assert_allclose(inc_ridge.intercept_, inc_ridge_loaded.intercept_, atol=1e-6)

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

@@ -17,62 +17,74 @@
 import numpy as np
 import pytest
 from numpy.testing import assert_allclose
+from scipy.linalg import lstsq
 from sklearn.datasets import make_regression
 
 from daal4py.sklearn._utils import daal_check_version
-from daal4py.sklearn.linear_model.tests.test_ridge import (
-    _test_multivariate_ridge_alpha_shape,
-    _test_multivariate_ridge_coefficients,
-)
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
+from sklearnex.tests.utils import _IS_INTEL
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("macro_block", [None, 1024])
-def test_sklearnex_import_linear(dataframe, queue, dtype, macro_block):
+@pytest.mark.parametrize("overdetermined", [False, True])
+@pytest.mark.parametrize("multi_output", [False, True])
+def test_sklearnex_import_linear(
+    dataframe, queue, dtype, macro_block, overdetermined, multi_output
+):
+    if (not overdetermined or multi_output) and not daal_check_version((2025, "P", 1)):
+        pytest.skip("Functionality introduced in later versions")
+    if (
+        not overdetermined
+        and queue
+        and queue.sycl_device.is_gpu
+        and not daal_check_version((2025, "P", 200))
+    ):
+        pytest.skip("Functionality introduced in later versions")
+
     from sklearnex.linear_model import LinearRegression
 
-    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
-    y = np.dot(X, np.array([1, 2])) + 3
-    X = X.astype(dtype=dtype)
-    y = y.astype(dtype=dtype)
-    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    rng = np.random.default_rng(seed=123)
+    X = rng.standard_normal(size=(10, 20) if not overdetermined else (20, 5))
+    y = rng.standard_normal(size=(X.shape[0], 3) if multi_output else X.shape[0])
+
+    Xi = np.c_[X, np.ones((X.shape[0], 1))]
+    expected_coefs = lstsq(Xi, y)[0]
+    expected_intercept = expected_coefs[-1]
+    expected_coefs = expected_coefs[: X.shape[1]]
+    if multi_output:
+        expected_coefs = expected_coefs.T
 
     linreg = LinearRegression()
     if daal_check_version((2024, "P", 0)) and macro_block is not None:
-        hparams = linreg.get_hyperparameters("fit")
+        hparams = LinearRegression.get_hyperparameters("fit")
         hparams.cpu_macro_block = macro_block
         hparams.gpu_macro_block = macro_block
 
+    X = X.astype(dtype=dtype)
+    y = y.astype(dtype=dtype)
+    y_list = y.tolist()
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
     linreg.fit(X, y)
 
     assert hasattr(linreg, "_onedal_estimator")
     assert "sklearnex" in linreg.__module__
-    assert linreg.n_features_in_ == 2
 
-    tol = 1e-5 if _as_numpy(linreg.coef_).dtype == np.float32 else 1e-7
-    assert_allclose(_as_numpy(linreg.intercept_), 3.0, rtol=tol)
-    assert_allclose(_as_numpy(linreg.coef_), [1.0, 2.0], rtol=tol)
+    rtol = 1e-3 if dtype == np.float32 else 1e-5
+    assert_allclose(_as_numpy(linreg.coef_), expected_coefs, rtol=rtol)
+    assert_allclose(_as_numpy(linreg.intercept_), expected_intercept, rtol=rtol)
 
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import_ridge(dataframe, queue):
-    from sklearnex.linear_model import Ridge
-
-    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
-    y = np.dot(X, np.array([1, 2])) + 3
-    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
-    ridgereg = Ridge().fit(X, y)
-    assert "daal4py" in ridgereg.__module__
-    assert_allclose(ridgereg.intercept_, 4.5)
-    assert_allclose(ridgereg.coef_, [0.8, 1.4])
+    # check that it also works with lists
+    if isinstance(X, np.ndarray):
+        linreg_list = LinearRegression().fit(X, y_list)
+        assert_allclose(linreg_list.coef_, linreg.coef_)
+        assert_allclose(linreg_list.intercept_, linreg.intercept_)
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
@@ -128,15 +140,3 @@ def test_sklearnex_reconstruct_model(dataframe, queue, dtype):
 
     tol = 1e-5 if _as_numpy(y_pred).dtype == np.float32 else 1e-7
     assert_allclose(gtr, _as_numpy(y_pred), rtol=tol)
-
-
-def test_sklearnex_multivariate_ridge_coefs():
-    from sklearnex.linear_model import Ridge
-
-    _test_multivariate_ridge_coefficients(Ridge, random_state=0)
-
-
-def test_sklearnex_multivariate_ridge_alpha_shape():
-    from sklearnex.linear_model import Ridge
-
-    _test_multivariate_ridge_alpha_shape(Ridge, random_state=0)

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/sklearnex/linear_model/tests/test_ridge.py

@@ -0,0 +1,256 @@
+# ===============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from sklearn.exceptions import NotFittedError
+
+from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn.linear_model.tests.test_ridge import (
+    _test_multivariate_ridge_alpha_shape,
+    _test_multivariate_ridge_coefficients,
+)
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+
+
+def _compute_ridge_coefficients(X, y, alpha, fit_intercept):
+    """
+    Computes Ridge regression coefficients for single or multiple target variables.
+
+    Parameters:
+    X : array-like of shape (n_samples, n_features)
+        Training data.
+    y : array-like of shape (n_samples,) or (n_samples, n_targets)
+        Target values.
+    alpha : float
+        Regularization strength.
+    fit_intercept : bool
+        Whether to calculate the intercept for this model.
+
+    Returns:
+    coeffs : ndarray of shape (n_features, n_targets)
+        Estimated coefficients for each target variable.
+    intercept : ndarray of shape (n_targets,)
+        Intercept terms for each target variable.
+    """
+    n_samples, n_features = X.shape
+    X_copy = X.copy()
+    y = np.asarray(y)
+
+    # making single-target y also multi-dim array for consistency
+    if y.ndim == 1:
+        y = y[:, np.newaxis]
+    n_targets = y.shape[1]
+
+    if fit_intercept:
+        # adding column of ones to X for the intercept term
+        X_copy = np.hstack([np.ones((n_samples, 1)), X])
+        identity_matrix = np.diag([0] + [1] * n_features)
+    else:
+        identity_matrix = np.eye(n_features)
+
+    # normal equation: (X^T * X + alpha * I) * w = X^T * y
+    A = X_copy.T @ X_copy + alpha * identity_matrix
+    b = X_copy.T @ y
+    coeffs = np.linalg.solve(A, b)
+
+    if fit_intercept:
+        intercept = coeffs[0, :]  # Shape (n_targets,)
+        coeffs = coeffs[1:, :]  # Shape (n_features, n_targets)
+    else:
+        intercept = np.zeros((n_targets,))  # Shape (n_targets,)
+
+    # in case of single target, flattening both coefficients and intercept
+    if n_targets == 1:
+        coeffs = coeffs.flatten()
+        intercept = intercept[0]
+    else:
+        coeffs = coeffs.T
+
+    return coeffs, intercept
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_ridge(dataframe, queue):
+    from sklearnex.linear_model import Ridge
+
+    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
+    y = np.dot(X, np.array([1, 2])) + 3
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    ridge_reg = Ridge(alpha=0.5).fit(X_c, y_c)
+
+    if daal_check_version((2024, "P", 600)):
+        assert (
+            "sklearnex" in ridge_reg.__module__ and "preview" not in ridge_reg.__module__
+        )
+    else:
+        assert "daal4py" in ridge_reg.__module__
+
+    assert_allclose(ridge_reg.intercept_, 3.86, rtol=1e-2)
+    assert_allclose(ridge_reg.coef_, [0.91, 1.64], rtol=1e-2)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("sample_size", [100, 1000])
+@pytest.mark.parametrize("feature_size", [10, 50])
+@pytest.mark.parametrize("alpha", [0.1, 0.5, 1.0])
+@pytest.mark.parametrize("fit_intercept", [True, False])
+def test_ridge_coefficients(
+    dataframe, queue, sample_size, feature_size, alpha, fit_intercept
+):
+    from sklearnex.linear_model import Ridge
+
+    X = np.random.rand(sample_size, feature_size)
+    y = np.random.rand(sample_size)
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    ridge_reg = Ridge(fit_intercept=fit_intercept, alpha=alpha).fit(X_c, y_c)
+
+    coefficients_manual, intercept_manual = _compute_ridge_coefficients(
+        X, y, alpha, fit_intercept=fit_intercept
+    )
+
+    assert_allclose(ridge_reg.coef_, coefficients_manual, rtol=1e-6, atol=1e-6)
+    assert_allclose(ridge_reg.intercept_, intercept_manual, rtol=1e-6, atol=1e-6)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 600)), reason="requires onedal 2024.6.0 or higher"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_ridge_score_before_fit(dataframe, queue):
+    from sklearnex.linear_model import Ridge
+
+    sample_count, feature_count = 10, 5
+
+    model = Ridge(fit_intercept=True, alpha=0.5)
+
+    X, y = np.random.rand(sample_count, feature_count), np.random.rand(sample_count)
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+
+    with pytest.raises(NotFittedError):
+        model.score(X_c, y_c)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 600)), reason="requires onedal 2024.6.0 or higher"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_ridge_predict_before_fit(dataframe, queue):
+    from sklearnex.linear_model import Ridge
+
+    sample_count, feature_count = 10, 5
+
+    model = Ridge(fit_intercept=True, alpha=0.5)
+
+    X = np.random.rand(sample_count, feature_count)
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    with pytest.raises(NotFittedError):
+        model.predict(X_c)
+
+
+@pytest.mark.skip(reason="Forced to use original sklearn for now.")
+def test_sklearnex_multivariate_ridge_coefs():
+    from sklearnex.linear_model import Ridge
+
+    _test_multivariate_ridge_coefficients(Ridge, random_state=0)
+
+
+@pytest.mark.skip(reason="Forced to use original sklearn for now.")
+def test_sklearnex_multivariate_ridge_alpha_shape():
+    from sklearnex.linear_model import Ridge
+
+    _test_multivariate_ridge_alpha_shape(Ridge, random_state=0)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 100)), reason="requires onedal 2025.1.0 or higher"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("overdetermined", [True, False])
+@pytest.mark.parametrize("alpha", [0.00001, 0.1, 1.0])
+@pytest.mark.parametrize("fit_intercept", [True, False])
+def test_ridge_overdetermined_system(
+    dataframe, queue, overdetermined, alpha, fit_intercept
+):
+    from sklearnex.linear_model import Ridge
+
+    if overdetermined:
+        X = np.random.rand(100, 10)
+        y = np.random.rand(100)
+    else:
+        X = np.random.rand(10, 100)
+        y = np.random.rand(10)
+
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    ridge_reg = Ridge(alpha=alpha, fit_intercept=fit_intercept).fit(X_c, y_c)
+
+    coefficients_manual, intercept_manual = _compute_ridge_coefficients(
+        X, y, alpha, fit_intercept=fit_intercept
+    )
+
+    assert_allclose(ridge_reg.coef_, coefficients_manual, rtol=1e-6, atol=1e-6)
+    assert_allclose(ridge_reg.intercept_, intercept_manual, rtol=1e-6, atol=1e-6)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("alpha", [0.1, 0.5, 1.0])
+def test_multivariate_ridge_scalar_alpha(dataframe, queue, fit_intercept, alpha):
+    from sklearn.datasets import make_regression
+
+    from sklearnex.linear_model import Ridge
+
+    X, y = make_regression(n_samples=10, n_features=3, n_targets=3, random_state=0)
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    ridge = Ridge(alpha=alpha, fit_intercept=fit_intercept)
+    ridge.fit(X_c, y_c)
+
+    coef_manual, intercept = _compute_ridge_coefficients(X, y, alpha, fit_intercept)
+    assert_allclose(ridge.coef_, coef_manual, rtol=1e-6, atol=1e-6)
+    assert_allclose(ridge.intercept_, intercept, rtol=1e-6, atol=1e-6)
+
+    predictions = _as_numpy(ridge.predict(X_c))
+    predictions_manual = X @ coef_manual.T + intercept
+    assert_allclose(predictions, predictions_manual, rtol=1e-6, atol=1e-6)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_underdetermined_positive_alpha_ridge(dataframe, queue):
+    from sklearn.datasets import make_regression
+
+    from sklearnex.linear_model import Ridge
+
+    X, y = make_regression(n_samples=5, n_features=6, n_targets=1, random_state=0)
+    alpha = 1.0
+    X_c = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_c = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    ridge = Ridge(alpha=alpha, fit_intercept=True).fit(X_c, y_c)
+
+    coef_manual, intercept = _compute_ridge_coefficients(X, y, alpha, fit_intercept=True)
+
+    assert_allclose(ridge.coef_, coef_manual, rtol=1e-6, atol=1e-6)
+    assert_allclose(ridge.intercept_, intercept, rtol=1e-6, atol=1e-6)