scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/covariance/incremental_covariance.py

@@ -13,12 +13,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ===============================================================================
+
 import numpy as np
 
-from daal4py.sklearn._utils import daal_check_version, get_dtype
+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 .._config import _get_config
 from ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 from .covariance import BaseEmpiricalCovariance
 
 
@@ -55,12 +61,21 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
     def __init__(self, method="dense", bias=False, assume_centered=False):
         super().__init__(method, bias, assume_centered)
         self._reset()
+        self._queue = None
+
+    @bind_default_backend("covariance")
+    def partial_compute(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("covariance")
+    def partial_compute_result(self): ...
+
+    @bind_default_backend("covariance")
+    def finalize_compute(self, params, partial_result): ...
 
     def _reset(self):
         self._need_to_finalize = False
-        self._partial_result = self._get_backend(
-            "covariance", None, "partial_compute_result"
-        )
+        self._queue = None
+        self._partial_result = self.partial_compute_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -73,6 +88,7 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
 
         return data
 
+    @supports_queue
     def partial_fit(self, X, y=None, queue=None):
         """
         Computes partial data for the covariance matrix
@@ -95,30 +111,27 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
-
-        self._queue = queue
+        use_raw_input = _get_config()["use_raw_input"] is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
 
-        policy = self._get_policy(queue, X)
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+        if not use_raw_input:
+            X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
 
+        self._queue = queue
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
             self._dtype = X_table.dtype
 
         params = self._get_onedal_params(self._dtype)
-        self._partial_result = self._get_backend(
-            "covariance",
-            None,
-            "partial_compute",
-            policy,
-            params,
-            self._partial_result,
-            X_table,
-        )
+        self._partial_result = self.partial_compute(params, self._partial_result, X_table)
         self._need_to_finalize = True
+        # store the queue for when we finalize
+        self._queue = queue
 
-    def finalize_fit(self, queue=None):
+    def finalize_fit(self):
         """
         Finalizes covariance matrix and obtains `covariance_` and `location_`
         attributes from the current `_partial_result`.
@@ -135,19 +148,9 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         """
         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,
-            )
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_compute(params, self._partial_result)
+
             if daal_check_version((2024, "P", 1)) or (not self.bias):
                 self.covariance_ = from_table(result.cov_matrix)
             else:

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -14,11 +14,9 @@
 # limitations under the License.
 # ==============================================================================
 
-import warnings
-
 import numpy as np
 
-from onedal import _backend, _is_dpc_backend
+from onedal import _default_backend as backend
 
 
 def _apply_and_pass(func, *args, **kwargs):
@@ -29,7 +27,7 @@ def _apply_and_pass(func, *args, **kwargs):
 
 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, queue)
+    return backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
 
 
 def to_table(*args, queue=None):
@@ -54,7 +52,7 @@ def to_table(*args, queue=None):
     return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
 
 
-if _is_dpc_backend:
+if backend.is_dpc:
 
     try:
         # try/catch is used here instead of dpep_helpers because
@@ -79,8 +77,6 @@ if _is_dpc_backend:
         def _table_to_array(table, xp=None):
             return xp.asarray(table)
 
-    from ..common._policy import _HostInteropPolicy
-
     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.
@@ -96,12 +92,12 @@ if _is_dpc_backend:
                 # Host tables first converted into numpy.narrays and then to array from xp
                 # namespace.
                 return xp.asarray(
-                    _backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
+                    backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
                 )
             else:
                 return _table_to_array(table, xp=xp)
 
-        return _backend.from_table(table)
+        return backend.from_table(table)
 
 else:
 
@@ -112,7 +108,7 @@ else:
             raise RuntimeError(
                 "SYCL usm array conversion from table requires the DPC backend"
             )
-        return _backend.from_table(table)
+        return backend.from_table(table)
 
 
 def from_table(*args, sycl_queue=None, sua_iface=None, xp=None):

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/datatypes/tests/test_data.py

@@ -19,19 +19,25 @@ import pytest
 import scipy.sparse as sp
 from numpy.testing import assert_allclose
 
-from onedal import _backend, _is_dpc_backend
+from onedal import _default_backend, _dpc_backend
+from onedal._device_offload import supports_queue
 from onedal.datatypes import from_table, to_table
 from onedal.utils._dpep_helpers import dpctl_available
 
+backend = _dpc_backend or _default_backend
+
 if dpctl_available:
     from onedal.datatypes.tests.common import (
         _assert_sua_iface_fields,
         _assert_tensor_attr,
     )
 
+from daal4py.sklearn._utils import get_dtype
+from onedal.cluster.dbscan import DBSCAN
 from onedal.primitives import linear_kernel
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
+    array_api_modules,
     get_dataframes_and_queues,
 )
 from onedal.tests.utils._device_selection import get_queues
@@ -53,42 +59,61 @@ unsupported_data_shapes = [
 ORDER_DICT = {"F": np.asfortranarray, "C": np.ascontiguousarray}
 
 
-if _is_dpc_backend:
-    from daal4py.sklearn._utils import get_dtype
-    from onedal.cluster.dbscan import BaseDBSCAN
-    from onedal.common._policy import _get_policy
-
-    class DummyEstimatorWithTableConversions:
-
-        def fit(self, X, y=None):
-            sua_iface, xp, _ = _get_sycl_namespace(X)
-            policy = _get_policy(X.sycl_queue, None)
-            bs_DBSCAN = BaseDBSCAN()
-            types = [xp.float32, xp.float64]
-            if get_dtype(X) not in types:
-                X = xp.astype(X, dtype=xp.float64)
-            dtype = get_dtype(X)
-            params = bs_DBSCAN._get_onedal_params(dtype)
-            X_table = to_table(X)
-            # TODO:
-            # check other candidates for the dummy base oneDAL func.
-            # oneDAL backend func is needed to check result table checks.
-            result = _backend.dbscan.clustering.compute(
-                policy, params, X_table, to_table(None)
-            )
-            result_responses_table = result.responses
-            result_responses_df = from_table(
-                result_responses_table,
-                sua_iface=sua_iface,
-                sycl_queue=X.sycl_queue,
-                xp=xp,
-            )
-            return X_table, result_responses_table, result_responses_df
-
-else:
-
-    class DummyEstimatorWithTableConversions:
-        pass
+class DummyEstimatorWithTableConversions:
+
+    @supports_queue
+    def fit(self, X, y=None, queue=None):
+        if not backend.is_dpc:
+            raise RuntimeError("Table conversions should be done with DPC backend.")
+
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        dbscan = DBSCAN()
+        types = [xp.float32, xp.float64]
+        if get_dtype(X) not in types:
+            X = xp.astype(X, dtype=xp.float64)
+        dtype = get_dtype(X)
+        params = dbscan._get_onedal_params(dtype)
+        X_table = to_table(X)
+        # TODO:
+        # check other candidates for the dummy base oneDAL func.
+        # oneDAL backend func is needed to check result table checks.
+        result = dbscan.compute(params, X_table, to_table(None))
+        result_responses_table = result.responses
+        result_responses_df = from_table(
+            result_responses_table,
+            sua_iface=sua_iface,
+            sycl_queue=X.sycl_queue,
+            xp=xp,
+        )
+        return X_table, result_responses_table, result_responses_df
+
+
+class _OnlyDLTensor:
+    """This is a temporary class to force use of the '__dlpack__' logic branch
+    in `to_table` as `__dlpack__` conversion is lower priority by design.
+    dpctl data with CPU SyclQueues are shown as on KDLOneAPI devices, which serve
+    to test the SYCL device support in `__dlpack__` logic without GPU hardware.
+    This takes inspiration from sklearn's `_NotAnArray`."""
+
+    def __init__(self, data):
+        self.data = data
+
+    def __dlpack__(self):
+        return self.data.__dlpack__()
+
+
+def _to_table_supported(array):
+    """This function provides a quick and easy way to determine characteristics
+    or behaviors of the to_table function.  For example, returned errors are
+    tested and are firstly dependent if they are of a proper array type.  This is
+    pertinent for circumstances such as direct use of other dataframe types (e.g.
+    Pandas)."""
+    return (
+        isinstance(array, np.ndarray)
+        or hasattr(array, "__sycl_usm_ndarray_interface__")
+        or hasattr(array, "__dlpack__")
+        or sp.issparse(array)
+    )
 
 
 def _test_input_format_c_contiguous_numpy(queue, dtype):
@@ -221,7 +246,7 @@ def test_conversion_to_table(dtype):
     reason="dpctl is required for checks.",
 )
 @pytest.mark.skipif(
-    not _is_dpc_backend,
+    not backend.is_dpc,
     reason="__sycl_usm_array_interface__ support requires DPC backend.",
 )
 @pytest.mark.parametrize(
@@ -229,7 +254,7 @@ def test_conversion_to_table(dtype):
 )
 @pytest.mark.parametrize("order", ["C", "F"])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
