scikit-learn-intelex 2024.1.0__py311-none-win_amd64.whl → 2025.1.0__py311-none-win_amd64.whl

scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex/preview/decomposition/tests/test_preview_pca.py → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -27,16 +27,32 @@ from onedal.tests.utils._dataframes_support import (
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("macro_block", [None, 1024])
-def test_sklearnex_import(dataframe, queue, macro_block):
-    from sklearnex.preview.decomposition import PCA
+def test_sklearnex_import(dataframe, queue):
+    from sklearnex.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")
-    if daal_check_version((2024, "P", 0)) and macro_block is not None:
-        pca.get_hyperparameters("fit").cpu_macro_block = macro_block
+    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="covariance_eigh")
     pca.fit(X)
-    assert "sklearnex" in pca.__module__
-    assert hasattr(pca, "_onedal_estimator")
-    assert_allclose(_as_numpy(pca.singular_values_), [6.30061232, 0.54980396])
+    X_transformed = pca.transform(X)
+    X_fit_transformed = PCA(n_components=2, svd_solver="covariance_eigh").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__
+
+    tol = 1e-5 if _as_numpy(X_transformed).dtype == np.float32 else 1e-7
+    assert_allclose([6.30061232, 0.54980396], _as_numpy(pca.singular_values_))
+    assert_allclose(X_transformed_expected, _as_numpy(X_transformed), rtol=tol)
+    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed), rtol=tol)

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2025.1.0.data}/data/Lib/site-packages/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,11 +33,77 @@ 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
+            import sklearn.decomposition as decomposition_module
+
+            # Preview classes for patching
+            from .preview.covariance import (
+                EmpiricalCovariance as EmpiricalCovariance_sklearnex,
+            )
+            from .preview.decomposition import IncrementalPCA as IncrementalPCA_sklearnex
+            from .preview.linear_model import Ridge as Ridge_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.
+            # Covariance
+            mapping["empiricalcovariance"] = [
+                [
+                    (
+                        covariance_module,
+                        "EmpiricalCovariance",
+                        EmpiricalCovariance_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
+            # IncrementalPCA
+            mapping["incrementalpca"] = [
+                [
+                    (
+                        decomposition_module,
+                        "IncrementalPCA",
+                        IncrementalPCA_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
+            # Ridge
+            linear_model_module, _, _ = mapping["ridge"][0][0]
+            sklearn_obj = mapping["ridge"][0][1]
+            mapping.pop("ridge")
+            mapping["ridge"] = [
+                [(linear_model_module, "Ridge", Ridge_sklearnex), sklearn_obj]
+            ]
+
+        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
@@ -45,6 +112,9 @@ def get_patch_map():
         import sklearn.decomposition as decomposition_module
         import sklearn.ensemble as ensemble_module
         import sklearn.linear_model as linear_model_module
+        import sklearn.manifold as manifold_module
+        import sklearn.metrics as metrics_module
+        import sklearn.model_selection as model_selection_module
         import sklearn.neighbors as neighbors_module
         import sklearn.svm as svm_module
 
@@ -64,80 +134,49 @@ def get_patch_map():
             from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
 
         from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .cluster import KMeans as KMeans_sklearnex
+        from .covariance import (
+            IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_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 ElasticNet as ElasticNet_sklearnex
+        from .linear_model import (
+            IncrementalLinearRegression as IncrementalLinearRegression_sklearnex,
+        )
+        from .linear_model import IncrementalRidge as IncrementalRidge_sklearnex
+        from .linear_model import Lasso as Lasso_sklearnex
         from .linear_model import LinearRegression as LinearRegression_sklearnex
+        from .linear_model import LogisticRegression as LogisticRegression_sklearnex
+        from .linear_model import Ridge as Ridge_sklearnex
+        from .manifold import TSNE as TSNE_sklearnex
+        from .metrics import pairwise_distances as pairwise_distances_sklearnex
+        from .metrics import roc_auc_score as roc_auc_score_sklearnex
+        from .model_selection import train_test_split as train_test_split_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]]
 
+        # KMeans
+        mapping.pop("kmeans")
+        mapping["kmeans"] = [[(cluster_module, "KMeans", KMeans_sklearnex), None]]
+
+        # PCA
+        mapping.pop("pca")
+        mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
+
         # SVM
         mapping.pop("svm")
         mapping.pop("svc")
@@ -146,6 +185,32 @@ def get_patch_map():
         mapping["nusvr"] = [[(svm_module, "NuSVR", NuSVR_sklearnex), None]]
         mapping["nusvc"] = [[(svm_module, "NuSVC", NuSVC_sklearnex), None]]
 
+        # ElasticNet
+        mapping.pop("elasticnet")
+        mapping["elasticnet"] = [
+            [
+                (
+                    linear_model_module,
+                    "ElasticNet",
+                    ElasticNet_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        # Lasso
+        mapping.pop("lasso")
+        mapping["lasso"] = [
+            [
+                (
+                    linear_model_module,
+                    "Lasso",
+                    Lasso_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
         # Linear Regression
         mapping.pop("linear")
         mapping.pop("linearregression")
@@ -161,6 +226,72 @@ 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"]
+
+        # Ridge
+        mapping.pop("ridge")
+        mapping["ridge"] = [
+            [
+                (
+                    linear_model_module,
+                    "Ridge",
+                    Ridge_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        # manifold
+        mapping.pop("tsne")
+        mapping["tsne"] = [
+            [
+                (manifold_module, "TSNE", TSNE_sklearnex),
+                None,
+            ]
+        ]
+
+        # metrics
+        mapping.pop("distances")
+        mapping.pop("roc_auc_score")
+        mapping["distances"] = [
+            [
+                (metrics_module, "pairwise_distances", pairwise_distances_sklearnex),
+                None,
+            ]
+        ]
+        mapping["pairwise_distances"] = mapping["distances"]
+        mapping["roc_auc_score"] = [
+            [
+                (metrics_module, "roc_auc_score", roc_auc_score_sklearnex),
+                None,
+            ]
+        ]
+
+        # model_selection
+        mapping.pop("train_test_split")
+        mapping["train_test_split"] = [
+            [
+                (model_selection_module, "train_test_split", train_test_split_sklearnex),
+                None,
+            ]
+        ]
+
         # kNN
         mapping.pop("knn_classifier")
         mapping.pop("kneighborsclassifier")
@@ -254,6 +385,43 @@ def get_patch_map():
         ]
         mapping["localoutlierfactor"] = mapping["lof"]
 
+        # IncrementalEmpiricalCovariance
+        mapping["incrementalempiricalcovariance"] = [
+            [
+                (
+                    covariance_module,
+                    "IncrementalEmpiricalCovariance",
+                    IncrementalEmpiricalCovariance_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        # IncrementalLinearRegression
+        mapping["incrementallinearregression"] = [
+            [
+                (
+                    linear_model_module,
+                    "IncrementalLinearRegression",
+                    IncrementalLinearRegression_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        if daal_check_version((2024, "P", 600)):
+            # IncrementalRidge
+            mapping["incrementalridge"] = [
+                [
+                    (
+                        linear_model_module,
+                        "IncrementalRidge",
+                        IncrementalRidge_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
         # Configs
         mapping["set_config"] = [
             [(base_module, "set_config", set_config_sklearnex), None]
@@ -275,6 +443,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())
 
@@ -282,10 +463,10 @@ def get_patch_names():
 def patch_sklearn(name=None, verbose=True, global_patch=False, preview=False):
     if preview:
         os.environ["SKLEARNEX_PREVIEW"] = "enabled_via_patch_sklearn"
-    if not sklearn_check_version("0.22"):
+    if not sklearn_check_version("0.24"):
         raise NotImplementedError(
             "Intel(R) Extension for Scikit-learn* patches apply "
-            "for scikit-learn >= 0.22 only ..."
+            "for scikit-learn >= 0.24 only ..."
         )
 
     if global_patch: