scikit-learn-intelex 2023.2.1__py310-none-win_amd64.whl → 2024.0.1__py310-none-win_amd64.whl

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+# ===============================================================================
+# 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 numbers
+from abc import ABC
+
+import numpy as np
+from scipy import sparse as sp
+from sklearn.cluster import DBSCAN as sklearn_DBSCAN
+from sklearn.utils.validation import _check_sample_weight
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.cluster import DBSCAN as onedal_DBSCAN
+
+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
+
+
+class BaseDBSCAN(ABC):
+    def _onedal_dbscan(self, **onedal_params):
+        return onedal_DBSCAN(**onedal_params)
+
+    def _save_attributes(self):
+        assert hasattr(self, "_onedal_estimator")
+
+        self.labels_ = self._onedal_estimator.labels_
+        self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
+        self.components_ = self._onedal_estimator.components_
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+
+class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
+    __doc__ = sklearn_DBSCAN.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {**sklearn_DBSCAN._parameter_constraints}
+
+    def __init__(
+        self,
+        eps=0.5,
+        *,
+        min_samples=5,
+        metric="euclidean",
+        metric_params=None,
+        algorithm="auto",
+        leaf_size=30,
+        p=None,
+        n_jobs=None,
+    ):
+        super(DBSCAN, self).__init__(
+            eps=eps,
+            min_samples=min_samples,
+            metric=metric,
+            metric_params=metric_params,
+            algorithm=algorithm,
+            leaf_size=leaf_size,
+            p=p,
+            n_jobs=n_jobs,
+        )
+        self.eps = eps
+        self.min_samples = min_samples
+        self.metric = metric
+        self.metric_params = metric_params
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.p = p
+        self.n_jobs = n_jobs
+
+    def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        onedal_params = {
+            "eps": self.eps,
+            "min_samples": self.min_samples,
+            "metric": self.metric,
+            "metric_params": self.metric_params,
+            "algorithm": self.algorithm,
+            "leaf_size": self.leaf_size,
+            "p": self.p,
+            "n_jobs": self.n_jobs,
+        }
+        self._onedal_estimator = self._onedal_dbscan(**onedal_params)
+
+        self._onedal_estimator.fit(X, y=y, sample_weight=sample_weight, queue=queue)
+        self._save_attributes()
+
+    def _onedal_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        patching_status = PatchingConditionsChain(
+            f"sklearn.cluster.{class_name}.{method_name}"
+        )
+        if method_name == "fit":
+            X, y, sample_weight = data
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in ["auto", "brute"],
+                        f"'{self.algorithm}' algorithm is not supported. "
+                        "Only 'auto' and 'brute' algorithms are supported",
+                    ),
+                    (
+                        self.metric == "euclidean"
+                        or (self.metric == "minkowski" and self.p == 2),
+                        f"'{self.metric}' (p={self.p}) metric is not supported. "
+                        "Only 'euclidean' or 'minkowski' with p=2 metrics are supported.",
+                    ),
+                    (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
+                ]
+            )
+            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 fit(self, X, y=None, sample_weight=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        elif sklearn_check_version("1.1"):
+            check_scalar(
+                self.eps,
+                "eps",
+                target_type=numbers.Real,
+                min_val=0.0,
+                include_boundaries="neither",
+            )
+            check_scalar(
+                self.min_samples,
+                "min_samples",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            check_scalar(
+                self.leaf_size,
+                "leaf_size",
+                target_type=numbers.Integral,
+                min_val=1,
+                include_boundaries="left",
+            )
+            if self.p is not None:
+                check_scalar(
+                    self.p,
+                    "p",
+                    target_type=numbers.Real,
+                    min_val=0.0,
+                    include_boundaries="left",
+                )
+            if self.n_jobs is not None:
+                check_scalar(self.n_jobs, "n_jobs", target_type=numbers.Integral)
+        else:
+            if self.eps <= 0.0:
+                raise ValueError(f"eps == {self.eps}, must be > 0.0.")
+
+        if sample_weight is not None:
+            sample_weight = _check_sample_weight(sample_weight, X)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_DBSCAN.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
+
+        return self

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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 daal4py.sklearn.cluster import KMeans

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/cluster/tests/test_dbscan.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,18 +13,24 @@
 # 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
 
 
-def test_sklearnex_import():
+# TODO:
+# adding this parameterized testing
+# somehow breaks other test with preview module patch:
+# sklearnex/tests/test_monkeypatch.py::test_preview_namespace.
+# @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_dbscan():
     from sklearnex.cluster import DBSCAN
-    X = np.array([[1, 2], [2, 2], [2, 3],
-                  [8, 7], [8, 8], [25, 80]])
+
+    X = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
     dbscan = DBSCAN(eps=3, min_samples=2).fit(X)
-    assert 'daal4py' in dbscan.__module__
+    assert "sklearnex" in dbscan.__module__
 
     result = dbscan.labels_
     expected = np.array([0, 0, 0, 1, 1, -1], dtype=np.int32)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,7 @@
 # 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 numpy.testing import assert_allclose
@@ -21,10 +21,10 @@ from numpy.testing import assert_allclose
 
 def test_sklearnex_import():
     from sklearnex.cluster import KMeans
-    X = np.array([[1, 2], [1, 4], [1, 0],
-                  [10, 2], [10, 4], [10, 0]])
+
+    X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
     kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
-    assert 'daal4py' in kmeans.__module__
+    assert "daal4py" in kmeans.__module__
 
     result = kmeans.predict([[0, 0], [12, 3]])
     expected = np.array([1, 0], dtype=np.int32)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/decomposition/__init__.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +13,8 @@
 # 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']
+__all__ = ["PCA"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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 daal4py.sklearn.decomposition import PCA

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,7 @@
 # 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 numpy.testing import assert_allclose
@@ -21,7 +21,8 @@ from numpy.testing import assert_allclose
 
 def test_sklearnex_import():
     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__
+    pca = PCA(n_components=2, svd_solver="full").fit(X)
+    assert "daal4py" in pca.__module__
     assert_allclose(pca.singular_values_, [6.30061232, 0.54980396])

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# ===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,7 @@
 # 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 os
 import sys
@@ -48,89 +48,46 @@ def get_patch_map():
         import sklearn.neighbors as neighbors_module
         import sklearn.svm as svm_module
 
+        if sklearn_check_version("1.2.1"):
+            import sklearn.utils.parallel as parallel_module
+        else:
+            import sklearn.utils.fixes as parallel_module
+
         # Classes and functions for patching
         from ._config import config_context as config_context_sklearnex
         from ._config import get_config as get_config_sklearnex
         from ._config import set_config as set_config_sklearnex
+
+        if sklearn_check_version("1.2.1"):
+            from .utils.parallel import _FuncWrapper as _FuncWrapper_sklearnex
+        else:
+            from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
+
+        from .cluster import DBSCAN as DBSCAN_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 .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
-        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
 
         # Preview classes for patching
         from .preview.cluster import KMeans as KMeans_sklearnex
         from .preview.decomposition import PCA as PCA_sklearnex
-        from .preview.linear_model import LinearRegression as LinearRegression_sklearnex
-        from .preview.ensemble import (
-            ExtraTreesClassifier as ExtraTreesClassifier_sklearnex,
-            ExtraTreesRegressor as ExtraTreesRegressor_sklearnex,
-            RandomForestClassifier as RandomForestClassifier_sklearnex,
-            RandomForestRegressor as RandomForestRegressor_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():
-            # Ensemble
-            mapping["extra_trees_classifier"] = [[(ensemble_module,
-                                                   "ExtraTreesClassifier",
-                                                   ExtraTreesClassifier_sklearnex),
-                                                  None]]
-            mapping["extra_trees_regressor"] = [[(ensemble_module,
-                                                  "ExtraTreesRegressor",
-                                                  ExtraTreesRegressor_sklearnex),
-                                                 None]]
-            mapping["extratreesclassifier"] = mapping["extra_trees_classifier"]
-            mapping["extratreesregressor"] = mapping["extra_trees_regressor"]
-            mapping.pop("random_forest_classifier")
-            mapping.pop("random_forest_regressor")
-            mapping.pop("randomforestclassifier")
-            mapping.pop("randomforestregressor")
-            mapping["random_forest_classifier"] = [
-                [
-                    (
-                        ensemble_module,
-                        "RandomForestClassifier",
-                        RandomForestClassifier_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-            mapping["random_forest_regressor"] = [
-                [
-                    (
-                        ensemble_module,
-                        "RandomForestRegressor",
-                        RandomForestRegressor_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-            mapping["randomforestclassifier"] = mapping["random_forest_classifier"]
-            mapping["randomforestregressor"] = mapping["random_forest_regressor"]
-
             # PCA
             mapping.pop("pca")
             mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
 
-            # Linear Regression
-            mapping.pop("linear")
-            mapping.pop("linearregression")
-            mapping["linear"] = [
-                [
-                    (
-                        linear_model_module,
-                        "LinearRegression",
-                        LinearRegression_sklearnex,
-                    ),
-                    None,
-                ]
-            ]
-            mapping["linearregression"] = mapping["linear"]
-
             # KMeans
             mapping.pop("kmeans")
             mapping["kmeans"] = [
@@ -144,6 +101,10 @@ def get_patch_map():
                 ]
             ]
 
+        # DBSCAN
+        mapping.pop("dbscan")
+        mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
+
         # SVM
         mapping.pop("svm")
         mapping.pop("svc")
@@ -152,6 +113,21 @@ def get_patch_map():
         mapping["nusvr"] = [[(svm_module, "NuSVR", NuSVR_sklearnex), None]]
         mapping["nusvc"] = [[(svm_module, "NuSVC", NuSVC_sklearnex), None]]
 
+        # Linear Regression
+        mapping.pop("linear")
+        mapping.pop("linearregression")
+        mapping["linear"] = [
+            [
+                (
+                    linear_model_module,
+                    "LinearRegression",
+                    LinearRegression_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["linearregression"] = mapping["linear"]
+
         # kNN
         mapping.pop("knn_classifier")
         mapping.pop("kneighborsclassifier")
@@ -186,6 +162,56 @@ def get_patch_map():
         mapping["kneighborsregressor"] = mapping["knn_regressor"]
         mapping["nearestneighbors"] = mapping["nearest_neighbors"]
 
+        # Ensemble
+        mapping["extra_trees_classifier"] = [
+            [
+                (
+                    ensemble_module,
+                    "ExtraTreesClassifier",
+                    ExtraTreesClassifier_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["extra_trees_regressor"] = [
+            [
+                (
+                    ensemble_module,
+                    "ExtraTreesRegressor",
+                    ExtraTreesRegressor_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["extratreesclassifier"] = mapping["extra_trees_classifier"]
+        mapping["extratreesregressor"] = mapping["extra_trees_regressor"]
+        mapping.pop("random_forest_classifier")
+        mapping.pop("random_forest_regressor")
+        mapping.pop("randomforestclassifier")
+        mapping.pop("randomforestregressor")
+        mapping["random_forest_classifier"] = [
+            [
+                (
+                    ensemble_module,
+                    "RandomForestClassifier",
+                    RandomForestClassifier_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["random_forest_regressor"] = [
+            [
+                (
+                    ensemble_module,
+                    "RandomForestRegressor",
+                    RandomForestRegressor_sklearnex,
+                ),
+                None,
+            ]
+        ]
+        mapping["randomforestclassifier"] = mapping["random_forest_classifier"]
+        mapping["randomforestregressor"] = mapping["random_forest_regressor"]
+
         # LocalOutlierFactor
         mapping["lof"] = [
             [
@@ -205,6 +231,14 @@ def get_patch_map():
         mapping["config_context"] = [
             [(base_module, "config_context", config_context_sklearnex), None]
         ]
+
+        # Necessary for proper work with multiple threads
+        mapping["parallel.get_config"] = [
+            [(parallel_module, "get_config", get_config_sklearnex), None]
+        ]
+        mapping["_funcwrapper"] = [
+            [(parallel_module, "_FuncWrapper", _FuncWrapper_sklearnex), None]
+        ]
     return mapping
 
 
@@ -239,9 +273,7 @@ def patch_sklearn(name=None, verbose=True, global_patch=False, preview=False):
                 algorithm, verbose=False, deprecation=False, get_map=get_patch_map
             )
     else:
-        patch_sklearn_orig(
-            name, verbose=False, deprecation=False, get_map=get_patch_map
-        )
+        patch_sklearn_orig(name, verbose=False, deprecation=False, get_map=get_patch_map)
 
     if verbose and sys.stderr is not None:
         sys.stderr.write(
@@ -288,9 +320,7 @@ def sklearn_is_patched(name=None, return_map=False):
                 )
             return is_patched
     else:
-        return sklearn_is_patched_orig(
-            name, get_map=get_patch_map, return_map=return_map
-        )
+        return sklearn_is_patched_orig(name, get_map=get_patch_map, return_map=return_map)
 
 
 def is_patched_instance(instance: object) -> bool:

{scikit_learn_intelex-2023.2.1.data/data/Lib/site-packages/sklearnex/preview → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex}/ensemble/__init__.py

@@ -15,8 +15,16 @@
 # limitations under the License.
 # ===============================================================================
 
-from .forest import RandomForestClassifier, RandomForestRegressor
-from .extra_trees import ExtraTreesClassifier, ExtraTreesRegressor
+from ._forest import (
+    ExtraTreesClassifier,
+    ExtraTreesRegressor,
+    RandomForestClassifier,
+    RandomForestRegressor,
+)
 
-__all__ = ['ExtraTreesClassifier', 'ExtraTreesRegressor',
-           'RandomForestClassifier', 'RandomForestRegressor']
+__all__ = [
+    "ExtraTreesClassifier",
+    "ExtraTreesRegressor",
+    "RandomForestClassifier",
+    "RandomForestRegressor",
+]