scikit-learn-intelex 2025.1.0__py310-none-manylinux_2_28_x86_64.whl

sklearnex/tests/test_monkeypatch.py

@@ -0,0 +1,276 @@
+# ===============================================================================
+# 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 sklearnex
+from daal4py.sklearn._utils import daal_check_version
+
+# General use of patch_sklearn and unpatch_sklearn in pytest is not recommended.
+# It changes global state and can impact the operation of other tests. This file
+# specifically tests patch_sklearn and unpatch_sklearn and is exempt from this.
+# If sklearnex patching is necessary in testing, use the 'with_sklearnex' pytest
+# fixture.
+
+
+def test_monkey_patching():
+    _tokens = sklearnex.get_patch_names()
+    _values = sklearnex.get_patch_map().values()
+    _classes = list()
+
+    for v in _values:
+        for c in v:
+            _classes.append(c[0])
+
+    try:
+        sklearnex.patch_sklearn()
+
+        for i, _ in enumerate(_tokens):
+            t = _tokens[i]
+            p = _classes[i][0]
+            n = _classes[i][1]
+
+            class_module = getattr(p, n).__module__
+            assert class_module.startswith("daal4py") or class_module.startswith(
+                "sklearnex"
+            ), "Patching has completed with error."
+
+        for i, _ in enumerate(_tokens):
+            t = _tokens[i]
+            p = _classes[i][0]
+            n = _classes[i][1]
+
+            sklearnex.unpatch_sklearn(t)
+            sklearn_class = getattr(p, n, None)
+            if sklearn_class is not None:
+                sklearn_class = sklearn_class.__module__
+            assert sklearn_class is None or sklearn_class.startswith(
+                "sklearn"
+            ), "Unpatching has completed with error."
+
+    finally:
+        sklearnex.unpatch_sklearn()
+
+    try:
+        for i, _ in enumerate(_tokens):
+            t = _tokens[i]
+            p = _classes[i][0]
+            n = _classes[i][1]
+
+            sklearn_class = getattr(p, n, None)
+            if sklearn_class is not None:
+                sklearn_class = sklearn_class.__module__
+            assert sklearn_class is None or sklearn_class.startswith(
+                "sklearn"
+            ), "Unpatching has completed with error."
+
+    finally:
+        sklearnex.unpatch_sklearn()
+
+    try:
+        for i, _ in enumerate(_tokens):
+            t = _tokens[i]
+            p = _classes[i][0]
+            n = _classes[i][1]
+
+            sklearnex.patch_sklearn(t)
+
+            class_module = getattr(p, n).__module__
+            assert class_module.startswith("daal4py") or class_module.startswith(
+                "sklearnex"
+            ), "Patching has completed with error."
+    finally:
+        sklearnex.unpatch_sklearn()
+
+
+def test_patch_by_list_simple():
+    try:
+        sklearnex.patch_sklearn(["LogisticRegression"])
+
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.neighbors import KNeighborsRegressor
+        from sklearn.svm import SVC
+
+        assert RandomForestRegressor.__module__.startswith("sklearn")
+        assert KNeighborsRegressor.__module__.startswith("sklearn")
+        if daal_check_version((2024, "P", 1)):
+            assert LogisticRegression.__module__.startswith("sklearnex")
+        else:
+            assert LogisticRegression.__module__.startswith("daal4py")
+        assert SVC.__module__.startswith("sklearn")
+    finally:
+        sklearnex.unpatch_sklearn()
+
+
+def test_patch_by_list_many_estimators():
+    try:
+        sklearnex.patch_sklearn(["LogisticRegression", "SVC"])
+
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.neighbors import KNeighborsRegressor
+        from sklearn.svm import SVC
+
+        assert RandomForestRegressor.__module__.startswith("sklearn")
+        assert KNeighborsRegressor.__module__.startswith("sklearn")
+        if daal_check_version((2024, "P", 1)):
+            assert LogisticRegression.__module__.startswith("sklearnex")
+        else:
+            assert LogisticRegression.__module__.startswith("daal4py")
+        assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith(
+            "sklearnex"
+        )
+
+    finally:
+        sklearnex.unpatch_sklearn()
+
+
+def test_unpatch_by_list_many_estimators():
+    try:
+        sklearnex.patch_sklearn()
+
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.neighbors import KNeighborsRegressor
+        from sklearn.svm import SVC
+
+        assert RandomForestRegressor.__module__.startswith("sklearnex")
+        assert KNeighborsRegressor.__module__.startswith(
+            "daal4py"
+        ) or KNeighborsRegressor.__module__.startswith("sklearnex")
+        if daal_check_version((2024, "P", 1)):
+            assert LogisticRegression.__module__.startswith("sklearnex")
+        else:
+            assert LogisticRegression.__module__.startswith("daal4py")
+        assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith(
+            "sklearnex"
+        )
+
+        sklearnex.unpatch_sklearn(["KNeighborsRegressor", "RandomForestRegressor"])
+
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.neighbors import KNeighborsRegressor
+        from sklearn.svm import SVC
+
+        assert RandomForestRegressor.__module__.startswith("sklearn")
+        assert KNeighborsRegressor.__module__.startswith("sklearn")
+        if daal_check_version((2024, "P", 1)):
+            assert LogisticRegression.__module__.startswith("sklearnex")
+        else:
+            assert LogisticRegression.__module__.startswith("daal4py")
+
+        assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith(
+            "sklearnex"
+        )
+    finally:
+        sklearnex.unpatch_sklearn()
+
+
+def test_patching_checker():
+    for name in [None, "SVC", "PCA"]:
+        try:
+            sklearnex.patch_sklearn(name=name)
+            assert sklearnex.sklearn_is_patched(name=name)
+
+        finally:
+            sklearnex.unpatch_sklearn(name=name)
+            assert not sklearnex.sklearn_is_patched(name=name)
+    try:
+        sklearnex.patch_sklearn()
+        patching_status_map = sklearnex.sklearn_is_patched(return_map=True)
+        assert len(patching_status_map) == len(sklearnex.get_patch_names())
+        for status in patching_status_map.values():
+            assert status
+    finally:
+        sklearnex.unpatch_sklearn()
+
+    patching_status_map = sklearnex.sklearn_is_patched(return_map=True)
+    assert len(patching_status_map) == len(sklearnex.get_patch_names())
+    for status in patching_status_map.values():
+        assert not status
+
+
+def test_preview_namespace():
+    def get_estimators():
+        from sklearn.cluster import DBSCAN
+        from sklearn.decomposition import PCA
+        from sklearn.ensemble import RandomForestClassifier
+        from sklearn.linear_model import LinearRegression, Ridge
+        from sklearn.svm import SVC
+
+        return (
+            Ridge(),
+            LinearRegression(),
+            PCA(),
+            DBSCAN(),
+            SVC(),
+            RandomForestClassifier(),
+        )
+
+    from sklearnex.dispatcher import _is_preview_enabled
+
+    try:
+        sklearnex.patch_sklearn(preview=True)
+
+        assert _is_preview_enabled()
+
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+        assert "sklearnex" in rfc.__module__
+
+        if daal_check_version((2024, "P", 600)):
+            assert "sklearnex.preview" in ridge.__module__
+
+        if daal_check_version((2023, "P", 100)):
+            assert "sklearnex" in lr.__module__
+        else:
+            assert "daal4py" in lr.__module__
+
+        assert "sklearnex" in pca.__module__
+        assert "sklearnex" in dbscan.__module__
+        assert "sklearnex" in svc.__module__
+
+    finally:
+        sklearnex.unpatch_sklearn()
+
+    # no patching behavior
+    ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+    assert "sklearn." in ridge.__module__ and "daal4py" not in ridge.__module__
+    assert "sklearn." in lr.__module__ and "daal4py" not in lr.__module__
+    assert "sklearn." in pca.__module__ and "daal4py" not in pca.__module__
+    assert "sklearn." in dbscan.__module__ and "daal4py" not in dbscan.__module__
+    assert "sklearn." in svc.__module__ and "daal4py" not in svc.__module__
+    assert "sklearn." in rfc.__module__ and "daal4py" not in rfc.__module__
+
+    # default patching behavior
+    try:
+        sklearnex.patch_sklearn()
+        assert not _is_preview_enabled()
+
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+
+        assert "daal4py" in ridge.__module__
+
+        if daal_check_version((2023, "P", 100)):
+            assert "sklearnex" in lr.__module__
+        else:
+            assert "daal4py" in lr.__module__
+
+        assert "sklearnex" in pca.__module__
+        assert "sklearnex" in rfc.__module__
+        assert "sklearnex" in dbscan.__module__
+        assert "sklearnex" in svc.__module__
+    finally:
+        sklearnex.unpatch_sklearn()

