scikit-learn-intelex 2024.1.0__py311-none-manylinux1_x86_64.whl → 2024.4.0__py311-none-manylinux1_x86_64.whl

sklearnex/tests/_utils.py

@@ -0,0 +1,164 @@
+# ==============================================================================
+# 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 inspect import isclass
+
+import numpy as np
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    ClusterMixin,
+    OutlierMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.datasets import load_diabetes, load_iris
+from sklearn.neighbors._base import KNeighborsMixin
+
+from onedal.tests.utils._dataframes_support import _convert_to_dataframe
+from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
+from sklearnex.linear_model import LogisticRegression
+from sklearnex.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearnex.svm import SVC, NuSVC
+
+
+def _load_all_models(with_sklearnex=True, estimator=True):
+    # insure that patch state is correct as dictated by patch_sklearn boolean
+    # and return it to the previous state no matter what occurs.
+    already_patched_map = sklearn_is_patched(return_map=True)
+    already_patched = any(already_patched_map.values())
+    try:
+        if with_sklearnex:
+            patch_sklearn()
+        elif already_patched:
+            unpatch_sklearn()
+
+        models = {}
+        for patch_infos in get_patch_map().values():
+            candidate = getattr(patch_infos[0][0][0], patch_infos[0][0][1], None)
+            if candidate is not None and isclass(candidate) == estimator:
+                if not estimator or issubclass(candidate, BaseEstimator):
+                    models[patch_infos[0][0][1]] = candidate
+    finally:
+        if with_sklearnex:
+            unpatch_sklearn()
+        # both branches are now in an unpatched state, repatch as necessary
+        if already_patched:
+            patch_sklearn(name=[i for i in already_patched_map if already_patched_map[i]])
+
+    return models
+
+
+PATCHED_MODELS = _load_all_models(with_sklearnex=True)
+UNPATCHED_MODELS = _load_all_models(with_sklearnex=False)
+
+PATCHED_FUNCTIONS = _load_all_models(with_sklearnex=True, estimator=False)
+UNPATCHED_FUNCTIONS = _load_all_models(with_sklearnex=False, estimator=False)
+
+mixin_map = [
+    [
+        ClassifierMixin,
+        ["decision_function", "predict", "predict_proba", "predict_log_proba", "score"],
+        "classification",
+    ],
+    [RegressorMixin, ["predict", "score"], "regression"],
+    [ClusterMixin, ["fit_predict"], "classification"],
+    [TransformerMixin, ["fit_transform", "transform", "score"], "classification"],
+    [OutlierMixin, ["fit_predict", "predict"], "classification"],
+    [KNeighborsMixin, ["kneighbors"], None],
+]
+
+
+SPECIAL_INSTANCES = {
+    str(i): i
+    for i in [
+        LocalOutlierFactor(novelty=True),
+        SVC(probability=True),
+        NuSVC(probability=True),
+        KNeighborsClassifier(algorithm="brute"),
+        KNeighborsRegressor(algorithm="brute"),
+        NearestNeighbors(algorithm="brute"),
+        LogisticRegression(solver="newton-cg"),
+    ]
+}
+
+
+def gen_models_info(algorithms):
+    output = []
+    for i in algorithms:
+
+        if i in PATCHED_MODELS:
+            est = PATCHED_MODELS[i]
+        elif i in SPECIAL_INSTANCES:
+            est = SPECIAL_INSTANCES[i].__class__
+        else:
+            raise KeyError(f"Unrecognized sklearnex estimator: {i}")
+
+        methods = set()
+        candidates = set(
+            [i for i in dir(est) if not i.startswith("_") and not i.endswith("_")]
+        )
+
+        for mixin, method, _ in mixin_map:
+            if issubclass(est, mixin):
+                methods |= candidates & set(method)
+
+        output += [[i, j] for j in methods] if methods else [[i, None]]
+
+    # In the case that no methods are available, set method to None.
+    # This will allow estimators without mixins to still test the fit
+    # method in various tests.
+    return output
+
+
+def gen_dataset(estimator, queue=None, target_df=None, dtype=np.float64):
+    dataset = None
+    name = estimator.__class__.__name__
+    est = PATCHED_MODELS[name]
+    for mixin, _, data in mixin_map:
+        if issubclass(est, mixin) and data is not None:
+            dataset = data
+    # load data
+    if dataset == "classification" or dataset is None:
+        X, y = load_iris(return_X_y=True)
+    elif dataset == "regression":
+        X, y = load_diabetes(return_X_y=True)
+    else:
+        raise ValueError("Unknown dataset type")
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=target_df, dtype=dtype)
+    return X, y
+
+
+DTYPES = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]

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:
@@ -94,12 +96,8 @@ def remove_duplicated_estimators(estimators_list):
     return estimators_map.values()
 
 
-BANNED_ESTIMATORS = (
-    "LocalOutlierFactor",  # fails on ndarray_c for sklearn > 1.0
-    "TSNE",  # too slow for using in testing on common data size
-)
+BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
 estimators = [
-    PreviewPCA,
     TrainTestSplitEstimator,
     FiniteCheckEstimator,
     CosineDistancesEstimator,
@@ -156,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"):
@@ -166,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
 
 
@@ -218,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)

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()