scikit-learn-intelex 2025.1.0__py310-none-manylinux_2_28_x86_64.whl

onedal/basic_statistics/tests/test_basic_statistics.py

@@ -0,0 +1,298 @@
+# ==============================================================================
+# 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_allclose
+from scipy import sparse as sp
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.basic_statistics import BasicStatistics
+from onedal.tests.utils._device_selection import get_queues
+
+
+def expected_sum(X):
+    return np.sum(X, axis=0)
+
+
+def expected_max(X):
+    return np.max(X, axis=0)
+
+
+def expected_min(X):
+    return np.min(X, axis=0)
+
+
+def expected_mean(X):
+    return np.mean(X, axis=0)
+
+
+def expected_standard_deviation(X):
+    return np.std(X, axis=0)
+
+
+def expected_variance(X):
+    return np.var(X, axis=0)
+
+
+def expected_variation(X):
+    return expected_standard_deviation(X) / expected_mean(X)
+
+
+def expected_sum_squares(X):
+    return np.sum(np.square(X), axis=0)
+
+
+def expected_sum_squares_centered(X):
+    return np.sum(np.square(X - expected_mean(X)), axis=0)
+
+
+def expected_standard_deviation(X):
+    return np.sqrt(expected_variance(X))
+
+
+def expected_second_order_raw_moment(X):
+    return np.mean(np.square(X), axis=0)
+
+
+options_and_tests = [
+    ("sum", expected_sum, (5e-4, 1e-7)),
+    ("min", expected_min, (1e-7, 1e-7)),
+    ("max", expected_max, (1e-7, 1e-7)),
+    ("mean", expected_mean, (5e-7, 1e-7)),
+    ("variance", expected_variance, (2e-3, 2e-3)),
+    ("variation", expected_variation, (5e-2, 5e-2)),
+    ("sum_squares", expected_sum_squares, (2e-4, 1e-7)),
+    ("sum_squares_centered", expected_sum_squares_centered, (2e-4, 1e-7)),
+    ("standard_deviation", expected_standard_deviation, (2e-3, 2e-3)),
+    ("second_order_raw_moment", expected_second_order_raw_moment, (1e-6, 1e-7)),
+]
+
+options_and_tests_csr = [
+    ("sum", "sum", (5e-6, 1e-9)),
+    ("min", "min", (0, 0)),
+    ("max", "max", (0, 0)),
+    ("mean", "mean", (5e-6, 1e-9)),
+]
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_single_option_on_random_data(
+    queue, option, row_count, column_count, weighted, dtype
+):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+    seed = 77
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+    else:
+        weights = None
+
+    basicstat = BasicStatistics(result_options=result_option)
+
+    result = basicstat.fit(data, sample_weight=weights, queue=queue)
+
+    res = getattr(result, result_option)
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+        gtr = function(weighted_data)
+    else:
+        gtr = function(data)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_multiple_options_on_random_data(queue, row_count, column_count, weighted, dtype):
+    seed = 42
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+    else:
+        weights = None
+
+    basicstat = BasicStatistics(result_options=["mean", "max", "sum"])
+
+    result = basicstat.fit(data, sample_weight=weights, queue=queue)
+
+    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(weighted_data),
+            expected_max(weighted_data),
+            expected_sum(weighted_data),
+        )
+    else:
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(data),
+            expected_max(data),
+            expected_sum(data),
+        )
+
+    tol = 5e-4 if res_mean.dtype == np.float32 else 1e-7
+    assert_allclose(gtr_mean, res_mean, atol=tol)
+    assert_allclose(gtr_max, res_max, atol=tol)
+    assert_allclose(gtr_sum, res_sum, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_all_option_on_random_data(queue, row_count, column_count, weighted, dtype):
+    seed = 77
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+    else:
+        weights = None
+
+    basicstat = BasicStatistics(result_options="all")
+
+    result = basicstat.fit(data, sample_weight=weights, queue=queue)
+
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+
+    for option in options_and_tests:
+        result_option, function, tols = option
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option)
+        if weighted:
+            gtr = function(weighted_data)
+        else:
+            gtr = function(data)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("data_size", [100, 1000])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_1d_input_on_random_data(queue, option, data_size, weighted, dtype):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+    seed = 77
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=data_size)
+    data = data.astype(dtype=dtype)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=data_size)
+        weights = weights.astype(dtype=dtype)
+    else:
+        weights = None
+
+    basicstat = BasicStatistics(result_options=result_option)
+
+    result = basicstat.fit(data, sample_weight=weights, queue=queue)
+
+    res = getattr(result, result_option)
+    if weighted:
+        weighted_data = weights * data
+        gtr = function(weighted_data)
+    else:
+        gtr = function(data)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.skipif(not hasattr(sp, "random_array"), reason="requires scipy>=1.12.0")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_basic_csr(queue, dtype):
+    seed = 42
+    row_count, column_count = 5000, 3008
+
+    gen = np.random.default_rng(seed)
+
+    data = sp.random_array(
+        shape=(row_count, column_count),
+        density=0.01,
+        format="csr",
+        dtype=dtype,
+        random_state=gen,
+    )
+
+    basicstat = BasicStatistics(result_options="mean")
+    result = basicstat.fit(data, queue=queue)
+
+    res_mean = result.mean
+    gtr_mean = data.mean(axis=0)
+    tol = 5e-6 if res_mean.dtype == np.float32 else 1e-9
+    assert_allclose(gtr_mean, res_mean, rtol=tol)
+
+
+@pytest.mark.skipif(not hasattr(sp, "random_array"), reason="requires scipy>=1.12.0")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("option", options_and_tests_csr)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_options_csr(queue, option, dtype):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+
+    if result_option == "max":
+        pytest.skip("There is a bug in oneDAL's max computations on GPU")
+
+    seed = 42
+    row_count, column_count = 20046, 4007
+
+    gen = np.random.default_rng(seed)
+
+    data = sp.random_array(
+        shape=(row_count, column_count),
+        density=0.002,
+        format="csr",
+        dtype=dtype,
+        random_state=gen,
+    )
+
+    basicstat = BasicStatistics(result_options=result_option)
+    result = basicstat.fit(data, queue=queue)
+
+    res = getattr(result, result_option)
+    func = getattr(data, function)
+    gtr = func(axis=0)
+    if type(gtr).__name__ != "ndarray":
+        gtr = gtr.toarray().flatten()
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+
+    assert_allclose(gtr, res, rtol=tol)

