scikit-learn-intelex 2024.1.0__py310-none-manylinux1_x86_64.whl → 2024.3.0__py310-none-manylinux1_x86_64.whl

sklearnex/tests/test_monkeypatch.py

@@ -17,6 +17,12 @@
 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()
@@ -27,129 +33,170 @@ def test_monkey_patching():
         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()
+    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():
-    sklearnex.patch_sklearn(["LogisticRegression"])
+    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")
-    assert LogisticRegression.__module__.startswith("daal4py")
-    assert SVC.__module__.startswith("sklearn")
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.neighbors import KNeighborsRegressor
+        from sklearn.svm import SVC
 
-    sklearnex.unpatch_sklearn()
+        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():
-    sklearnex.patch_sklearn(["LogisticRegression", "SVC"])
+    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
+        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")
+        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"
+        )
 
-    sklearnex.unpatch_sklearn()
+    finally:
+        sklearnex.unpatch_sklearn()
 
 
 def test_unpatch_by_list_many_estimators():
-    sklearnex.patch_sklearn()
+    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
 
-    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"
+        )
 
-    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"])
 
-    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
 
-    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 RandomForestRegressor.__module__.startswith("sklearn")
-    assert KNeighborsRegressor.__module__.startswith("sklearn")
-    assert LogisticRegression.__module__.startswith("daal4py")
-    assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
+        assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith(
+            "sklearnex"
+        )
+    finally:
+        sklearnex.unpatch_sklearn()
 
 
 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
+        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()
 
-    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():
@@ -161,67 +208,61 @@ def test_preview_namespace():
         from sklearn.cluster import DBSCAN
         from sklearn.decomposition import PCA
         from sklearn.ensemble import RandomForestClassifier
-        from sklearn.linear_model import LinearRegression, LogisticRegression
+        from sklearn.linear_model import LinearRegression
         from sklearn.svm import SVC
 
         return (
             LinearRegression(),
-            LogisticRegression(),
             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)
     from sklearnex.dispatcher import _is_preview_enabled
 
-    assert _is_preview_enabled()
+    try:
+        sklearnex.patch_sklearn(preview=True)
+
+        assert _is_preview_enabled()
 
-    lr, log_reg, pca, dbscan, svc, rfc = get_estimators()
-    assert "sklearnex" in rfc.__module__
+        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__
+        if daal_check_version((2023, "P", 100)):
+            assert "sklearnex" in lr.__module__
+        else:
+            assert "daal4py" in lr.__module__
 
-    if daal_check_version((2024, "P", 1)):
-        assert "sklearnex" in log_reg.__module__
-    else:
-        assert "daal4py" in log_reg.__module__
+        assert "sklearnex" in pca.__module__
+        assert "sklearnex" in dbscan.__module__
+        assert "sklearnex" in svc.__module__
 
-    assert "sklearnex.preview" in pca.__module__
-    assert "sklearnex" in dbscan.__module__
-    assert "sklearnex" in svc.__module__
-    sklearnex.unpatch_sklearn()
+    finally:
+        sklearnex.unpatch_sklearn()
 
     # no patching behavior
-    lr, log_reg, pca, dbscan, svc, rfc = get_estimators()
+    lr, pca, dbscan, svc, rfc = get_estimators()
     assert "sklearn." in lr.__module__ and "daal4py" not in lr.__module__
-    assert "sklearn." in log_reg.__module__ and "daal4py" not in log_reg.__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
-    sklearnex.patch_sklearn()
-    assert not _is_preview_enabled()
-
-    lr, log_reg, 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 log_reg.__module__
-    assert "daal4py" in pca.__module__
-    assert "sklearnex" in rfc.__module__
-    assert "sklearnex" in dbscan.__module__
-    assert "sklearnex" in svc.__module__
-    sklearnex.unpatch_sklearn()
+    try:
+        sklearnex.patch_sklearn()
+        assert not _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 "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

@@ -14,18 +14,80 @@
 # 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.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
 
-from sklearnex.cluster import KMeans
-from sklearnex.linear_model import ElasticNet, Lasso, Ridge
-from sklearnex.svm import SVC, SVR, NuSVC, NuSVR
+    def check_method(*args, method, caplog):
+        method(*args)
+        assert check_n_jobs_entry_in_logs(caplog, method.__name__, n_jobs)
 
-estimators = [KMeans, SVC, SVR, NuSVC, NuSVR, Lasso, Ridge, ElasticNet]
+    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"
 
-@pytest.mark.parametrize("estimator", estimators)
-def test_n_jobs_support(estimator):
-    # use `n_jobs` parameter where original sklearn doesn't expect it
-    estimator(n_jobs=1)
+    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
+    estimator_instance = estimator_class(**estimator_kwargs)
     # check `n_jobs` parameter doc entry
-    assert "n_jobs" in estimator.__doc__
+    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)
+        if len(inspect.signature(method).parameters) == 0:
+            check_method(method=method, caplog=caplog)
+        else:
+            check_method(X, method=method, caplog=caplog)
+    # check if correct methods were decorated
+    check_methods_decoration(estimator_class)
+    check_methods_decoration(estimator_instance)

sklearnex/tests/test_parallel.py

@@ -15,13 +15,7 @@
 # ==============================================================================
 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
+from sklearnex import config_context
 
 try:
     import dpctl
@@ -38,7 +32,11 @@ except (ImportError, ModuleNotFoundError):
     "to see raised 'SyclQueueCreationError'. "
     "'dpctl' module is required for test.",
 )
-def test_config_context_in_parallel():
+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):