sklearnex/tests/test_n_jobs_support.py

@@ -0,0 +1,108 @@
+# ==============================================================================
+# 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.datasets import make_classification
+from sklearn.exceptions import NotFittedError
+
+from sklearnex.tests.utils import (
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+)
+
+_X, _Y = make_classification(n_samples=40, n_features=4, random_state=42)
+
+
+def _get_estimator_instance(estimator):
+    if estimator in PATCHED_MODELS:
+        est = PATCHED_MODELS[estimator]()
+    elif estimator in SPECIAL_INSTANCES:
+        est = SPECIAL_INSTANCES[estimator]
+    else:
+        raise KeyError(f"{estimator} not in patch_map or SPECIAL_INSTANCES")
+    return est
+
+
+def _check_n_jobs_entry_in_logs(records, function_name, n_jobs):
+    expected_n_jobs = max(n_jobs, n_jobs % (cpu_count() + 1)) if n_jobs else cpu_count()
+    for rec in records:
+        if f"{function_name}: setting {expected_n_jobs} threads" in rec:
+            return True
+    # False if n_jobs is set and not found in logs
+    return n_jobs is None
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+def test_n_jobs_documentation(estimator):
+    est = _get_estimator_instance(estimator)
+    assert "n_jobs" in est.__doc__
+    assert "n_jobs" in est.__class__.__doc__
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+def test_n_jobs_method_decoration(estimator):
+    est = _get_estimator_instance(estimator)
+    for func_name, func in vars(est).items():
+        # hasattr check necessary due to sklearn's available_if wrapper
+        if hasattr(est, func_name) and callable(func):
+            assert hasattr(func, "__onedal_n_jobs_decorated__") == (
+                func_name in est._n_jobs_supported_onedal_methods
+            ), f"{est}.{func_name} n_jobs decoration does not match {est} n_jobs supported methods"
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+@pytest.mark.parametrize("n_jobs", [None, -1, 1, 2])
+def test_n_jobs_support(estimator, n_jobs, caplog):
+
+    est = _get_estimator_instance(estimator)
+    caplog.set_level(logging.DEBUG, logger="sklearnex")
+
+    # copy params and modify n_jobs, assumes estimator inherits from BaseEstimator
+    # or properly supports get_params and set_params methods as defined by sklearn
+    params = est.get_params()
+    params["n_jobs"] = n_jobs
+    est.set_params(**params)
+
+    # check `n_jobs` log entry for supported methods
+    # `fit` call is required before other methods
+    est.fit(_X, _Y)
+    messages = [msg.message for msg in caplog.records]
+    assert _check_n_jobs_entry_in_logs(messages, "fit", n_jobs)
+
+    for method_name in est._n_jobs_supported_onedal_methods:
+        # do not call fit again, handle sklearn's available_if wrapper
+        if method_name == "fit" or (
+            "NearestNeighbors" in estimator and "radius" in method_name
+        ):
+            # radius_neighbors and radius_neighbors_graph violate sklearn fallback guard
+            # but use sklearnex interally, additional development must be done to those
+            # functions to bring them to design compliance.
+            continue
+        try:
+            call_method(est, method_name, _X, _Y)
+        except (NotFittedError, AttributeError) as e:
+            # handle sklearns available_if wrapper
+            continue
+
+        messages = [msg.message for msg in caplog.records]
+        assert _check_n_jobs_entry_in_logs(messages, method_name, n_jobs)

sklearnex/tests/test_parallel.py

@@ -0,0 +1,48 @@
+# ==============================================================================
+# 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 pytest
+
+from sklearnex import config_context
+
+try:
+    import dpctl
+
+    dpctl_is_available = True
+    gpu_is_available = dpctl.has_gpu_devices()
+except (ImportError, ModuleNotFoundError):
+    dpctl_is_available = False
+
+
+@pytest.mark.skipif(
+    not dpctl_is_available or gpu_is_available,
+    reason="GPU device should not be available for this test "
+    "to see raised 'SyclQueueCreationError'. "
+    "'dpctl' module is required for test.",
+)
+def test_config_context_in_parallel(with_sklearnex):
+    from sklearn.datasets import make_classification
+    from sklearn.ensemble import BaggingClassifier
+    from sklearn.svm import SVC
+
+    x, y = make_classification(random_state=42)
+    try:
+        with config_context(target_offload="gpu", allow_fallback_to_host=False):
+            BaggingClassifier(SVC(), n_jobs=2).fit(x, y)
+        raise ValueError(
+            "'SyclQueueCreationError' wasn't raised " "for non-existing 'gpu' device"
+        )
+    except dpctl._sycl_queue.SyclQueueCreationError:
+        pass