onedal/basic_statistics/tests/test_incremental_basic_statistics.py

@@ -0,0 +1,196 @@
+# ==============================================================================
+# Copyright 2024 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 onedal.basic_statistics import IncrementalBasicStatistics
+from onedal.basic_statistics.tests.test_basic_statistics import (
+    expected_max,
+    expected_mean,
+    expected_sum,
+    options_and_tests,
+)
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_multiple_options_on_gold_data(queue, weighted, dtype):
+    X = np.array([[0, 0], [1, 1]])
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, 2)
+    if weighted:
+        weights = np.array([1, 0.5])
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, 2)
+
+    incbs = IncrementalBasicStatistics()
+    for i in range(2):
+        if weighted:
+            incbs.partial_fit(X_split[i], weights_split[i], queue=queue)
+        else:
+            incbs.partial_fit(X_split[i], queue=queue)
+
+    result = incbs.finalize_fit()
+
+    if weighted:
+        expected_weighted_mean = np.array([0.25, 0.25])
+        expected_weighted_min = np.array([0, 0])
+        expected_weighted_max = np.array([0.5, 0.5])
+        assert_allclose(expected_weighted_mean, result.mean)
+        assert_allclose(expected_weighted_max, result.max)
+        assert_allclose(expected_weighted_min, result.min)
+    else:
+        expected_mean = np.array([0.5, 0.5])
+        expected_min = np.array([0, 0])
+        expected_max = np.array([1, 1])
+        assert_allclose(expected_mean, result.mean)
+        assert_allclose(expected_max, result.max)
+        assert_allclose(expected_min, result.min)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_single_option_on_random_data(
+    queue, num_batches, option, row_count, column_count, weighted, dtype
+):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+    seed = 77
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+    data_split = np.array_split(data, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options=result_option)
+
+    for i in range(num_batches):
+        if weighted:
+            incbs.partial_fit(data_split[i], weights_split[i], queue=queue)
+        else:
+            incbs.partial_fit(data_split[i], queue=queue)
+    result = incbs.finalize_fit()
+
+    res = getattr(result, result_option)
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+        gtr = function(weighted_data)
+    else:
+        gtr = function(data)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_multiple_options_on_random_data(
+    queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 42
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+    data_split = np.array_split(data, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options=["mean", "max", "sum"])
+
+    for i in range(num_batches):
+        if weighted:
+            incbs.partial_fit(data_split[i], weights_split[i], queue=queue)
+        else:
+            incbs.partial_fit(data_split[i], queue=queue)
+    result = incbs.finalize_fit()
+
+    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(weighted_data),
+            expected_max(weighted_data),
+            expected_sum(weighted_data),
+        )
+    else:
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(data),
+            expected_max(data),
+            expected_sum(data),
+        )
+
+    tol = 3e-4 if res_mean.dtype == np.float32 else 1e-7
+    assert_allclose(gtr_mean, res_mean, atol=tol)
+    assert_allclose(gtr_max, res_max, atol=tol)
+    assert_allclose(gtr_sum, res_sum, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_all_option_on_random_data(
+    queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 77
+    gen = np.random.default_rng(seed)
+    data = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    data = data.astype(dtype=dtype)
+    data_split = np.array_split(data, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options="all")
+
+    for i in range(num_batches):
+        if weighted:
+            incbs.partial_fit(data_split[i], weights_split[i], queue=queue)
+        else:
+            incbs.partial_fit(data_split[i], queue=queue)
+    result = incbs.finalize_fit()
+
+    if weighted:
+        weighted_data = np.diag(weights) @ data
+
+    for option in options_and_tests:
+        result_option, function, tols = option
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option)
+        if weighted:
+            gtr = function(weighted_data)
+        else:
+            gtr = function(data)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)

