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

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/cluster/kmeans_init.py

@@ -21,7 +21,7 @@ from sklearn.utils import check_random_state
 from daal4py.sklearn._utils import daal_check_version, get_dtype
 
 from ..common._base import BaseEstimator as onedal_BaseEstimator
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 
 if daal_check_version((2023, "P", 200)):
@@ -50,26 +50,23 @@ if daal_check_version((2023, "P", 200)):
 
         def _get_onedal_params(self, dtype=np.float32):
             return {
-                "fptype": "float" if dtype == np.float32 else "double",
+                "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, policy):
+        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 = _convert_to_supported(policy, X)
-
-            dtype = get_dtype(X)
-            params = self._get_onedal_params(dtype)
-            return (params, to_table(X), dtype)
+            X = to_table(X, queue=queue)
+            params = self._get_onedal_params(X.dtype)
+            return (params, X, X.dtype)
 
         def _compute_raw(self, X_table, module, policy, dtype=np.float32):
             params = self._get_onedal_params(dtype)
@@ -83,7 +80,7 @@ if daal_check_version((2023, "P", 200)):
             # oneDAL KMeans Init for sparse data does not have GPU support
             if issparse(X):
                 policy = self._get_policy(None, None)
-            _, X_table, dtype = self._get_params_and_input(X, policy)
+            _, X_table, dtype = self._get_params_and_input(X, queue)
 
             centroids = self._compute_raw(X_table, module, policy, dtype)
 

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/common/_policy.py

@@ -48,12 +48,8 @@ class _HostInteropPolicy(_backend.host_policy):
 
 
 if _is_dpc_backend:
-    from onedal._device_offload import DummySyclQueue
 
     class _DataParallelInteropPolicy(_backend.data_parallel_policy):
         def __init__(self, queue):
             self._queue = queue
-            if isinstance(queue, DummySyclQueue):
-                super().__init__(self._queue.sycl_device.get_filter_string())
-                return
             super().__init__(self._queue)

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -0,0 +1,128 @@
+# ==============================================================================
+# 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 onedal import _backend, _is_dpc_backend
+from onedal.tests.utils._device_selection import get_queues
+from onedal.utils._dpep_helpers import dpctl_available
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("device_type", ["cpu", "gpu"])
+@pytest.mark.parametrize("device_number", [None, 0, 1, 2, 3])
+def test_sycl_queue_string_creation(device_type, device_number):
+    # create devices from strings
+    from dpctl import SyclQueue
+    from dpctl._sycl_queue import SyclQueueCreationError
+
+    onedal_SyclQueue = _backend.SyclQueue
+
+    device = (
+        ":".join([device_type, str(device_number)])
+        if device_number is not None
+        else device_type
+    )
+
+    raised_exception_dpctl = False
+    raised_exception_backend = False
+
+    try:
+        dpctl_string = SyclQueue(device).sycl_device.filter_string
+    except SyclQueueCreationError:
+        raised_exception_dpctl = True
+
+    try:
+        onedal_string = onedal_SyclQueue(device).sycl_device.filter_string
+    except RuntimeError:
+        raised_exception_backend = True
+
+    assert raised_exception_dpctl == raised_exception_backend
+    if not raised_exception_backend:
+        # dpctl filter string converts simple sycl filter_strings
+        # i.e. "gpu:1" -> "opencl:gpu:0", use SyclQueue to convert
+        # for matching, as oneDAL sycl queue only returns simple
+        # strings as these are operationally sufficient
+        assert SyclQueue(onedal_string).sycl_device.filter_string == dpctl_string
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_queue_conversion(queue):
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    SyclQueue = queue.__class__
+    onedal_SyclQueue = _backend.SyclQueue
+
+    q = onedal_SyclQueue(queue)
+
+    # convert back and forth to test `_get_capsule` attribute
+    for i in range(10):
+        q = SyclQueue(q.sycl_device.filter_string)
+        q = onedal_SyclQueue(q)
+
+    assert q.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_device_attributes(queue):
+    from dpctl import SyclQueue
+
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    onedal_SyclQueue = _backend.SyclQueue
+
+    onedal_queue = onedal_SyclQueue(queue)
+
+    # check fp64 support
+    assert onedal_queue.sycl_device.has_aspect_fp64 == queue.sycl_device.has_aspect_fp64
+    # check fp16 support
+    assert onedal_queue.sycl_device.has_aspect_fp16 == queue.sycl_device.has_aspect_fp16
+    # check is_cpu
+    assert onedal_queue.sycl_device.is_cpu == queue.sycl_device.is_cpu
+    # check is_gpu
+    assert onedal_queue.sycl_device.is_gpu == queue.sycl_device.is_gpu
+    # check device number
+    assert onedal_queue.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(not _is_dpc_backend, reason="requires dpc backend")
+def test_backend_queue():
+    try:
+        q = _backend.SyclQueue("cpu")
+    except RuntimeError:
+        pytest.skip("OpenCL CPU runtime not installed")
+
+    # verify copying via a py capsule object is functional
+    q2 = _backend.SyclQueue(q._get_capsule())
+    # verify copying via the _get_capsule attribute
+    q3 = _backend.SyclQueue(q)
+
+    q_array = [q, q2, q3]
+
+    assert all([queue.sycl_device.has_aspect_fp64 for queue in q_array])
+    assert all([queue.sycl_device.has_aspect_fp16 for queue in q_array])
+    assert all([queue.sycl_device.is_cpu for queue in q_array])
+    assert all([not queue.sycl_device.is_gpu for queue in q_array])
+    assert all(["cpu" in queue.sycl_device.filter_string for queue in q_array])

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/covariance/covariance.py

@@ -22,7 +22,7 @@ from onedal.utils import _check_array
 
 from ..common._base import BaseEstimator
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 
 
 class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
@@ -33,7 +33,7 @@ class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
 
     def _get_onedal_params(self, dtype=np.float32):
         params = {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "method": self.method,
         }
         if daal_check_version((2024, "P", 1)):
@@ -95,9 +95,8 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         """
         policy = self._get_policy(queue, X)
         X = _check_array(X, dtype=[np.float64, np.float32])
-        X = _convert_to_supported(policy, X)
-        dtype = get_dtype(X)
-        params = self._get_onedal_params(dtype)
+        X = to_table(X, queue=queue)
+        params = self._get_onedal_params(X.dtype)
         hparams = get_hyperparameters("covariance", "compute")
         if hparams is not None and not hparams.is_default:
             result = self._get_backend(
@@ -107,12 +106,10 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
                 policy,
                 params,
                 hparams.backend,
-                to_table(X),
+                X,
             )
         else:
-            result = self._get_backend(
-                "covariance", None, "compute", policy, params, to_table(X)
-            )
+            result = self._get_backend("covariance", None, "compute", policy, params, X)
         if daal_check_version((2024, "P", 1)) or (not self.bias):
             self.covariance_ = from_table(result.cov_matrix)
         else:

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/covariance/incremental_covariance.py

@@ -17,7 +17,7 @@ import numpy as np
 
 from daal4py.sklearn._utils import daal_check_version, get_dtype
 
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 from .covariance import BaseEmpiricalCovariance
 
@@ -57,10 +57,22 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self._reset()
 
     def _reset(self):
+        self._need_to_finalize = False
         self._partial_result = self._get_backend(
             "covariance", None, "partial_compute_result"
         )
 
+    def __getstate__(self):
+        # Since finalize_fit can't be dispatched without directly provided queue
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
+
     def partial_fit(self, X, y=None, queue=None):
         """
         Computes partial data for the covariance matrix
@@ -89,13 +101,12 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
 
         policy = self._get_policy(queue, X)
 
-        X = _convert_to_supported(policy, X)
+        X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
+            self._dtype = X_table.dtype
 
         params = self._get_onedal_params(self._dtype)
-        table_X = to_table(X)
         self._partial_result = self._get_backend(
             "covariance",
             None,
@@ -103,8 +114,9 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
             policy,
             params,
             self._partial_result,
-            table_X,
+            X_table,
         )
+        self._need_to_finalize = True
 
     def finalize_fit(self, queue=None):
         """
@@ -121,26 +133,29 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        params = self._get_onedal_params(self._dtype)
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-
-        result = self._get_backend(
-            "covariance",
-            None,
-            "finalize_compute",
-            policy,
-            params,
-            self._partial_result,
-        )
-        if daal_check_version((2024, "P", 1)) or (not self.bias):
-            self.covariance_ = from_table(result.cov_matrix)
-        else:
-            n_rows = self._partial_result.partial_n_rows
-            self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
-
-        self.location_ = from_table(result.means).ravel()
+        if self._need_to_finalize:
+            params = self._get_onedal_params(self._dtype)
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+
+            result = self._get_backend(
+                "covariance",
+                None,
+                "finalize_compute",
+                policy,
+                params,
+                self._partial_result,
+            )
+            if daal_check_version((2024, "P", 1)) or (not self.bias):
+                self.covariance_ = from_table(result.cov_matrix)
+            else:
+                n_rows = self._partial_result.partial_n_rows
+                self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
+
+            self.location_ = from_table(result.means).ravel()
+
+            self._need_to_finalize = False
 
         return self

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/covariance/tests/test_incremental_covariance.py

@@ -18,6 +18,7 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+from onedal.datatypes import from_table
 from onedal.tests.utils._device_selection import get_queues
 
 
@@ -42,8 +43,8 @@ def test_on_gold_data_unbiased(queue, dtype):
     assert_allclose(expected_means, result.location_)
 
     X = np.array([[1, 2], [3, 6]])
-    X_split = np.array_split(X, 2)
     X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
     inccov = IncrementalEmpiricalCovariance()
 
     for i in range(2):
@@ -120,3 +121,70 @@ def test_partial_fit_on_random_data(
 
     assert_allclose(expected_covariance, result.covariance_, atol=1e-6)
     assert_allclose(expected_means, result.location_, atol=1e-6)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    inccov = IncrementalEmpiricalCovariance()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov.partial_fit(X_split[0], queue=queue)
+    inccov_loaded.partial_fit(X_split[0], queue=queue)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert inccov_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(inccov._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(inccov_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(inccov._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        inccov_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sums = from_table(inccov._partial_result.partial_sums)
+    partial_sums_loaded = from_table(inccov_loaded._partial_result.partial_sums)
+    assert_allclose(partial_sums, partial_sums_loaded)
+
+    inccov.partial_fit(X_split[1], queue=queue)
+    inccov_loaded.partial_fit(X_split[1], queue=queue)
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == False
+
+    inccov.finalize_fit()
+    inccov_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert_allclose(inccov.location_, inccov_loaded.location_, atol=1e-6)
+    assert_allclose(inccov.covariance_, inccov_loaded.covariance_, atol=1e-6)

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from ._data_conversion import from_table, to_table
+
+__all__ = ["from_table", "to_table"]

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -27,20 +27,20 @@ def _apply_and_pass(func, *args, **kwargs):
     return tuple(map(lambda arg: func(arg, **kwargs), args))
 
 
-def _convert_one_to_table(arg):
+def _convert_one_to_table(arg, queue=None):
     # All inputs for table conversion must be array-like or sparse, not scalars
-    return _backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg)
+    return _backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
 
 
-def to_table(*args):
+def to_table(*args, queue=None):
     """Create oneDAL tables from scalars and/or arrays.
 
-    Note: this implementation can be used with contiguous scipy.sparse, numpy
-    ndarrays, DPCTL/DPNP usm_ndarrays and scalars. Tables will use pointers to the
-    original array data. Scalars will be copies. Arrays may be modified in-
-    place by oneDAL during computation. This works for data located on CPU and
-    SYCL-enabled Intel GPUs. Each array may only be of a single datatype (i.e.
-    each must be homogeneous).
+    Note: this implementation can be used with scipy.sparse, numpy ndarrays,
+    DPCTL/DPNP usm_ndarrays and scalars. Tables will use pointers to the
+    original array data. Scalars and non-contiguous arrays will be copies.
+    Arrays may be modified in-place by oneDAL during computation. This works
+    for data located on CPU and SYCL-enabled Intel GPUs. Each array may only
+    be of a single datatype (i.e. each must be homogeneous).
 
     Parameters
     ----------
@@ -51,7 +51,7 @@ def to_table(*args):
     -------
     tables: {oneDAL homogeneous tables}
     """
-    return _apply_and_pass(_convert_one_to_table, *args)
+    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
 
 
 if _is_dpc_backend:
@@ -81,33 +81,6 @@ if _is_dpc_backend:
 
     from ..common._policy import _HostInteropPolicy
 
-    def _convert_to_supported(policy, *data):
-        def func(x):
-            return x
-
-        # CPUs support FP64 by default
-        if isinstance(policy, _HostInteropPolicy):
-            return _apply_and_pass(func, *data)
-
-        # It can be either SPMD or DPCPP policy
-        device = policy._queue.sycl_device
-
-        def convert_or_pass(x):
-            if (x is not None) and (x.dtype == np.float64):
-                warnings.warn(
-                    "Data will be converted into float32 from "
-                    "float64 because device does not support it",
-                    RuntimeWarning,
-                )
-                return x.astype(np.float32)
-            else:
-                return x
-
-        if not device.has_aspect_fp64:
-            func = convert_or_pass
-
-        return _apply_and_pass(func, *data)
-
     def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
         # Currently only `__sycl_usm_array_interface__` protocol used to
         # convert into dpnp/dpctl tensors.
@@ -132,12 +105,6 @@ if _is_dpc_backend:
 
 else:
 
-    def _convert_to_supported(policy, *data):
-        def func(x):
-            return x
-
-        return _apply_and_pass(func, *data)
-
     def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
         # Currently only `__sycl_usm_array_interface__` protocol used to
         # convert into dpnp/dpctl tensors.