scikit-learn-intelex 2025.0.1__py311-none-win_amd64.whl → 2025.2.0__py311-none-win_amd64.whl

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/datatypes/tests/test_data.py

@@ -1,235 +0,0 @@
-# ==============================================================================
-# Copyright 2021 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 import _backend
-from onedal.datatypes import from_table, to_table
-from onedal.primitives import linear_kernel
-from onedal.tests.utils._device_selection import get_queues
-
-try:
-    import dpctl
-    import dpctl.tensor as dpt
-
-    dpctl_available = dpctl.__version__ >= "0.14"
-except ImportError:
-    dpctl_available = False
-
-
-def _test_input_format_c_contiguous_numpy(queue, dtype):
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="C")
-    assert x_numpy.flags.c_contiguous
-    assert not x_numpy.flags.f_contiguous
-    assert not x_numpy.flags.fnc
-
-    expected = linear_kernel(x_default, queue=queue)
-    result = linear_kernel(x_numpy, queue=queue)
-    assert_allclose(expected, result)
-
-
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_input_format_c_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
-    _test_input_format_c_contiguous_numpy(queue, dtype)
-
-
-def _test_input_format_f_contiguous_numpy(queue, dtype):
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="F")
-    assert not x_numpy.flags.c_contiguous
-    assert x_numpy.flags.f_contiguous
-    assert x_numpy.flags.fnc
-
-    expected = linear_kernel(x_default, queue=queue)
-    result = linear_kernel(x_numpy, queue=queue)
-    assert_allclose(expected, result)
-
-
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_input_format_f_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
-    _test_input_format_f_contiguous_numpy(queue, dtype)
-
-
-def _test_input_format_c_not_contiguous_numpy(queue, dtype):
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
-
-    dummy_data = np.insert(x_default, range(1, x_default.shape[1]), 8, axis=1)
-    x_numpy = dummy_data[:, ::2]
-
-    assert_allclose(x_numpy, x_default)
-
-    assert not x_numpy.flags.c_contiguous
-    assert not x_numpy.flags.f_contiguous
-    assert not x_numpy.flags.fnc
-
-    expected = linear_kernel(x_default, queue=queue)
-    result = linear_kernel(x_numpy, queue=queue)
-    assert_allclose(expected, result)
-
-
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_input_format_c_not_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
-    _test_input_format_c_not_contiguous_numpy(queue, dtype)
-
-
-def _test_input_format_c_contiguous_pandas(queue, dtype):
-    pd = pytest.importorskip("pandas")
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="C")
-    assert x_numpy.flags.c_contiguous
-    assert not x_numpy.flags.f_contiguous
-    assert not x_numpy.flags.fnc
-    x_df = pd.DataFrame(x_numpy)
-
-    expected = linear_kernel(x_df, queue=queue)
-    result = linear_kernel(x_numpy, queue=queue)
-    assert_allclose(expected, result)
-
-
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_input_format_c_contiguous_pandas(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
-    _test_input_format_c_contiguous_pandas(queue, dtype)
-
-
-def _test_input_format_f_contiguous_pandas(queue, dtype):
-    pd = pytest.importorskip("pandas")
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="F")
-    assert not x_numpy.flags.c_contiguous
-    assert x_numpy.flags.f_contiguous
-    assert x_numpy.flags.fnc
-    x_df = pd.DataFrame(x_numpy)
-
-    expected = linear_kernel(x_df, queue=queue)
-    result = linear_kernel(x_numpy, queue=queue)
-    assert_allclose(expected, result)
-
-
-@pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_input_format_f_contiguous_pandas(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
-    _test_input_format_f_contiguous_pandas(queue, dtype)
-
-
-def _test_conversion_to_table(dtype):
-    np.random.seed()
-    if dtype in [np.int32, np.int64]:
-        x = np.random.randint(0, 10, (15, 3), dtype=dtype)
-    else:
-        x = np.random.uniform(-2, 2, (18, 6)).astype(dtype)
-    x_table = to_table(x)
-    x2 = from_table(x_table)
-    assert x.dtype == x2.dtype
-    assert np.array_equal(x, x2)
-
-
-@pytest.mark.parametrize("dtype", [np.int32, np.int64, np.float32, np.float64])
-def test_conversion_to_table(dtype):
-    _test_conversion_to_table(dtype)
-
-
-# TODO:
-# Currently `dpctl_to_table` is not used in onedal estimators.
-# The test will be enabled after future data management update, that brings
-# re-impl of conversions between onedal tables and usm ndarrays.
-@pytest.mark.skip(
-    reason="Currently removed. Will be enabled after data management update"
-)
-@pytest.mark.skipif(not dpctl_available, reason="requires dpctl>=0.14")
-@pytest.mark.parametrize("queue", get_queues("cpu,gpu"))
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
-def test_input_format_c_contiguous_dpctl(queue, dtype):
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 59)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="C")
-    x_dpt = dpt.asarray(x_numpy, usm_type="device", sycl_queue=queue)
-    # assert not x_dpt.flags.fnc
-    assert isinstance(x_dpt, dpt.usm_ndarray)
-
-    x_table = _backend.dpctl_to_table(x_dpt)
-    assert hasattr(x_table, "__sycl_usm_array_interface__")
-    x_dpt_from_table = dpt.asarray(x_table)
-
-    assert (
-        x_dpt.__sycl_usm_array_interface__["data"][0]
-        == x_dpt_from_table.__sycl_usm_array_interface__["data"][0]
-    )
-    assert x_dpt.shape == x_dpt_from_table.shape
-    assert x_dpt.strides == x_dpt_from_table.strides
-    assert x_dpt.dtype == x_dpt_from_table.dtype
-    assert x_dpt.flags.c_contiguous
-    assert x_dpt_from_table.flags.c_contiguous
-
-
-# TODO:
-# Currently `dpctl_to_table` is not used in onedal estimators.
-# The test will be enabled after future data management update, that brings
-# re-impl of conversions between onedal tables and usm ndarrays.
-@pytest.mark.skip(
-    reason="Currently removed. Will be enabled after data management update"
-)
-@pytest.mark.skipif(not dpctl_available, reason="requires dpctl>=0.14")
-@pytest.mark.parametrize("queue", get_queues("cpu,gpu"))
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
-def test_input_format_f_contiguous_dpctl(queue, dtype):
-    rng = np.random.RandomState(0)
-    x_default = np.array(5 * rng.random_sample((10, 59)), dtype=dtype)
-
-    x_numpy = np.asanyarray(x_default, dtype=dtype, order="F")
-    x_dpt = dpt.asarray(x_numpy, usm_type="device", sycl_queue=queue)
-    # assert not x_dpt.flags.fnc
-    assert isinstance(x_dpt, dpt.usm_ndarray)
-
-    x_table = _backend.dpctl_to_table(x_dpt)
-    assert hasattr(x_table, "__sycl_usm_array_interface__")
-    x_dpt_from_table = dpt.asarray(x_table)
-
-    assert (
-        x_dpt.__sycl_usm_array_interface__["data"][0]
-        == x_dpt_from_table.__sycl_usm_array_interface__["data"][0]
-    )
-    assert x_dpt.shape == x_dpt_from_table.shape
-    assert x_dpt.strides == x_dpt_from_table.strides
-    assert x_dpt.dtype == x_dpt_from_table.dtype
-    assert x_dpt.flags.f_contiguous
-    assert x_dpt_from_table.flags.f_contiguous

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/linear_model/logistic_path.py

@@ -1,17 +0,0 @@
-# ===============================================================================
-# Copyright 2021 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 daal4py.sklearn.linear_model import LogisticRegression, logistic_regression_path

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/linear_model/ridge.py

@@ -1,24 +0,0 @@
-# ===============================================================================
-# Copyright 2021 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 daal4py.sklearn.linear_model import Ridge
-from onedal._device_offload import support_input_format
-
-# Note: `sklearnex.linear_model.Ridge` only has functional
-# sycl GPU support. No GPU device will be offloaded.
-Ridge.fit = support_input_format(queue_param=False)(Ridge.fit)
-Ridge.predict = support_input_format(queue_param=False)(Ridge.predict)
-Ridge.score = support_input_format(queue_param=False)(Ridge.score)

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/manifold/tests/test_tsne.py

@@ -1,26 +0,0 @@
-# ===============================================================================
-# Copyright 2021 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
-from numpy.testing import assert_allclose
-
-
-def test_sklearnex_import():
-    from sklearnex.manifold import TSNE
-
-    X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
-    tsne = TSNE(n_components=2, perplexity=2.0).fit(X)
-    assert "daal4py" in tsne.__module__

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/preview/linear_model/__init__.py

@@ -1,19 +0,0 @@
-# ===============================================================================
-# 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 .ridge import Ridge
-
-__all__ = ["Ridge"]

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

