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

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

@@ -1,222 +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 gc
-import logging
-import tracemalloc
-import types
-
-import numpy as np
-import pandas as pd
-import pytest
-from scipy.stats import pearsonr
-from sklearn.base import BaseEstimator
-from sklearn.datasets import make_classification
-from sklearn.model_selection import KFold
-
-from sklearnex import get_patch_map
-from sklearnex.metrics import pairwise_distances, roc_auc_score
-from sklearnex.model_selection import train_test_split
-from sklearnex.preview.decomposition import PCA as PreviewPCA
-from sklearnex.utils import _assert_all_finite
-
-
-class TrainTestSplitEstimator:
-    def __init__(self):
-        pass
-
-    def fit(self, x, y):
-        train_test_split(x, y)
-
-
-class FiniteCheckEstimator:
-    def __init__(self):
-        pass
-
-    def fit(self, x, y):
-        _assert_all_finite(x)
-        _assert_all_finite(y)
-
-
-class PairwiseDistancesEstimator:
-    def fit(self, x, y):
-        pairwise_distances(x, metric=self.metric)
-
-
-class CosineDistancesEstimator(PairwiseDistancesEstimator):
-    def __init__(self):
-        self.metric = "cosine"
-
-
-class CorrelationDistancesEstimator(PairwiseDistancesEstimator):
-    def __init__(self):
-        self.metric = "correlation"
-
-
-class RocAucEstimator:
-    def __init__(self):
-        pass
-
-    def fit(self, x, y):
-        print(roc_auc_score(y, np.zeros(shape=y.shape, dtype=np.int32)))
-
-
-# add all daal4py estimators enabled in patching (except banned)
-def get_patched_estimators(ban_list, output_list):
-    patched_estimators = get_patch_map().values()
-    for listing in patched_estimators:
-        estimator, name = listing[0][0][2], listing[0][0][1]
-        if not isinstance(estimator, types.FunctionType):
-            if name not in ban_list:
-                if issubclass(estimator, BaseEstimator):
-                    if hasattr(estimator, "fit"):
-                        output_list.append(estimator)
-
-
-def remove_duplicated_estimators(estimators_list):
-    estimators_map = {}
-    for estimator in estimators_list:
-        full_name = f"{estimator.__module__}.{estimator.__name__}"
-        estimators_map[full_name] = estimator
-    return estimators_map.values()
-
-
-BANNED_ESTIMATORS = ("TSNE",)  # too slow for using in testing on common data size
-estimators = [
-    PreviewPCA,
-    TrainTestSplitEstimator,
-    FiniteCheckEstimator,
-    CosineDistancesEstimator,
-    CorrelationDistancesEstimator,
-    RocAucEstimator,
-]
-get_patched_estimators(BANNED_ESTIMATORS, estimators)
-estimators = remove_duplicated_estimators(estimators)
-
-
-def ndarray_c(x, y):
-    return np.ascontiguousarray(x), y
-
-
-def ndarray_f(x, y):
-    return np.asfortranarray(x), y
-
-
-def dataframe_c(x, y):
-    return pd.DataFrame(np.ascontiguousarray(x)), pd.Series(y)
-
-
-def dataframe_f(x, y):
-    return pd.DataFrame(np.asfortranarray(x)), pd.Series(y)
-
-
-data_transforms = [ndarray_c, ndarray_f, dataframe_c, dataframe_f]
-
-data_shapes = [(1000, 100), (2000, 50)]
-
-EXTRA_MEMORY_THRESHOLD = 0.15
-N_SPLITS = 10
-
-
-def gen_clsf_data(n_samples, n_features):
-    data, label = make_classification(
-        n_classes=2, n_samples=n_samples, n_features=n_features, random_state=777
-    )
-    return (
-        data,
-        label,
-        data.size * data.dtype.itemsize + label.size * label.dtype.itemsize,
-    )
-
-
-def split_train_inference(kf, x, y, estimator):
-    mem_tracks = []
-    for train_index, test_index in kf.split(x):
-        if isinstance(x, np.ndarray):
-            x_train, x_test = x[train_index], x[test_index]
-            y_train, y_test = y[train_index], y[test_index]
-        elif isinstance(x, pd.core.frame.DataFrame):
-            x_train, x_test = x.iloc[train_index], x.iloc[test_index]
-            y_train, y_test = y.iloc[train_index], y.iloc[test_index]
-        # TODO: add parameters for all estimators to prevent
-        # fallback to stock scikit-learn with default parameters
-        alg = estimator()
-        alg.fit(x_train, y_train)
-        if hasattr(alg, "predict"):
-            alg.predict(x_test)
-        elif hasattr(alg, "transform"):
-            alg.transform(x_test)
-        elif hasattr(alg, "kneighbors"):
-            alg.kneighbors(x_test)
-        del alg, x_train, x_test, y_train, y_test
-        mem_tracks.append(tracemalloc.get_traced_memory()[0])
-
-    return mem_tracks
-
-
-def _kfold_function_template(estimator, data_transform_function, data_shape):
-    tracemalloc.start()
-
-    n_samples, n_features = data_shape
-    x, y, data_memory_size = gen_clsf_data(n_samples, n_features)
-    kf = KFold(n_splits=N_SPLITS)
-    x, y = data_transform_function(x, y)
-
-    mem_before, _ = tracemalloc.get_traced_memory()
-    mem_tracks = split_train_inference(kf, x, y, estimator)
-    mem_iter_diffs = np.array(mem_tracks[1:]) - np.array(mem_tracks[:-1])
-    mem_incr_mean, mem_incr_std = mem_iter_diffs.mean(), mem_iter_diffs.std()
-    mem_incr_mean, mem_incr_std = round(mem_incr_mean), round(mem_incr_std)
-    mem_iter_corr, _ = pearsonr(mem_tracks, list(range(len(mem_tracks))))
-    if mem_iter_corr > 0.95:
-        logging.warning(
-            "Memory usage is steadily increasing with iterations "
-            "(Pearson correlation coefficient between "
-            f"memory tracks and iterations is {mem_iter_corr})\n"
-            "Memory usage increase per iteration: "
-            f"{mem_incr_mean}±{mem_incr_std} bytes"
-        )
-    mem_before_gc, _ = tracemalloc.get_traced_memory()
-    mem_diff = mem_before_gc - mem_before
-    message = (
-        "Size of extra allocated memory {} using garbage collector "
-        f"is greater than {EXTRA_MEMORY_THRESHOLD * 100}% of input data"
-        f"\n\tAlgorithm: {estimator.__name__}"
-        f"\n\tInput data size: {data_memory_size} bytes"
-        "\n\tExtra allocated memory size: {} bytes"
-        " / {} %"
-    )
-    if mem_diff >= EXTRA_MEMORY_THRESHOLD * data_memory_size:
-        logging.warning(
-            message.format(
-                "before", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
-            )
-        )
-    gc.collect()
-    mem_after, _ = tracemalloc.get_traced_memory()
-    tracemalloc.stop()
-    mem_diff = mem_after - mem_before
-
-    assert mem_diff < EXTRA_MEMORY_THRESHOLD * data_memory_size, message.format(
-        "after", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
-    )
-
-
-@pytest.mark.parametrize("data_transform_function", data_transforms)
-@pytest.mark.parametrize("estimator", estimators)
-@pytest.mark.parametrize("data_shape", data_shapes)
-def test_memory_leaks(estimator, data_transform_function, data_shape):
-    _kfold_function_template(estimator, data_transform_function, data_shape)

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_n_jobs_support.py

