scikit-learn-intelex 2024.1.0__py310-none-manylinux1_x86_64.whl → 2024.3.0__py310-none-manylinux1_x86_64.whl

sklearnex/decomposition/pca.py

@@ -14,4 +14,325 @@
 # limitations under the License.
 # ===============================================================================
 
-from daal4py.sklearn.decomposition import PCA
+import logging
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2024, "P", 100)):
+    import numbers
+    from math import sqrt
+
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.utils.validation import check_is_fitted
+
+    from daal4py.sklearn._n_jobs_support import control_n_jobs
+    from daal4py.sklearn._utils import sklearn_check_version
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain
+
+    if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
+        from sklearn.utils import check_scalar
+
+    from sklearn.decomposition import PCA as sklearn_PCA
+
+    from onedal.decomposition import PCA as onedal_PCA
+
+    @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
+    class PCA(sklearn_PCA):
+        __doc__ = sklearn_PCA.__doc__
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**sklearn_PCA._parameter_constraints}
+
+        if sklearn_check_version("1.1"):
+
+            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
+
+        else:
+
+            def __init__(
+                self,
+                n_components=None,
+                copy=True,
+                whiten=False,
+                svd_solver="auto",
+                tol=0.0,
+                iterated_power="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.random_state = random_state
+
+        def fit(self, X, y=None):
+            self._fit(X)
+            return self
+
+        def _fit(self, X):
+            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,
+                )
+
+            U, S, Vt = dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_PCA._fit,
+                },
+                X,
+            )
+            return U, S, Vt
+
+        def _onedal_fit(self, X, queue=None):
+            X = self._validate_data(
+                X,
+                dtype=[np.float64, np.float32],
+                ensure_2d=True,
+                copy=self.copy,
+            )
+
+            onedal_params = {
+                "n_components": self.n_components,
+                "is_deterministic": True,
+                "method": "cov",
+                "whiten": self.whiten,
+            }
+            self._onedal_estimator = onedal_PCA(**onedal_params)
+            self._onedal_estimator.fit(X, queue=queue)
+            self._save_attributes()
+
+            U = None
+            S = self.singular_values_
+            Vt = self.components_
+
+            return U, S, Vt
+
+        @wrap_output_data
+        def transform(self, X):
+            return dispatch(
+                self,
+                "transform",
+                {
+                    "onedal": self.__class__._onedal_transform,
+                    "sklearn": sklearn_PCA.transform,
+                },
+                X,
+            )
+
+        def _onedal_transform(self, X, queue=None):
+            check_is_fitted(self)
+            X = self._validate_data(
+                X,
+                dtype=[np.float64, np.float32],
+                reset=False,
+            )
+            self._validate_n_features_in_after_fitting(X)
+            if sklearn_check_version("1.0"):
+                self._check_feature_names(X, reset=False)
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        @wrap_output_data
+        def fit_transform(self, X, y=None):
+            U, S, Vt = self._fit(X)
+            if U is None:
+                # oneDAL PCA was fit
+                X_transformed = self._onedal_transform(X)
+                return X_transformed
+            else:
+                # Scikit-learn PCA was fit
+                U = U[:, : self.n_components_]
+
+                if self.whiten:
+                    U *= sqrt(X.shape[0] - 1)
+                else:
+                    U *= S[: self.n_components_]
+
+                return U
+
+        def _onedal_supported(self, method_name, X):
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(
+                f"sklearn.decomposition.{class_name}.{method_name}"
+            )
+
+            if method_name == "fit":
+                shape_tuple, _is_shape_compatible = self._get_shape_compatibility(X)
+                patching_status.and_conditions(
+                    [
+                        (
+                            _is_shape_compatible,
+                            "Data shape is not compatible.",
+                        ),
+                        (
+                            self._is_solver_compatible_with_onedal(shape_tuple),
+                            f"Only 'full' svd solver is supported.",
+                        ),
+                        (not issparse(X), "oneDAL PCA does not support sparse data"),
+                    ]
+                )
+                return patching_status
+
+            if method_name == "transform":
+                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 _get_shape_compatibility(self, X):
+            _is_shape_compatible = False
+            _empty_shape = (0, 0)
+            if hasattr(X, "shape"):
+                shape_tuple = X.shape
+                if len(shape_tuple) == 1:
+                    shape_tuple = (1, shape_tuple[0])
+            elif isinstance(X, list):
+                if np.ndim(X) == 1:
+                    shape_tuple = (1, len(X))
+                elif np.ndim(X) == 2:
+                    shape_tuple = (len(X), len(X[0]))
+            else:
+                return _empty_shape, _is_shape_compatible
+
+            if shape_tuple[0] > 0 and shape_tuple[1] > 0 and len(shape_tuple) == 2:
+                _is_shape_compatible = shape_tuple[1] / shape_tuple[0] < 2
+
+            return shape_tuple, _is_shape_compatible
+
+        def _is_solver_compatible_with_onedal(self, shape_tuple):
+            self._fit_svd_solver = self.svd_solver
+            n_sf_min = min(shape_tuple)
+            n_components = n_sf_min if self.n_components is None else self.n_components
+
+            if self._fit_svd_solver == "auto":
+                if sklearn_check_version("1.1"):
+                    if max(shape_tuple) <= 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:
+                        # check if sklearnex is faster than randomized sklearn
+                        # Refer to daal4py
+                        regression_coefs = np.array(
+                            [
+                                [
+                                    9.779873e-11,
+                                    shape_tuple[0] * shape_tuple[1] * n_components,
+                                ],
+                                [
+                                    -1.122062e-11,
+                                    shape_tuple[0] * shape_tuple[1] * shape_tuple[1],
+                                ],
+                                [1.127905e-09, shape_tuple[0] ** 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 self._fit_svd_solver == "full":
+                return True
+            else:
+                return False
+
+        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_
+            elif sklearn_check_version("0.24"):
+                self.n_features_ = self._onedal_estimator.n_features_
+                self.n_features_in_ = self._onedal_estimator.n_features_
+            else:
+                self.n_features_ = self._onedal_estimator.n_features_
+            self.n_components_ = self._onedal_estimator.n_components_
+            self.components_ = self._onedal_estimator.components_
+            self.mean_ = self._onedal_estimator.mean_
+            self.singular_values_ = self._onedal_estimator.singular_values_
+            self.explained_variance_ = self._onedal_estimator.explained_variance_.ravel()
+            self.explained_variance_ratio_ = (
+                self._onedal_estimator.explained_variance_ratio_
+            )
+            self.noise_variance_ = self._onedal_estimator.noise_variance_
+
+        def _validate_n_features_in_after_fitting(self, X):
+            if sklearn_check_version("1.2"):
+                expected_n_features = self.n_features_in_
+            else:
+                expected_n_features = self.n_features_
+            if X.shape[1] != expected_n_features:
+                raise ValueError(
+                    (
+                        f"X has {X.shape[1]} features, "
+                        f"but PCA is expecting {expected_n_features} features as input"
+                    )
+                )
+
+        fit.__doc__ = sklearn_PCA.fit.__doc__
+        transform.__doc__ = sklearn_PCA.transform.__doc__
+        fit_transform.__doc__ = sklearn_PCA.fit_transform.__doc__
+
+else:
+    from daal4py.sklearn.decomposition import PCA
+
+    logging.warning(
+        "Sklearnex PCA requires oneDAL version >= 2024.1.0 but it was not found"
+    )

sklearnex/decomposition/tests/test_pca.py

@@ -15,13 +15,42 @@
 # ===============================================================================
 
 import numpy as np
+import pytest
 from numpy.testing import assert_allclose
 
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
 
-def test_sklearnex_import():
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import(dataframe, queue):
     from sklearnex.decomposition import PCA
 
-    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
-    pca = PCA(n_components=2, svd_solver="full").fit(X)
-    assert "daal4py" in pca.__module__
-    assert_allclose(pca.singular_values_, [6.30061232, 0.54980396])
+    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_transformed_expected = [
+        [-1.38340578, -0.2935787],
+        [-2.22189802, 0.25133484],
+        [-3.6053038, -0.04224385],
+        [1.38340578, 0.2935787],
+        [2.22189802, -0.25133484],
+        [3.6053038, 0.04224385],
+    ]
+
+    pca = PCA(n_components=2, svd_solver="full")
+    pca.fit(X)
+    X_transformed = pca.transform(X)
+    X_fit_transformed = PCA(n_components=2, svd_solver="full").fit_transform(X)
+
+    if daal_check_version((2024, "P", 100)):
+        assert "sklearnex" in pca.__module__
+        assert hasattr(pca, "_onedal_estimator")
+    else:
+        assert "daal4py" in pca.__module__
+    assert_allclose([6.30061232, 0.54980396], _as_numpy(pca.singular_values_))
+    assert_allclose(X_transformed_expected, _as_numpy(X_transformed))
+    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed))

sklearnex/dispatcher.py

@@ -1,5 +1,6 @@
 # ==============================================================================
 # Copyright 2021 Intel Corporation
+# Copyright 2024 Fujitsu Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,7 +23,7 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
 
 def _is_new_patching_available():
-    return os.environ.get("OFF_ONEDAL_IFACE") is None and daal_check_version(
+    return os.environ.get("OFF_ONEDAL_IFACE", "0") == "0" and daal_check_version(
         (2021, "P", 300)
     )
 
@@ -32,16 +33,66 @@ def _is_preview_enabled():
 
 
 @lru_cache(maxsize=None)
-def get_patch_map():
+def get_patch_map_core(preview=False):
+    if preview:
+        # use recursion to guarantee that state of preview
+        # and non-preview maps are done at the same time.
+        # The two lru_cache dicts are actually one underneath.
+        # Preview is always secondary. Both sklearnex patch
+        # maps are referring to the daal4py dict unless the
+        # key has been replaced. Use with caution.
+        mapping = get_patch_map_core().copy()
+
+        if _is_new_patching_available():
+            import sklearn.covariance as covariance_module
+
+            # Preview classes for patching
+            from .preview.cluster import KMeans as KMeans_sklearnex
+            from .preview.covariance import (
+                EmpiricalCovariance as EmpiricalCovariance_sklearnex,
+            )
+
+            # Since the state of the lru_cache without preview cannot be
+            # guaranteed to not have already enabled sklearnex algorithms
+            # when preview is used, setting the mapping element[1] to None
+            # should NOT be done. This may lose track of the unpatched
+            # sklearn estimator or function.
+            # KMeans
+            cluster_module, _, _ = mapping["kmeans"][0][0]
+            sklearn_obj = mapping["kmeans"][0][1]
+            mapping.pop("kmeans")
+            mapping["kmeans"] = [
+                [(cluster_module, "kmeans", KMeans_sklearnex), sklearn_obj]
+            ]
+
+            # Covariance
+            mapping["empiricalcovariance"] = [
+                [
+                    (
+                        covariance_module,
+                        "EmpiricalCovariance",
+                        EmpiricalCovariance_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+        return mapping
+
     from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms
 
+    # NOTE: this is a shallow copy of a dict, modification is dangerous
     mapping = _get_map_of_algorithms().copy()
 
+    # NOTE: Use of daal4py _get_map_of_algorithms and
+    # get_patch_map/get_patch_map_core should not be used concurrently.
+    # The setting of elements to None below may cause loss of state
+    # when interacting with sklearn. A dictionary key must not be
+    # modified but totally replaced, otherwise it will cause chaos.
+    # Hence why pop is being used.
     if _is_new_patching_available():
         # Scikit-learn* modules
         import sklearn as base_module
         import sklearn.cluster as cluster_module
-        import sklearn.covariance as covariance_module
         import sklearn.decomposition as decomposition_module
         import sklearn.ensemble as ensemble_module
         import sklearn.linear_model as linear_model_module
@@ -64,80 +115,30 @@ def get_patch_map():
             from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
 
         from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .decomposition import PCA as PCA_sklearnex
         from .ensemble import ExtraTreesClassifier as ExtraTreesClassifier_sklearnex
         from .ensemble import ExtraTreesRegressor as ExtraTreesRegressor_sklearnex
         from .ensemble import RandomForestClassifier as RandomForestClassifier_sklearnex
         from .ensemble import RandomForestRegressor as RandomForestRegressor_sklearnex
         from .linear_model import LinearRegression as LinearRegression_sklearnex
+        from .linear_model import LogisticRegression as LogisticRegression_sklearnex
         from .neighbors import KNeighborsClassifier as KNeighborsClassifier_sklearnex
         from .neighbors import KNeighborsRegressor as KNeighborsRegressor_sklearnex
         from .neighbors import LocalOutlierFactor as LocalOutlierFactor_sklearnex
         from .neighbors import NearestNeighbors as NearestNeighbors_sklearnex
-
-        # Preview classes for patching
-        from .preview.cluster import KMeans as KMeans_sklearnex
-        from .preview.covariance import (
-            EmpiricalCovariance as EmpiricalCovariance_sklearnex,
-        )
-        from .preview.decomposition import PCA as PCA_sklearnex
-        from .preview.linear_model import (
-            LogisticRegression as LogisticRegression_sklearnex,
-        )
         from .svm import SVC as SVC_sklearnex
         from .svm import SVR as SVR_sklearnex
         from .svm import NuSVC as NuSVC_sklearnex
         from .svm import NuSVR as NuSVR_sklearnex
 
-        # Patch for mapping
-        if _is_preview_enabled():
-            # PCA
-            mapping.pop("pca")
-            mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
-
-            # KMeans
-            mapping.pop("kmeans")
-            mapping["kmeans"] = [
-                [
-                    (
-                        cluster_module,
-                        "KMeans",
-                        KMeans_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-
-            # Covariance
-            mapping["empiricalcovariance"] = [
-                [
-                    (
-                        covariance_module,
-                        "EmpiricalCovariance",
-                        EmpiricalCovariance_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-
-            # LogisticRegression
-            mapping.pop("logisticregression")
-            mapping.pop("log_reg")
-            mapping["log_reg"] = [
-                [
-                    (
-                        linear_model_module,
-                        "LogisticRegression",
-                        LogisticRegression_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-            mapping["logisticregression"] = mapping["log_reg"]
-
         # DBSCAN
         mapping.pop("dbscan")
         mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
 
+        # PCA
+        mapping.pop("pca")
+        mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
+
         # SVM
         mapping.pop("svm")
         mapping.pop("svc")
@@ -161,6 +162,24 @@ def get_patch_map():
         ]
         mapping["linearregression"] = mapping["linear"]
 
+        # Logistic Regression
+
+        mapping.pop("logisticregression")
+        mapping.pop("log_reg")
+        mapping.pop("logistic")
+        mapping.pop("_logistic_regression_path")
+        mapping["log_reg"] = [
+            [
+                (
+                    linear_model_module,
+                    "LogisticRegression",
+                    LogisticRegression_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["logisticregression"] = mapping["log_reg"]
+
         # kNN
         mapping.pop("knn_classifier")
         mapping.pop("kneighborsclassifier")
@@ -275,6 +294,19 @@ def get_patch_map():
     return mapping
 
 
+# This is necessary to properly cache the patch_map when
+# using preview.
+def get_patch_map():
+    preview = _is_preview_enabled()
+    return get_patch_map_core(preview=preview)
+
+
+get_patch_map.cache_clear = get_patch_map_core.cache_clear
+
+
+get_patch_map.cache_info = get_patch_map_core.cache_info
+
+
 def get_patch_names():
     return list(get_patch_map().keys())