-def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
+def test_input_zero_copy_sycl_usm(dataframe, queue, order, dtype):
     """Checking that values ​​representing USM allocations `__sycl_usm_array_interface__`
     are preserved during conversion to onedal table.
     """
@@ -257,7 +282,7 @@ def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
     reason="dpctl is required for checks.",
 )
 @pytest.mark.skipif(
-    not _is_dpc_backend,
+    not backend.is_dpc,
     reason="__sycl_usm_array_interface__ support requires DPC backend.",
 )
 @pytest.mark.parametrize(
@@ -266,7 +291,7 @@ def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_table_conversions(dataframe, queue, order, data_shape, dtype):
+def test_table_conversions_sycl_usm(dataframe, queue, order, data_shape, dtype):
     """Checking that values ​​representing USM allocations `__sycl_usm_array_interface__`
     are preserved during conversion to onedal table and from onedal table to
     sycl usm array dataformat.
@@ -313,32 +338,25 @@ def test_table_conversions(dataframe, queue, order, data_shape, dtype):
     )
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend,
-    reason="__sycl_usm_array_interface__ support requires DPC backend.",
-)
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("data_shape", unsupported_data_shapes)
-def test_sua_iface_interop_invalid_shape(dataframe, queue, data_shape):
+def test_interop_invalid_shape(dataframe, queue, data_shape):
     X = np.zeros(data_shape)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    sua_iface, _, _ = _get_sycl_namespace(X)
 
-    expected_err_msg = (
-        "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
-    )
+    expected_err_msg = r"Input array has wrong dimensionality \(must be 2d\)."
+    if dataframe in "dpctl,dpnp":
+        expected_err_msg = (
+            "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
+        )
     with pytest.raises(ValueError, match=expected_err_msg):
         to_table(X)
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend,
-    reason="__sycl_usm_array_interface__ support requires DPC backend.",
-)
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize(
     "dtype",
@@ -348,17 +366,16 @@ def test_sua_iface_interop_invalid_shape(dataframe, queue, data_shape):
         pytest.param(np.uint64, id=np.dtype(np.uint64).name),
     ],
 )
-def test_sua_iface_interop_unsupported_dtypes(dataframe, queue, dtype):
+def test_interop_unsupported_dtypes(dataframe, queue, dtype):
     # sua iface interobility supported only for oneDAL supported dtypes
     # for input data: int32, int64, float32, float64.
     # Checking some common dtypes supported by dpctl, dpnp for exception
     # raise.
     X = np.zeros((10, 20), dtype=dtype)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    sua_iface, _, _ = _get_sycl_namespace(X)
+    expected_err_msg = r"Found unsupported (array|tensor) type"
 
-    expected_err_msg = "Unable to convert from SUA interface: unknown data type"
-    with pytest.raises(ValueError, match=expected_err_msg):
+    with pytest.raises(TypeError, match=expected_err_msg):
         to_table(X)
 
 
@@ -366,27 +383,25 @@ def test_sua_iface_interop_unsupported_dtypes(dataframe, queue, dtype):
     "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,dpnp", "cpu,gpu")
 )
 def test_to_table_non_contiguous_input(dataframe, queue):
-    if dataframe in "dpnp,dpctl" and not _is_dpc_backend:
+    if dataframe in "dpnp,dpctl" and not backend.is_dpc:
         pytest.skip("__sycl_usm_array_interface__ support requires DPC backend.")
     X, _ = np.mgrid[:10, :10]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     X = X[:, :3]
-    sua_iface, _, _ = _get_sycl_namespace(X)
-    # X expected to be non-contiguous.
     assert not X.flags.c_contiguous and not X.flags.f_contiguous
     X_t = to_table(X)
     assert X_t and X_t.shape == (10, 3) and X_t.has_data
 
 
 @pytest.mark.skipif(
-    _is_dpc_backend,
+    backend.is_dpc,
     reason="Required check should be done if no DPC backend.",
 )
 @pytest.mark.parametrize(
     "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sua_iface_interop_if_no_dpc_backend(dataframe, queue, dtype):
+def test_interop_if_no_dpc_backend_sycl_usm(dataframe, queue, dtype):
     X = np.zeros((10, 20), dtype=dtype)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     sua_iface, _, _ = _get_sycl_namespace(X)
@@ -396,12 +411,7 @@ def test_sua_iface_interop_if_no_dpc_backend(dataframe, queue, dtype):
         to_table(X)
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend, reason="Requires DPC backend for dtype conversion"
-)
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-@pytest.mark.parametrize("sparse", [True, False])
-def test_low_precision_gpu_conversion(dtype, sparse):
+def _test_low_precision_gpu_conversion(dtype, sparse, dataframe):
     # Use a dummy queue as fp32 hardware is not in public testing
 
     class DummySyclQueue:
@@ -418,7 +428,9 @@ def test_low_precision_gpu_conversion(dtype, sparse):
     if sparse:
         X = sp.random(100, 100, format="csr", dtype=dtype)
     else:
-        X = np.random.rand(100, 100).astype(dtype)
+        X = _convert_to_dataframe(
+            np.random.rand(100, 100).astype(dtype), target_df=dataframe
+        )
 
     if dtype == np.float64:
         with pytest.warns(
@@ -434,21 +446,51 @@ def test_low_precision_gpu_conversion(dtype, sparse):
         assert_allclose(X, from_table(X_table))
 
 
+@pytest.mark.skipif(
+    not backend.is_dpc, reason="Requires DPC backend for dtype conversion"
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("sparse", [True, False])
+def test_low_precision_gpu_conversion_numpy(dtype, sparse):
+    _test_low_precision_gpu_conversion(dtype, sparse, "numpy")
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or "array_api" not in array_api_modules,
+    reason="Requires DPC backend and array_api_strict for the test",
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_low_precision_gpu_conversion_array_api(dtype):
+    _test_low_precision_gpu_conversion(dtype, False, "array_api")
+
+
 @pytest.mark.parametrize("X", [None, 5, "test", True, [], np.pi, lambda: None])
 @pytest.mark.parametrize("queue", get_queues())
 def test_non_array(X, queue):
     # Verify that to and from table doesn't raise errors
     # no guarantee is made about type or content
+    error = ValueError
     err_str = ""
 
+    xp = X.__array_namespace__() if hasattr(X, "__array_namespace__") else np
+    types = [xp.float64, xp.float32, xp.int64, xp.int32]
+
     if np.isscalar(X):
-        if np.atleast_2d(X).dtype not in [np.float64, np.float32, np.int64, np.int32]:
-            err_str = "Found unsupported array type"
-    elif not (X is None or isinstance(X, np.ndarray)):
+        if np.atleast_2d(X).dtype not in types:
+            error = TypeError
+            err_str = r"Found unsupported array type"
+    elif _to_table_supported(X):
+        if X.dtype not in types:
+            error = TypeError
+            err_str = r"Found unsupported (array|tensor) type"
+        if 0 in X.shape:
+            # not set to a consistent string between the various conversions
+            err_str = r".*"
+    elif X is not None:
         err_str = r"\[convert_to_table\] Not available input format for convert Python object to onedal table."
 
     if err_str:
-        with pytest.raises(ValueError, match=err_str):
+        with pytest.raises(error, match=err_str):
             to_table(X)
     else:
         X_table = to_table(X, queue=queue)
@@ -456,10 +498,10 @@ def test_non_array(X, queue):
 
 
 @pytest.mark.skipif(
-    not _is_dpc_backend, reason="Requires DPC backend for dtype conversion"
+    not backend.is_dpc, reason="Requires DPC backend for dtype conversion"
 )
 @pytest.mark.parametrize("X", [None, 5, "test", True, [], np.pi, lambda: None])
-def test_low_precision_non_array(X):
+def test_low_precision_non_array_numpy(X):
     # Use a dummy queue as fp32 hardware is not in public testing
 
     class DummySyclQueue:
@@ -473,3 +515,62 @@ def test_low_precision_non_array(X):
 
     queue = DummySyclQueue()
     test_non_array(X, queue)
+
+
+@pytest.mark.parametrize("X", [5, True, np.pi])
+def test_basic_ndarray_types_numpy(X):
+    # Verify that the various supported basic types can go in and out of tables
+    test_non_array(np.asarray(X), None)
+
+
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy", "cpu,gpu")
+)
+@pytest.mark.parametrize("can_copy", [True, False])
+def test_to_table_non_contiguous_input_dlpack(dataframe, queue, can_copy):
+    X, _ = np.mgrid[:10, :10]
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, dataframe=dataframe)
+    if not hasattr(X_df, "__dlpack__"):
+        pytest.skip("underlying array doesn't support dlpack")
+
+    X_tens = _OnlyDLTensor(X_df[:, :3])
+
+    # give the _OnlyDLTensor the ability to copy
+    if can_copy:
+        X_tens.copy = lambda: _OnlyDLTensor(
+            X_tens.data.__array_namespace__().copy(X_tens.data)
+            if hasattr(X_tens.data, "__array_namespace__")
+            else X_tens.data.copy()
+        )
+        X_table = to_table(X_tens)
+        X_out = from_table(X_table)
+        assert_allclose(X[:, :3], X_out)
+    else:
+        with pytest.raises(RuntimeError, match="Wrong strides"):
+            to_table(X_tens)
+
+
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy", "cpu,gpu")
+)
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_table_conversions_dlpack(dataframe, queue, order, data_shape, dtype):
+    """Test if __dlpack__ data can be properly consumed when only __dlpack__ attribute is exposed.
+    This tests kDLOneAPI devices as well as kDLCPU devices
+    """
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample(data_shape), dtype=dtype)
+
+    X = ORDER_DICT[order](X)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_tens = _OnlyDLTensor(X_df)
+
+    X_table = to_table(X_tens)
+    X_out = from_table(X_table)
+    print(X_table.shape, X_tens.data.shape)
+    # oneDAL table construction sets 1d arrays to 2d arrays with 1 col
+    # this is counter the numpy strategy, and requires numpy's squeeze
+    assert_allclose(np.squeeze(X), np.squeeze(X_out))