@@ -1,93 +0,0 @@
-# ==============================================================================
-# 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 inspect
-import logging
-from multiprocessing import cpu_count
-
-import pytest
-from sklearn.base import BaseEstimator
-from sklearn.datasets import make_classification
-
-from sklearnex.dispatcher import get_patch_map
-from sklearnex.svm import SVC, NuSVC
-
-ESTIMATORS = set(
-    filter(
-        lambda x: inspect.isclass(x) and issubclass(x, BaseEstimator),
-        [value[0][0][2] for value in get_patch_map().values()],
-    )
-)
-
-X, Y = make_classification(n_samples=40, n_features=4, random_state=42)
-
-
-@pytest.mark.parametrize("estimator_class", ESTIMATORS)
-@pytest.mark.parametrize("n_jobs", [None, -1, 1, 2])
-def test_n_jobs_support(caplog, estimator_class, n_jobs):
-    def check_estimator_doc(estimator):
-        if estimator.__doc__ is not None:
-            assert "n_jobs" in estimator.__doc__
-
-    def check_n_jobs_entry_in_logs(caplog, function_name, n_jobs):
-        for rec in caplog.records:
-            if function_name in rec.message and "threads" in rec.message:
-                expected_n_jobs = n_jobs if n_jobs > 0 else cpu_count() + 1 + n_jobs
-                logging.info(f"{function_name}: setting {expected_n_jobs} threads")
-                if f"{function_name}: setting {expected_n_jobs} threads" in rec.message:
-                    return True
-        # False if n_jobs is set and not found in logs
-        return n_jobs is None
-
-    def check_method(*args, method, caplog):
-        method(*args)
-        assert check_n_jobs_entry_in_logs(caplog, method.__name__, n_jobs)
-
-    def check_methods_decoration(estimator):
-        funcs = {
-            i: getattr(estimator, i)
-            for i in dir(estimator)
-            if hasattr(estimator, i) and callable(getattr(estimator, i))
-        }
-
-        for func_name, func in funcs.items():
-            assert hasattr(func, "__onedal_n_jobs_decorated__") == (
-                func_name in estimator._n_jobs_supported_onedal_methods
-            ), f"{estimator}.{func_name} n_jobs decoration does not match {estimator} n_jobs supported methods"
-
-    caplog.set_level(logging.DEBUG, logger="sklearnex")
-    estimator_kwargs = {"n_jobs": n_jobs}
-    # by default, [Nu]SVC.predict_proba is restricted by @available_if decorator
-    if estimator_class in [SVC, NuSVC]:
-        estimator_kwargs["probability"] = True
-    estimator_instance = estimator_class(**estimator_kwargs)
-    # check `n_jobs` parameter doc entry
-    check_estimator_doc(estimator_class)
-    check_estimator_doc(estimator_instance)
-    # check `n_jobs` log entry for supported methods
-    # `fit` call is required before other methods
-    check_method(X, Y, method=estimator_instance.fit, caplog=caplog)
-    for method_name in estimator_instance._n_jobs_supported_onedal_methods:
-        if method_name == "fit":
-            continue
-        method = getattr(estimator_instance, method_name)
-        if len(inspect.signature(method).parameters) == 0:
-            check_method(method=method, caplog=caplog)
-        else:
-            check_method(X, method=method, caplog=caplog)
-    # check if correct methods were decorated
-    check_methods_decoration(estimator_class)
-    check_methods_decoration(estimator_instance)