scikit-learn-intelex 2024.2.0__py312-none-win_amd64.whl → 2024.3.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+
 import gc
 import logging
 import tracemalloc
@@ -30,7 +31,6 @@ from sklearn.model_selection import KFold
 from sklearnex import get_patch_map
 from sklearnex.metrics import pairwise_distances, roc_auc_score
 from sklearnex.model_selection import train_test_split
-from sklearnex.preview.decomposition import PCA as PreviewPCA
 from sklearnex.utils import _assert_all_finite
 
 
@@ -75,6 +75,8 @@ class RocAucEstimator:
 
 
 # add all daal4py estimators enabled in patching (except banned)
+
+
 def get_patched_estimators(ban_list, output_list):
     patched_estimators = get_patch_map().values()
     for listing in patched_estimators:
@@ -96,7 +98,6 @@ def remove_duplicated_estimators(estimators_list):
 
 BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
 estimators = [
-    PreviewPCA,
     TrainTestSplitEstimator,
     FiniteCheckEstimator,
     CosineDistancesEstimator,
@@ -153,6 +154,7 @@ def split_train_inference(kf, x, y, estimator):
             y_train, y_test = y.iloc[train_index], y.iloc[test_index]
         # TODO: add parameters for all estimators to prevent
         # fallback to stock scikit-learn with default parameters
+
         alg = estimator()
         alg.fit(x_train, y_train)
         if hasattr(alg, "predict"):
@@ -163,7 +165,6 @@ def split_train_inference(kf, x, y, estimator):
             alg.kneighbors(x_test)
         del alg, x_train, x_test, y_train, y_test
         mem_tracks.append(tracemalloc.get_traced_memory()[0])
-
     return mem_tracks
 
 
@@ -215,6 +216,10 @@ def _kfold_function_template(estimator, data_transform_function, data_shape):
     )
 
 
+# disable fallback check as logging impacts memory use
+
+
+@pytest.mark.allow_sklearn_fallback
 @pytest.mark.parametrize("data_transform_function", data_transforms)
 @pytest.mark.parametrize("estimator", estimators)
 @pytest.mark.parametrize("data_shape", data_shapes)

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

@@ -0,0 +1,268 @@
+# ===============================================================================
+# 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
+        from sklearn.svm import SVC
+
+        return (
+            LinearRegression(),
+            PCA(),
+            DBSCAN(),
+            SVC(),
+            RandomForestClassifier(),
+        )
+
+    from sklearnex.dispatcher import _is_preview_enabled
+
+    try:
+        sklearnex.patch_sklearn(preview=True)
+
+        assert _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" in pca.__module__
+        assert "sklearnex" in dbscan.__module__
+        assert "sklearnex" in svc.__module__
+
+    finally:
+        sklearnex.unpatch_sklearn()
+
+    # no patching behavior
+    lr, pca, dbscan, svc, rfc = get_estimators()
+    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()
+
+        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()

{scikit_learn_intelex-2024.2.0.data → scikit_learn_intelex-2024.3.0.data}/data/Lib/site-packages/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):