scikit-learn-intelex 2024.0.1__py312-none-win_amd64.whl

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -0,0 +1,210 @@
+# ===============================================================================
+# 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
+
+
+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])
+
+    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)
+        class_module = getattr(p, n).__module__
+        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
+
+    sklearnex.unpatch_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("sklearn"), "Unpatching has completed with error."
+
+    sklearnex.unpatch_sklearn()
+
+    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."
+
+    sklearnex.unpatch_sklearn()
+
+
+def test_patch_by_list_simple():
+    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")
+    assert LogisticRegression.__module__.startswith("daal4py")
+    assert SVC.__module__.startswith("sklearn")
+
+    sklearnex.unpatch_sklearn()
+
+
+def test_patch_by_list_many_estimators():
+    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")
+    assert LogisticRegression.__module__.startswith("daal4py")
+    assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
+
+    sklearnex.unpatch_sklearn()
+
+
+def test_unpatch_by_list_many_estimators():
+    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")
+    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")
+    assert LogisticRegression.__module__.startswith("daal4py")
+    assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
+
+
+def test_patching_checker():
+    for name in [None, "SVC", "PCA"]:
+        sklearnex.patch_sklearn(name=name)
+        assert sklearnex.sklearn_is_patched(name=name)
+
+        sklearnex.unpatch_sklearn(name=name)
+        assert not sklearnex.sklearn_is_patched(name=name)
+
+    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
+
+    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
+        from sklearn.svm import SVC
+
+        return LinearRegression(), PCA(), DBSCAN(), SVC(), RandomForestClassifier()
+
+    # BUG: previous patching tests force PCA to be patched with daal4py.
+    # This unpatching returns behavior to expected
+    sklearnex.unpatch_sklearn()
+    # behavior with enabled preview
+    sklearnex.patch_sklearn(preview=True)
+    assert sklearnex.dispatcher._is_preview_enabled()
+
+    lr, pca, dbscan, svc, rfc = get_estimators()
+    assert "sklearnex" in rfc.__module__
+
+    if daal_check_version((2023, "P", 100)):
+        assert "sklearnex" in lr.__module__
+    else:
+        assert "daal4py" in lr.__module__
+
+    assert "sklearnex.preview" in pca.__module__
+    assert "sklearnex" in dbscan.__module__
+    assert "sklearnex" in svc.__module__
+    sklearnex.unpatch_sklearn()
+
+    # no patching behavior
+    lr, pca, dbscan, svc, rfc = get_estimators()
+    assert "sklearn." in lr.__module__
+    assert "sklearn." in pca.__module__
+    assert "sklearn." in dbscan.__module__
+    assert "sklearn." in svc.__module__
+    assert "sklearn." in rfc.__module__
+
+    # default patching behavior
+    sklearnex.patch_sklearn()
+    assert not sklearnex.dispatcher._is_preview_enabled()
+
+    lr, pca, dbscan, svc, rfc = get_estimators()
+    if daal_check_version((2023, "P", 100)):
+        assert "sklearnex" in lr.__module__
+    else:
+        assert "daal4py" in lr.__module__
+    assert "daal4py" in pca.__module__
+    assert "sklearnex" in rfc.__module__
+    assert "sklearnex" in dbscan.__module__
+    assert "sklearnex" in svc.__module__
+    sklearnex.unpatch_sklearn()

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/tests/test_parallel.py

@@ -0,0 +1,50 @@
+# ==============================================================================
+# 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, patch_sklearn
+
+patch_sklearn()
+
+from sklearn.datasets import make_classification
+from sklearn.ensemble import BaggingClassifier
+from sklearn.svm import SVC
+
+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():
+    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

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -0,0 +1,122 @@
+# ==============================================================================
+# 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 os
+import pathlib
+import re
+import subprocess
+import sys
+from inspect import isclass
+
+import pytest
+from _models_info import TO_SKIP
+from sklearn.base import BaseEstimator
+
+from sklearnex import get_patch_map, is_patched_instance, patch_sklearn, unpatch_sklearn
+
+
+def get_branch(s):
+    if len(s) == 0:
+        return "NO INFO"
+    for i in s:
+        if "failed to run accelerated version, fallback to original Scikit-learn" in i:
+            return "was in OPT, but go in Scikit"
+    for i in s:
+        if "running accelerated version" in i:
+            return "OPT"
+    return "Scikit"
+
+
+def run_parse(mas, result):
+    name, dtype = mas[0].split()
+    temp = []
+    INFO_POS = 16
+    for i in range(1, len(mas)):
+        mas[i] = mas[i][INFO_POS:]  # remove 'SKLEARNEX INFO: '
+        if not mas[i].startswith("sklearn"):
+            ind = name + " " + dtype + " " + mas[i]
+            result[ind] = get_branch(temp)
+            temp.clear()
+        else:
+            temp.append(mas[i])
+
+
+def get_result_log():
+    os.environ["SKLEARNEX_VERBOSE"] = "INFO"
+    absolute_path = str(pathlib.Path(__file__).parent.absolute())
+    try:
+        process = subprocess.check_output(
+            [sys.executable, absolute_path + "/utils/_launch_algorithms.py"]
+        )
+    except subprocess.CalledProcessError as e:
+        print(e)
+        exit(1)
+    mas = []
+    result = {}
+    for i in process.decode().split("\n"):
+        if i.startswith("SKLEARNEX WARNING"):
+            continue
+        if not i.startswith("SKLEARNEX INFO") and len(mas) != 0:
+            run_parse(mas, result)
+            mas.clear()
+            mas.append(i.strip())
+        else:
+            mas.append(i.strip())
+    del os.environ["SKLEARNEX_VERBOSE"]
+    return result
+
+
+result_log = get_result_log()
+
+
+@pytest.mark.parametrize("configuration", result_log)
+def test_patching(configuration):
+    if "OPT" in result_log[configuration]:
+        return
+    for skip in TO_SKIP:
+        if re.search(skip, configuration) is not None:
+            pytest.skip("SKIPPED", allow_module_level=False)
+    raise ValueError("Test patching failed: " + configuration)
+
+
+def _load_all_models(patched):
+    if patched:
+        patch_sklearn()
+
+    models = []
+    for patch_infos in get_patch_map().values():
+        maybe_class = getattr(patch_infos[0][0][0], patch_infos[0][0][1])
+        if (
+            maybe_class is not None
+            and isclass(maybe_class)
+            and issubclass(maybe_class, BaseEstimator)
+        ):
+            models.append(maybe_class())
+
+    if patched:
+        unpatch_sklearn()
+
+    return models
+
+
+PATCHED_MODELS = _load_all_models(patched=True)
+UNPATCHED_MODELS = _load_all_models(patched=False)
+
+
+@pytest.mark.parametrize(("patched", "unpatched"), zip(PATCHED_MODELS, UNPATCHED_MODELS))
+def test_is_patched_instance(patched, unpatched):
+    assert is_patched_instance(patched), f"{patched} is a patched instance"
+    assert not is_patched_instance(unpatched), f"{unpatched} is an unpatched instance"