scikit-learn-intelex 2024.4.0__py310-none-win_amd64.whl → 2024.5.0__py310-none-win_amd64.whl

scikit_learn_intelex-2024.5.0.data/data/Lib/site-packages/sklearnex/linear_model/tests/test_incremental_linear.py

@@ -0,0 +1,200 @@
+# ===============================================================================
+# 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 onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.linear_model import IncrementalLinearRegression
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_fit_on_gold_data(dataframe, queue, fit_intercept, macro_block, dtype):
+    X = np.array([[1], [2]])
+    X = X.astype(dtype=dtype)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = np.array([1, 2])
+    y = y.astype(dtype=dtype)
+    y_df = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+    inclin.fit(X_df, y_df)
+
+    y_pred = inclin.predict(X_df)
+
+    tol = 2e-6 if dtype == np.float32 else 1e-7
+    assert_allclose(inclin.coef_, [1], atol=tol)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, [0], atol=tol)
+    assert_allclose(_as_numpy(y_pred), y, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_partial_fit_on_gold_data(
+    dataframe, queue, fit_intercept, macro_block, dtype
+):
+    X = np.array([[1], [2], [3], [4]])
+    X = X.astype(dtype=dtype)
+    y = X + 3
+    y = y.astype(dtype=dtype)
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+
+    inclin = IncrementalLinearRegression()
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+    for i in range(2):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        y_split_df = _convert_to_dataframe(
+            y_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        inclin.partial_fit(X_split_df, y_split_df)
+
+    assert inclin.n_features_in_ == 1
+    tol = 2e-6 if dtype == np.float32 else 1e-7
+    assert_allclose(inclin.coef_, [[1]], atol=tol)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, 3, atol=tol)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_pred = inclin.predict(X_df)
+
+    assert_allclose(_as_numpy(y_pred), y, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_partial_fit_multitarget_on_gold_data(
+    dataframe, queue, fit_intercept, macro_block, dtype
+):
+    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
+    X = X.astype(dtype=dtype)
+    y = np.dot(X, [1, 2]) + 3
+    y = y.astype(dtype=dtype)
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+
+    inclin = IncrementalLinearRegression()
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+    for i in range(2):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        y_split_df = _convert_to_dataframe(
+            y_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        inclin.partial_fit(X_split_df, y_split_df)
+
+    assert inclin.n_features_in_ == 2
+    tol = 7e-6 if dtype == np.float32 else 1e-7
+    assert_allclose(inclin.coef_, [1.0, 2.0], atol=tol)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, 3.0, atol=tol)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y_pred = inclin.predict(X_df)
+
+    assert_allclose(_as_numpy(y_pred), y, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("num_samples", [100, 1000])
+@pytest.mark.parametrize("num_features", [5, 10])
+@pytest.mark.parametrize("num_targets", [1, 2])
+@pytest.mark.parametrize("num_blocks", [1, 10])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_partial_fit_on_random_data(
+    dataframe,
+    queue,
+    fit_intercept,
+    num_samples,
+    num_features,
+    num_targets,
+    num_blocks,
+    macro_block,
+    dtype,
+):
+    seed = 42
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=num_targets, dtype=dtype)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples, num_features), dtype=dtype)
+    if fit_intercept:
+        y = X @ coef + intercept[np.newaxis, :]
+    else:
+        y = X @ coef
+
+    X_split = np.array_split(X, num_blocks)
+    y_split = np.array_split(y, num_blocks)
+
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+    for i in range(num_blocks):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        y_split_df = _convert_to_dataframe(
+            y_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        inclin.partial_fit(X_split_df, y_split_df)
+
+    tol = 1e-4 if dtype == np.float32 else 1e-7
+    assert_allclose(coef, inclin.coef_.T, atol=tol)
+
+    if fit_intercept:
+        assert_allclose(intercept, inclin.intercept_, atol=tol)
+
+    X_test = gen.random(size=(num_samples, num_features), dtype=dtype)
+    if fit_intercept:
+        expected_y_pred = X_test @ coef + intercept[np.newaxis, :]
+    else:
+        expected_y_pred = X_test @ coef
+
+    X_test_df = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+
+    y_pred = inclin.predict(X_test_df)
+
+    assert_allclose(expected_y_pred, _as_numpy(y_pred), atol=tol)

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

@@ -52,7 +52,7 @@ def test_sklearnex_import_linear(dataframe, queue, dtype, macro_block):
     assert "sklearnex" in linreg.__module__
     assert linreg.n_features_in_ == 2
 
-    tol = 1e-5 if X.dtype == np.float32 else 1e-7
+    tol = 1e-5 if 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)
 
