scikit-learn-intelex 2024.4.0__py310-none-win_amd64.whl → 2024.6.0__py310-none-win_amd64.whl

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -1,130 +0,0 @@
-# ===============================================================================
-# Copyright 2024 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.utils import check_array, gen_batches
-
-from daal4py.sklearn._n_jobs_support import control_n_jobs
-from onedal._device_offload import support_usm_ndarray
-from onedal.covariance import (
-    IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
-)
-
-
-@control_n_jobs(decorated_methods=["partial_fit"])
-class IncrementalEmpiricalCovariance:
-    """
-    Incremental estimator for covariance.
-    Allows to compute empirical covariance estimated by maximum
-    likelihood method if data are splitted into batches.
-
-    Parameters
-    ----------
-    batch_size : int, default=None
-        The number of samples to use for each batch. Only used when calling
-        ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
-        is inferred from the data and set to ``5 * n_features``, to provide a
-        balance between approximation accuracy and memory consumption.
-
-    Attributes
-    ----------
-    location_ : ndarray of shape (n_features,)
-        Estimated location, i.e. the estimated mean.
-
-    covariance_ : ndarray of shape (n_features, n_features)
-        Estimated covariance matrix
-    """
-
-    _onedal_incremental_covariance = staticmethod(onedal_IncrementalEmpiricalCovariance)
-
-    def __init__(self, batch_size=None):
-        self._need_to_finalize = False  # If True then finalize compute should
-        #      be called to obtain covariance_ or location_ from partial compute data
-        self.batch_size = batch_size
-
-    def _onedal_finalize_fit(self):
-        assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
-        self._need_to_finalize = False
-
-    def _onedal_partial_fit(self, X, queue):
-        onedal_params = {
-            "method": "dense",
-            "bias": True,
-        }
-        if not hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator = self._onedal_incremental_covariance(**onedal_params)
-        self._onedal_estimator.partial_fit(X, queue)
-        self._need_to_finalize = True
-
-    @property
-    def covariance_(self):
-        if self._need_to_finalize:
-            self._onedal_finalize_fit()
-        return self._onedal_estimator.covariance_
-
-    @property
-    def location_(self):
-        if self._need_to_finalize:
-            self._onedal_finalize_fit()
-        return self._onedal_estimator.location_
-
-    @support_usm_ndarray()
-    def partial_fit(self, X, queue=None):
-        """
-        Incremental fit with X. All of X is processed as a single batch.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        X = check_array(X, dtype=[np.float64, np.float32])
-        self._onedal_partial_fit(X, queue)
-        return self
-
-    def fit(self, X, queue=None):
-        """
-        Fit the model with X, using minibatches of size batch_size.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        n_samples, n_features = X.shape
-        if self.batch_size is None:
-            batch_size_ = 5 * n_features
-        else:
-            batch_size_ = self.batch_size
-        for batch in gen_batches(n_samples, batch_size_):
-            X_batch = X[batch]
-            self.partial_fit(X_batch, queue=queue)
-
-        self._onedal_finalize_fit()
-        return self

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -1,185 +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.
-# ==============================================================================
-
-from abc import ABC
-
-import numpy as np
-from sklearn.calibration import CalibratedClassifierCV
-from sklearn.model_selection import StratifiedKFold
-from sklearn.preprocessing import LabelEncoder
-
-from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils import _column_or_1d
-
-from .._utils import PatchingConditionsChain
-
-
-def get_dual_coef(self):
-    return self.dual_coef_
-
-
-def set_dual_coef(self, value):
-    self.dual_coef_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.dual_coef_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
-
-
-def get_intercept(self):
-    return self._intercept_
-
-
-def set_intercept(self, value):
-    self._intercept_ = value
-    if hasattr(self, "_onedal_estimator"):
-        self._onedal_estimator.intercept_ = value
-        if not self._is_in_fit:
-            del self._onedal_estimator._onedal_model
-
-
-class BaseSVM(ABC):
-    def _onedal_gpu_supported(self, method_name, *data):
-        patching_status = PatchingConditionsChain(f"sklearn.{method_name}")
-        patching_status.and_conditions([(False, "GPU offloading is not supported.")])
-        return patching_status
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        patching_status = PatchingConditionsChain(
-            f"sklearn.svm.{class_name}.{method_name}"
-        )
-        if method_name == "fit":
-            patching_status.and_conditions(
-                [
-                    (
-                        self.kernel in ["linear", "rbf", "poly", "sigmoid"],
-                        f'Kernel is "{self.kernel}" while '
-                        '"linear", "rbf", "poly" and "sigmoid" are only supported.',
-                    )
-                ]
-            )
-            return patching_status
-        inference_methods = (
-            ["predict"]
-            if class_name.endswith("R")
-            else ["predict", "predict_proba", "decision_function", "score"]
-        )
-        if method_name in inference_methods:
-            patching_status.and_conditions(
-                [(hasattr(self, "_onedal_estimator"), "oneDAL model was not trained.")]
-            )
-            return patching_status
-        raise RuntimeError(f"Unknown method {method_name} in {class_name}")
-
-
-class BaseSVC(BaseSVM):
-    def _compute_balanced_class_weight(self, y):
-        y_ = _column_or_1d(y)
-        classes, _ = np.unique(y_, return_inverse=True)
-
-        le = LabelEncoder()
-        y_ind = le.fit_transform(y_)
-        if not all(np.in1d(classes, le.classes_)):
-            raise ValueError("classes should have valid labels that are in y")
-
-        recip_freq = len(y_) / (len(le.classes_) * np.bincount(y_ind).astype(np.float64))
-        return recip_freq[le.transform(classes)]
-
-    def _fit_proba(self, X, y, sample_weight=None, queue=None):
-        params = self.get_params()
-        params["probability"] = False
-        params["decision_function_shape"] = "ovr"
-        clf_base = self.__class__(**params)
-
-        try:
-            n_splits = 5
-            n_jobs = n_splits if queue is None or queue.sycl_device.is_cpu else 1
-            cv = StratifiedKFold(
-                n_splits=n_splits, shuffle=True, random_state=self.random_state
-            )
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base, ensemble=False, cv=cv, method="sigmoid", n_jobs=n_jobs
-            )
-            self.clf_prob.fit(X, y, sample_weight)
-        except ValueError:
-            clf_base = clf_base.fit(X, y, sample_weight)
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base, cv="prefit", method="sigmoid"
-            )
-            self.clf_prob.fit(X, y, sample_weight)
-
-    def _save_attributes(self):
-        self.support_vectors_ = self._onedal_estimator.support_vectors_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self.fit_status_ = 0
-        self.dual_coef_ = self._onedal_estimator.dual_coef_
-        self.shape_fit_ = self._onedal_estimator.class_weight_
-        self.classes_ = self._onedal_estimator.classes_
-        self.class_weight_ = self._onedal_estimator.class_weight_
-        self.support_ = self._onedal_estimator.support_
-
-        self._intercept_ = self._onedal_estimator.intercept_
-        self._n_support = self._onedal_estimator._n_support
-        self._sparse = False
-        self._gamma = self._onedal_estimator._gamma
-        if self.probability:
-            length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
-            self._probA = np.zeros(length)
-            self._probB = np.zeros(length)
-        else:
-            self._probA = np.empty(0)
-            self._probB = np.empty(0)
-
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
-
-        if sklearn_check_version("1.1"):
-            length = int(len(self.classes_) * (len(self.classes_) - 1) / 2)
-            self.n_iter_ = np.full((length,), self._onedal_estimator.n_iter_)
-
-
-class BaseSVR(BaseSVM):
-    def _save_attributes(self):
-        self.support_vectors_ = self._onedal_estimator.support_vectors_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self.fit_status_ = 0
-        self.dual_coef_ = self._onedal_estimator.dual_coef_
-        self.shape_fit_ = self._onedal_estimator.shape_fit_
-        self.support_ = self._onedal_estimator.support_
-
-        self._intercept_ = self._onedal_estimator.intercept_
-        self._n_support = [self.support_vectors_.shape[0]]
-        self._sparse = False
-        self._gamma = self._onedal_estimator._gamma
-        self._probA = None
-        self._probB = None
-
-        self._dual_coef_ = property(get_dual_coef, set_dual_coef)
-        self.intercept_ = property(get_intercept, set_intercept)
-
-        self._is_in_fit = True
-        self._dual_coef_ = self.dual_coef_
-        self.intercept_ = self._intercept_
-        self._is_in_fit = False
-
-        if sklearn_check_version("1.1"):
-            self.n_iter_ = self._onedal_estimator.n_iter_

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

@@ -1,227 +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.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 = [
-    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)
-    )
-
-
-# disable fallback check as logging impacts memory use
-
-
-@pytest.mark.allow_sklearn_fallback
-@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)