@@ -1,102 +0,0 @@
-# ===============================================================================
-# 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 numpy.testing import assert_allclose
-from sklearn.exceptions import NotFittedError
-
-from daal4py.sklearn._utils import daal_check_version
-from onedal.tests.utils._dataframes_support import (
-    _convert_to_dataframe,
-    get_dataframes_and_queues,
-)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import_ridge(dataframe, queue):
-    from sklearnex.preview.linear_model import Ridge
-
-    X = numpy.array([[1, 1], [1, 2], [2, 2], [2, 3]])
-    y = numpy.dot(X, numpy.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 "preview" 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])
-def test_ridge_coefficients(dataframe, queue, sample_size, feature_size, alpha):
-    from sklearnex.preview.linear_model import Ridge
-
-    X = numpy.random.rand(sample_size, feature_size)
-    y = numpy.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=False, alpha=alpha).fit(X_c, y_c)
-
-    # computing the coefficients manually
-    # using the normal equation formula: (X^T * X + lambda * I)^-1 * X^T * y
-    lambda_identity = alpha * numpy.eye(X.shape[1])
-    inverse_term = numpy.linalg.inv(numpy.dot(X.T, X) + lambda_identity)
-    xt_y = numpy.dot(X.T, y)
-    coefficients_manual = numpy.dot(inverse_term, xt_y)
-
-    assert_allclose(ridge_reg.coef_, coefficients_manual, rtol=1e-6, atol=1e-6)
-
-
-if daal_check_version((2024, "P", 600)):
-
-    @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-    def test_ridge_score_before_fit(dataframe, queue):
-        from sklearnex.preview.linear_model import Ridge
-
-        sample_count, feature_count = 10, 5
-
-        model = Ridge(fit_intercept=True, alpha=0.5)
-
-        X, y = numpy.random.rand(sample_count, feature_count), numpy.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.parametrize("dataframe,queue", get_dataframes_and_queues())
-    def test_ridge_predict_before_fit(dataframe, queue):
-        from sklearnex.preview.linear_model import Ridge
-
-        sample_count, feature_count = 10, 5
-
-        model = Ridge(fit_intercept=True, alpha=0.5)
-
-        X = numpy.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)

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -1,54 +0,0 @@
-# ==============================================================================
-# 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 os
-from glob import glob
-
-import pytest
-
-ALLOWED_LOCATIONS = [
-    "_config.py",
-    "_device_offload.py",
-    "test",
-    "svc.py",
-    "svm" + os.sep + "_common.py",
-]
-
-
-def test_target_offload_ban():
-    """This test blocks the use of target_offload in
-    in sklearnex files. Offloading computation to devices
-    via target_offload should only occur externally, and not
-    within the architecture of the sklearnex classes. This
-    is for clarity, traceability and maintainability.
-    """
-    from sklearnex import __file__ as loc
-
-    path = loc.replace("__init__.py", "")
-    files = [y for x in os.walk(path) for y in glob(os.path.join(x[0], "*.py"))]
-
-    output = []
-
-    for f in files:
-        if open(f, "r").read().find("target_offload") != -1:
-            output += [f.replace(path, "sklearnex" + os.sep)]
-
-    # remove this file from the list
-    for allowed in ALLOWED_LOCATIONS:
-        output = [i for i in output if allowed not in i]
-
-    output = "\n".join(output)
-    assert output == "", f"sklearn versioning is occuring in: \n{output}"

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -1,43 +0,0 @@
-# ==============================================================================
-# Copyright 2021 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 sklearn
-
-import onedal
-import sklearnex
-
-
-def test_get_config_contains_sklearn_params():
-    skex_config = sklearnex.get_config()
-    sk_config = sklearn.get_config()
-
-    assert all(value in skex_config.keys() for value in sk_config.keys())
-
-
-def test_set_config_works():
-    default_config = sklearnex.get_config()
-    sklearnex.set_config(
-        assume_finite=True, target_offload="cpu:0", allow_fallback_to_host=True
-    )
-
-    config = sklearnex.get_config()
-    onedal_config = onedal._config._get_config()
-    assert config["target_offload"] == "cpu:0"
-    assert config["allow_fallback_to_host"]
-    assert config["assume_finite"]
-    assert onedal_config["target_offload"] == "cpu:0"
-    assert onedal_config["allow_fallback_to_host"]
-    sklearnex.set_config(**default_config)

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py

