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/basic_statistics/tests/test_basic_statistics.py

@@ -17,18 +17,30 @@
 import numpy as np
 import pytest
 from numpy.testing import assert_allclose
+from scipy import sparse as sp
 
-from onedal.basic_statistics.tests.test_basic_statistics import (
-    expected_max,
-    expected_mean,
-    expected_sum,
-    options_and_tests,
-)
+from daal4py.sklearn._utils import daal_check_version
+from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
+    get_queues,
 )
+from sklearnex import config_context
 from sklearnex.basic_statistics import BasicStatistics
+from sklearnex.tests.utils import gen_sparse_dataset
+
+
+# Compute the basic statistics on sparse data on CPU or GPU depending on the queue
+def compute_sparse_result(X_sparse, options, queue):
+    if queue is not None and queue.sycl_device.is_gpu:
+        with config_context(target_offload="gpu"):
+            basicstat = BasicStatistics(result_options=options)
+            result = basicstat.fit(X_sparse)
+    else:
+        basicstat = BasicStatistics(result_options=options)
+        result = basicstat.fit(X_sparse)
+    return result
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
@@ -45,9 +57,9 @@ def test_sklearnex_import_basic_statistics(dataframe, queue):
     expected_min = np.array([0, 0])
     expected_max = np.array([1, 1])
 
-    assert_allclose(expected_mean, result.mean)
-    assert_allclose(expected_max, result.max)
-    assert_allclose(expected_min, result.min)
+    assert_allclose(expected_mean, result.mean_)
+    assert_allclose(expected_max, result.max_)
+    assert_allclose(expected_min, result.min_)
 
     result = BasicStatistics().fit(X_df, sample_weight=weights_df)
 
@@ -55,9 +67,9 @@ def test_sklearnex_import_basic_statistics(dataframe, queue):
     expected_weighted_min = np.array([0, 0])
     expected_weighted_max = np.array([0.5, 0.5])
 
-    assert_allclose(expected_weighted_mean, result.mean)
-    assert_allclose(expected_weighted_min, result.min)
-    assert_allclose(expected_weighted_max, result.max)
+    assert_allclose(expected_weighted_mean, result.mean_)
+    assert_allclose(expected_weighted_min, result.min_)
+    assert_allclose(expected_weighted_max, result.max_)
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
@@ -82,28 +94,28 @@ def test_multiple_options_on_gold_data(dataframe, queue, weighted, dtype):
         expected_weighted_mean = np.array([0.25, 0.25])
         expected_weighted_min = np.array([0, 0])
         expected_weighted_max = np.array([0.5, 0.5])
-        assert_allclose(expected_weighted_mean, result.mean)
-        assert_allclose(expected_weighted_max, result.max)
-        assert_allclose(expected_weighted_min, result.min)
+        assert_allclose(expected_weighted_mean, result.mean_)
+        assert_allclose(expected_weighted_max, result.max_)
+        assert_allclose(expected_weighted_min, result.min_)
     else:
         expected_mean = np.array([0.5, 0.5])
         expected_min = np.array([0, 0])
         expected_max = np.array([1, 1])
-        assert_allclose(expected_mean, result.mean)
-        assert_allclose(expected_max, result.max)
-        assert_allclose(expected_min, result.min)
+        assert_allclose(expected_mean, result.mean_)
+        assert_allclose(expected_max, result.max_)
+        assert_allclose(expected_min, result.min_)
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("result_option", options_and_tests.keys())
 @pytest.mark.parametrize("row_count", [100, 1000])
 @pytest.mark.parametrize("column_count", [10, 100])
 @pytest.mark.parametrize("weighted", [True, False])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_single_option_on_random_data(
-    dataframe, queue, option, row_count, column_count, weighted, dtype
+    dataframe, queue, result_option, row_count, column_count, weighted, dtype
 ):
-    result_option, function, tols = option
+    function, tols = options_and_tests[result_option]
     fp32tol, fp64tol = tols
     seed = 77
     gen = np.random.default_rng(seed)
