scikit-learn-intelex 2023.2.1__py39-none-win_amd64.whl → 2024.0.1__py39-none-win_amd64.whl

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

@@ -0,0 +1,170 @@
+# ==============================================================================
+# 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 numpy as np
+from sklearn.cluster import DBSCAN, KMeans
+from sklearn.decomposition import PCA
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.linear_model import (
+    ElasticNet,
+    Lasso,
+    LinearRegression,
+    LogisticRegression,
+    LogisticRegressionCV,
+    Ridge,
+)
+from sklearn.manifold import TSNE
+from sklearn.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearn.svm import SVC
+
+MODELS_INFO = [
+    {
+        "model": KNeighborsClassifier(algorithm="brute"),
+        "methods": ["kneighbors", "predict", "predict_proba", "score"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KNeighborsRegressor(algorithm="brute"),
+        "methods": ["kneighbors", "predict", "score"],
+        "dataset": "regression",
+    },
+    {
+        "model": NearestNeighbors(algorithm="brute"),
+        "methods": ["kneighbors"],
+        "dataset": "blobs",
+    },
+    {
+        "model": LocalOutlierFactor(novelty=False),
+        "methods": ["fit_predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": LocalOutlierFactor(novelty=True),
+        "methods": ["predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": DBSCAN(),
+        "methods": ["fit_predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": SVC(probability=True),
+        "methods": ["decision_function", "predict", "predict_proba", "score"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KMeans(),
+        "methods": ["fit_predict", "fit_transform", "transform", "predict", "score"],
+        "dataset": "blobs",
+    },
+    {
+        "model": ElasticNet(),
+        "methods": ["predict", "score"],
+        "dataset": "regression",
+    },
+    {
+        "model": Lasso(),
+        "methods": ["predict", "score"],
+        "dataset": "regression",
+    },
+    {
+        "model": PCA(),
+        "methods": ["fit_transform", "transform", "score"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegression(max_iter=100, multi_class="multinomial"),
+        "methods": [
+            "decision_function",
+            "predict",
+            "predict_proba",
+            "predict_log_proba",
+            "score",
+        ],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegressionCV(max_iter=100),
+        "methods": [
+            "decision_function",
+            "predict",
+            "predict_proba",
+            "predict_log_proba",
+            "score",
+        ],
+        "dataset": "classifier",
+    },
+    {
+        "model": RandomForestClassifier(n_estimators=10),
+        "methods": ["predict", "predict_proba", "predict_log_proba", "score"],
+        "dataset": "classifier",
+    },
+    {
+        "model": RandomForestRegressor(n_estimators=10),
+        "methods": ["predict", "score"],
+        "dataset": "regression",
+    },
+    {
+        "model": LinearRegression(),
+        "methods": ["predict", "score"],
+        "dataset": "regression",
+    },
+    {
+        "model": Ridge(),
+        "methods": ["predict", "score"],
+        "dataset": "regression",
+    },
+]
+
+TYPES = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]
+
+TO_SKIP = [
+    # --------------- NO INFO ---------------
+    r"KMeans .*transform",
+    r"KMeans .*score",
+    r"PCA .*score",
+    r"LogisticRegression .*decision_function",
+    r"LogisticRegressionCV .*decision_function",
+    r"LogisticRegressionCV .*predict",
+    r"LogisticRegressionCV .*predict_proba",
+    r"LogisticRegressionCV .*predict_log_proba",
+    r"LogisticRegressionCV .*score",
+    # --------------- Scikit ---------------
+    r"Ridge float16 predict",
+    r"Ridge float16 score",
+    r"RandomForestClassifier .*predict_proba",
+    r"RandomForestClassifier .*predict_log_proba",
+    r"pairwise_distances .*pairwise_distances",  # except float64
+    r"roc_auc_score .*roc_auc_score",
+]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,9 +12,10 @@
 # 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 sklearn
+
 import sklearnex
 
 
@@ -27,12 +28,12 @@ def test_get_config_contains_sklearn_params():
 
 def test_set_config_works():
     default_config = sklearnex.get_config()
-    sklearnex.set_config(assume_finite=True,
-                         target_offload='cpu:0',
-                         allow_fallback_to_host=True)
+    sklearnex.set_config(
+        assume_finite=True, target_offload="cpu:0", allow_fallback_to_host=True
+    )
 
     config = sklearnex.get_config()
-    assert config['target_offload'] == 'cpu:0'
-    assert config['allow_fallback_to_host']
-    assert config['assume_finite']
+    assert config["target_offload"] == "cpu:0"
+    assert config["allow_fallback_to_host"]
+    assert config["assume_finite"]
     sklearnex.set_config(**default_config)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,31 +12,26 @@
 # 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
-import types
+import gc
+import logging
 import tracemalloc
+import types
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy.stats import pearsonr
+from sklearn.base import BaseEstimator
+from sklearn.datasets import make_classification
+from sklearn.model_selection import KFold
+
 from sklearnex import get_patch_map
-from sklearnex.model_selection import train_test_split
-from sklearnex.utils import _assert_all_finite
 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.preview.linear_model import LinearRegression as PreviewLinearRegression
-from sklearnex.preview.ensemble import (
-    RandomForestClassifier as PreviewRandomForestClassifier,
-    RandomForestRegressor as PreviewRandomForestRegressor,
-    ExtraTreesClassifier as PreviewExtraTreesClassifier,
-    ExtraTreesRegressor as PreviewExtraTreesRegressor
-)
-from sklearn.base import BaseEstimator
-from sklearn.model_selection import KFold
-from sklearn.datasets import make_classification
-from scipy.stats import pearsonr
-import pandas as pd
-import numpy as np
-import gc
-import logging
+from sklearnex.utils import _assert_all_finite
 
 
 class TrainTestSplitEstimator:
@@ -63,12 +58,12 @@ class PairwiseDistancesEstimator:
 
 class CosineDistancesEstimator(PairwiseDistancesEstimator):
     def __init__(self):
-        self.metric = 'cosine'
+        self.metric = "cosine"
 
 
 class CorrelationDistancesEstimator(PairwiseDistancesEstimator):
     def __init__(self):
-        self.metric = 'correlation'
+        self.metric = "correlation"
 
 
 class RocAucEstimator:
@@ -86,35 +81,30 @@ def get_patched_estimators(ban_list, output_list):
         estimator, name = listing[0][0][2], listing[0][0][1]
         if not isinstance(estimator, types.FunctionType):
             if name not in ban_list:
-                if isinstance(estimator(), BaseEstimator):
-                    if hasattr(estimator, 'fit'):
+                if issubclass(estimator, BaseEstimator):
+                    if hasattr(estimator, "fit"):
                         output_list.append(estimator)
 
 
 def remove_duplicated_estimators(estimators_list):
     estimators_map = {}
     for estimator in estimators_list:
-        full_name = f'{estimator.__module__}.{estimator.__name__}'
+        full_name = f"{estimator.__module__}.{estimator.__name__}"
         estimators_map[full_name] = estimator
     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
+    "LocalOutlierFactor",  # fails on ndarray_c for sklearn > 1.0
+    "TSNE",  # too slow for using in testing on common data size
 )
 estimators = [
     PreviewPCA,
-    PreviewLinearRegression,
-    PreviewRandomForestClassifier,
-    PreviewRandomForestRegressor,
-    PreviewExtraTreesClassifier,
-    PreviewExtraTreesRegressor,
     TrainTestSplitEstimator,
     FiniteCheckEstimator,
     CosineDistancesEstimator,
     CorrelationDistancesEstimator,
-    RocAucEstimator
+    RocAucEstimator,
 ]
 get_patched_estimators(BANNED_ESTIMATORS, estimators)
 estimators = remove_duplicated_estimators(estimators)
@@ -136,17 +126,9 @@ def dataframe_f(x, y):
     return pd.DataFrame(np.asfortranarray(x)), pd.Series(y)
 
 
-data_transforms = [
-    ndarray_c,
-    ndarray_f,
-    dataframe_c,
-    dataframe_f
-]
+data_transforms = [ndarray_c, ndarray_f, dataframe_c, dataframe_f]
 
-data_shapes = [
-    (1000, 100),
-    (2000, 50)
-]
+data_shapes = [(1000, 100), (2000, 50)]
 
 EXTRA_MEMORY_THRESHOLD = 0.15
 N_SPLITS = 10
@@ -154,9 +136,13 @@ N_SPLITS = 10
 
 def gen_clsf_data(n_samples, n_features):
     data, label = make_classification(
-        n_classes=2, n_samples=n_samples, n_features=n_features, random_state=777)
-    return data, label, \
-        data.size * data.dtype.itemsize + label.size * label.dtype.itemsize
+        n_classes=2, n_samples=n_samples, n_features=n_features, random_state=777
+    )
+    return (
+        data,
+        label,
+        data.size * data.dtype.itemsize + label.size * label.dtype.itemsize,
+    )
 
 
 def split_train_inference(kf, x, y, estimator):
@@ -172,11 +158,11 @@ def split_train_inference(kf, x, y, estimator):
         # fallback to stock scikit-learn with default parameters
         alg = estimator()
         alg.fit(x_train, y_train)
-        if hasattr(alg, 'predict'):
+        if hasattr(alg, "predict"):
             alg.predict(x_test)
-        elif hasattr(alg, 'transform'):
+        elif hasattr(alg, "transform"):
             alg.transform(x_test)
-        elif hasattr(alg, 'kneighbors'):
+        elif hasattr(alg, "kneighbors"):
             alg.kneighbors(x_test)
         del alg, x_train, x_test, y_train, y_test
         mem_tracks.append(tracemalloc.get_traced_memory()[0])
@@ -194,38 +180,46 @@ def _kfold_function_template(estimator, data_transform_function, data_shape):
 
     mem_before, _ = tracemalloc.get_traced_memory()
     mem_tracks = split_train_inference(kf, x, y, estimator)
-    mem_iter_diffs = (np.array(mem_tracks[1:]) - np.array(mem_tracks[:-1]))
+    mem_iter_diffs = np.array(mem_tracks[1:]) - np.array(mem_tracks[:-1])
     mem_incr_mean, mem_incr_std = mem_iter_diffs.mean(), mem_iter_diffs.std()
     mem_incr_mean, mem_incr_std = round(mem_incr_mean), round(mem_incr_std)
     mem_iter_corr, _ = pearsonr(mem_tracks, list(range(len(mem_tracks))))
     if mem_iter_corr > 0.95:
-        logging.warning('Memory usage is steadily increasing with iterations '
-                        '(Pearson correlation coefficient between '
-                        f'memory tracks and iterations is {mem_iter_corr})\n'
-                        'Memory usage increase per iteration: '
-                        f'{mem_incr_mean}±{mem_incr_std} bytes')
+        logging.warning(
+            "Memory usage is steadily increasing with iterations "
+            "(Pearson correlation coefficient between "
+            f"memory tracks and iterations is {mem_iter_corr})\n"
+            "Memory usage increase per iteration: "
+            f"{mem_incr_mean}±{mem_incr_std} bytes"
+        )
     mem_before_gc, _ = tracemalloc.get_traced_memory()
     mem_diff = mem_before_gc - mem_before
-    message = 'Size of extra allocated memory {} using garbage collector ' \
-        f'is greater than {EXTRA_MEMORY_THRESHOLD * 100}% of input data' \
-        f'\n\tAlgorithm: {estimator.__name__}' \
-        f'\n\tInput data size: {data_memory_size} bytes' \
-        '\n\tExtra allocated memory size: {} bytes' \
-        ' / {} %'
+    message = (
+        "Size of extra allocated memory {} using garbage collector "
+        f"is greater than {EXTRA_MEMORY_THRESHOLD * 100}% of input data"
+        f"\n\tAlgorithm: {estimator.__name__}"
+        f"\n\tInput data size: {data_memory_size} bytes"
+        "\n\tExtra allocated memory size: {} bytes"
+        " / {} %"
+    )
     if mem_diff >= EXTRA_MEMORY_THRESHOLD * data_memory_size:
-        logging.warning(message.format(
-            'before', mem_diff, round((mem_diff) / data_memory_size * 100, 2)))
+        logging.warning(
+            message.format(
+                "before", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
+            )
+        )
     gc.collect()
     mem_after, _ = tracemalloc.get_traced_memory()
     tracemalloc.stop()
     mem_diff = mem_after - mem_before
 
-    assert mem_diff < EXTRA_MEMORY_THRESHOLD * data_memory_size, \
-        message.format('after', mem_diff, round((mem_diff) / data_memory_size * 100, 2))
+    assert mem_diff < EXTRA_MEMORY_THRESHOLD * data_memory_size, message.format(
+        "after", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
+    )
 
 
-@pytest.mark.parametrize('data_transform_function', data_transforms)
-@pytest.mark.parametrize('estimator', estimators)
-@pytest.mark.parametrize('data_shape', data_shapes)
+@pytest.mark.parametrize("data_transform_function", data_transforms)
+@pytest.mark.parametrize("estimator", estimators)
+@pytest.mark.parametrize("data_shape", data_shapes)
 def test_memory_leaks(estimator, data_transform_function, data_shape):
     _kfold_function_template(estimator, data_transform_function, data_shape)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,7 +12,7 @@
 # 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
@@ -35,9 +35,9 @@ def test_monkey_patching():
         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."
+        assert class_module.startswith("daal4py") or class_module.startswith(
+            "sklearnex"
+        ), "Patching has completed with error."
 
     for i, _ in enumerate(_tokens):
         t = _tokens[i]
@@ -46,8 +46,7 @@ def test_monkey_patching():
 
         sklearnex.unpatch_sklearn(t)
         class_module = getattr(p, n).__module__
-        assert class_module.startswith('sklearn'), \
-            "Unpatching has completed with error."
+        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
 
     sklearnex.unpatch_sklearn()
 
@@ -57,8 +56,7 @@ def test_monkey_patching():
         n = _classes[i][1]
 
         class_module = getattr(p, n).__module__
-        assert class_module.startswith('sklearn'), \
-            "Unpatching has completed with error."
+        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
 
     sklearnex.unpatch_sklearn()
 
@@ -70,9 +68,9 @@ def test_monkey_patching():
         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."
+        assert class_module.startswith("daal4py") or class_module.startswith(
+            "sklearnex"
+        ), "Patching has completed with error."
 
     sklearnex.unpatch_sklearn()
 
@@ -81,14 +79,14 @@ def test_patch_by_list_simple():
     sklearnex.patch_sklearn(["LogisticRegression"])
 
     from sklearn.ensemble import RandomForestRegressor
-    from sklearn.neighbors import KNeighborsRegressor
     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')
+    assert RandomForestRegressor.__module__.startswith("sklearn")
+    assert KNeighborsRegressor.__module__.startswith("sklearn")
+    assert LogisticRegression.__module__.startswith("daal4py")
+    assert SVC.__module__.startswith("sklearn")
 
     sklearnex.unpatch_sklearn()
 
@@ -97,14 +95,14 @@ def test_patch_by_list_many_estimators():
     sklearnex.patch_sklearn(["LogisticRegression", "SVC"])
 
     from sklearn.ensemble import RandomForestRegressor
-    from sklearn.neighbors import KNeighborsRegressor
     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")
+    assert LogisticRegression.__module__.startswith("daal4py")
+    assert SVC.__module__.startswith("daal4py") or SVC.__module__.startswith("sklearnex")
 
     sklearnex.unpatch_sklearn()
 
@@ -113,31 +111,32 @@ def test_unpatch_by_list_many_estimators():
     sklearnex.patch_sklearn()
 
     from sklearn.ensemble import RandomForestRegressor
-    from sklearn.neighbors import KNeighborsRegressor
     from sklearn.linear_model import LogisticRegression
+    from sklearn.neighbors import KNeighborsRegressor
     from sklearn.svm import SVC
 
-    assert RandomForestRegressor.__module__.startswith('daal4py')
-    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')
+    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.neighbors import KNeighborsRegressor
     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")
+    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']:
+    for name in [None, "SVC", "PCA"]:
         sklearnex.patch_sklearn(name=name)
         assert sklearnex.sklearn_is_patched(name=name)
 
@@ -159,10 +158,10 @@ def test_patching_checker():
 
 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.decomposition import PCA
-        from sklearn.cluster import DBSCAN
         from sklearn.svm import SVC
 
         return LinearRegression(), PCA(), DBSCAN(), SVC(), RandomForestClassifier()
@@ -175,34 +174,37 @@ def test_preview_namespace():
     assert sklearnex.dispatcher._is_preview_enabled()
 
     lr, pca, dbscan, svc, rfc = get_estimators()
-    assert 'sklearnex.preview' in rfc.__module__
+    assert "sklearnex" in rfc.__module__
 
-    if daal_check_version((2023, 'P', 100)):
-        assert 'sklearnex.preview' in lr.__module__
+    if daal_check_version((2023, "P", 100)):
+        assert "sklearnex" in lr.__module__
     else:
-        assert 'daal4py' in lr.__module__
+        assert "daal4py" in lr.__module__
 
-    assert 'sklearnex.preview' in pca.__module__
-    assert 'daal4py' 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()
 
     # 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__
+    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()
-    assert 'daal4py' in lr.__module__
-    assert 'daal4py' in pca.__module__
-    assert 'daal4py' in rfc.__module__
-    assert 'daal4py' in dbscan.__module__
-    assert 'sklearnex' in svc.__module__
+    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()