scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/linear_model/tests/test_enet.py

@@ -0,0 +1,157 @@
+# ==============================================================================
+# Copyright contributors to the oneDAL project
+#
+# 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 warnings
+
+import numpy as np
+import pytest
+from sklearn.datasets import make_regression
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.linear_model import ElasticNet as _sklElasticnet
+from sklearn.linear_model import Lasso as _sklLasso
+
+from daal4py.sklearn.linear_model import ElasticNet, Lasso
+
+
+def fn_lasso(model, X, y, lambda_):
+    resid = y - model.predict(X)
+    fn_ssq = resid.reshape(-1) @ resid.reshape(-1)
+    fn_l1 = np.abs(model.coef_).sum()
+    return (1 / (2 * X.shape[0])) * fn_ssq + lambda_ * fn_l1
+
+
+@pytest.mark.parametrize("nrows", [10, 20])
+@pytest.mark.parametrize("ncols", [10, 20])
+@pytest.mark.parametrize("n_targets", [1, 2])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.parametrize("positive", [False, True])
+@pytest.mark.parametrize("l1_ratio", [0.0, 1.0, 0.5])
+def test_enet_is_correct(nrows, ncols, n_targets, fit_intercept, positive, l1_ratio):
+    X, y = make_regression(
+        n_samples=nrows, n_features=ncols, n_targets=n_targets, random_state=123
+    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", ConvergenceWarning)
+        model_d4p = ElasticNet(
+            fit_intercept=fit_intercept,
+            positive=positive,
+            l1_ratio=l1_ratio,
+            tol=1e-7,
+            max_iter=int(1e4),
+        ).fit(X, y)
+        model_skl = _sklElasticnet(
+            fit_intercept=fit_intercept,
+            positive=positive,
+            l1_ratio=l1_ratio,
+            tol=1e-7,
+            max_iter=int(1e4),
+        ).fit(X, y)
+
+    # Note: lasso is not guaranteed to have a unique global optimum.
+    # If the coefficients do not match, this makes another check on
+    # the optimality of the function values instead. It checks that
+    # the result from daal4py is no worse than scikit-learn's.
+
+    tol = 1e-6 if n_targets == 1 else 1e-5
+    try:
+        np.testing.assert_allclose(model_d4p.coef_, model_skl.coef_, atol=tol, rtol=tol)
+    except AssertionError as e:
+        if l1_ratio != 1:
+            raise e
+        fn_d4p = fn_lasso(model_d4p, X, y, model_d4p.alpha)
+        fn_skl = fn_lasso(model_skl, X, y, model_skl.alpha)
+        assert fn_d4p <= fn_skl
+
+    if fit_intercept:
+        np.testing.assert_allclose(
+            model_d4p.intercept_, model_skl.intercept_, atol=tol, rtol=tol
+        )
+
+    if positive:
+        assert np.all(model_d4p.coef_ >= 0)
+
+
+@pytest.mark.parametrize("nrows", [10, 20])
+@pytest.mark.parametrize("ncols", [10, 20])
+@pytest.mark.parametrize("n_targets", [1, 2])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.parametrize("positive", [False, True])
+@pytest.mark.parametrize("alpha", [1e-2, 1e2])
+def test_lasso_is_correct(nrows, ncols, n_targets, fit_intercept, positive, alpha):
+    X, y = make_regression(
+        n_samples=nrows, n_features=ncols, n_targets=n_targets, random_state=123
+    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", ConvergenceWarning)
+        model_d4p = Lasso(
+            fit_intercept=fit_intercept,
+            positive=positive,
+            alpha=alpha,
+            tol=1e-7,
+            max_iter=int(1e4),
+        ).fit(X, y)
+        model_skl = _sklLasso(
+            fit_intercept=fit_intercept,
+            positive=positive,
+            alpha=alpha,
+            tol=1e-7,
+            max_iter=int(1e4),
+        ).fit(X, y)
+
+    tol = 1e-4 if alpha < 1 else (1e-6 if n_targets == 1 else 1e-5)
+    try:
+        np.testing.assert_allclose(model_d4p.coef_, model_skl.coef_, atol=tol, rtol=tol)
+        if fit_intercept:
+            np.testing.assert_allclose(
+                model_d4p.intercept_, model_skl.intercept_, atol=tol, rtol=tol
+            )
+    except AssertionError as e:
+        fn_d4p = fn_lasso(model_d4p, X, y, model_d4p.alpha)
+        fn_skl = fn_lasso(model_skl, X, y, model_skl.alpha)
+        assert fn_d4p <= fn_skl
+
+    if positive:
+        assert np.all(model_d4p.coef_ >= 0)
+
+
+@pytest.mark.parametrize("n_targets", [1, 2])
+def test_warm_start(n_targets):
+    X, y = make_regression(
+        n_samples=20, n_features=10, n_targets=n_targets, random_state=123
+    )
+    X1 = X[:10]
+    y1 = y[:10]
+    X2 = X[10:]
+    y2 = y[10:]
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", ConvergenceWarning)
+        model_d4p = ElasticNet(
+            warm_start=True,
+            tol=1e-7,
+            max_iter=int(1e4),
+        ).fit(X1, y1)
+        coefs_ref = model_d4p.coef_.copy()
+        intercept_ref = model_d4p.intercept_.copy()
+
+        model_d4p.set_params(max_iter=1)
+        model_d4p.fit(X2, y2)
+
+        model_from_scratch = ElasticNet(tol=1e-7, max_iter=int(1e4)).fit(X2, y2)
+
+    diff_ref = np.linalg.norm(model_d4p.coef_ - coefs_ref)
+    diff_from_scratch = np.linalg.norm(model_d4p.coef_ - model_from_scratch.coef_)
+
+    assert diff_ref < diff_from_scratch

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/linear_model/tests/test_linear.py

@@ -0,0 +1,198 @@
+# ==============================================================================
+# Copyright 2020 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 sklearn.datasets import make_regression
+from sklearn.linear_model import LinearRegression
+from sklearn.utils._testing import assert_array_almost_equal
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+
+def make_dataset(n_samples, n_features, kind=np.array, random_state=0, types=None):
+    try:
+        from pandas import DataFrame
+
+        if kind not in (list, np.array, DataFrame):
+            kind = np.array
+    except ImportError:
+        if kind not in (list, np.array):
+            kind = np.array
+
+    x, y = make_regression(n_samples, n_features, random_state=random_state)
+
+    if kind == list:
+        x = list(x)
+        for i, row in enumerate(x):
+            x[i] = list(row)
+        y = list(y)
+
+        if types:
+            n_types = len(types)
+            for i, row in enumerate(x):
+                for j, cell in enumerate(row):
+                    x[i][j] = types[j % n_types](cell)
+
+    try:
+        from pandas import DataFrame
+
+        if kind == DataFrame:
+            x = DataFrame(data=x, index=None, columns=None)
+            y = DataFrame(y)
+
+            if types:
+                n_types = len(types)
+                dir_dtypes = {col: types[i % n_types] for i, col in enumerate(x.columns)}
+                x = x.astype(dir_dtypes)
+    except ImportError:
+        pass
+
+    return x, y
+
+
+def test_linear_array_vs_dataframe_homogen():
+    pd = pytest.importorskip("pandas")
+
+    x_train, y_train = make_dataset(100, 20)
+    x_test, _ = make_dataset(100, 20, random_state=1)
+
+    df_x_train, df_y_train = make_dataset(100, 20, pd.DataFrame)
+    df_x_test, _ = make_dataset(100, 20, pd.DataFrame, random_state=1)
+
+    array_reg = LinearRegression()
+    array_reg.fit(x_train, y_train)
+
+    df_reg = LinearRegression()
+    df_reg.fit(df_x_train, df_y_train)
+
+    assert_array_almost_equal(
+        array_reg.coef_.reshape((-1, 1)), df_reg.coef_.reshape((-1, 1))
+    )
+    assert_array_almost_equal(array_reg.intercept_, df_reg.intercept_)
+    assert_array_almost_equal(
+        array_reg.predict(x_test).reshape((-1, 1)),
+        df_reg.predict(df_x_test).reshape((-1, 1)),
+    )
+
+
+def test_linear_array_vs_dataframe_heterogen():
+    pd = pytest.importorskip("pandas")
+
+    types = (np.float64, np.float32)
+
+    x_train, y_train = make_dataset(100, 20)
+    x_test, _ = make_dataset(100, 20, random_state=1)
+
+    df_x_train, df_y_train = make_dataset(100, 20, pd.DataFrame, types=types)
+    df_x_test, _ = make_dataset(100, 20, pd.DataFrame, random_state=1, types=types)
+
+    array_reg = LinearRegression()
+    array_reg.fit(x_train, y_train)
+
+    df_reg = LinearRegression()
+    df_reg.fit(df_x_train, df_y_train)
+
+    assert_array_almost_equal(
+        array_reg.coef_.reshape((-1, 1)), df_reg.coef_.reshape((-1, 1))
+    )
+    assert_array_almost_equal(array_reg.intercept_, df_reg.intercept_)
+    assert_array_almost_equal(
+        array_reg.predict(x_test).reshape((-1, 1)),
+        df_reg.predict(df_x_test).reshape((-1, 1)),
+        decimal=5,
+    )
+
+
+def test_linear_array_vs_dataframe_heterogen_double_float():
+    pd = pytest.importorskip("pandas")
+
+    types = (np.float64, np.float32)
+
+    x_train, y_train = make_dataset(100, 20, list, types=types)
+    x_test, _ = make_dataset(100, 20, list, random_state=1, types=types)
+
+    df_x_train, df_y_train = make_dataset(100, 20, pd.DataFrame, types=types)
+    df_x_test, _ = make_dataset(100, 20, pd.DataFrame, random_state=1, types=types)
+
+    array_reg = LinearRegression()
+    array_reg.fit(x_train, y_train)
+
+    df_reg = LinearRegression()
+    df_reg.fit(df_x_train, df_y_train)
+
+    assert_array_almost_equal(
+        array_reg.coef_.reshape((-1, 1)), df_reg.coef_.reshape((-1, 1))
+    )
+    assert_array_almost_equal(array_reg.intercept_, df_reg.intercept_)
+    assert_array_almost_equal(
+        array_reg.predict(x_test).reshape((-1, 1)),
+        df_reg.predict(df_x_test).reshape((-1, 1)),
+    )
+
+
+def test_linear_array_vs_dataframe_heterogen_double_int():
+    pd = pytest.importorskip("pandas")
+
+    types = (np.float64, np.int32)
+
+    x_train, y_train = make_dataset(100, 20, list, types=types)
+    x_test, _ = make_dataset(100, 20, list, random_state=1, types=types)
+
+    df_x_train, df_y_train = make_dataset(100, 20, pd.DataFrame, types=types)
+    df_x_test, _ = make_dataset(100, 20, pd.DataFrame, random_state=1, types=types)
+
+    array_reg = LinearRegression()
+    array_reg.fit(x_train, y_train)
+
+    df_reg = LinearRegression()
+    df_reg.fit(df_x_train, df_y_train)
+
+    assert_array_almost_equal(
+        array_reg.coef_.reshape((-1, 1)), df_reg.coef_.reshape((-1, 1))
+    )
+    assert_array_almost_equal(array_reg.intercept_, df_reg.intercept_)
+    assert_array_almost_equal(
+        array_reg.predict(x_test).reshape((-1, 1)),
+        df_reg.predict(df_x_test).reshape((-1, 1)),
+    )
+
+
+def test_linear_array_vs_dataframe_heterogen_float_int():
+    pd = pytest.importorskip("pandas")
+
+    types = (np.float32, np.int32)
+
+    x_train, y_train = make_dataset(100, 20, list, types=types)
+    x_test, _ = make_dataset(100, 20, list, random_state=1, types=types)
+
+    df_x_train, df_y_train = make_dataset(100, 20, pd.DataFrame, types=types)
+    df_x_test, _ = make_dataset(100, 20, pd.DataFrame, random_state=1, types=types)
+
+    array_reg = LinearRegression()
+    array_reg.fit(x_train, y_train)
+
+    df_reg = LinearRegression()
+    df_reg.fit(df_x_train, df_y_train)
+
+    assert_array_almost_equal(
+        array_reg.coef_.reshape((-1, 1)), df_reg.coef_.reshape((-1, 1))
+    )
+    assert_array_almost_equal(array_reg.intercept_, df_reg.intercept_)
+    assert_array_almost_equal(
+        array_reg.predict(x_test).reshape((-1, 1)),
+        df_reg.predict(df_x_test).reshape((-1, 1)),
+    )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/linear_model/tests/test_ridge.py

@@ -0,0 +1,69 @@
+# ==============================================================================
+# 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
+import pytest
+from sklearn.datasets import make_regression
+
+
+def _test_multivariate_ridge_coefficients(ridge_class, random_state):
+    X, y = make_regression(
+        n_samples=10, n_features=5, n_targets=3, random_state=random_state
+    )
+    alpha = 3 + numpy.random.rand(3) * 5
+
+    # computing coefficients using daal4py Ridge
+    model = ridge_class(fit_intercept=False, alpha=alpha)
+    model.fit(X, y)
+
+    # computing coefficients manually
+    n_features, n_targets = X.shape[1], y.shape[1]
+    betas = numpy.zeros((n_targets, n_features))
+
+    identity_matrix = numpy.eye(n_features)
+
+    for j in range(n_targets):
+        y_j = y[:, j]
+        inverse_term = numpy.linalg.inv(numpy.dot(X.T, X) + alpha[j] * identity_matrix)
+        beta_j = numpy.dot(inverse_term, numpy.dot(X.T, y_j))
+        betas[j, :] = beta_j
+
+    # asserting that the coefficients are close
+    numpy.testing.assert_allclose(model.coef_, betas, rtol=1e-3, atol=1e-3)
+
+
+def _test_multivariate_ridge_alpha_shape(ridge_class, random_state):
+    X, y = make_regression(
+        n_samples=10, n_features=5, n_targets=3, random_state=random_state
+    )
+    wrong_shape_alpha = numpy.random.rand(5)
+    # asserting exception if alpha has wrong shape
+    with pytest.raises(ValueError):
+        ridge_class(alpha=wrong_shape_alpha).fit(X, y)
+
+
+def test_multivariate_ridge_coefficients():
+    from daal4py.sklearn.linear_model._ridge import Ridge
+
+    random_state = 0
+    _test_multivariate_ridge_coefficients(Ridge, random_state)
+
+
+def test_multivariate_ridge_alpha_shape():
+    from daal4py.sklearn.linear_model._ridge import Ridge
+
+    random_state = 0
+    _test_multivariate_ridge_alpha_shape(Ridge, random_state)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/manifold/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# Copyright 2020 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.
+# ==============================================================================
+
+from ._t_sne import TSNE
+
+__all__ = ["TSNE"]