@@ -121,7 +133,7 @@ def test_single_option_on_random_data(
     else:
         result = basicstat.fit(X_df)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = np.diag(weights) @ X
         gtr = function(weighted_data)
@@ -132,6 +144,49 @@ def test_single_option_on_random_data(
     assert_allclose(gtr, res, atol=tol)
 
 
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("result_option", options_and_tests.keys())
+@pytest.mark.parametrize("row_count", [500, 2000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_single_option_on_random_sparse_data(
+    queue, result_option, row_count, column_count, dtype
+):
+    if not daal_check_version((2025, "P", 200)) and result_option in [
+        "max",
+        "sum_squares",
+    ]:
+        pytest.skip(
+            "'max' and 'sum_squares' calculate using a subset of the data in oneDAL version < 2025.2"
+        )
+
+    function, tols = options_and_tests[result_option]
+    fp32tol, fp64tol = tols
+    seed = 77
+
+    gen = np.random.default_rng(seed)
+
+    X_sparse = gen_sparse_dataset(
+        row_count,
+        column_count,
+        density=0.01,
+        format="csr",
+        dtype=dtype,
+        random_state=gen,
+    )
+
+    X_dense = X_sparse.toarray()
+
+    result = compute_sparse_result(X_sparse, result_option, queue)
+
+    res = getattr(result, result_option + "_")
+
+    gtr = function(X_dense)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("row_count", [100, 1000])
 @pytest.mark.parametrize("column_count", [10, 100])
@@ -156,19 +211,19 @@ def test_multiple_options_on_random_data(
     else:
         result = basicstat.fit(X_df)
 
-    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    res_mean, res_max, res_sum = result.mean_, result.max_, result.sum_
     if weighted:
         weighted_data = np.diag(weights) @ X
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(weighted_data),
-            expected_max(weighted_data),
-            expected_sum(weighted_data),
+            options_and_tests["mean"][0](weighted_data),
+            options_and_tests["max"][0](weighted_data),
+            options_and_tests["sum"][0](weighted_data),
         )
     else:
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(X),
-            expected_max(X),
-            expected_sum(X),
+            options_and_tests["mean"][0](X),
+            options_and_tests["max"][0](X),
+            options_and_tests["sum"][0](X),
         )
 
     tol = 5e-4 if res_mean.dtype == np.float32 else 1e-7
@@ -177,6 +232,48 @@ def test_multiple_options_on_random_data(
     assert_allclose(gtr_sum, res_sum, atol=tol)
 
 
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_multiple_options_on_random_sparse_data(queue, row_count, column_count, dtype):
+    seed = 77
+
+    gen = np.random.default_rng(seed)
+
+    X_sparse = gen_sparse_dataset(
+        row_count,
+        column_count,
+        density=0.05,
+        format="csr",
+        dtype=dtype,
+        random_state=gen,
+    )
+
+    X_dense = X_sparse.toarray()
+
+    options = [
+        "sum",
+        "min",
+        "mean",
+        "standard_deviation",
+        "variance",
+        "second_order_raw_moment",
+    ]
+
+    result = compute_sparse_result(X_sparse, options, queue)
+
+    for result_option in options_and_tests:
+        function, tols = options_and_tests[result_option]
+        if not result_option in options:
+            continue
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option + "_")
+        gtr = function(X_dense)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)
+
+
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("row_count", [100, 1000])
 @pytest.mark.parametrize("column_count", [10, 100])
@@ -204,10 +301,10 @@ def test_all_option_on_random_data(
     if weighted:
         weighted_data = np.diag(weights) @ X
 
-    for option in options_and_tests:
-        result_option, function, tols = option
+    for result_option in options_and_tests:
+        function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(result, result_option)
+        res = getattr(result, result_option + "_")
         if weighted:
             gtr = function(weighted_data)
         else:
@@ -216,13 +313,52 @@ def test_all_option_on_random_data(
         assert_allclose(gtr, res, atol=tol)
 
 
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_all_option_on_random_sparse_data(queue, row_count, column_count, dtype):
+    seed = 77
+
+    gen = np.random.default_rng(seed)
+
+    X_sparse = gen_sparse_dataset(
+        row_count,
+        column_count,
+        density=0.05,
+        format="csr",
+        dtype=dtype,
+        random_state=gen,
+    )
+    X_dense = X_sparse.toarray()
+
+    result = compute_sparse_result(X_sparse, "all", queue)
+
+    for result_option in options_and_tests:
+        if not daal_check_version((2025, "P", 200)) and result_option in [
+            "max",
+            "sum_squares",
+        ]:
+            continue
+        function, tols = options_and_tests[result_option]
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option + "_")
+
+        gtr = function(X_dense)
+
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)
+
+
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("result_option", options_and_tests.keys())
 @pytest.mark.parametrize("data_size", [100, 1000])
 @pytest.mark.parametrize("weighted", [True, False])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_1d_input_on_random_data(dataframe, queue, option, data_size, weighted, dtype):
-    result_option, function, tols = option
+def test_1d_input_on_random_data(
+    dataframe, queue, result_option, data_size, weighted, dtype
+):
+    function, tols = options_and_tests[result_option]
     fp32tol, fp64tol = tols
     seed = 77
     gen = np.random.default_rng(seed)
@@ -240,7 +376,7 @@ def test_1d_input_on_random_data(dataframe, queue, option, data_size, weighted,
     else:
         result = basicstat.fit(X_df)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = weights * X
         gtr = function(weighted_data)
@@ -249,3 +385,21 @@ def test_1d_input_on_random_data(dataframe, queue, option, data_size, weighted,
 
     tol = fp32tol if res.dtype == np.float32 else fp64tol
     assert_allclose(gtr, res, atol=tol)
+
+
+def test_warning():
+    basicstat = BasicStatistics("all")
+    data = np.array([0, 1])
+
+    basicstat.fit(data)
+    for i in basicstat._onedal_estimator.get_all_result_options():
+        with pytest.warns(
+            UserWarning,
+            match="Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0",
+        ) as warn_record:
+            getattr(basicstat, i)
+
+        if daal_check_version((2026, "P", 0)):
+            assert len(warn_record) == 0, i
+        else:
+            assert len(warn_record) == 1, i

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

@@ -18,12 +18,8 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
-from onedal.basic_statistics.tests.test_basic_statistics import (
-    expected_max,
-    expected_mean,
-    expected_sum,
-    options_and_tests,
-)
+from daal4py.sklearn._utils import daal_check_version
+from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
@@ -74,15 +70,15 @@ def test_partial_fit_multiple_options_on_gold_data(dataframe, queue, weighted, d
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("num_batches", [2, 10])
-@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("result_option", options_and_tests.keys())
 @pytest.mark.parametrize("row_count", [100, 1000])
 @pytest.mark.parametrize("column_count", [10, 100])
 @pytest.mark.parametrize("weighted", [True, False])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_partial_fit_single_option_on_random_data(
-    dataframe, queue, num_batches, option, row_count, column_count, weighted, dtype
+    dataframe, queue, num_batches, result_option, row_count, column_count, weighted, dtype
 ):
-    result_option, function, tols = option
+    function, tols = options_and_tests[result_option]
     fp32tol, fp64tol = tols
     seed = 77
     gen = np.random.default_rng(seed)
@@ -154,15 +150,15 @@ def test_partial_fit_multiple_options_on_random_data(
     if weighted:
         weighted_data = np.diag(weights) @ X
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(weighted_data),
-            expected_max(weighted_data),
-            expected_sum(weighted_data),
+            options_and_tests["mean"][0](weighted_data),
+            options_and_tests["max"][0](weighted_data),
+            options_and_tests["sum"][0](weighted_data),
         )
     else:
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(X),
-            expected_max(X),
-            expected_sum(X),
+            options_and_tests["mean"][0](X),
+            options_and_tests["max"][0](X),
+            options_and_tests["sum"][0](X),
         )
 
     tol = 3e-4 if res_mean.dtype == np.float32 else 1e-7
@@ -206,8 +202,8 @@ def test_partial_fit_all_option_on_random_data(
     if weighted:
         weighted_data = np.diag(weights) @ X
 
-    for option in options_and_tests:
-        result_option, function, tols = option
+    for result_option in options_and_tests:
+        function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
         res = getattr(result, result_option)
         if weighted:
@@ -254,15 +250,15 @@ def test_fit_multiple_options_on_gold_data(dataframe, queue, weighted, dtype):
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("num_batches", [2, 10])
-@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("result_option", options_and_tests.keys())
 @pytest.mark.parametrize("row_count", [100, 1000])
 @pytest.mark.parametrize("column_count", [10, 100])
 @pytest.mark.parametrize("weighted", [True, False])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_fit_single_option_on_random_data(
-    dataframe, queue, num_batches, option, row_count, column_count, weighted, dtype
+    dataframe, queue, num_batches, result_option, row_count, column_count, weighted, dtype
 ):
-    result_option, function, tols = option
+    function, tols = options_and_tests[result_option]
     fp32tol, fp64tol = tols
     seed = 77
     gen = np.random.default_rng(seed)
@@ -326,15 +322,15 @@ def test_fit_multiple_options_on_random_data(
     if weighted:
         weighted_data = np.diag(weights) @ X
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(weighted_data),
-            expected_max(weighted_data),
-            expected_sum(weighted_data),
+            options_and_tests["mean"][0](weighted_data),
+            options_and_tests["max"][0](weighted_data),
+            options_and_tests["sum"][0](weighted_data),
         )
     else:
         gtr_mean, gtr_max, gtr_sum = (
-            expected_mean(X),
-            expected_max(X),
-            expected_sum(X),
+            options_and_tests["mean"][0](X),
+            options_and_tests["max"][0](X),
+            options_and_tests["sum"][0](X),
         )
 
     tol = 3e-4 if res_mean.dtype == np.float32 else 1e-7
@@ -372,8 +368,8 @@ def test_fit_all_option_on_random_data(
     if weighted:
         weighted_data = np.diag(weights) @ X
 
-    for option in options_and_tests:
-        result_option, function, tols = option
+    for result_option in options_and_tests:
+        function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
         res = getattr(result, result_option)
         if weighted:
@@ -382,3 +378,78 @@ def test_fit_all_option_on_random_data(
             gtr = function(X)
         tol = fp32tol if res.dtype == np.float32 else fp64tol
         assert_allclose(gtr, res, atol=tol)
+
+
+def test_warning():
+    basicstat = IncrementalBasicStatistics("all")
+    # Only 2d inputs supported into IncrementalBasicStatistics
+    data = np.array([[0.0], [1.0]])
+
+    basicstat.fit(data)
+    for i in basicstat._onedal_estimator.get_all_result_options():
+        with pytest.warns(
+            UserWarning,
+            match="Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0",
+        ) as warn_record:
+            getattr(basicstat, i)
+
+        if daal_check_version((2026, "P", 0)):
+            assert len(warn_record) == 0, i
+        else:
+            assert len(warn_record) == 1, i
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_incremental_estimatior_pickle(dataframe, queue, dtype):
+    import pickle
+
+    from sklearnex.basic_statistics import IncrementalBasicStatistics
+
+    incbs = IncrementalBasicStatistics()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(incbs)
+    incbs_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)
+    X_split = np.array_split(X, 2)
+    X_split_df = _convert_to_dataframe(X_split[0], sycl_queue=queue, target_df=dataframe)
+    incbs.partial_fit(X_split_df)
+    incbs_loaded.partial_fit(X_split_df)
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(incbs_loaded)
+    incbs_loaded = pickle.loads(dump)
+
+    X_split_df = _convert_to_dataframe(X_split[1], sycl_queue=queue, target_df=dataframe)
+    incbs.partial_fit(X_split_df)
+    incbs_loaded.partial_fit(X_split_df)
+    dump = pickle.dumps(incbs)
+    incbs_loaded = pickle.loads(dump)
+    assert incbs.batch_size == incbs_loaded.batch_size
+    assert incbs.n_features_in_ == incbs_loaded.n_features_in_
+    assert incbs.n_samples_seen_ == incbs_loaded.n_samples_seen_
+    if hasattr(incbs, "_parameter_constraints"):
+        assert incbs._parameter_constraints == incbs_loaded._parameter_constraints
+    assert incbs.n_jobs == incbs_loaded.n_jobs
+    for result_option in options_and_tests:
+        _, tols = options_and_tests[result_option]
+        fp32tol, fp64tol = tols
+        res = getattr(incbs, result_option)
+        res_loaded = getattr(incbs_loaded, result_option)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(res, res_loaded, atol=tol)
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(incbs_loaded)
+    incbs_loaded = pickle.loads(dump)
+    for result_option in options_and_tests:
+        _, tols = options_and_tests[result_option]
+        fp32tol, fp64tol = tols
+        res = getattr(incbs, result_option)
+        res_loaded = getattr(incbs_loaded, result_option)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(res, res_loaded, atol=tol)

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -18,7 +18,7 @@ import numbers
 from abc import ABC
 
 from scipy import sparse as sp
-from sklearn.cluster import DBSCAN as sklearn_DBSCAN
+from sklearn.cluster import DBSCAN as _sklearn_DBSCAN
 from sklearn.utils.validation import _check_sample_weight
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
@@ -31,6 +31,11 @@ from .._utils import PatchingConditionsChain
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = _sklearn_DBSCAN._validate_data
+
 
 class BaseDBSCAN(ABC):
     def _onedal_dbscan(self, **onedal_params):
@@ -46,11 +51,11 @@ class BaseDBSCAN(ABC):
 
 
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
-    __doc__ = sklearn_DBSCAN.__doc__
+class DBSCAN(_sklearn_DBSCAN, BaseDBSCAN):
+    __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_DBSCAN._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_DBSCAN._parameter_constraints}
 
     def __init__(
         self,
@@ -85,7 +90,7 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         if sklearn_check_version("1.0"):
-            X = self._validate_data(X, force_all_finite=False)
+            X = validate_data(self, X, force_all_finite=False)
 
         onedal_params = {
             "eps": self.eps,
@@ -180,7 +185,7 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_DBSCAN.fit,
+                "sklearn": _sklearn_DBSCAN.fit,
             },
             X,
             y,
@@ -189,4 +194,4 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
 
         return self
 
-    fit.__doc__ = sklearn_DBSCAN.fit.__doc__
+    fit.__doc__ = _sklearn_DBSCAN.fit.__doc__