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

scikit_learn_intelex-2024.2.0.data/data/Lib/site-packages/sklearnex/neighbors/knn_regression.py

@@ -1,308 +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 warnings
-
-from sklearn.neighbors._ball_tree import BallTree
-from sklearn.neighbors._base import NeighborsBase as sklearn_NeighborsBase
-from sklearn.neighbors._kd_tree import KDTree
-
-from daal4py.sklearn._n_jobs_support import control_n_jobs
-from daal4py.sklearn._utils import sklearn_check_version
-
-if not sklearn_check_version("1.2"):
-    from sklearn.neighbors._base import _check_weights
-
-import numpy as np
-from sklearn.neighbors._base import VALID_METRICS
-from sklearn.neighbors._regression import (
-    KNeighborsRegressor as sklearn_KNeighborsRegressor,
-)
-from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestNeighbors
-from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
-
-from onedal.neighbors import KNeighborsRegressor as onedal_KNeighborsRegressor
-from onedal.utils import _check_array, _num_features, _num_samples
-
-from .._device_offload import dispatch, wrap_output_data
-from .common import KNeighborsDispatchingBase
-
-if sklearn_check_version("0.24"):
-
-    class KNeighborsRegressor_(sklearn_KNeighborsRegressor):
-        if sklearn_check_version("1.2"):
-            _parameter_constraints: dict = {
-                **sklearn_KNeighborsRegressor._parameter_constraints
-            }
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
-            self.weights = (
-                weights if sklearn_check_version("1.0") else _check_weights(weights)
-            )
-
-elif sklearn_check_version("0.22"):
-    from sklearn.neighbors._base import SupervisedFloatMixin as BaseSupervisedFloatMixin
-
-    class KNeighborsRegressor_(sklearn_KNeighborsRegressor, BaseSupervisedFloatMixin):
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
-            self.weights = _check_weights(weights)
-
-else:
-    from sklearn.neighbors.base import SupervisedFloatMixin as BaseSupervisedFloatMixin
-
-    class KNeighborsRegressor_(sklearn_KNeighborsRegressor, BaseSupervisedFloatMixin):
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
-            self.weights = _check_weights(weights)
-
-
-@control_n_jobs(decorated_methods=["fit", "predict", "kneighbors"])
-class KNeighborsRegressor(KNeighborsRegressor_, KNeighborsDispatchingBase):
-    if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**KNeighborsRegressor_._parameter_constraints}
-
-    if sklearn_check_version("1.0"):
-
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-            )
-
-    else:
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
-
-    def fit(self, X, y):
-        self._fit_validation(X, y)
-        dispatch(
-            self,
-            "fit",
-            {
-                "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_KNeighborsRegressor.fit,
-            },
-            X,
-            y,
-        )
-        return self
-
-    @wrap_output_data
-    def predict(self, X):
-        check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
-        return dispatch(
-            self,
-            "predict",
-            {
-                "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_KNeighborsRegressor.predict,
-            },
-            X,
-        )
-
-    @wrap_output_data
-    def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
-        check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
-        return dispatch(
-            self,
-            "kneighbors",
-            {
-                "onedal": self.__class__._onedal_kneighbors,
-                "sklearn": sklearn_KNeighborsRegressor.kneighbors,
-            },
-            X,
-            n_neighbors=n_neighbors,
-            return_distance=return_distance,
-        )
-
-    @wrap_output_data
-    def radius_neighbors(
-        self, X=None, radius=None, return_distance=True, sort_results=False
-    ):
-        _onedal_estimator = getattr(self, "_onedal_estimator", None)
-
-        if (
-            _onedal_estimator is not None
-            or getattr(self, "_tree", 0) is None
-            and self._fit_method == "kd_tree"
-        ):
-            if sklearn_check_version("0.24"):
-                sklearn_NearestNeighbors.fit(self, self._fit_X, getattr(self, "_y", None))
-            else:
-                sklearn_NearestNeighbors.fit(self, self._fit_X)
-        if sklearn_check_version("0.22"):
-            result = sklearn_NearestNeighbors.radius_neighbors(
-                self, X, radius, return_distance, sort_results
-            )
-        else:
-            result = sklearn_NearestNeighbors.radius_neighbors(
-                self, X, radius, return_distance
-            )
-
-        return result
-
-    def _onedal_fit(self, X, y, queue=None):
-        onedal_params = {
-            "n_neighbors": self.n_neighbors,
-            "weights": self.weights,
-            "algorithm": self.algorithm,
-            "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"],
-        }
-
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
-        self._onedal_estimator = onedal_KNeighborsRegressor(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
-        self._onedal_estimator.effective_metric_ = self.effective_metric_
-        self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
-        self._onedal_estimator.fit(X, y, queue=queue)
-
-        self._save_attributes()
-
-    def _onedal_predict(self, X, queue=None):
-        return self._onedal_estimator.predict(X, queue=queue)
-
-    def _onedal_kneighbors(
-        self, X=None, n_neighbors=None, return_distance=True, queue=None
-    ):
-        return self._onedal_estimator.kneighbors(
-            X, n_neighbors, return_distance, queue=queue
-        )
-
-    def _save_attributes(self):
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
-        self.n_samples_fit_ = self._onedal_estimator.n_samples_fit_
-        self._fit_X = self._onedal_estimator._fit_X
-        self._y = self._onedal_estimator._y
-        self._fit_method = self._onedal_estimator._fit_method
-        self._tree = self._onedal_estimator._tree

scikit_learn_intelex-2024.2.0.data/data/Lib/site-packages/sklearnex/preview/decomposition/__init__.py

@@ -1,19 +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.
-# ===============================================================================
-
-from .pca import PCA
-
-__all__ = ["PCA"]

scikit_learn_intelex-2024.2.0.data/data/Lib/site-packages/sklearnex/preview/decomposition/pca.py

@@ -1,374 +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 numbers
-from math import sqrt
-
-import numpy as np
-from scipy.sparse import issparse
-from sklearn.base import BaseEstimator
-from sklearn.utils.extmath import stable_cumsum
-from sklearn.utils.validation import check_array, check_is_fitted
-
-from daal4py.sklearn._n_jobs_support import control_n_jobs
-from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils import _check_array
-
-from ..._device_offload import dispatch
-from ..._utils import PatchingConditionsChain, register_hyperparameters
-
-if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
-    from sklearn.utils import check_scalar
-if sklearn_check_version("0.23"):
-    from sklearn.decomposition._pca import _infer_dimension
-else:
-    from sklearn.decomposition._pca import _infer_dimension_
-
-from sklearn.decomposition import PCA as sklearn_PCA
-
-from onedal.common.hyperparameters import get_hyperparameters
-from onedal.decomposition import PCA as onedal_PCA
-
-
-@register_hyperparameters({"fit": get_hyperparameters("covariance", "compute")})
-@control_n_jobs(decorated_methods=["fit", "transform"])
-class PCA(sklearn_PCA):
-    __doc__ = sklearn_PCA.__doc__
-
-    if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_PCA._parameter_constraints}
-
-    def __init__(
-        self,
-        n_components=None,
-        *,
-        copy=True,
-        whiten=False,
-        svd_solver="auto",
-        tol=0.0,
-        iterated_power="auto",
-        n_oversamples=10,
-        power_iteration_normalizer="auto",
-        random_state=None,
-    ):
-        self.n_components = n_components
-        self.copy = copy
-        self.whiten = whiten
-        self.svd_solver = svd_solver
-        self.tol = tol
-        self.iterated_power = iterated_power
-        self.n_oversamples = n_oversamples
-        self.power_iteration_normalizer = power_iteration_normalizer
-        self.random_state = random_state
-
-    def _validate_n_components(self, n_components, n_samples, n_features, n_sf_min):
-        if n_components == "mle":
-            if n_samples < n_features:
-                raise ValueError(
-                    "n_components='mle' is only supported if" " n_samples >= n_features"
-                )
-        elif not 0 <= n_components <= n_sf_min:
-            raise ValueError(
-                "n_components=%r must be between 0 and "
-                "min(n_samples, n_features)=%r with "
-                "svd_solver='full'" % (n_components, min(n_samples, n_features))
-            )
-        elif n_components >= 1:
-            if not isinstance(n_components, numbers.Integral):
-                raise ValueError(
-                    "n_components=%r must be of type int "
-                    "when greater than or equal to 1, "
-                    "was of type=%r" % (n_components, type(n_components))
-                )
-
-    def fit(self, X, y=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-        elif sklearn_check_version("1.1"):
-            check_scalar(
-                self.n_oversamples,
-                "n_oversamples",
-                min_val=1,
-                target_type=numbers.Integral,
-            )
-
-        if sklearn_check_version("0.23"):
-            X = self._validate_data(
-                X,
-                dtype=[np.float64, np.float32],
-                ensure_2d=True,
-                copy=False,
-                accept_sparse=True,
-            )
-        else:
-            X = _check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                ensure_2d=True,
-                copy=False,
-                accept_sparse=True,
-            )
-
-        n_samples, n_features = X.shape
-        n_sf_min = min(n_samples, n_features)
-
-        if self.n_components is None:
-            if self.svd_solver == "arpack":
-                n_components = n_sf_min - 1
-            else:
-                n_components = n_sf_min
-        else:
-            n_components = self.n_components
-
-        self._validate_n_components(n_components, n_samples, n_features, n_sf_min)
-
-        self._fit_svd_solver = self.svd_solver
-
-        if self._fit_svd_solver == "auto":
-            if sklearn_check_version("1.1"):
-                if max(X.shape) <= 500 or n_components == "mle":
-                    self._fit_svd_solver = "full"
-                elif 1 <= n_components < 0.8 * n_sf_min:
-                    self._fit_svd_solver = "randomized"
-                else:
-                    self._fit_svd_solver = "full"
-            else:
-                if n_components == "mle":
-                    self._fit_svd_solver = "full"
-                else:
-                    n, p, k = X.shape[0], X.shape[1], n_components
-                    # check if sklearnex is faster than randomized sklearn
-                    # Refer to daal4py
-                    regression_coefs = np.array(
-                        [
-                            [9.779873e-11, n * p * k],
-                            [-1.122062e-11, n * p * p],
-                            [1.127905e-09, n**2],
-                        ]
-                    )
-
-                    if (
-                        n_components >= 1
-                        and np.dot(regression_coefs[:, 0], regression_coefs[:, 1]) <= 0
-                    ):
-                        self._fit_svd_solver = "randomized"
-                    else:
-                        self._fit_svd_solver = "full"
-
-        dispatch(
-            self,
-            "fit",
-            {
-                "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_PCA.fit,
-            },
-            X,
-        )
-        return self
-
-    def _onedal_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        X = data[0]
-
-        if method_name == "fit":
-            patching_status = PatchingConditionsChain(
-                f"sklearn.decomposition.{class_name}.{method_name}"
-            )
-            patching_status.and_conditions(
-                [
-                    (
-                        self._fit_svd_solver == "full",
-                        f"'{self._fit_svd_solver}' SVD solver is not supported. "
-                        "Only 'full' solver is supported.",
-                    ),
-                    (not issparse(X), "oneDAL PCA does not support sparse inputs"),
-                    (
-                        X.shape[1] / X.shape[0] < 2,
-                        "The shape of X does not satisfy oneDAL requirements: "
-                        "number of features / number of samples >= 2",
-                    ),
-                ]
-            )
-            return patching_status
-        elif method_name == "transform":
-            patching_status = PatchingConditionsChain(
-                f"sklearn.decomposition.{class_name}.{method_name}"
-            )
-            patching_status.and_conditions(
-                [
-                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained"),
-                ]
-            )
-            return patching_status
-        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        return self._onedal_supported(method_name, *data)
-
-    def _onedal_gpu_supported(self, method_name, *data):
-        return self._onedal_supported(method_name, *data)
-
-    def _onedal_fit(self, X, y=None, queue=None):
-        if self.n_components == "mle" or self.n_components is None:
-            onedal_n_components = min(X.shape)
-        elif 0 < self.n_components < 1:
-            onedal_n_components = min(X.shape)
-        else:
-            onedal_n_components = self.n_components
-
-        onedal_params = {
-            "n_components": onedal_n_components,
-            "is_deterministic": True,
-            "method": "precomputed",
-        }
-        self._onedal_estimator = onedal_PCA(**onedal_params)
-        self._onedal_estimator.fit(X, queue=queue)
-        self._save_attributes()
-
-        U = None
-        S = self.singular_values_
-        V = self.components_
-
-        return U, S, V
-
-    def _onedal_predict(self, X, queue=None):
-        return self._onedal_estimator.predict(X, queue)
-
-    def _onedal_transform(self, X):
-        X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False)
-
-        if hasattr(self, "n_features_in_"):
-            if self.n_features_in_ != X.shape[1]:
-                raise ValueError(
-                    f"X has {X.shape[1]} features, "
-                    f"but {self.__class__.__name__} is expecting "
-                    f"{self.n_features_in_} features as input"
-                )
-        elif hasattr(self, "n_features_"):
-            if self.n_features_ != X.shape[1]:
-                raise ValueError(
-                    f"X has {X.shape[1]} features, "
-                    f"but {self.__class__.__name__} is expecting "
-                    f"{self.n_features_} features as input"
-                )
-
-        # Mean center
-        X_centered = X - self.mean_
-        return dispatch(
-            self,
-            "transform",
-            {
-                "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_PCA.transform,
-            },
-            X_centered,
-        )
-
-    def transform(self, X):
-        check_is_fitted(self)
-        if hasattr(self, "_onedal_estimator"):
-            X_new = self._onedal_transform(X)[:, : self.n_components_]
-            if self.whiten:
-                X_new /= np.sqrt(self.explained_variance_)
-        else:
-            return super().transform(X)
-        return X_new
-
-    def fit_transform(self, X, y=None):
-        """Fit the model with X and apply the dimensionality reduction on X.
-        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.
-        y : Ignored.
-
-        Returns
-        -------
-        X_new : ndarray of shape (n_samples, n_components)
-            Transformed values of X.
-        """
-        if self.svd_solver in ["randomized", "arpack"]:
-            return super().fit_transform(X)
-        else:
-            self.fit(X)
-            if hasattr(self, "_onedal_estimator"):
-                X_new = self._onedal_transform(X)[:, : self.n_components_]
-                if self.whiten:
-                    X_new /= np.sqrt(self.explained_variance_)
-                return X_new
-            else:
-                return super().transform(X)
-
-    fit.__doc__ = sklearn_PCA.fit.__doc__
-    transform.__doc__ = sklearn_PCA.transform.__doc__
-    fit_transform.__doc__ = sklearn_PCA.fit_transform.__doc__
-
-    def _save_attributes(self):
-        self.n_samples_ = self._onedal_estimator.n_samples_
-
-        if sklearn_check_version("1.2"):
-            self.n_features_in_ = self._onedal_estimator.n_features_in_
-            n_features = self.n_features_in_
-        elif sklearn_check_version("0.24"):
-            self.n_features_ = self._onedal_estimator.n_features_
-            self.n_features_in_ = self._onedal_estimator.n_features_in_
-            n_features = self.n_features_in_
-        else:
-            self.n_features_ = self._onedal_estimator.n_features_
-            n_features = self.n_features_
-        n_sf_min = min(self.n_samples_, n_features)
-
-        self.mean_ = self._onedal_estimator.mean_
-        self.singular_values_ = self._onedal_estimator.singular_values_
-        self.explained_variance_ = self._onedal_estimator.explained_variance_
-        self.explained_variance_ratio_ = self._onedal_estimator.explained_variance_ratio_
-
-        if self.n_components is None:
-            self.n_components_ = self._onedal_estimator.n_components_
-        elif self.n_components == "mle":
-            if sklearn_check_version("0.23"):
-                self.n_components_ = _infer_dimension(
-                    self.explained_variance_, self.n_samples_
-                )
-            else:
-                self.n_components_ = _infer_dimension_(
-                    self.explained_variance_, self.n_samples_, n_features
-                )
-        elif 0 < self.n_components < 1.0:
-            ratio_cumsum = stable_cumsum(self.explained_variance_ratio_)
-            self.n_components_ = (
-                np.searchsorted(ratio_cumsum, self.n_components, side="right") + 1
-            )
-        else:
-            self.n_components_ = self._onedal_estimator.n_components_
-
-        if self.n_components_ < n_sf_min:
-            if self.explained_variance_.shape[0] == n_sf_min:
-                self.noise_variance_ = self.explained_variance_[
-                    self.n_components_ :
-                ].mean()
-            else:
-                self.noise_variance_ = self._onedal_estimator.noise_variance_
-        else:
-            self.noise_variance_ = 0.0
-
-        self.explained_variance_ = self.explained_variance_[: self.n_components_]
-        self.explained_variance_ratio_ = self.explained_variance_ratio_[
-            : self.n_components_
-        ]
-        self.components_ = self._onedal_estimator.components_[: self.n_components_]
-        self.singular_values_ = self.singular_values_[: self.n_components_]