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

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2025.1.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -17,20 +17,25 @@
 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.cluster import DBSCAN as _sklearn_DBSCAN
 from sklearn.utils.validation import _check_sample_weight
 
-from daal4py.sklearn._utils import control_n_jobs, run_with_n_jobs, sklearn_check_version
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+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 .._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("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = _sklearn_DBSCAN._validate_data
+
 
 class BaseDBSCAN(ABC):
     def _onedal_dbscan(self, **onedal_params):
@@ -45,12 +50,12 @@ class BaseDBSCAN(ABC):
         self.n_features_in_ = self._onedal_estimator.n_features_in_
 
 
-@control_n_jobs
-class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
-    __doc__ = sklearn_DBSCAN.__doc__
+@control_n_jobs(decorated_methods=["fit"])
+class DBSCAN(_sklearn_DBSCAN, BaseDBSCAN):
+    __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_DBSCAN._parameter_constraints}
+        _parameter_constraints: dict = {**_sklearn_DBSCAN._parameter_constraints}
 
     def __init__(
         self,
@@ -83,8 +88,10 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
         self.p = p
         self.n_jobs = n_jobs
 
-    @run_with_n_jobs
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
+        if sklearn_check_version("1.0"):
+            X = validate_data(self, X, force_all_finite=False)
+
         onedal_params = {
             "eps": self.eps,
             "min_samples": self.min_samples,
@@ -178,7 +185,7 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_DBSCAN.fit,
+                "sklearn": _sklearn_DBSCAN.fit,
             },
             X,
             y,
@@ -186,3 +193,5 @@ class DBSCAN(sklearn_DBSCAN, BaseDBSCAN):
         )
 
         return self