@@ -1,103 +0,0 @@
-# ==============================================================================
-# Copyright 2023 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 inspect
-import logging
-from multiprocessing import cpu_count
-
-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
-
-ESTIMATORS = set(
-    filter(
-        lambda x: inspect.isclass(x) and issubclass(x, BaseEstimator),
-        [value[0][0][2] for value in get_patch_map().values()],
-    )
-)
-
-X, Y = make_classification(n_samples=40, n_features=4, random_state=42)
-
-
-@pytest.mark.parametrize("estimator_class", ESTIMATORS)
-@pytest.mark.parametrize("n_jobs", [None, -1, 1, 2])
-def test_n_jobs_support(caplog, estimator_class, n_jobs):
-    def check_estimator_doc(estimator):
-        if estimator.__doc__ is not None:
-            assert "n_jobs" in estimator.__doc__
-
-    def check_n_jobs_entry_in_logs(caplog, function_name, n_jobs):
-        for rec in caplog.records:
-            if function_name in rec.message and "threads" in rec.message:
-                expected_n_jobs = n_jobs if n_jobs > 0 else cpu_count() + 1 + n_jobs
-                logging.info(f"{function_name}: setting {expected_n_jobs} threads")
-                if f"{function_name}: setting {expected_n_jobs} threads" in rec.message:
-                    return True
-        # False if n_jobs is set and not found in logs
-        return n_jobs is None
-
-    def check_method(*args, method, caplog):
-        method(*args)
-        assert check_n_jobs_entry_in_logs(caplog, method.__name__, n_jobs)
-
-    def check_methods_decoration(estimator):
-        funcs = {
-            i: getattr(estimator, i)
-            for i in dir(estimator)
-            if hasattr(estimator, i) and callable(getattr(estimator, i))
-        }
-
-        for func_name, func in funcs.items():
-            assert hasattr(func, "__onedal_n_jobs_decorated__") == (
-                func_name in estimator._n_jobs_supported_onedal_methods
-            ), f"{estimator}.{func_name} n_jobs decoration does not match {estimator} n_jobs supported methods"
-
-    caplog.set_level(logging.DEBUG, logger="sklearnex")
-    estimator_kwargs = {"n_jobs": 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)
-    check_estimator_doc(estimator_instance)
-    # check `n_jobs` log entry for supported methods
-    # `fit` call is required before other methods
-    check_method(X, Y, method=estimator_instance.fit, caplog=caplog)
-    for method_name in estimator_instance._n_jobs_supported_onedal_methods:
-        if method_name == "fit":
-            continue
-        method = getattr(estimator_instance, method_name)
-        argdict = inspect.signature(method).parameters
-        argnum = len(
-            [i for i in argdict if argdict[i].default == inspect.Parameter.empty]
-        )
-        if argnum == 0:
-            check_method(method=method, caplog=caplog)
-        elif argnum == 1:
-            check_method(X, method=method, caplog=caplog)
-        else:
-            check_method(X, Y, method=method, caplog=caplog)
-    # check if correct methods were decorated
-    check_methods_decoration(estimator_class)
-    check_methods_decoration(estimator_instance)

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

@@ -1,19 +0,0 @@
-# ===============================================================================
-# Copyright 2022 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 .validation import _assert_all_finite
-
-__all__ = ["_assert_all_finite"]