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

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

@@ -0,0 +1,428 @@
+# ===============================================================================
+# Copyright 2020 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 random
+
+import numpy as np
+import pytest
+
+import daal4py as d4p
+from sklearnex import patch_sklearn
+
+patch_sklearn()
+
+from scipy import sparse
+from sklearn.cluster import DBSCAN, KMeans
+from sklearn.datasets import (
+    load_breast_cancer,
+    load_diabetes,
+    load_iris,
+    make_classification,
+    make_regression,
+)
+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.metrics import pairwise_distances, roc_auc_score
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    LocalOutlierFactor,
+    NearestNeighbors,
+)
+from sklearn.svm import SVC, SVR, NuSVC, NuSVR
+
+from daal4py.sklearn._utils import daal_check_version
+
+# to reproduce errors even in CI
+d4p.daalinit(nthreads=100)
+
+
+def get_class_name(x):
+    return x.__class__.__name__
+
+
+def method_processing(X, clf, methods):
+    res = []
+    name = []
+    for i in methods:
+        if i == "predict":
+            res.append(clf.predict(X))
+            name.append(get_class_name(clf) + ".predict(X)")
+        elif i == "predict_proba":
+            res.append(clf.predict_proba(X))
+            name.append(get_class_name(clf) + ".predict_proba(X)")
+        elif i == "decision_function":
+            res.append(clf.decision_function(X))
+            name.append(get_class_name(clf) + ".decision_function(X)")
+        elif i == "kneighbors":
+            dist, idx = clf.kneighbors(X)
+            res.append(dist)
+            name.append("dist")
+            res.append(idx)
+            name.append("idx")
+        elif i == "fit_predict":
+            predict = clf.fit_predict(X)
+            res.append(predict)
+            name.append(get_class_name(clf) + ".fit_predict")
+        elif i == "fit_transform":
+            res.append(clf.fit_transform(X))
+            name.append(get_class_name(clf) + ".fit_transform")
+        elif i == "transform":
+            res.append(clf.transform(X))
+            name.append(get_class_name(clf) + ".transform(X)")
+        elif i == "get_covariance":
+            res.append(clf.get_covariance())
+            name.append(get_class_name(clf) + ".get_covariance()")
+        elif i == "get_precision":
+            res.append(clf.get_precision())
+            name.append(get_class_name(clf) + ".get_precision()")
+        elif i == "score_samples":
+            res.append(clf.score_samples(X))
+            name.append(get_class_name(clf) + ".score_samples(X)")
+    return res, name
+
+
+def func(X, Y, clf, methods):
+    clf.fit(X, Y)
+    res, name = method_processing(X, clf, methods)
+
+    for i in clf.__dict__.keys():
+        ans = getattr(clf, i)
+        if isinstance(ans, (bool, float, int, np.ndarray, np.float64)):
+            if isinstance(ans, np.ndarray) and None in ans:
+                continue
+            res.append(ans)
+            name.append(get_class_name(clf) + "." + i)
+    return res, name
+
+
+def _run_test(model, methods, dataset):
+    datasets = []
+    if dataset in ["blobs", "classifier", "sparse"]:
+        X1, y1 = load_iris(return_X_y=True)
+        if dataset == "sparse":
+            X1 = sparse.csr_matrix(X1)
+        datasets.append((X1, y1))
+        X2, y2 = load_breast_cancer(return_X_y=True)
+        if dataset == "sparse":
+            X2 = sparse.csr_matrix(X2)
+        datasets.append((X2, y2))
+    elif dataset == "regression":
+        X1, y1 = make_regression(
+            n_samples=500, n_features=10, noise=64.0, random_state=42
+        )
+        datasets.append((X1, y1))
+        X2, y2 = load_diabetes(return_X_y=True)
+        datasets.append((X2, y2))
+    else:
+        raise ValueError("Unknown dataset type")
+
+    for X, y in datasets:
+        baseline, name = func(X, y, model, methods)
+        for i in range(10):
+            res, _ = func(X, y, model, methods)
+
+            for a, b, n in zip(res, baseline, name):
+                np.testing.assert_allclose(
+                    a, b, rtol=0.0, atol=0.0, err_msg=str(n + " is incorrect")
+                )
+
+
+MODELS_INFO = [
+    {
+        "model": KNeighborsClassifier(
+            n_neighbors=10, algorithm="brute", weights="uniform"
+        ),
+        "methods": ["predict", "predict_proba", "kneighbors"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KNeighborsClassifier(
+            n_neighbors=10, algorithm="brute", weights="distance"
+        ),
+        "methods": ["predict", "predict_proba", "kneighbors"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KNeighborsClassifier(
+            n_neighbors=10, algorithm="kd_tree", weights="uniform"
+        ),
+        "methods": ["predict", "predict_proba", "kneighbors"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KNeighborsClassifier(
+            n_neighbors=10, algorithm="kd_tree", weights="distance"
+        ),
+        "methods": ["predict", "predict_proba", "kneighbors"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KNeighborsRegressor(
+            n_neighbors=10, algorithm="kd_tree", weights="distance"
+        ),
+        "methods": ["predict", "kneighbors"],
+        "dataset": "regression",
+    },
+    {
+        "model": KNeighborsRegressor(
+            n_neighbors=10, algorithm="kd_tree", weights="uniform"
+        ),
+        "methods": ["predict", "kneighbors"],
+        "dataset": "regression",
+    },
+    {
+        "model": KNeighborsRegressor(
+            n_neighbors=10, algorithm="brute", weights="distance"
+        ),
+        "methods": ["predict", "kneighbors"],
+        "dataset": "regression",
+    },
+    {
+        "model": KNeighborsRegressor(
+            n_neighbors=10, algorithm="brute", weights="uniform"
+        ),
+        "methods": ["predict", "kneighbors"],
+        "dataset": "regression",
+    },
+    {
+        "model": NearestNeighbors(n_neighbors=10, algorithm="brute"),
+        "methods": ["kneighbors"],
+        "dataset": "blobs",
+    },
+    {
+        "model": NearestNeighbors(n_neighbors=10, algorithm="kd_tree"),
+        "methods": ["kneighbors"],
+        "dataset": "blobs",
+    },
+    {
+        "model": LocalOutlierFactor(n_neighbors=10, novelty=False),
+        "methods": ["fit_predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": LocalOutlierFactor(n_neighbors=10, novelty=True),
+        "methods": ["predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": DBSCAN(algorithm="brute", n_jobs=-1),
+        "methods": [],
+        "dataset": "blobs",
+    },
+    {
+        "model": SVC(kernel="rbf"),
+        "methods": ["predict", "decision_function"],
+        "dataset": "classifier",
+    },
+    {
+        "model": SVC(kernel="rbf"),
+        "methods": ["predict", "decision_function"],
+        "dataset": "sparse",
+    },
+    {
+        "model": NuSVC(kernel="rbf"),
+        "methods": ["predict", "decision_function"],
+        "dataset": "classifier",
+    },
+    {
+        "model": SVR(kernel="rbf"),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": NuSVR(kernel="rbf"),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": TSNE(random_state=0),
+        "methods": ["fit_transform"],
+        "dataset": "classifier",
+    },
+    {
+        "model": KMeans(random_state=0, init="k-means++"),
+        "methods": ["predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": KMeans(random_state=0, init="random"),
+        "methods": ["predict"],
+        "dataset": "blobs",
+    },
+    {
+        "model": KMeans(random_state=0, init="k-means++"),
+        "methods": ["predict"],
+        "dataset": "sparse",
+    },
+    {
+        "model": KMeans(random_state=0, init="random"),
+        "methods": ["predict"],
+        "dataset": "sparse",
+    },
+    {
+        "model": ElasticNet(random_state=0),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": Lasso(random_state=0),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": PCA(n_components=0.5, svd_solver="full", random_state=0),
+        "methods": ["transform", "get_covariance", "get_precision", "score_samples"],
+        "dataset": "classifier",
+    },
+    {
+        "model": RandomForestClassifier(
+            random_state=0, oob_score=True, max_samples=0.5, max_features="sqrt"
+        ),
+        "methods": ["predict", "predict_proba"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegression(random_state=0, solver="newton-cg", max_iter=1000),
+        "methods": ["predict", "predict_proba"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegression(random_state=0, solver="lbfgs", max_iter=1000),
+        "methods": ["predict", "predict_proba"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegressionCV(
+            random_state=0, solver="newton-cg", n_jobs=-1, max_iter=1000
+        ),
+        "methods": ["predict", "predict_proba"],
+        "dataset": "classifier",
+    },
+    {
+        "model": LogisticRegressionCV(
+            random_state=0, solver="lbfgs", n_jobs=-1, max_iter=1000
+        ),
+        "methods": ["predict", "predict_proba"],
+        "dataset": "classifier",
+    },
+    {
+        "model": RandomForestRegressor(
+            random_state=0, oob_score=True, max_samples=0.5, max_features="sqrt"
+        ),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": LinearRegression(),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+    {
+        "model": Ridge(random_state=0),
+        "methods": ["predict"],
+        "dataset": "regression",
+    },
+]
+
+TO_SKIP = [
+    "TSNE",  # Absolute diff is 1e-10, potential problem in KNN,
+    # will be fixed for next release. (UPD. KNN is fixed but there is a problem
+    # with stability of stock sklearn. It is already stable in master, so, we
+    # need to wait for the next sklearn release)
+    "LogisticRegression",  # Absolute diff is 1e-8, will be fixed for next release
+    "LogisticRegressionCV",  # Absolute diff is 1e-10, will be fixed for next release
+    "RandomForestRegressor",  # Absolute diff is 1e-14 in OOB score,
+    # will be fixed for next release
+]
+
+
+@pytest.mark.parametrize("model_head", MODELS_INFO)
+def test_models(model_head):
+    stable_algos = []
+    if get_class_name(model_head["model"]) in stable_algos and daal_check_version(
+        (2021, "P", 300)
+    ):
+        try:
+            TO_SKIP.remove(get_class_name(model_head["model"]))
+        except ValueError:
+            pass
+    if get_class_name(model_head["model"]) in TO_SKIP:
+        pytest.skip("Unstable", allow_module_level=False)
+    _run_test(model_head["model"], model_head["methods"], model_head["dataset"])
+
+
+@pytest.mark.parametrize("features", range(5, 10))
+def test_train_test_split(features):
+    X, y = make_classification(
+        n_samples=4000,
+        n_features=features,
+        n_informative=features,
+        n_redundant=0,
+        n_clusters_per_class=8,
+        random_state=0,
+    )
+    (
+        baseline_X_train,
+        baseline_X_test,
+        baseline_y_train,
+        baseline_y_test,
+    ) = train_test_split(X, y, test_size=0.33, random_state=0)
+    baseline = [baseline_X_train, baseline_X_test, baseline_y_train, baseline_y_test]
+    for _ in range(10):
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.33, random_state=0
+        )
+        res = [X_train, X_test, y_train, y_test]
+        for a, b in zip(res, baseline):
+            np.testing.assert_allclose(
+                a, b, rtol=0.0, atol=0.0, err_msg=str("train_test_split is incorrect")
+            )
+
+
+@pytest.mark.parametrize("metric", ["cosine", "correlation"])
+def test_pairwise_distances(metric):
+    X = np.random.rand(1000)
+    X = np.array(X, dtype=np.float64)
+    baseline = pairwise_distances(X.reshape(1, -1), metric=metric)
+    for _ in range(5):
+        res = pairwise_distances(X.reshape(1, -1), metric=metric)
+        for a, b in zip(res, baseline):
+            np.testing.assert_allclose(
+                a, b, rtol=0.0, atol=0.0, err_msg=str("pairwise_distances is incorrect")
+            )
+
+
+@pytest.mark.parametrize("array_size", [100, 1000, 10000])
+def test_roc_auc(array_size):
+    a = [random.randint(0, 1) for i in range(array_size)]
+    b = [random.randint(0, 1) for i in range(array_size)]
+    baseline = roc_auc_score(a, b)
+    for _ in range(5):
+        res = roc_auc_score(a, b)
+        np.testing.assert_allclose(
+            baseline, res, rtol=0.0, atol=0.0, err_msg=str("roc_auc is incorrect")
+        )

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

@@ -0,0 +1,118 @@
+# ==============================================================================
+# 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()

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

@@ -0,0 +1,19 @@
+# ===============================================================================
+# Copyright 2022 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 .validation import _assert_all_finite
+
+__all__ = ["_assert_all_finite"]

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/utils/parallel.py

@@ -0,0 +1,59 @@
+# ===============================================================================
+# 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 warnings
+from functools import update_wrapper
+
+from .._config import config_context, get_config
+
+
+class _FuncWrapper:
+    """Load the global configuration before calling the function."""
+
+    def __init__(self, function):
+        self.function = function
+        update_wrapper(self, self.function)
+
+    def with_config(self, config):
+        self.config = config
+        return self
+
+    def __call__(self, *args, **kwargs):
+        config = getattr(self, "config", None)
+        if config is None:
+            warnings.warn(
+                "`sklearn.utils.parallel.delayed` should be used with "
+                "`sklearn.utils.parallel.Parallel` to make it possible to propagate "
+                "the scikit-learn configuration of the current thread to the "
+                "joblib workers.",
+                UserWarning,
+            )
+            config = {}
+        with config_context(**config):
+            return self.function(*args, **kwargs)
+
+
+class _FuncWrapperOld:
+    """Load the global configuration before calling the function."""
+
+    def __init__(self, function):
+        self.function = function
+        self.config = get_config()
+        update_wrapper(self, self.function)
+
+    def __call__(self, *args, **kwargs):
+        with config_context(**self.config):
+            return self.function(*args, **kwargs)

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/utils/validation.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# ===============================================================================
+# Copyright 2022 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.utils.validation import _assert_all_finite