scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

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

@@ -16,7 +16,6 @@
 
 
 import importlib
-import inspect
 import logging
 import os
 import re
@@ -28,21 +27,23 @@ import numpy.random as nprnd
 import pytest
 from sklearn.base import BaseEstimator
 
-from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn._utils import _package_check_version, sklearn_check_version
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
-from sklearnex import is_patched_instance
+from sklearnex import config_context, is_patched_instance
+from sklearnex._utils import get_tags
 from sklearnex.dispatcher import _is_preview_enabled
 from sklearnex.metrics import pairwise_distances, roc_auc_score
-from sklearnex.tests._utils import (
+from sklearnex.tests.utils import (
     DTYPES,
     PATCHED_FUNCTIONS,
     PATCHED_MODELS,
     SPECIAL_INSTANCES,
     UNPATCHED_FUNCTIONS,
     UNPATCHED_MODELS,
+    call_method,
     gen_dataset,
     gen_models_info,
 )
@@ -61,12 +62,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 +94,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,
@@ -113,46 +120,17 @@ def test_roc_auc_score_patching(caplog, dataframe, queue, dtype):
     ), f"sklearnex patching issue in roc_auc_score with log: \n{caplog.text}"
 
 
-@pytest.mark.parametrize("dtype", DTYPES)
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
-def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
-    with caplog.at_level(logging.WARNING, logger="sklearnex"):
-        est = PATCHED_MODELS[estimator]()
-
-        if queue:
-            if dtype == np.float16 and not queue.sycl_device.has_aspect_fp16:
-                pytest.skip("Hardware does not support fp16 SYCL testing")
-            elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
-                pytest.skip("Hardware does not support fp64 SYCL testing")
-            elif queue.sycl_device.is_gpu and estimator in [
-                "KMeans",
-                "ElasticNet",
-                "Lasso",
-                "Ridge",
-            ]:
-                pytest.skip(f"{estimator} does not support GPU queues")
-
-        if estimator == "TSNE" and method == "fit_transform":
-            pytest.skip("TSNE.fit_transform is too slow for common testing")
-        elif (
-            estimator == "Ridge"
-            and method in ["predict", "score"]
-            and sys.platform == "win32"
-            and dtype in [np.uint32, np.uint64]
-        ):
-            pytest.skip("Windows segmentation fault for Ridge.predict for unsigned ints")
-        elif method and not hasattr(est, method):
-            pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+def _check_estimator_patching(caplog, dataframe, queue, dtype, est, method):
+    # This should be modified as more array_api frameworks are tested and for
+    # upcoming changes in dpnp and dpctl
 
-        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)
+    with caplog.at_level(logging.WARNING, logger="sklearnex"):
+        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
         est.fit(X, y)
 
         if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+            call_method(est, method, X, y)