@@ -113,5 +113,5 @@ def test_sklearnex_reconstruct_model(dataframe, queue, dtype):
 
     y_pred = linreg.predict(X)
 
-    tol = 1e-5 if X.dtype == np.float32 else 1e-7
+    tol = 1e-5 if dtype == np.float32 else 1e-7
     assert_allclose(gtr, _as_numpy(y_pred), rtol=tol)

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/neighbors/tests/test_neighbors.py

@@ -47,9 +47,9 @@ def test_sklearnex_import_knn_regression(dataframe, queue):
     y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
     neigh = KNeighborsRegressor(n_neighbors=2).fit(X, y)
     y_test = _convert_to_dataframe([[1.5]], sycl_queue=queue, target_df=dataframe)
-    pred = _as_numpy(neigh.predict(y_test))
+    pred = _as_numpy(neigh.predict(y_test)).squeeze()
     assert "sklearnex" in neigh.__module__
-    assert_allclose(pred, [0.5])
+    assert_allclose(pred, 0.5)
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/tests/_utils.py

@@ -17,6 +17,7 @@
 from inspect import isclass
 
 import numpy as np
+from sklearn import clone
 from sklearn.base import (
     BaseEstimator,
     ClassifierMixin,
@@ -87,18 +88,26 @@ mixin_map = [
 ]
 
 
-SPECIAL_INSTANCES = {
-    str(i): i
-    for i in [
-        LocalOutlierFactor(novelty=True),
-        SVC(probability=True),
-        NuSVC(probability=True),
-        KNeighborsClassifier(algorithm="brute"),
-        KNeighborsRegressor(algorithm="brute"),
-        NearestNeighbors(algorithm="brute"),
-        LogisticRegression(solver="newton-cg"),
-    ]
-}
+class _sklearn_clone_dict(dict):
+
+    def __getitem__(self, key):
+        return clone(super().__getitem__(key))
+
+
+SPECIAL_INSTANCES = _sklearn_clone_dict(
+    {
+        str(i): i
+        for i in [
+            LocalOutlierFactor(novelty=True),
+            SVC(probability=True),
+            NuSVC(probability=True),
+            KNeighborsClassifier(algorithm="brute"),
+            KNeighborsRegressor(algorithm="brute"),
+            NearestNeighbors(algorithm="brute"),
+            LogisticRegression(solver="newton-cg"),
+        ]
+    }
+)
 
 
 def gen_models_info(algorithms):

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -96,7 +96,11 @@ def remove_duplicated_estimators(estimators_list):
     return estimators_map.values()
 
 
-BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
+BANNED_ESTIMATORS = (
+    "IncrementalEmpiricalCovariance",  # dataframe_f issues
+    "IncrementalLinearRegression",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
+    "TSNE",  # too slow for using in testing on common data size
+)
 estimators = [
     TrainTestSplitEstimator,
     FiniteCheckEstimator,

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py

@@ -22,6 +22,7 @@ import pytest
 from sklearn.base import BaseEstimator
 from sklearn.datasets import make_classification
 
+from sklearnex.decomposition import PCA
 from sklearnex.dispatcher import get_patch_map
 from sklearnex.svm import SVC, NuSVC
 
@@ -73,6 +74,9 @@ def test_n_jobs_support(caplog, estimator_class, n_jobs):
     # by default, [Nu]SVC.predict_proba is restricted by @available_if decorator
     if estimator_class in [SVC, NuSVC]:
         estimator_kwargs["probability"] = True
+    # explicitly request oneDAL's PCA-Covariance algorithm
+    if estimator_class == PCA:
+        estimator_kwargs["svd_solver"] = "covariance_eigh"
     estimator_instance = estimator_class(**estimator_kwargs)
     # check `n_jobs` parameter doc entry
     check_estimator_doc(estimator_class)

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -61,12 +61,15 @@ def test_pairwise_distances_patching(caplog, dataframe, queue, dtype, metric):
             pytest.skip("pairwise_distances does not support GPU queues")
 
         rng = nprnd.default_rng()
-        X = _convert_to_dataframe(
-            rng.random(size=1000).reshape(1, -1),
-            sycl_queue=queue,
-            target_df=dataframe,
-            dtype=dtype,
-        )
+        if dataframe == "pandas":
+            X = _convert_to_dataframe(
+                rng.random(size=1000).astype(dtype).reshape(1, -1),
+                target_df=dataframe,
+            )
+        else:
+            X = _convert_to_dataframe(
+                rng.random(size=1000), sycl_queue=queue, target_df=dataframe, dtype=dtype
+            )[None, :]
 
         _ = pairwise_distances(X, metric=metric)
     assert all(
@@ -90,14 +93,17 @@ def test_roc_auc_score_patching(caplog, dataframe, queue, dtype):
 
     with caplog.at_level(logging.WARNING, logger="sklearnex"):
         rng = nprnd.default_rng()
+        X = rng.integers(2, size=1000)
+        y = rng.integers(2, size=1000)
+
         X = _convert_to_dataframe(
-            rng.integers(2, size=1000),
+            X,
             sycl_queue=queue,
             target_df=dataframe,
             dtype=dtype,
         )
         y = _convert_to_dataframe(
-            rng.integers(2, size=1000),
+            y,
             sycl_queue=queue,
             target_df=dataframe,
             dtype=dtype,
@@ -142,6 +148,19 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             and dtype in [np.uint32, np.uint64]
         ):
             pytest.skip("Windows segmentation fault for Ridge.predict for unsigned ints")
+        elif estimator == "IncrementalLinearRegression" and dtype in [
+            np.int8,
+            np.int16,
+            np.int32,
+            np.int64,
+            np.uint8,
+            np.uint16,
+            np.uint32,
+            np.uint64,
+        ]:
+            pytest.skip(
+                "IncrementalLinearRegression fails on oneDAL side with int types because dataset is filled by zeroes"
+            )
         elif method and not hasattr(est, method):
             pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
 

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2024.5.0.data}/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability_tests.py

@@ -294,7 +294,7 @@ MODELS_INFO = [
         "dataset": "regression",
     },
     {
-        "model": PCA(n_components=0.5, svd_solver="full", random_state=0),
+        "model": PCA(n_components=0.5, svd_solver="covariance_eigh", random_state=0),
         "methods": ["transform", "get_covariance", "get_precision", "score_samples"],
         "dataset": "classifier",
     },

scikit_learn_intelex-2024.5.0.data/data/Lib/site-packages/sklearnex/utils/tests/test_finite.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# 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 time
+
+import numpy as np
+import numpy.random as rand
+import pytest
+from numpy.testing import assert_raises
+
+from sklearnex.utils import _assert_all_finite
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [
+            2**16 + 3,
+        ],
+        [1000, 1000],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+def test_sum_infinite_actually_finite(dtype, shape, allow_nan):
+    X = np.array(shape, dtype=dtype)
+    X.fill(np.finfo(dtype).max)
+    _assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [
+            2**16 + 3,
+        ],
+        [1000, 1000],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, int(time.time())])
+def test_assert_finite_random_location(dtype, shape, allow_nan, check, seed):
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=shape).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X.reshape((-1,))[loc] = float(check)
+
+    if check is None or (allow_nan and check == "NaN"):
+        _assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        assert_raises(ValueError, _assert_all_finite, X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, int(time.time())])
+def test_assert_finite_random_shape_and_location(dtype, allow_nan, check, seed):
+    lb, ub = 32768, 1048576  # lb is a patching condition, ub 2^20
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=rand.randint(lb, ub)).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X[loc] = float(check)
+
+    if check is None or (allow_nan and check == "NaN"):
+        _assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        assert_raises(ValueError, _assert_all_finite, X, allow_nan=allow_nan)