scikit-learn-intelex 2024.1.0__py39-none-win_amd64.whl → 2025.1.0__py39-none-win_amd64.whl

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch/dispatcher.py

@@ -0,0 +1,232 @@
+# ==============================================================================
+# Copyright 2014 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 sys
+import warnings
+from functools import lru_cache
+
+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.linear_model._logistic as logistic_module
+import sklearn.manifold as manifold_module
+import sklearn.neighbors as neighbors_module
+import sklearn.svm as svm_module
+from sklearn import metrics, model_selection
+from sklearn.utils import validation
+
+from daal4py.sklearn._utils import set_idp_sklearn_verbose
+
+from ..cluster.dbscan import DBSCAN as DBSCAN_daal4py
+from ..cluster.k_means import KMeans as KMeans_daal4py
+from ..decomposition._pca import PCA as PCA_daal4py
+from ..ensemble._forest import RandomForestClassifier as RandomForestClassifier_daal4py
+from ..ensemble._forest import RandomForestRegressor as RandomForestRegressor_daal4py
+from ..linear_model.coordinate_descent import ElasticNet as ElasticNet_daal4py
+from ..linear_model.coordinate_descent import Lasso as Lasso_daal4py
+from ..linear_model.linear import LinearRegression as LinearRegression_daal4py
+from ..linear_model.logistic_path import LogisticRegression as LogisticRegression_daal4py
+from ..linear_model.logistic_path import (
+    logistic_regression_path as daal_optimized_logistic_path,
+)
+from ..linear_model.ridge import Ridge as Ridge_daal4py
+from ..manifold import TSNE as TSNE_daal4py
+from ..metrics import pairwise_distances, roc_auc_score
+from ..model_selection import train_test_split
+from ..neighbors import KNeighborsClassifier as KNeighborsClassifier_daal4py
+from ..neighbors import KNeighborsRegressor as KNeighborsRegressor_daal4py
+from ..neighbors import NearestNeighbors as NearestNeighbors_daal4py
+from ..svm.svm import SVC as SVC_daal4py
+from ..utils.validation import _assert_all_finite
+
+
+@lru_cache(maxsize=None)
+def _get_map_of_algorithms():
+    mapping = {
+        "pca": [[(decomposition_module, "PCA", PCA_daal4py), None]],
+        "kmeans": [[(cluster_module, "KMeans", KMeans_daal4py), None]],
+        "dbscan": [[(cluster_module, "DBSCAN", DBSCAN_daal4py), None]],
+        "distances": [[(metrics, "pairwise_distances", pairwise_distances), None]],
+        "linear": [
+            [(linear_model_module, "LinearRegression", LinearRegression_daal4py), None]
+        ],
+        "ridge": [[(linear_model_module, "Ridge", Ridge_daal4py), None]],
+        "elasticnet": [[(linear_model_module, "ElasticNet", ElasticNet_daal4py), None]],
+        "lasso": [[(linear_model_module, "Lasso", Lasso_daal4py), None]],
+        "svm": [[(svm_module, "SVC", SVC_daal4py), None]],
+        "logistic": [
+            [
+                (
+                    logistic_module,
+                    "_logistic_regression_path",
+                    daal_optimized_logistic_path,
+                ),
+                None,
+            ]
+        ],
+        "log_reg": [
+            [
+                (linear_model_module, "LogisticRegression", LogisticRegression_daal4py),
+                None,
+            ]
+        ],
+        "knn_classifier": [
+            [
+                (neighbors_module, "KNeighborsClassifier", KNeighborsClassifier_daal4py),
+                None,
+            ]
+        ],
+        "nearest_neighbors": [
+            [(neighbors_module, "NearestNeighbors", NearestNeighbors_daal4py), None]
+        ],
+        "knn_regressor": [
+            [(neighbors_module, "KNeighborsRegressor", KNeighborsRegressor_daal4py), None]
+        ],
+        "random_forest_classifier": [
+            [
+                (
+                    ensemble_module,
+                    "RandomForestClassifier",
+                    RandomForestClassifier_daal4py,
+                ),
+                None,
+            ]
+        ],
+        "random_forest_regressor": [
+            [
+                (ensemble_module, "RandomForestRegressor", RandomForestRegressor_daal4py),
+                None,
+            ]
+        ],
+        "train_test_split": [
+            [(model_selection, "train_test_split", train_test_split), None]
+        ],
+        "fin_check": [[(validation, "_assert_all_finite", _assert_all_finite), None]],
+        "roc_auc_score": [[(metrics, "roc_auc_score", roc_auc_score), None]],
+        "tsne": [[(manifold_module, "TSNE", TSNE_daal4py), None]],
+    }
+    mapping["svc"] = mapping["svm"]
+    mapping["logisticregression"] = mapping["log_reg"]
+    mapping["kneighborsclassifier"] = mapping["knn_classifier"]
+    mapping["nearestneighbors"] = mapping["nearest_neighbors"]
+    mapping["kneighborsregressor"] = mapping["knn_regressor"]
+    mapping["randomforestclassifier"] = mapping["random_forest_classifier"]
+    mapping["randomforestregressor"] = mapping["random_forest_regressor"]
+    mapping["linearregression"] = mapping["linear"]
+    mapping["logisticregression"] = mapping["log_reg"]
+    mapping["_logistic_regression_path"] = mapping["logistic"]
+    mapping["_assert_all_finite"] = mapping["fin_check"]
+    mapping["pairwise_distances"] = mapping["distances"]
+    return mapping
+
+
+def do_patch(name, get_map=_get_map_of_algorithms):
+    lname = name.lower()
+    if lname in get_map():
+        for descriptor in get_map()[lname]:
+            which, what, replacer = descriptor[0]
+            if descriptor[1] is None:
+                descriptor[1] = getattr(which, what, False)
+            setattr(which, what, replacer)
+    else:
+        raise ValueError("Has no patch for: " + name)
+
+
+def do_unpatch(name, get_map=_get_map_of_algorithms):
+    lname = name.lower()
+    if lname in get_map():
+        for descriptor in get_map()[lname]:
+            if descriptor[1] is not None:
+                which, what, _ = descriptor[0]
+                if descriptor[1]:
+                    setattr(which, what, descriptor[1])
+                elif hasattr(which, what):
+                    delattr(which, what)
+    else:
+        raise ValueError("Has no patch for: " + name)
+
+
+def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algorithms):
+    if name is not None:
+        do_patch(name, get_map)
+    else:
+        for key in get_map():
+            do_patch(key, get_map)
+    if deprecation:
+        set_idp_sklearn_verbose()
+        warnings.warn_explicit(
+            "\nScikit-learn patching with daal4py is deprecated "
+            "and will be removed in the future.\n"
+            "Use Intel(R) Extension "
+            "for Scikit-learn* module instead "
+            "(pip install scikit-learn-intelex).\n"
+            "To enable patching, please use one of the "
+            "following options:\n"
+            "1) From the command line:\n"
+            "    python -m sklearnex <your_script>\n"
+            "2) From your script:\n"
+            "    from sklearnex import patch_sklearn\n"
+            "    patch_sklearn()",
+            FutureWarning,
+            "dispatcher.py",
+            151,
+        )
+    if verbose and deprecation and sys.stderr is not None:
+        sys.stderr.write(
+            "Intel(R) oneAPI Data Analytics Library solvers for sklearn enabled: "
+            "https://intelpython.github.io/daal4py/sklearn.html\n"
+        )
+
+
+def disable(name=None, get_map=_get_map_of_algorithms):
+    if name is not None:
+        do_unpatch(name, get_map)
+    else:
+        for key in get_map():
+            do_unpatch(key, get_map)
+        get_map.cache_clear()
+
+
+def _is_enabled(name, get_map=_get_map_of_algorithms):
+    lname = name.lower()
+    if lname in get_map():
+        enabled = True
+        for descriptor in get_map()[lname]:
+            which, what, replacer = descriptor[0]
+            enabled = enabled and getattr(which, what, None) == replacer
+        return enabled
+    else:
+        raise ValueError("Has no patch for: " + name)
+
+
+def patch_is_enabled(name=None, get_map=_get_map_of_algorithms, return_map=False):
+    if name is not None:
+        return _is_enabled(name, get_map)
+    else:
+        if return_map:
+            enabled = {}
+            for key in get_map():
+                enabled[key] = _is_enabled(key, get_map)
+        else:
+            enabled = True
+            for key in get_map():
+                enabled = enabled and _is_enabled(key, get_map)
+        return enabled
+
+
+def _patch_names():
+    return list(_get_map_of_algorithms().keys())

{scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch}/tests/_models_info.py

@@ -27,14 +27,11 @@ from sklearn.linear_model import (
     Ridge,
 )
 from sklearn.manifold import TSNE
-from sklearn.neighbors import (
-    KNeighborsClassifier,
-    KNeighborsRegressor,
-    LocalOutlierFactor,
-    NearestNeighbors,
-)
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors
 from sklearn.svm import SVC
 
+from daal4py.sklearn._utils import daal_check_version
+
 MODELS_INFO = [
     {
         "model": KNeighborsClassifier(algorithm="brute"),
@@ -51,16 +48,6 @@ MODELS_INFO = [
         "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"],
@@ -91,6 +78,11 @@ MODELS_INFO = [
         "methods": ["fit_transform", "transform", "score"],
         "dataset": "classifier",
     },
+    {
+        "model": RandomForestClassifier(n_estimators=10),
+        "methods": ["predict", "predict_proba", "predict_log_proba", "score"],
+        "dataset": "classifier",
+    },
     {
         "model": LogisticRegression(max_iter=100, multi_class="multinomial"),
         "methods": [
@@ -113,11 +105,6 @@ MODELS_INFO = [
         ],
         "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"],
@@ -166,5 +153,9 @@ TO_SKIP = [
     r"RandomForestClassifier .*predict_proba",
     r"RandomForestClassifier .*predict_log_proba",
     r"pairwise_distances .*pairwise_distances",  # except float64
-    r"roc_auc_score .*roc_auc_score",
+    (
+        r"roc_auc_score .*roc_auc_score"
+        if not daal_check_version((2021, "P", 200))
+        else None
+    ),
 ]

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch/tests/test_monkeypatch.py

@@ -0,0 +1,71 @@
+# ===============================================================================
+# 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 daal4py.sklearn
+
+
+def test_monkey_patching():
+    _tokens = daal4py.sklearn.sklearn_patch_names()
+    _values = daal4py.sklearn.sklearn_patch_map().values()
+    _classes = list()
+    for v in _values:
+        _classes.append(v[0][0])
+
+    assert len(_tokens) == len(_classes)
+    assert (
+        isinstance(_tokens, list) and len(_tokens) > 0
+    ), "Internal Error: list of patched names has unexcepable format."
+
+    daal4py.sklearn.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"), "Patching has completed with error."
+
+    for i, _ in enumerate(_tokens):
+        t = _tokens[i]
+        p = _classes[i][0]
+        n = _classes[i][1]
+
+        daal4py.sklearn.unpatch_sklearn(t)
+        class_module = getattr(p, n).__module__
+        assert class_module.startswith("sklearn"), "Unpatching has completed with error."
+
+    daal4py.sklearn.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."
+
+    for i, _ in enumerate(_tokens):
+        t = _tokens[i]
+        p = _classes[i][0]
+        n = _classes[i][1]
+
+        daal4py.sklearn.patch_sklearn(t)
+
+        class_module = getattr(p, n).__module__
+        assert class_module.startswith("daal4py"), "Patching has completed with error."
+
+    daal4py.sklearn.unpatch_sklearn()

{scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch}/tests/test_patching.py

@@ -19,13 +19,9 @@ import pathlib
 import re
 import subprocess
 import sys
-from inspect import isclass
 
 import pytest
 from _models_info import TO_SKIP
-from sklearn.base import BaseEstimator
-
-from sklearnex import get_patch_map, is_patched_instance, patch_sklearn, unpatch_sklearn
 
 
 def get_branch(s):
@@ -43,9 +39,9 @@ def get_branch(s):
 def run_parse(mas, result):
     name, dtype = mas[0].split()
     temp = []
-    INFO_POS = 16
+    INFO_POS = 6
     for i in range(1, len(mas)):
-        mas[i] = mas[i][INFO_POS:]  # remove 'SKLEARNEX INFO: '
+        mas[i] = mas[i][INFO_POS:]  # remove 'INFO: '
         if not mas[i].startswith("sklearn"):
             ind = name + " " + dtype + " " + mas[i]
             result[ind] = get_branch(temp)
@@ -55,27 +51,29 @@ def run_parse(mas, result):
 
 
 def get_result_log():
-    os.environ["SKLEARNEX_VERBOSE"] = "INFO"
+    os.environ["IDP_SKLEARN_VERBOSE"] = "INFO"
     absolute_path = str(pathlib.Path(__file__).parent.absolute())
     try:
         process = subprocess.check_output(
-            [sys.executable, absolute_path + "/utils/_launch_algorithms.py"]
+            [
+                sys.executable,
+                os.sep.join([absolute_path, "utils", "_launch_algorithms.py"]),
+            ]
         )
     except subprocess.CalledProcessError as e:
         print(e)
         exit(1)
+
     mas = []
     result = {}
     for i in process.decode().split("\n"):
-        if i.startswith("SKLEARNEX WARNING"):
-            continue
-        if not i.startswith("SKLEARNEX INFO") and len(mas) != 0:
+        if not i.startswith("INFO") and len(mas) != 0:
             run_parse(mas, result)
             mas.clear()
             mas.append(i.strip())
         else:
             mas.append(i.strip())
-    del os.environ["SKLEARNEX_VERBOSE"]
+    del os.environ["IDP_SKLEARN_VERBOSE"]
     return result
 
 
@@ -90,33 +88,3 @@ def test_patching(configuration):
         if re.search(skip, configuration) is not None:
             pytest.skip("SKIPPED", allow_module_level=False)
     raise ValueError("Test patching failed: " + configuration)
-
-
-def _load_all_models(patched):
-    if patched:
-        patch_sklearn()
-
-    models = []
-    for patch_infos in get_patch_map().values():
-        maybe_class = getattr(patch_infos[0][0][0], patch_infos[0][0][1])
-        if (
-            maybe_class is not None
-            and isclass(maybe_class)
-            and issubclass(maybe_class, BaseEstimator)
-        ):
-            models.append(maybe_class())
-
-    if patched:
-        unpatch_sklearn()
-
-    return models
-
-
-PATCHED_MODELS = _load_all_models(patched=True)
-UNPATCHED_MODELS = _load_all_models(patched=False)
-
-
-@pytest.mark.parametrize(("patched", "unpatched"), zip(PATCHED_MODELS, UNPATCHED_MODELS))
-def test_is_patched_instance(patched, unpatched):
-    assert is_patched_instance(patched), f"{patched} is a patched instance"
-    assert not is_patched_instance(unpatched), f"{unpatched} is an unpatched instance"

{scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch}/tests/utils/_launch_algorithms.py

@@ -19,7 +19,7 @@ import random
 
 import numpy as np
 
-from sklearnex import patch_sklearn
+from daal4py.sklearn import patch_sklearn
 
 patch_sklearn()
 
@@ -29,8 +29,7 @@ import sys
 from sklearn.datasets import load_diabetes, load_iris, make_regression
 from sklearn.metrics import pairwise_distances, roc_auc_score
 
-absolute_path = str(pathlib.Path(__file__).parent.absolute())
-sys.path.append(absolute_path + "/../")
+sys.path.append(str(pathlib.Path(__file__).parent.parent.absolute()))
 from _models_info import MODELS_INFO, TYPES
 
 
@@ -84,7 +83,7 @@ def run_patch(model_info, dtype):
         logging.info(i)
 
 
-def run_algotithms():
+def run_algorithms():
     for info in MODELS_INFO:
         for t in TYPES:
             model_name = get_class_name(info["model"])
@@ -114,5 +113,5 @@ def run_utils():
 
 
 if __name__ == "__main__":
-    run_algotithms()
+    run_algorithms()
     run_utils()

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/daal4py/sklearn/neighbors/__init__.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+# Copyright 2014 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 ._classification import KNeighborsClassifier
+from ._regression import KNeighborsRegressor
+from ._unsupervised import NearestNeighbors
+
+__all__ = ["KNeighborsClassifier", "NearestNeighbors", "KNeighborsRegressor"]