scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/cluster/kmeans_init.py

@@ -0,0 +1,145 @@
+# ==============================================================================
+# 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
+from sklearn.utils import check_random_state
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
+from sklearnex._config import config_context, get_config
+
+from ..datatypes import from_table, to_table
+from ..utils.validation import _check_array
+
+if daal_check_version((2023, "P", 200)):
+
+    def force_host_if_csr(func):
+        """
+        Decorator to force computation on the host if the input data is in CSR format.
+
+        CSR (Compressed Sparse Row) format is not supported on GPU. This decorator ensures that
+        the computation is performed on the host (CPU) when the input data is in CSR format.
+        It is necessary that `self.is_csr` is to the correct value (True or False) before calling.
+        It temporarily modifies the configuration to target the CPU and removes the global SYCL queue
+        to ensure the computation is executed on the host. The original configuration is restored upon exit.
+
+        Parameters:
+        func (function): The function to be decorated.
+
+        Returns:
+        function: The wrapped function with the modified configuration if the input data is in CSR format.
+        """
+        config = get_config()
+        # `auto` rather than `cpu` is necessary in order to force host when a SYCL cpu target is unavailable
+        config["target_offload"] = "auto"
+
+        def wrapper(self, *args, **kwargs):
+            if self.is_csr:
+                with (
+                    config_context(**config),
+                    QM.manage_global_queue(None, None),
+                ):
+                    return func(self, *args, **kwargs)
+            else:
+                return func(self, *args, **kwargs)
+
+        return wrapper
+
+    class KMeansInit:
+        """
+        KMeansInit oneDAL implementation.
+        """
+
+        def __init__(
+            self,
+            cluster_count,
+            seed=777,
+            local_trials_count=None,
+            algorithm="plus_plus_dense",
+            is_csr=False,
+        ):
+            self.cluster_count = cluster_count
+            self.seed = seed
+            self.local_trials_count = local_trials_count
+            self.algorithm = algorithm
+            self.is_csr = is_csr
+
+            if local_trials_count is None:
+                self.local_trials_count = 2 + int(np.log(cluster_count))
+            else:
+                self.local_trials_count = local_trials_count
+
+        @bind_default_backend("kmeans_init.init", lookup_name="compute")
+        def backend_compute(self, params, X_table): ...
+
+        def _get_onedal_params(self, dtype=np.float32):
+            return {
+                "fptype": dtype,
+                "local_trials_count": self.local_trials_count,
+                "method": self.algorithm,
+                "seed": self.seed,
+                "cluster_count": self.cluster_count,
+            }
+
+        def _get_params_and_input(self, X, queue):
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                accept_sparse="csr",
+                force_all_finite=False,
+            )
+            X = to_table(X, queue=queue)
+            params = self._get_onedal_params(X.dtype)
+            return (params, X, X.dtype)
+
+        def _compute_raw(self, X_table, dtype=np.float32):
+            params = self._get_onedal_params(dtype)
+            result = self.backend_compute(params, X_table)
+            return result.centroids
+
+        def _compute(self, X):
+            _, X_table, dtype = self._get_params_and_input(X, queue=QM.get_global_queue())
+            centroids = self._compute_raw(X_table, dtype)
+            return from_table(centroids)
+
+        @force_host_if_csr
+        def compute_raw(self, X_table, dtype=np.float32, queue=None):
+            # no @supports_queue decorator here, because we only accept X_table that has no queue information
+            return self._compute_raw(X_table, dtype)
+
+        @force_host_if_csr
+        @supports_queue
+        def compute(self, X, queue=None):
+            return self._compute(X)
+
+    def kmeans_plusplus(
+        X,
+        n_clusters,
+        *,
+        x_squared_norms=None,
+        random_state=None,
+        n_local_trials=None,
+        queue=None,
+    ):
+        random_seed = check_random_state(random_state).tomaxint()
+        return (
+            KMeansInit(
+                n_clusters, seed=random_seed, local_trials_count=n_local_trials
+            ).compute(X, queue=queue),
+            np.full(n_clusters, -1),
+        )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/cluster/tests/test_dbscan.py

