scikit-learn-intelex 2024.2.0__py311-none-win_amd64.whl → 2024.4.0__py311-none-win_amd64.whl

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

@@ -1,170 +0,0 @@
-# ==============================================================================
-# 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-2024.2.0.data/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -1,240 +0,0 @@
-# ===============================================================================
-# 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 sklearnex
-from daal4py.sklearn._utils import daal_check_version
-
-
-def test_monkey_patching():
-    _tokens = sklearnex.get_patch_names()
-    _values = sklearnex.get_patch_map().values()
-    _classes = list()
-
-    for v in _values:
-        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)
-        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."
-
-    sklearnex.unpatch_sklearn()
-
-    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."
-
-    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()
-
-
-def test_patch_by_list_simple():
-    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")
-    if daal_check_version((2024, "P", 1)):
-        assert LogisticRegression.__module__.startswith("sklearnex")
-    else:
-        assert LogisticRegression.__module__.startswith("daal4py")
-    assert SVC.__module__.startswith("sklearn")
-
-    sklearnex.unpatch_sklearn()
-
-
-def test_patch_by_list_many_estimators():
-    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
-
-    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()
-
-
-def test_unpatch_by_list_many_estimators():
-    sklearnex.patch_sklearn()
-
-    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")
-
-    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
-
-    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")
-
-
-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
-
-    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():
-        assert not status
-
-
-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.svm import SVC
-
-        return (
-            LinearRegression(),
-            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()
-
-    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__
-
-    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__ and "daal4py" not in lr.__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, 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 pca.__module__
-    assert "sklearnex" in rfc.__module__
-    assert "sklearnex" in dbscan.__module__
-    assert "sklearnex" in svc.__module__
-    sklearnex.unpatch_sklearn()

scikit_learn_intelex-2024.2.0.data/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -1,136 +0,0 @@
-# ==============================================================================
-# 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 inspect
-import os
-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):
-    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 = 16
-    for i in range(1, len(mas)):
-        mas[i] = mas[i][INFO_POS:]  # remove 'SKLEARNEX 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["SKLEARNEX_VERBOSE"] = "INFO"
-    absolute_path = str(pathlib.Path(__file__).parent.absolute())
-    try:
-        process = subprocess.check_output(
-            [sys.executable, 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:
-            run_parse(mas, result)
-            mas.clear()
-            mas.append(i.strip())
-        else:
-            mas.append(i.strip())
-    del os.environ["SKLEARNEX_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)
-
-
-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], None)
-        if (
-            maybe_class is not None
-            and isclass(maybe_class)
-            and issubclass(maybe_class, BaseEstimator)
-        ):
-            models[patch_infos[0][0][1]] = 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("estimator", UNPATCHED_MODELS.keys())
-def test_is_patched_instance(estimator):
-    patched = PATCHED_MODELS[estimator]
-    unpatched = UNPATCHED_MODELS[estimator]
-    assert is_patched_instance(patched), f"{patched} is a patched instance"
-    assert not is_patched_instance(unpatched), f"{unpatched} is an unpatched instance"
-
-
-@pytest.mark.parametrize("member", ["_onedal_cpu_supported", "_onedal_gpu_supported"])
-@pytest.mark.parametrize(
-    "name",
-    [i for i in PATCHED_MODELS.keys() if "sklearnex" in PATCHED_MODELS[i].__module__],
-)
-def test_onedal_supported_member(name, member):
-    patched = PATCHED_MODELS[name]
-    sig = str(inspect.signature(getattr(patched, member)))
-    assert "(self, method_name, *data)" == sig

scikit_learn_intelex-2024.2.0.data/data/Lib/site-packages/sklearnex/tests/utils/_launch_algorithms.py

@@ -1,118 +0,0 @@
-# ==============================================================================
-# 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 sklearnex 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
-
-absolute_path = str(pathlib.Path(__file__).parent.absolute())
-sys.path.append(absolute_path + "/../")
-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_algotithms():
-    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_algotithms()
-    run_utils()