scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch/tests/_models_info.py

@@ -0,0 +1,164 @@
+# ==============================================================================
+# 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, NearestNeighbors
+from sklearn.svm import SVC
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+
+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": 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": RandomForestClassifier(n_estimators=10),
+        "methods": ["predict", "predict_proba", "predict_log_proba", "score"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegression(
+            max_iter=100,
+            **({} if sklearn_check_version("1.8") else {"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": 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"
+        if not daal_check_version((2021, "P", 200))
+        else None
+    ),
+]

scikit_learn_intelex-2025.10.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-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch/tests/test_patching.py

@@ -0,0 +1,90 @@
+# ==============================================================================
+# 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 pathlib
+import re
+import subprocess
+import sys
+
+import pytest
+from _models_info import TO_SKIP
+
+
+def get_branch(s):
+    if len(s) == 0:
+        return "NO INFO"
+    for i in s:
+        if "failed to run accelerated version, fallback to original Scikit-learn" in i:
+            return "was in OPT, but go in Scikit"
+    for i in s:
+        if "running accelerated version" in i:
+            return "OPT"
+    return "Scikit"
+
+
+def run_parse(mas, result):
+    name, dtype = mas[0].split()
+    temp = []
+    INFO_POS = 6
+    for i in range(1, len(mas)):
+        mas[i] = mas[i][INFO_POS:]  # remove 'INFO: '
+        if not mas[i].startswith("sklearn"):
+            ind = name + " " + dtype + " " + mas[i]
+            result[ind] = get_branch(temp)
+            temp.clear()
+        else:
+            temp.append(mas[i])
+
+
+def get_result_log():
+    os.environ["IDP_SKLEARN_VERBOSE"] = "INFO"
+    absolute_path = str(pathlib.Path(__file__).parent.absolute())
+    try:
+        process = subprocess.check_output(
+            [
+                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 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["IDP_SKLEARN_VERBOSE"]
+    return result
+
+
+result_log = get_result_log()
+
+
+@pytest.mark.parametrize("configuration", result_log)
+def test_patching(configuration):
+    if "OPT" in result_log[configuration]:
+        return
+    for skip in TO_SKIP:
+        if re.search(skip, configuration) is not None:
+            pytest.skip("SKIPPED", allow_module_level=False)
+    raise ValueError("Test patching failed: " + configuration)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/daal4py/sklearn/monkeypatch/tests/utils/_launch_algorithms.py

@@ -0,0 +1,117 @@
+# ==============================================================================
+# 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 logging
+import random
+
+import numpy as np
+
+from daal4py.sklearn import patch_sklearn
+
+patch_sklearn()
+
+import pathlib
+import sys
+
+from sklearn.datasets import load_diabetes, load_iris, make_regression
+from sklearn.metrics import pairwise_distances, roc_auc_score
+
+sys.path.append(str(pathlib.Path(__file__).parent.parent.absolute()))
+from _models_info import MODELS_INFO, TYPES
+
+
+def get_class_name(x):
+    return x.__class__.__name__
+
+
+def generate_dataset(name, dtype, model_name):
+    if model_name == "LinearRegression":
+        X, y = make_regression(n_samples=1000, n_features=5)
+    elif name in ["blobs", "classifier"]:
+        X, y = load_iris(return_X_y=True)
+    elif name == "regression":
+        X, y = load_diabetes(return_X_y=True)
+    else:
+        raise ValueError("Unknown dataset type")
+    X = np.array(X, dtype=dtype)
+    y = np.array(y, dtype=dtype)
+    return (X, y)
+
+
+def run_patch(model_info, dtype):
+    print(get_class_name(model_info["model"]), dtype.__name__)
+    X, y = generate_dataset(
+        model_info["dataset"], dtype, get_class_name(model_info["model"])
+    )
+    model = model_info["model"]
+    model.fit(X, y)
+    logging.info("fit")
+    for i in model_info["methods"]:
+        if i == "predict":
+            model.predict(X)
+        elif i == "predict_proba":
+            model.predict_proba(X)
+        elif i == "predict_log_proba":
+            model.predict_log_proba(X)
+        elif i == "decision_function":
+            model.decision_function(X)
+        elif i == "fit_predict":
+            model.fit_predict(X)
+        elif i == "transform":
+            model.transform(X)
+        elif i == "fit_transform":
+            model.fit_transform(X)
+        elif i == "kneighbors":
+            model.kneighbors(X)
+        elif i == "score":
+            model.score(X, y)
+        else:
+            raise ValueError(i + " is wrong method")
+        logging.info(i)
+
+
+def run_algorithms():
+    for info in MODELS_INFO:
+        for t in TYPES:
+            model_name = get_class_name(info["model"])
+            if model_name in ["Ridge", "LinearRegression"] and t.__name__ == "uint32":
+                continue
+            run_patch(info, t)
+
+
+def run_utils():
+    # pairwise_distances
+    for metric in ["cosine", "correlation"]:
+        for t in TYPES:
+            X = np.random.rand(1000)
+            X = np.array(X, dtype=t)
+            print("pairwise_distances", t.__name__)
+            _ = pairwise_distances(X.reshape(1, -1), metric=metric)
+            logging.info("pairwise_distances")
+    # roc_auc_score
+    for t in [np.float32, np.float64]:
+        a = [random.randint(0, 1) for i in range(1000)]
+        b = [random.randint(0, 1) for i in range(1000)]
+        a = np.array(a, dtype=t)
+        b = np.array(b, dtype=t)
+        print("roc_auc_score", t.__name__)
+        _ = roc_auc_score(a, b)
+        logging.info("roc_auc_score")
+
+
+if __name__ == "__main__":
+    run_algorithms()
+    run_utils()

scikit_learn_intelex-2025.10.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"]