scikit-learn-intelex 2024.0.1__py311-none-manylinux1_x86_64.whl → 2024.4.0__py311-none-manylinux1_x86_64.whl

sklearnex/preview/decomposition/pca.py

@@ -1,376 +0,0 @@
-#!/usr/bin/env python
-# ===============================================================================
-# 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._utils import sklearn_check_version
-from onedal.utils import _check_array
-
-from ..._device_offload import dispatch
-from ..._utils import PatchingConditionsChain
-
-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.decomposition import PCA as onedal_PCA
-
-
-class PCA(sklearn_PCA):
-    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,
-            )
-        self._fit(X)
-        return self
-
-    def _fit(self, X):
-        if issparse(X):
-            raise TypeError(
-                "PCA does not support sparse input. See "
-                "TruncatedSVD for a possible alternative."
-            )
-
-        if sklearn_check_version("0.23"):
-            X = self._validate_data(
-                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
-            )
-        else:
-            X = _check_array(
-                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
-            )
-
-        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
-        shape_good_for_daal = X.shape[1] / X.shape[0] < 2
-        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"
-
-        if not shape_good_for_daal or self._fit_svd_solver != "full":
-            if sklearn_check_version("0.23"):
-                X = self._validate_data(X, copy=self.copy)
-            else:
-                X = check_array(X, copy=self.copy)
-
-        # Call different fits for either full or truncated SVD
-        if shape_good_for_daal and self._fit_svd_solver == "full":
-            return dispatch(
-                self,
-                "fit",
-                {
-                    "onedal": self.__class__._onedal_fit,
-                    "sklearn": sklearn_PCA._fit_full,
-                },
-                X,
-            )
-        elif not shape_good_for_daal and self._fit_svd_solver == "full":
-            return sklearn_PCA._fit_full(self, X, n_components)
-        elif self._fit_svd_solver in ["arpack", "randomized"]:
-            return sklearn_PCA._fit_truncated(
-                self,
-                X,
-                n_components,
-                self._fit_svd_solver,
-            )
-        else:
-            raise ValueError("Unrecognized svd_solver='{0}'".format(self._fit_svd_solver))
-
-    def _onedal_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        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.",
-                    ),
-                ]
-            )
-            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 sklearn_PCA.transform(self, 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 sklearn_PCA.fit_transform(self, 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 sklearn_PCA.transform(self, X)
-
-    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_]

sklearnex/preview/decomposition/tests/test_preview_pca.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python
-# ===============================================================================
-# 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 numpy as np
-import pytest
-from numpy.testing import assert_allclose
-
-from onedal.tests.utils._dataframes_support import (
-    _as_numpy,
-    _convert_to_dataframe,
-    get_dataframes_and_queues,
-)
-
-
-@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-def test_sklearnex_import(dataframe, queue):
-    from sklearnex.preview.decomposition import PCA
-
-    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
-    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    pca = PCA(n_components=2, svd_solver="full").fit(X)
-    assert "sklearnex" in pca.__module__
-    assert hasattr(pca, "_onedal_estimator")
-    assert_allclose(_as_numpy(pca.singular_values_), [6.30061232, 0.54980396])

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",
-]

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()