onedal/cluster/__init__.py

@@ -0,0 +1,27 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from daal4py.sklearn._utils import daal_check_version
+
+from .dbscan import DBSCAN
+from .kmeans import KMeans, k_means
+
+__all__ = ["DBSCAN", "KMeans", "k_means"]
+
+if daal_check_version((2023, "P", 200)):
+    from .kmeans_init import KMeansInit, kmeans_plusplus
+
+    __all__ += ["KMeansInit", "kmeans_plusplus"]

onedal/cluster/dbscan.py

@@ -0,0 +1,110 @@
+# ===============================================================================
+# 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 daal4py.sklearn._utils import get_dtype, make2d
+
+from ..common._base import BaseEstimator
+from ..common._mixin import ClusterMixin
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _check_array
+
+
+class BaseDBSCAN(BaseEstimator, ClusterMixin):
+    def __init__(
+        self,
+        eps=0.5,
+        *,
+        min_samples=5,
+        metric="euclidean",
+        metric_params=None,
+        algorithm="auto",
+        leaf_size=30,
+        p=None,
+        n_jobs=None,
+    ):
+        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 _get_onedal_params(self, dtype=np.float32):
+        return {
+            "fptype": "float" if dtype == np.float32 else "double",
+            "method": "by_default",
+            "min_observations": int(self.min_samples),
+            "epsilon": float(self.eps),
+            "mem_save_mode": False,
+            "result_options": "core_observation_indices|responses",
+        }
+
+    def _fit(self, X, y, sample_weight, module, queue):
+        policy = self._get_policy(queue, X)
+        X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+        sample_weight = make2d(sample_weight) if sample_weight is not None else None
+        X = make2d(X)
+
+        types = [np.float32, np.float64]
+        if get_dtype(X) not in types:
+            X = X.astype(np.float64)
+        X = _convert_to_supported(policy, X)
+        dtype = get_dtype(X)
+        params = self._get_onedal_params(dtype)
+        result = module.compute(policy, params, to_table(X), to_table(sample_weight))
+
+        self.labels_ = from_table(result.responses).ravel()
+        if result.core_observation_indices is not None:
+            self.core_sample_indices_ = from_table(
+                result.core_observation_indices
+            ).ravel()
+        else:
+            self.core_sample_indices_ = np.array([], dtype=np.intc)
+        self.components_ = np.take(X, self.core_sample_indices_, axis=0)
+        self.n_features_in_ = X.shape[1]
+        return self
+
+
+class DBSCAN(BaseDBSCAN):
+    def __init__(
+        self,
+        eps=0.5,
+        *,
+        min_samples=5,
+        metric="euclidean",
+        metric_params=None,
+        algorithm="auto",
+        leaf_size=30,
+        p=None,
+        n_jobs=None,
+    ):
+        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 fit(self, X, y=None, sample_weight=None, queue=None):
+        return super()._fit(
+            X, y, sample_weight, self._get_backend("dbscan", "clustering", None), queue
+        )