+
     assert all(
         [
             "running accelerated version" in i.message
@@ -162,40 +140,101 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
     ), f"sklearnex patching issue in {estimator}.{method} with log: \n{caplog.text}"
 
 
+@pytest.mark.parametrize("dtype", DTYPES)
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
+def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
+    est = PATCHED_MODELS[estimator]()
+
+    if queue:
+        if dtype == np.float16 and not queue.sycl_device.has_aspect_fp16:
+            pytest.skip("Hardware does not support fp16 SYCL testing")
+        elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
+            pytest.skip("Hardware does not support fp64 SYCL testing")
+        elif queue.sycl_device.is_gpu and estimator in [
+            "ElasticNet",
+            "Lasso",
+        ]:
+            pytest.skip(f"{estimator} does not support GPU queues")
+
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+
+    if estimator == "TSNE" and method == "fit_transform":
+        pytest.skip("TSNE.fit_transform is too slow for common testing")
+    elif estimator == "IncrementalLinearRegression" and np.issubdtype(dtype, np.integer):
+        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}")
+
+    if dataframe == "array_api":
+        # as array_api dispatching is experimental, sklearn support isn't guaranteed.
+        # the infrastructure from sklearn that sklearnex depends on is also susceptible
+        # to failure. In this case compare to sklearn for the same failure. By design
+        # the patching of sklearn should act similarly. Technically this is conformance.
+        if (
+            (estimator == "PCA" and "transform" in method)
+            or (estimator == "IncrementalEmpiricalCovariance" and method == "mahalanobis")
+        ) and not _package_check_version("2.0", np.__version__):
+            # issue not to be observed with normal numpy usage
+            pytest.skip(
+                f"numpy backend does not properly handle the __dlpack__ attribute."
+            )
+        elif (
+            not sklearn_check_version("1.3")
+            and estimator == "IncrementalEmpiricalCovariance"
+            and method == "score"
+        ):
+            pytest.skip(
+                f"array checking in sklearn <1.3 does not fully support array_api inputs, causes sklearnex-only estimator failure"
+            )
+
+        with config_context(array_api_dispatch=True):
+            try:
+                _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
+            except Exception as e:
+                # if we are borrowing from sklearn and it fails, then this is something
+                # failing on sklearn-side. It is only allowed to fail if the underlying sklearn
+                # function doesn't support array_api with the set parameters and array_api
+                # support isn't promised by oneDAL
+                tags = get_tags(est)
+                array_api_check = (
+                    hasattr(tags, "array_api_support")
+                    and tags.array_api_support
+                    or hasattr(tags, "onedal_array_api")
+                    and tags.onedal_array_api
+                )
+                if (
+                    array_api_check
+                    or estimator not in UNPATCHED_MODELS
+                    or getattr(PATCHED_MODELS[estimator], method)
+                    != getattr(UNPATCHED_MODELS[estimator], method, None)
+                ):
+                    raise e
+
+    else:
+        _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
+
+
 @pytest.mark.parametrize("dtype", DTYPES)
 @pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("estimator, method", gen_models_info(SPECIAL_INSTANCES))
 def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
-    # prepare logging
-
-    with caplog.at_level(logging.WARNING, logger="sklearnex"):
-        est = SPECIAL_INSTANCES[estimator]
+    est = SPECIAL_INSTANCES[estimator]
 
+    if queue:
         # Its not possible to get the dpnp/dpctl arrays to be in the proper dtype
-        if dtype == np.float16 and queue and not queue.sycl_device.has_aspect_fp16:
+        if dtype == np.float16 and not queue.sycl_device.has_aspect_fp16:
             pytest.skip("Hardware does not support fp16 SYCL testing")
-        elif dtype == np.float64 and queue and not queue.sycl_device.has_aspect_fp64:
+        elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
             pytest.skip("Hardware does not support fp64 SYCL testing")
 
-        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)
-        est.fit(X, y)
-
-        if method and not hasattr(est, method):
-            pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
-
-        if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
-    assert all(
-        [
-            "running accelerated version" in i.message
-            or "fallback to original Scikit-learn" in i.message
-            for i in caplog.records
-        ]
-    ), f"sklearnex patching issue in {estimator}.{method} with log: \n{caplog.text}"
+    _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
 
 
 @pytest.mark.parametrize("estimator", UNPATCHED_MODELS.keys())
@@ -279,9 +318,17 @@ def test_patch_map_match():
 
     def list_all_attr(string):
         try:
-            modules = set(importlib.import_module(string).__all__)
+            mod = importlib.import_module(string)
         except ModuleNotFoundError:
-            modules = set([None])
+            return set([None])
+
+        # Some sklearn estimators exist in python
+        # files rather than folders under sklearn
+        modules = set(
+            getattr(
+                mod, "__all__", [name for name in dir(mod) if not name.startswith("_")]
+            )
+        )
         return modules
 
     if _is_preview_enabled():
@@ -367,5 +414,5 @@ def test_docstring_patching_match(estimator):
 )
 def test_onedal_supported_member(name, member):
     patched = PATCHED_MODELS[name]
-    sig = str(inspect.signature(getattr(patched, member)))
+    sig = str(signature(getattr(patched, member)))
     assert "(self, method_name, *data)" == sig

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability.py