+
+    fit.__doc__ = _sklearn_DBSCAN.fit.__doc__

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -0,0 +1,395 @@
+# ==============================================================================
+# 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
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+
+    import numbers
+    import warnings
+
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.cluster import KMeans as _sklearn_KMeans
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    from sklearn.utils.validation import (
+        _check_sample_weight,
+        _num_samples,
+        check_is_fitted,
+    )
+
+    from daal4py.sklearn._n_jobs_support import control_n_jobs
+    from daal4py.sklearn._utils import sklearn_check_version
+    from onedal.cluster import KMeans as onedal_KMeans
+    from onedal.utils import _is_csr
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain
+
+    if sklearn_check_version("1.6"):
+        from sklearn.utils.validation import validate_data
+    else:
+        validate_data = _sklearn_KMeans._validate_data
+
+    @control_n_jobs(decorated_methods=["fit", "fit_transform", "predict", "score"])
+    class KMeans(_sklearn_KMeans):
+        __doc__ = _sklearn_KMeans.__doc__
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**_sklearn_KMeans._parameter_constraints}
+
+        def __init__(
+            self,
+            n_clusters=8,
+            *,
+            init="k-means++",
+            n_init=(
+                "auto"
+                if sklearn_check_version("1.4")
+                else "warn" if sklearn_check_version("1.2") else 10
+            ),
+            max_iter=300,
+            tol=1e-4,
+            verbose=0,
+            random_state=None,
+            copy_x=True,
+            algorithm="lloyd" if sklearn_check_version("1.1") else "auto",
+        ):
+            super().__init__(
+                n_clusters=n_clusters,
+                init=init,
+                max_iter=max_iter,
+                tol=tol,
+                n_init=n_init,
+                verbose=verbose,
+                random_state=random_state,
+                copy_x=copy_x,
+                algorithm=algorithm,
+            )
+
+        def _initialize_onedal_estimator(self):
+            onedal_params = {
+                "n_clusters": self.n_clusters,
+                "init": self.init,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "n_init": self.n_init,
+                "verbose": self.verbose,
+                "random_state": self.random_state,
+            }
+
+            self._onedal_estimator = onedal_KMeans(**onedal_params)
+
+        def _onedal_fit_supported(self, method_name, X, y=None, sample_weight=None):
+            assert method_name == "fit"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
+
+            sample_count = _num_samples(X)
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+            correct_count = self.n_clusters < sample_count
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            _acceptable_sample_weights = self._validate_sample_weight(sample_weight, X)
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd",
+                    ),
+                    (correct_count, "n_clusters is smaller than number of samples"),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Accepted options are None, constant, or equal weights.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        def fit(self, X, y=None, sample_weight=None):
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": _sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+            return self
+
+        def _onedal_fit(self, X, _, sample_weight, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                dtype=[np.float64, np.float32],
+                order="C",
+                copy=self.copy_x,
+                accept_large_sparse=False,
+            )
+
+            if sklearn_check_version("1.2"):
+                self._check_params_vs_input(X)
+            else:
+                self._check_params(X)
+
+            self._n_features_out = self.n_clusters
+
+            self._initialize_onedal_estimator()
+            self._n_threads = _openmp_effective_n_threads()
+            self._onedal_estimator.fit(X, queue=queue)
+
+            self._save_attributes()
+
+        def _validate_sample_weight(self, sample_weight, X):
+            if sample_weight is None:
+                return True
+            elif isinstance(sample_weight, numbers.Number) or isinstance(
+                sample_weight, str
+            ):
+                return True
+            else:
+                sample_weight = _check_sample_weight(
+                    sample_weight,
+                    X,
+                    dtype=X.dtype if hasattr(X, "dtype") else None,
+                )
+                if np.all(sample_weight == sample_weight[0]):
+                    return True
+                else:
+                    return False
+
+        def _onedal_predict_supported(self, method_name, *data):
+            class_name = self.__class__.__name__
+
+            patching_status = PatchingConditionsChain(
+                f"sklearn.cluster.{class_name}.{method_name}"
+            )
+
+            X = data[0]
+            sample_weight = data[-1] if len(data) > 1 else None
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            # algorithm "auto" has been deprecated since 1.1,
+            # algorithm "full" has been replaced by "lloyd"
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+
+            _acceptable_sample_weights = True
+            if not sklearn_check_version("1.5"):
+                _acceptable_sample_weights = self._validate_sample_weight(
+                    sample_weight, X
+                )
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Acceptable options are None, constant, or equal weights.",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        if sklearn_check_version("1.5"):
+
+            @wrap_output_data
+            def predict(self, X):
+                self._validate_params()
+                check_is_fitted(self)
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": _sklearn_KMeans.predict,
+                    },
+                    X,
+                )
+
+        else:
+
+            @wrap_output_data
+            def predict(
+                self,
+                X,
+                sample_weight="deprecated" if sklearn_check_version("1.3") else None,
+            ):
+                if sklearn_check_version("1.2"):
+                    self._validate_params()
+
+                if sklearn_check_version("1.3"):
+                    if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                        sample_weight = None
+
+                    if sample_weight is not None:
+                        warnings.warn(
+                            "'sample_weight' was deprecated in version 1.3 and "
+                            "will be removed in 1.5.",
+                            FutureWarning,
+                        )
+                check_is_fitted(self)
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": _sklearn_KMeans.predict,
+                    },
+                    X,
+                    sample_weight,
+                )
+
+        def _onedal_predict(self, X, sample_weight=None, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        def _onedal_supported(self, method_name, *data):
+            if method_name == "fit":
+                return self._onedal_fit_supported(method_name, *data)
+            if method_name in ["predict", "score"]:
+                return self._onedal_predict_supported(method_name, *data)
+            raise RuntimeError(
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
+
+        _onedal_gpu_supported = _onedal_supported
+        _onedal_cpu_supported = _onedal_supported
+
+        @wrap_output_data
+        def fit_transform(self, X, y=None, sample_weight=None):
+            return self.fit(X, sample_weight=sample_weight)._transform(X)
+
+        @wrap_output_data
+        def transform(self, X):
+            check_is_fitted(self)
+
+            X = self._check_test_data(X)
+            return self._transform(X)
+
+        @wrap_output_data
+        def score(self, X, y=None, sample_weight=None):
+            check_is_fitted(self)
+            return dispatch(
+                self,
+                "score",
+                {
+                    "onedal": self.__class__._onedal_score,
+                    "sklearn": _sklearn_KMeans.score,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+        def _onedal_score(self, X, y=None, sample_weight=None, queue=None):
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.score(X, queue=queue)
+
+        def _save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.cluster_centers_ = self._onedal_estimator.cluster_centers_
+            self.labels_ = self._onedal_estimator.labels_
+            self.inertia_ = self._onedal_estimator.inertia_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+            self._n_init = self._onedal_estimator._n_init
+
+        fit.__doc__ = _sklearn_KMeans.fit.__doc__
+        predict.__doc__ = _sklearn_KMeans.predict.__doc__
+        transform.__doc__ = _sklearn_KMeans.transform.__doc__
+        fit_transform.__doc__ = _sklearn_KMeans.fit_transform.__doc__
+        score.__doc__ = _sklearn_KMeans.score.__doc__
+
+else:
+    from daal4py.sklearn.cluster import KMeans
+
+    logging.warning(
+        "Sklearnex KMeans requires oneDAL version >= 2023.2, falling back to daal4py."
+    )

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

@@ -18,16 +18,18 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
 
-# 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():
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_dbscan(dataframe, queue):
     from sklearnex.cluster import DBSCAN
 
     X = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     dbscan = DBSCAN(eps=3, min_samples=2).fit(X)
     assert "sklearnex" in dbscan.__module__
 

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -0,0 +1,159 @@
+# ===============================================================================
+# 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
+import pytest
+from numpy.testing import assert_allclose
+from scipy.sparse import csr_matrix
+from sklearn.datasets import make_blobs
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+    get_queues,
+)
+from sklearnex import config_context
+from sklearnex.tests.utils import _IS_INTEL
+
+
+def generate_dense_dataset(n_samples, n_features, density, n_clusters):
+    np.random.seed(2024 + n_samples + n_features + n_clusters)
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        n_features=n_features,
+        centers=n_clusters,
+        cluster_std=1.0,
+        random_state=42,
+    )
+    mask = np.random.binomial(1, density, (n_samples, n_features))
+    X = X * mask
+    return X
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_dense_data(dataframe, queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_dense_df = _convert_to_dataframe(X_dense, sycl_queue=queue, target_df=dataframe)
+
+    kmeans_dense = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_dense_df)
+
+    if daal_check_version((2023, "P", 200)):
+        assert "sklearnex" in kmeans_dense.__module__
+    else:
+        assert "daal4py" in kmeans_dense.__module__
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_sparse_data(queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_sparse = csr_matrix(X_dense)
+
+    kmeans_sparse = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_sparse)
+
+    assert "sklearnex" in kmeans_sparse.__module__
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+def test_results_on_dense_gold_data(dataframe, queue, algorithm):
+    from sklearnex.cluster import KMeans
+
+    X_train = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
+    X_test = np.array([[0, 0], [12, 3]])
+    X_train_df = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    X_test_df = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+
+    kmeans = KMeans(n_clusters=2, random_state=0, algorithm=algorithm).fit(X_train_df)
+
+    if queue and queue.sycl_device.is_gpu:
+        # KMeans Init Dense GPU implementation is different from CPU
+        expected_cluster_labels = np.array([0, 1], dtype=np.int32)
+        expected_cluster_centers = np.array([[1.0, 2.0], [10.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+    else:
+        expected_cluster_labels = np.array([1, 0], dtype=np.int32)
+        expected_cluster_centers = np.array([[10.0, 2.0], [1.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+
+    assert_allclose(expected_cluster_labels, _as_numpy(kmeans.predict(X_test_df)))
+    assert_allclose(expected_cluster_centers, _as_numpy(kmeans.cluster_centers_))
+    assert expected_inertia == kmeans.inertia_
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("init", ["k-means++", "random", "arraylike"])
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
+@pytest.mark.parametrize(
+    "dims", [(1000, 10, 0.95, 3), (50000, 100, 0.75, 10), (10000, 10, 0.8, 5)]
+)
+def test_dense_vs_sparse(queue, init, algorithm, dims):
+    from sklearnex.cluster import KMeans
+
+    if init == "random" or (not _IS_INTEL and init == "k-means++"):
+        if daal_check_version((2025, "P", 200)):
+            pytest.fail("Re-verify failure of k-means++ in 2025.2 oneDAL")
+        pytest.skip(f"{init} initialization for sparse K-means is non-conformant.")
+
+    # For higher level of sparsity (smaller density) the test may fail
+    n_samples, n_features, density, n_clusters = dims
+    X_dense = generate_dense_dataset(n_samples, n_features, density, n_clusters)
+    X_sparse = csr_matrix(X_dense)
+
+    if init == "arraylike":
+        np.random.seed(2024 + n_samples + n_features + n_clusters)
+        init = X_dense[np.random.choice(n_samples, size=n_clusters, replace=False)]
+
+    kmeans_dense = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_dense)
+    kmeans_sparse = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_sparse)
+
+    assert_allclose(
+        kmeans_dense.cluster_centers_,
+        kmeans_sparse.cluster_centers_,
+    )