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

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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 numbers
+from abc import ABC
+
+import numpy as np
+from scipy import sparse as sp
+from sklearn.cluster import DBSCAN as sklearn_DBSCAN
+from sklearn.utils.validation import _check_sample_weight
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.cluster import DBSCAN as onedal_DBSCAN
+
+from .._device_offload import dispatch, wrap_output_data
+from .._utils import PatchingConditionsChain
+
+if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
+    from sklearn.utils import check_scalar
+
+
+class BaseDBSCAN(ABC):
+    def _onedal_dbscan(self, **onedal_params):
+        return onedal_DBSCAN(**onedal_params)
+
+    def _save_attributes(self):
+        assert hasattr(self, "_onedal_estimator")
+
+        self.labels_ = self._onedal_estimator.labels_
+        self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
+        self.components_ = self._onedal_estimator.components_
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+
+class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
+    __doc__ = sklearn_DBSCAN.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {**sklearn_DBSCAN._parameter_constraints}
+
+    def __init__(
+        self,
+        eps=0.5,
+        *,
+        min_samples=5,
+        metric="euclidean",
+        metric_params=None,
+        algorithm="auto",
+        leaf_size=30,
+        p=None,
+        n_jobs=None,
+    ):
+        super(DBSCAN, self).__init__(
+            eps=eps,
+            min_samples=min_samples,
+            metric=metric,
+            metric_params=metric_params,
+            algorithm=algorithm,
+            leaf_size=leaf_size,
+            p=p,
+            n_jobs=n_jobs,
+        )
+        self.eps = eps
+        self.min_samples = min_samples
+        self.metric = metric
+        self.metric_params = metric_params
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.p = p
+        self.n_jobs = n_jobs
+
+    def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        onedal_params = {
+            "eps": self.eps,
+            "min_samples": self.min_samples,
+            "metric": self.metric,
+            "metric_params": self.metric_params,
+            "algorithm": self.algorithm,
+            "leaf_size": self.leaf_size,
+            "p": self.p,
+            "n_jobs": self.n_jobs,
+        }
+        self._onedal_estimator = self._onedal_dbscan(**onedal_params)
+
+        self._onedal_estimator.fit(X, y=y, sample_weight=sample_weight, queue=queue)
+        self._save_attributes()
+
+    def _onedal_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        patching_status = PatchingConditionsChain(
+            f"sklearn.cluster.{class_name}.{method_name}"
+        )
+        if method_name == "fit":
+            X, y, sample_weight = data
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in ["auto", "brute"],
+                        f"'{self.algorithm}' algorithm is not supported. "
+                        "Only 'auto' and 'brute' algorithms are supported",
+                    ),
+                    (
+                        self.metric == "euclidean"
+                        or (self.metric == "minkowski" and self.p == 2),
+                        f"'{self.metric}' (p={self.p}) metric is not supported. "
+                        "Only 'euclidean' or 'minkowski' with p=2 metrics are supported.",
+                    ),
+                    (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
+                ]
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        return self._onedal_supported(method_name, *data)
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        return self._onedal_supported(method_name, *data)
+
+    def fit(self, X, y=None, sample_weight=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        elif sklearn_check_version("1.1"):
+            check_scalar(
+                self.eps,
+                "eps",
+                target_type=numbers.Real,
+                min_val=0.0,
+                include_boundaries="neither",
+            )
+            check_scalar(
+                self.min_samples,
+                "min_samples",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            check_scalar(
+                self.leaf_size,
+                "leaf_size",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            if self.p is not None:
+                check_scalar(
+                    self.p,
+                    "p",
+                    target_type=numbers.Real,
+                    min_val=0.0,
+                    include_boundaries="left",
+                )
+            if self.n_jobs is not None:
+                check_scalar(self.n_jobs, "n_jobs", target_type=numbers.Integral)
+        else:
+            if self.eps <= 0.0:
+                raise ValueError(f"eps == {self.eps}, must be > 0.0.")
+
+        if sample_weight is not None:
+            sample_weight = _check_sample_weight(sample_weight, X)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_DBSCAN.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
+
+        return self

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from daal4py.sklearn.cluster import KMeans

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

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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
+import pytest
+from numpy.testing import assert_allclose
+
+
+# TODO:
+# adding this parameterized testing
+# somehow breaks other test with preview module patch:
+# sklearnex/tests/test_monkeypatch.py::test_preview_namespace.
+# @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_dbscan():
+    from sklearnex.cluster import DBSCAN
+
+    X = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
+    dbscan = DBSCAN(eps=3, min_samples=2).fit(X)
+    assert "sklearnex" in dbscan.__module__
+
+    result = dbscan.labels_
+    expected = np.array([0, 0, 0, 1, 1, -1], dtype=np.int32)
+    assert_allclose(expected, result)

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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 numpy.testing import assert_allclose
+
+
+def test_sklearnex_import():
+    from sklearnex.cluster import KMeans
+
+    X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
+    kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
+    assert "daal4py" in kmeans.__module__
+
+    result = kmeans.predict([[0, 0], [12, 3]])
+    expected = np.array([1, 0], dtype=np.int32)
+    assert_allclose(expected, result)

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/decomposition/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from .pca import PCA
+
+__all__ = ["PCA"]

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from daal4py.sklearn.decomposition import PCA

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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 numpy as np
+from numpy.testing import assert_allclose
+
+
+def test_sklearnex_import():
+    from sklearnex.decomposition import PCA
+
+    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    pca = PCA(n_components=2, svd_solver="full").fit(X)
+    assert "daal4py" in pca.__module__
+    assert_allclose(pca.singular_values_, [6.30061232, 0.54980396])

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python
+# ==============================================================================
+# 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 sys
+from functools import lru_cache
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+
+
+def _is_new_patching_available():
+    return os.environ.get("OFF_ONEDAL_IFACE") is None and daal_check_version(
+        (2021, "P", 300)
+    )
+
+
+def _is_preview_enabled():
+    return os.environ.get("SKLEARNEX_PREVIEW") is not None
+
+
+@lru_cache(maxsize=None)
+def get_patch_map():
+    from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms
+
+    mapping = _get_map_of_algorithms().copy()
+
+    if _is_new_patching_available():
+        # Scikit-learn* modules
+        import sklearn as base_module
+        import sklearn.cluster as cluster_module
+        import sklearn.decomposition as decomposition_module
+        import sklearn.ensemble as ensemble_module
+        import sklearn.linear_model as linear_model_module
+        import sklearn.neighbors as neighbors_module
+        import sklearn.svm as svm_module
+
+        if sklearn_check_version("1.2.1"):
+            import sklearn.utils.parallel as parallel_module
+        else:
+            import sklearn.utils.fixes as parallel_module
+
+        # Classes and functions for patching
+        from ._config import config_context as config_context_sklearnex
+        from ._config import get_config as get_config_sklearnex
+        from ._config import set_config as set_config_sklearnex
+
+        if sklearn_check_version("1.2.1"):
+            from .utils.parallel import _FuncWrapper as _FuncWrapper_sklearnex
+        else:
+            from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
+
+        from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .ensemble import ExtraTreesClassifier as ExtraTreesClassifier_sklearnex
+        from .ensemble import ExtraTreesRegressor as ExtraTreesRegressor_sklearnex
+        from .ensemble import RandomForestClassifier as RandomForestClassifier_sklearnex
+        from .ensemble import RandomForestRegressor as RandomForestRegressor_sklearnex
+        from .linear_model import LinearRegression as LinearRegression_sklearnex
+        from .neighbors import KNeighborsClassifier as KNeighborsClassifier_sklearnex
+        from .neighbors import KNeighborsRegressor as KNeighborsRegressor_sklearnex
+        from .neighbors import LocalOutlierFactor as LocalOutlierFactor_sklearnex
+        from .neighbors import NearestNeighbors as NearestNeighbors_sklearnex
+
+        # Preview classes for patching
+        from .preview.cluster import KMeans as KMeans_sklearnex
+        from .preview.decomposition import PCA as PCA_sklearnex
+        from .svm import SVC as SVC_sklearnex
+        from .svm import SVR as SVR_sklearnex
+        from .svm import NuSVC as NuSVC_sklearnex
+        from .svm import NuSVR as NuSVR_sklearnex
+
+        # Patch for mapping
+        if _is_preview_enabled():
+            # PCA
+            mapping.pop("pca")
+            mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
+
+            # KMeans
+            mapping.pop("kmeans")
+            mapping["kmeans"] = [
+                [
+                    (
+                        cluster_module,
+                        "KMeans",
+                        KMeans_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
+        # DBSCAN
+        mapping.pop("dbscan")
+        mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
+
+        # SVM
+        mapping.pop("svm")
+        mapping.pop("svc")
+        mapping["svr"] = [[(svm_module, "SVR", SVR_sklearnex), None]]
+        mapping["svc"] = [[(svm_module, "SVC", SVC_sklearnex), None]]
+        mapping["nusvr"] = [[(svm_module, "NuSVR", NuSVR_sklearnex), None]]
+        mapping["nusvc"] = [[(svm_module, "NuSVC", NuSVC_sklearnex), None]]
+
+        # Linear Regression
+        mapping.pop("linear")
+        mapping.pop("linearregression")
+        mapping["linear"] = [
+            [
+                (
+                    linear_model_module,
+                    "LinearRegression",
+                    LinearRegression_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["linearregression"] = mapping["linear"]
+
+        # kNN
+        mapping.pop("knn_classifier")
+        mapping.pop("kneighborsclassifier")
+        mapping.pop("knn_regressor")
+        mapping.pop("kneighborsregressor")
+        mapping.pop("nearest_neighbors")
+        mapping.pop("nearestneighbors")
+        mapping["knn_classifier"] = [
+            [
+                (
+                    neighbors_module,
+                    "KNeighborsClassifier",
+                    KNeighborsClassifier_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["knn_regressor"] = [
+            [
+                (
+                    neighbors_module,
+                    "KNeighborsRegressor",
+                    KNeighborsRegressor_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["nearest_neighbors"] = [
+            [(neighbors_module, "NearestNeighbors", NearestNeighbors_sklearnex), None]
+        ]
+        mapping["kneighborsclassifier"] = mapping["knn_classifier"]
+        mapping["kneighborsregressor"] = mapping["knn_regressor"]
+        mapping["nearestneighbors"] = mapping["nearest_neighbors"]
+
+        # Ensemble
+        mapping["extra_trees_classifier"] = [
+            [
+                (
+                    ensemble_module,
+                    "ExtraTreesClassifier",
+                    ExtraTreesClassifier_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["extra_trees_regressor"] = [
+            [
+                (
+                    ensemble_module,
+                    "ExtraTreesRegressor",
+                    ExtraTreesRegressor_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["extratreesclassifier"] = mapping["extra_trees_classifier"]
+        mapping["extratreesregressor"] = mapping["extra_trees_regressor"]
+        mapping.pop("random_forest_classifier")
+        mapping.pop("random_forest_regressor")
+        mapping.pop("randomforestclassifier")
+        mapping.pop("randomforestregressor")
+        mapping["random_forest_classifier"] = [
+            [
+                (
+                    ensemble_module,
+                    "RandomForestClassifier",
+                    RandomForestClassifier_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["random_forest_regressor"] = [
+            [
+                (
+                    ensemble_module,
+                    "RandomForestRegressor",
+                    RandomForestRegressor_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["randomforestclassifier"] = mapping["random_forest_classifier"]
+        mapping["randomforestregressor"] = mapping["random_forest_regressor"]
+
+        # LocalOutlierFactor
+        mapping["lof"] = [
+            [
+                (neighbors_module, "LocalOutlierFactor", LocalOutlierFactor_sklearnex),
+                None,
+            ]
+        ]
+        mapping["localoutlierfactor"] = mapping["lof"]
+
+        # Configs
+        mapping["set_config"] = [
+            [(base_module, "set_config", set_config_sklearnex), None]
+        ]
+        mapping["get_config"] = [
+            [(base_module, "get_config", get_config_sklearnex), None]
+        ]
+        mapping["config_context"] = [
+            [(base_module, "config_context", config_context_sklearnex), None]
+        ]
+
+        # Necessary for proper work with multiple threads
+        mapping["parallel.get_config"] = [
+            [(parallel_module, "get_config", get_config_sklearnex), None]
+        ]
+        mapping["_funcwrapper"] = [
+            [(parallel_module, "_FuncWrapper", _FuncWrapper_sklearnex), None]
+        ]
+    return mapping
+
+
+def get_patch_names():
+    return list(get_patch_map().keys())
+
+
+def patch_sklearn(name=None, verbose=True, global_patch=False, preview=False):
+    if preview:
+        os.environ["SKLEARNEX_PREVIEW"] = "enabled_via_patch_sklearn"
+    if not sklearn_check_version("0.22"):
+        raise NotImplementedError(
+            "Intel(R) Extension for Scikit-learn* patches apply "
+            "for scikit-learn >= 0.22 only ..."
+        )
+
+    if global_patch:
+        from sklearnex.glob.dispatcher import patch_sklearn_global
+
+        patch_sklearn_global(name, verbose)
+
+    from daal4py.sklearn import patch_sklearn as patch_sklearn_orig
+
+    if _is_new_patching_available():
+        for config in ["set_config", "get_config", "config_context"]:
+            patch_sklearn_orig(
+                config, verbose=False, deprecation=False, get_map=get_patch_map
+            )
+    if isinstance(name, list):
+        for algorithm in name:
+            patch_sklearn_orig(
+                algorithm, verbose=False, deprecation=False, get_map=get_patch_map
+            )
+    else:
+        patch_sklearn_orig(name, verbose=False, deprecation=False, get_map=get_patch_map)
+
+    if verbose and sys.stderr is not None:
+        sys.stderr.write(
+            "Intel(R) Extension for Scikit-learn* enabled "
+            "(https://github.com/intel/scikit-learn-intelex)\n"
+        )
+
+
+def unpatch_sklearn(name=None, global_unpatch=False):
+    if global_unpatch:
+        from sklearnex.glob.dispatcher import unpatch_sklearn_global
+
+        unpatch_sklearn_global()
+    from daal4py.sklearn import unpatch_sklearn as unpatch_sklearn_orig
+
+    if isinstance(name, list):
+        for algorithm in name:
+            unpatch_sklearn_orig(algorithm, get_map=get_patch_map)
+    else:
+        if _is_new_patching_available():
+            for config in ["set_config", "get_config", "config_context"]:
+                unpatch_sklearn_orig(config, get_map=get_patch_map)
+        unpatch_sklearn_orig(name, get_map=get_patch_map)
+    if os.environ.get("SKLEARNEX_PREVIEW") == "enabled_via_patch_sklearn":
+        os.environ.pop("SKLEARNEX_PREVIEW")
+
+
+def sklearn_is_patched(name=None, return_map=False):
+    from daal4py.sklearn import sklearn_is_patched as sklearn_is_patched_orig
+
+    if isinstance(name, list):
+        if return_map:
+            result = {}
+            for algorithm in name:
+                result[algorithm] = sklearn_is_patched_orig(
+                    algorithm, get_map=get_patch_map
+                )
+            return result
+        else:
+            is_patched = True
+            for algorithm in name:
+                is_patched = is_patched and sklearn_is_patched_orig(
+                    algorithm, get_map=get_patch_map
+                )
+            return is_patched
+    else:
+        return sklearn_is_patched_orig(name, get_map=get_patch_map, return_map=return_map)
+
+
+def is_patched_instance(instance: object) -> bool:
+    """Returns True if the `instance` is patched with scikit-learn-intelex"""
+    module = getattr(instance, "__module__", "")
+    return ("daal4py" in module) or ("sklearnex" in module)