@@ -0,0 +1,335 @@
+# ===============================================================================
+# 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 random
+from collections.abc import Iterable
+from functools import partial
+from numbers import Number
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from scipy import sparse
+from sklearn.datasets import (
+    load_breast_cancer,
+    load_diabetes,
+    load_iris,
+    make_classification,
+    make_regression,
+)
+
+import daal4py as d4p
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import _as_numpy, get_dataframes_and_queues
+from sklearnex.basic_statistics import BasicStatistics
+from sklearnex.cluster import DBSCAN, KMeans
+from sklearnex.decomposition import PCA
+from sklearnex.metrics import pairwise_distances, roc_auc_score
+from sklearnex.model_selection import train_test_split
+from sklearnex.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    NearestNeighbors,
+)
+from sklearnex.svm import SVC
+from sklearnex.tests.utils import (
+    _IS_INTEL,
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+    sklearn_clone_dict,
+)
+
+# to reproduce errors even in CI
+d4p.daalinit(nthreads=100)
+
+_dataset_dict = {
+    "classification": [
+        partial(load_iris, return_X_y=True),
+        partial(load_breast_cancer, return_X_y=True),
+    ],
+    "regression": [
+        partial(load_diabetes, return_X_y=True),
+        partial(
+            make_regression, n_samples=500, n_features=10, noise=64.0, random_state=42
+        ),
+    ],
+}
+
+
+def eval_method(X, y, est, method):
+    res = []
+    est.fit(X, y)
+
+    if method:
+        res = call_method(est, method, X, y)
+
+    if not isinstance(res, Iterable):
+        results = [_as_numpy(res)] if res is not est else []
+    elif hasattr(res, "dtype") and res.dtype not in [np.object_, np.flexible]:
+        # array_api inputs do not have an __iter__ and this also allows for
+        # multidimensional array-like inputs to be analyzed without slicing.
+        # The check for object and flexible types is because of the
+        # radius_neighbors method in kNeighors algorithms which can return
+        # numpy object arrays of numpy numeric arrays
+        results = [_as_numpy(res).flatten()]
+    else:
+        results = [_as_numpy(i) for i in res]
+
+    attributes = [method] * len(results)
+
+    # if estimator follows sklearn design rules, then set attributes should have a
+    # trailing underscore
+    attributes += [
+        i
+        for i in dir(est)
+        if hasattr(est, i) and not i.startswith("_") and i.endswith("_")
+    ]
+    results += [getattr(est, i) for i in attributes if i != method]
+    return results, attributes
+
+
+def _run_test(estimator, method, datasets):
+
+    for X, y in datasets:
+        baseline, attributes = eval_method(X, y, estimator, method)
+
+        for i in range(10):
+            res, _ = eval_method(X, y, estimator, method)
+
+            for r, b, n in zip(res, baseline, attributes):
+                if (
+                    isinstance(b, Number)
+                    or hasattr(b, "__array__")
+                    or hasattr(b, "__array_namespace__")
+                    or hasattr(b, "__sycl_usm_ndarray__")
+                ):
+                    assert_allclose(
+                        r, b, rtol=0.0, atol=0.0, err_msg=str(n + " is incorrect")
+                    )
+
+
+_sparse_instances = [SVC()]
+if daal_check_version((2025, "P", 200)):  # Test for >= 2025.2.0
+    _sparse_instances.extend(
+        [
+            BasicStatistics(result_options=["sum", "min"]),
+        ]
+    )
+if daal_check_version((2024, "P", 700)):  # Test for > 2024.7.0
+    _sparse_instances.extend(
+        [
+            KMeans(),
+            KMeans(init="random"),
+            KMeans(init="k-means++"),
+        ]
+    )
+SPARSE_INSTANCES = sklearn_clone_dict({str(i): i for i in _sparse_instances})
+
+STABILITY_INSTANCES = sklearn_clone_dict(
+    {
+        str(i): i
+        for i in [
+            KNeighborsClassifier(algorithm="brute", weights="distance"),
+            KNeighborsClassifier(algorithm="kd_tree", weights="distance"),
+            KNeighborsClassifier(algorithm="kd_tree"),
+            KNeighborsRegressor(algorithm="brute", weights="distance"),
+            KNeighborsRegressor(algorithm="kd_tree", weights="distance"),
+            KNeighborsRegressor(algorithm="kd_tree"),
+            NearestNeighbors(algorithm="kd_tree"),
+            DBSCAN(algorithm="brute"),
+            PCA(n_components=0.5, svd_solver="covariance_eigh"),
+            KMeans(init="random"),
+        ]
+    }
+)
+
+
+def _skip_neighbors(estimator, method):
+    if (
+        not _IS_INTEL
+        and ("Neighbors" in estimator or "LocalOutlierFactor" in estimator)
+        and method
+        in ["score", "predict", "kneighbors", "kneighbors_graph", "predict_proba"]
+    ):
+        pytest.skip(f"{estimator} shows instability on non-Intel(R) hardware")
+
+
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
+@pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
+def test_standard_estimator_stability(estimator, method, dataframe, queue):
+    if estimator in ["LogisticRegression", "TSNE"]:
+        pytest.skip(f"stability not guaranteed for {estimator}")
+    if estimator in ["KMeans", "PCA"] and "score" in method and queue == None:
+        pytest.skip(f"variation observed in {estimator}.score")
+    if estimator in ["IncrementalEmpiricalCovariance"] and method == "mahalanobis":
+        pytest.skip("allowed fallback to sklearn occurs")
+    if estimator == "DummyRegressor":
+        pytest.skip("default parameters fall back to sklearn")
+    _skip_neighbors(estimator, method)
+
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+
+    est = PATCHED_MODELS[estimator]()
+
+    if method and not hasattr(est, method):
+        pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+
+    params = est.get_params().copy()
+    if "random_state" in params:
+        params["random_state"] = 0
+        est.set_params(**params)
+
+    datasets = gen_dataset(est, datasets=_dataset_dict, queue=queue, target_df=dataframe)
+    _run_test(est, method, datasets)
+
+
+@pytest.mark.allow_sklearn_fallback
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
+@pytest.mark.parametrize("estimator, method", gen_models_info(SPECIAL_INSTANCES))
+def test_special_estimator_stability(estimator, method, dataframe, queue):
+    if queue is None and estimator in ["LogisticRegression(solver='newton-cg')"]:
+        pytest.skip(f"stability not guaranteed for {estimator}")
+    if "KMeans" in estimator and method == "score" and queue == None:
+        pytest.skip(f"variation observed in KMeans.score")
+    if estimator == "BasicStatistics()" and queue == None:
+        pytest.skip(f"BasicStatistics not deterministic")
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    _skip_neighbors(estimator, method)
+
+    est = SPECIAL_INSTANCES[estimator]
+
+    if method and not hasattr(est, method):
+        pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+
+    params = est.get_params().copy()
+    if "random_state" in params:
+        params["random_state"] = 0
+        est.set_params(**params)
+
+    datasets = gen_dataset(est, datasets=_dataset_dict, queue=queue, target_df=dataframe)
+    _run_test(est, method, datasets)
+
+
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
+@pytest.mark.parametrize("estimator, method", gen_models_info(SPARSE_INSTANCES))
+def test_sparse_estimator_stability(estimator, method, dataframe, queue):
+    if "KMeans" in estimator and method in "score" and queue == None:
+        pytest.skip(f"variation observed in KMeans.{method}")
+    if (
+        not daal_check_version((2025, "P", 0))
+        and "KMeans()" in estimator
+        and queue == None
+    ):
+        pytest.skip(f"variation observed in KMeans.{method} in 2024.7 oneDAL")
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    _skip_neighbors(estimator, method)
+
+    est = SPARSE_INSTANCES[estimator]
+
+    if method and not hasattr(est, method):
+        pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+
+    params = est.get_params().copy()
+    if "random_state" in params:
+        params["random_state"] = 0
+        est.set_params(**params)
+
+    datasets = gen_dataset(
+        est, sparse=True, datasets=_dataset_dict, queue=queue, target_df=dataframe
+    )
+    _run_test(est, method, datasets)
+
+
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
+@pytest.mark.parametrize("estimator, method", gen_models_info(STABILITY_INSTANCES))
+def test_other_estimator_stability(estimator, method, dataframe, queue):
+    if "KMeans" in estimator and method == "score" and queue == None:
+        pytest.skip(f"variation observed in KMeans.score")
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    _skip_neighbors(estimator, method)
+
+    est = STABILITY_INSTANCES[estimator]
+
+    if method and not hasattr(est, method):
+        pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+
+    params = est.get_params().copy()
+    if "random_state" in params:
+        params["random_state"] = 0
+        est.set_params(**params)
+
+    datasets = gen_dataset(est, datasets=_dataset_dict, queue=queue, target_df=dataframe)
+    _run_test(est, method, datasets)
+
+
+@pytest.mark.parametrize("features", range(5, 10))
+def test_train_test_split(features):
+    X, y = make_classification(
+        n_samples=4000,
+        n_features=features,
+        n_informative=features,
+        n_redundant=0,
+        n_clusters_per_class=8,
+        random_state=0,
+    )
+    (
+        baseline_X_train,
+        baseline_X_test,
+        baseline_y_train,
+        baseline_y_test,
+    ) = train_test_split(X, y, test_size=0.33, random_state=0)
+    baseline = [baseline_X_train, baseline_X_test, baseline_y_train, baseline_y_test]
+    for _ in range(10):
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.33, random_state=0
+        )
+        res = [X_train, X_test, y_train, y_test]
+        for a, b in zip(res, baseline):
+            np.testing.assert_allclose(
+                a, b, rtol=0.0, atol=0.0, err_msg=str("train_test_split is incorrect")
+            )
+
+
+@pytest.mark.parametrize("metric", ["cosine", "correlation"])
+def test_pairwise_distances(metric):
+    X = np.random.rand(1000)
+    X = np.array(X, dtype=np.float64)
+    baseline = pairwise_distances(X.reshape(1, -1), metric=metric)
+    for _ in range(5):
+        res = pairwise_distances(X.reshape(1, -1), metric=metric)
+        for a, b in zip(res, baseline):
+            np.testing.assert_allclose(
+                a, b, rtol=0.0, atol=0.0, err_msg=str("pairwise_distances is incorrect")
+            )
+
+
+@pytest.mark.parametrize("array_size", [100, 1000, 10000])
+def test_roc_auc(array_size):
+    a = [random.randint(0, 1) for i in range(array_size)]
+    b = [random.randint(0, 1) for i in range(array_size)]
+    baseline = roc_auc_score(a, b)
+    for _ in range(5):
+        res = roc_auc_score(a, b)
+        np.testing.assert_allclose(
+            baseline, res, rtol=0.0, atol=0.0, err_msg=str("roc_auc is incorrect")
+        )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/tests/utils/__init__.py

@@ -0,0 +1,48 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from .base import (
+    DTYPES,
+    PATCHED_FUNCTIONS,
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    UNPATCHED_FUNCTIONS,
+    UNPATCHED_MODELS,
+    DummyEstimator,
+    _get_processor_info,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+    gen_sparse_dataset,
+    sklearn_clone_dict,
+)
+
+__all__ = [
+    "DTYPES",
+    "PATCHED_FUNCTIONS",
+    "PATCHED_MODELS",
+    "UNPATCHED_FUNCTIONS",
+    "UNPATCHED_MODELS",
+    "SPECIAL_INSTANCES",
+    "call_method",
+    "gen_models_info",
+    "gen_dataset",
+    "gen_sparse_dataset",
+    "sklearn_clone_dict",
+    "DummyEstimator",
+]
+
+_IS_INTEL = "GenuineIntel" in _get_processor_info()