@@ -0,0 +1,125 @@
+# ===============================================================================
+# 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 sklearn.cluster import DBSCAN as DBSCAN_SKLEARN
+from sklearn.cluster.tests.common import generate_clustered_data
+
+from onedal.cluster import DBSCAN as ONEDAL_DBSCAN
+from onedal.tests.utils._device_selection import get_queues
+
+
+def generate_data(
+    low: int, high: int, samples_number: int, sample_dimension: tuple
+) -> tuple:
+    generator = np.random.RandomState()
+    table_size = (samples_number, sample_dimension)
+    return generator.uniform(low=low, high=high, size=table_size), generator.uniform(
+        size=samples_number
+    )
+
+
+def check_labels_equals(left_labels: np.ndarray, right_labels: np.ndarray) -> bool:
+    if left_labels.shape != right_labels.shape:
+        raise Exception("Shapes not equal")
+    if len(left_labels.shape) != 1:
+        raise Exception("Shapes size not equals 1")
+    if len(set(left_labels)) != len(set(right_labels)):
+        raise Exception("Cluster counts not equal")
+    dict_checker = {}
+    for index_sample in range(left_labels.shape[0]):
+        if left_labels[index_sample] not in dict_checker:
+            dict_checker[left_labels[index_sample]] = right_labels[index_sample]
+        elif dict_checker[left_labels[index_sample]] != right_labels[index_sample]:
+            raise Exception("Wrong clustering")
+    return True
+
+
+def _test_dbscan_big_data_numpy_gen(
+    queue,
+    eps: float,
+    min_samples: int,
+    metric: str,
+    use_weights: bool,
+    low=-100.0,
+    high=100.0,
+    samples_number=1000,
+    sample_dimension=4,
+):
+    data, weights = generate_data(
+        low=low,
+        high=high,
+        samples_number=samples_number,
+        sample_dimension=sample_dimension,
+    )
+    if use_weights is False:
+        weights = None
+    initialized_daal_dbscan = ONEDAL_DBSCAN(
+        eps=eps, min_samples=min_samples, metric=metric
+    ).fit(X=data, sample_weight=weights, queue=queue)
+    initialized_sklearn_dbscan = DBSCAN_SKLEARN(
+        metric=metric, eps=eps, min_samples=min_samples
+    ).fit(X=data, sample_weight=weights)
+    check_labels_equals(
+        initialized_daal_dbscan.labels_, initialized_sklearn_dbscan.labels_
+    )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_dbscan_big_data_numpy_gen(queue, metric, use_weights: bool):
+    eps = 35.0
+    min_samples = 6
+    _test_dbscan_big_data_numpy_gen(
+        queue, eps=eps, min_samples=min_samples, metric=metric, use_weights=use_weights
+    )
+
+
+def _test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    eps_begin = 0.05
+    eps_end = 0.5
+    eps_step = 0.05
+    min_samples_begin = 5
+    min_samples_end = 15
+    min_samples_step = 1
+    for eps in np.arange(eps_begin, eps_end, eps_step):
+        for min_samples in range(min_samples_begin, min_samples_end, min_samples_step):
+            _test_dbscan_big_data_numpy_gen(
+                queue,
+                eps=eps,
+                min_samples=min_samples,
+                metric=metric,
+                use_weights=use_weights,
+            )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    _test_across_grid_parameter_numpy_gen(queue, metric=metric, use_weights=use_weights)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/cluster/tests/test_kmeans.py

@@ -0,0 +1,88 @@
+# ==============================================================================
+# 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_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.cluster import kmeans_plusplus as init_external
+    from sklearn.neighbors import NearestNeighbors
+
+    from onedal.cluster import KMeans
+    from onedal.cluster import kmeans_plusplus as init_internal
+    from onedal.tests.utils._device_selection import get_queues
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 4, 17, 24])
+    @pytest.mark.parametrize("n_cluster", [9, 11, 32])
+    @pytest.mark.parametrize("pipeline", ["implicit", "external", "internal"])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster, pipeline):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        if pipeline == "external":
+            init_data, _ = init_external(X, n_cluster)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        elif pipeline == "internal":
+            init_data, _ = init_internal(X, n_cluster, queue=queue)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        else:
+            m = KMeans(n_cluster, init="k-means++", max_iter=5)
+
+        m.fit(X, queue=queue)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 3 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        # TODO: investigate accuracy with kmeans++ init and remove - 1
+        assert desired_accuracy - 1 <= exp_accuracy

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/cluster/tests/test_kmeans_init.py

@@ -0,0 +1,93 @@
+# ===============================================================================
+# 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_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.datasets import load_breast_cancer
+    from sklearn.metrics import davies_bouldin_score
+
+    from onedal.cluster import KMeans, kmeans_plusplus
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_cluster", [2, 5, 11, 128])
+    def test_breast_cancer(queue, dtype, n_cluster):
+        X, _ = load_breast_cancer(return_X_y=True)
+        X = np.asarray(X).astype(dtype=dtype)
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=777, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=1)
+        res = davies_bouldin_score(X, m.fit(X).predict(X))
+        thr = 0.45 if n_cluster < 20 else 0.55
+        assert res > thr
+
+    from sklearn.neighbors import NearestNeighbors
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 12, 17])
+    @pytest.mark.parametrize("n_cluster", [2, 15, 61])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=seed, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=3, algorithm="lloyd").fit(X)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 2 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        if d.dtype == np.float64:
+            desired_accuracy = desired_accuracy - 1
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        assert desired_accuracy <= exp_accuracy