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

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -0,0 +1,154 @@
+# ==============================================================================
+# 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 warnings
+
+import numpy as np
+
+from onedal import _backend, _is_dpc_backend
+
+
+def _apply_and_pass(func, *args, **kwargs):
+    if len(args) == 1:
+        return func(args[0], **kwargs)
+    return tuple(map(lambda arg: func(arg, **kwargs), args))
+
+
+def _convert_one_to_table(arg):
+    # 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)
+
+
+def to_table(*args):
+    """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).
+
+    Parameters
+    ----------
+    *args : {scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array}
+        arg1, arg2... The arrays should be given as arguments.
+
+    Returns
+    -------
+    tables: {oneDAL homogeneous tables}
+    """
+    return _apply_and_pass(_convert_one_to_table, *args)
+
+
+if _is_dpc_backend:
+
+    try:
+        # try/catch is used here instead of dpep_helpers because
+        # of circular import issues of _data_conversion.py and
+        # utils/validation.py. This is a temporary fix until the
+        # issue with dpnp is addressed, at which point this can
+        # be removed entirely.
+        import dpnp
+
+        def _table_to_array(table, xp=None):
+            # By default DPNP ndarray created with a copy.
+            # TODO:
+            # investigate why dpnp.array(table, copy=False) doesn't work.
+            # Work around with using dpctl.tensor.asarray.
+            if xp == dpnp:
+                return dpnp.array(dpnp.dpctl.tensor.asarray(table), copy=False)
+            else:
+                return xp.asarray(table)
+
+    except ImportError:
+
+        def _table_to_array(table, xp=None):
+            return xp.asarray(table)
+
+    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.
+        if sua_iface:
+            if (
+                sycl_queue
+                and sycl_queue.sycl_device.is_cpu
+                and table.__sycl_usm_array_interface__["syclobj"] is None
+            ):
+                # oneDAL returns tables with None sycl queue for CPU sycl queue inputs.
+                # This workaround is necessary for the functional preservation
+                # of the compute-follows-data execution.
+                # 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
+                )
+            else:
+                return _table_to_array(table, xp=xp)
+
+        return _backend.from_table(table)
+
+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.
+        if sua_iface:
+            raise RuntimeError(
+                "SYCL usm array conversion from table requires the DPC backend"
+            )
+        return _backend.from_table(table)
+
+
+def from_table(*args, sycl_queue=None, sua_iface=None, xp=None):
+    return _apply_and_pass(
+        convert_one_from_table, *args, sycl_queue=sycl_queue, sua_iface=sua_iface, xp=xp
+    )

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/onedal/datatypes/tests/common.py

@@ -0,0 +1,126 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from onedal.utils._dpep_helpers import dpctl_available, dpnp_available
+
+if dpnp_available:
+    import dpnp
+
+if dpctl_available:
+    import dpctl
+    from dpctl.tensor import usm_ndarray
+
+    def _get_sycl_queue(syclobj):
+        if hasattr(syclobj, "_get_capsule"):
+            return dpctl.SyclQueue(syclobj._get_capsule())
+        else:
+            return dpctl.SyclQueue(syclobj)
+
+    def _assert_tensor_attr(actual, desired, order):
+        """Check attributes of two given USM tensors."""
+        is_usm_tensor = (
+            lambda x: dpnp_available
+            and isinstance(x, dpnp.ndarray)
+            or isinstance(x, usm_ndarray)
+        )
+        assert is_usm_tensor(actual)
+        assert is_usm_tensor(desired)
+        # dpctl.tensor is the dpnp.ndarrays's core tensor structure along
+        # with advanced device management. Convert dpnp to dpctl.tensor with zero copy.
+        get_tensor = lambda x: (
+            x.get_array() if dpnp_available and isinstance(x, dpnp.ndarray) else x
+        )
+        # Now DPCtl tensors
+        actual = get_tensor(actual)
+        desired = get_tensor(desired)
+
+        assert actual.shape == desired.shape
+        assert actual.strides == desired.strides
+        assert actual.dtype == desired.dtype
+        if order == "F":
+            assert actual.flags.f_contiguous
+            assert desired.flags.f_contiguous
+            assert actual.flags.f_contiguous == desired.flags.f_contiguous
+        else:
+            assert actual.flags.c_contiguous
+            assert desired.flags.c_contiguous
+            assert actual.flags.c_contiguous == desired.flags.c_contiguous
+        assert actual.flags == desired.flags
+        assert actual.sycl_queue == desired.sycl_queue
+        # TODO:
+        # check better way to check usm ptrs.
+        assert actual.usm_data._pointer == desired.usm_data._pointer
+
+    def _assert_sua_iface_fields(
+        actual, desired, skip_syclobj=False, skip_data_0=False, skip_data_1=False
+    ):
+        """Check attributes of two given reprsesentations of
+        USM allocations `__sycl_usm_array_interface__`.
+
+        For full documentation about `__sycl_usm_array_interface__` refer
+        https://intelpython.github.io/dpctl/latest/api_reference/dpctl/sycl_usm_array_interface.html.
+
+        Parameters
+        ----------
+        actual : dict, __sycl_usm_array_interface__
+        desired : dict, __sycl_usm_array_interface__
+        skip_syclobj : bool, default=False
+            If True, check for __sycl_usm_array_interface__["syclobj"]
+            will be skipped.
+        skip_data_0 : bool, default=False
+            If True, check for __sycl_usm_array_interface__["data"][0]
+            will be skipped.
+        skip_data_1 : bool, default=False
+            If True, check for __sycl_usm_array_interface__["data"][1]
+            will be skipped.
+        """
+        assert hasattr(actual, "__sycl_usm_array_interface__")
+        assert hasattr(desired, "__sycl_usm_array_interface__")
+        actual_sua_iface = actual.__sycl_usm_array_interface__
+        desired_sua_iface = desired.__sycl_usm_array_interface__
+        # data: A 2-tuple whose first element is a Python integer encoding
+        # USM pointer value. The second entry in the tuple is a read-only flag
+        # (True means the data area is read-only).
+        if not skip_data_0:
+            assert actual_sua_iface["data"][0] == desired_sua_iface["data"][0]
+        if not skip_data_1:
+            assert actual_sua_iface["data"][1] == desired_sua_iface["data"][1]
+        # shape: a tuple of integers describing dimensions of an N-dimensional array.
+        # Reformating shapes for check cases (r,) vs (r,1). Contiguous flattened array
+        # shape (r,) becoming (r,1) just for the check, since oneDAL supports only (r,1)
+        # for 1-D arrays. In code after from_table conversion for 1-D expected outputs
+        # xp.ravel or reshape(-1) is used.
+        get_shape_if_1d = lambda shape: (shape[0], 1) if len(shape) == 1 else shape
+        actual_shape = get_shape_if_1d(actual_sua_iface["shape"])
+        desired_shape = get_shape_if_1d(desired_sua_iface["shape"])
+        assert actual_shape == desired_shape
+        # strides: An optional tuple of integers describing number of array elements
+        # needed to jump to the next array element in the corresponding dimensions.
+        if not actual_sua_iface["strides"] and not desired_sua_iface["strides"]:
+            # None to indicate a C-style contiguous 1D array.
+            # onedal4py constructs __sycl_usm_array_interface__["strides"] with
+            # real values.
+            assert actual_sua_iface["strides"] == desired_sua_iface["strides"]
+        # versions: Version of the interface.
+        assert actual_sua_iface["version"] == desired_sua_iface["version"]
+        # typestr: a string encoding elemental data type of the array.
+        assert actual_sua_iface["typestr"] == desired_sua_iface["typestr"]
+        # syclobj: Python object from which SYCL context to which represented USM
+        # allocation is bound.
+        if not skip_syclobj and dpctl_available:
+            actual_sycl_queue = _get_sycl_queue(actual_sua_iface["syclobj"])
+            desired_sycl_queue = _get_sycl_queue(desired_sua_iface["syclobj"])
+            assert actual_sycl_queue == desired_sycl_queue

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/onedal/datatypes/tests/test_data.py

@@ -0,0 +1,414 @@
+# ==============================================================================
+# 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 onedal import _backend, _is_dpc_backend
+from onedal.datatypes import from_table, to_table
+from onedal.utils._dpep_helpers import dpctl_available
+
+if dpctl_available:
+    from onedal.datatypes.tests.common import (
+        _assert_sua_iface_fields,
+        _assert_tensor_attr,
+    )
+
+from onedal.primitives import linear_kernel
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from onedal.tests.utils._device_selection import get_queues
+from onedal.utils._array_api import _get_sycl_namespace
+
+data_shapes = [
+    pytest.param((1000, 100), id="(1000, 100)"),  # 2-D array
+    pytest.param((2000, 50), id="(2000, 50)"),  # 2-D array
+    pytest.param((50, 1), id="(50, 1)"),  # 2-D array
+    pytest.param((1, 50), id="(1, 50)"),  # 2-D array
+    pytest.param((50,), id="(50,)"),  # 1-D array
+]
+
+unsupported_data_shapes = [
+    pytest.param((2, 3, 4), id="(2, 3, 4)"),
+    pytest.param((2, 3, 4, 5), id="(2, 3, 4, 5)"),
+]
+
+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
+
+
+def _test_input_format_c_contiguous_numpy(queue, dtype):
+    rng = np.random.RandomState(0)
+    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+
+    x_numpy = np.asanyarray(x_default, dtype=dtype, order="C")
+    assert x_numpy.flags.c_contiguous
+    assert not x_numpy.flags.f_contiguous
+    assert not x_numpy.flags.fnc
+
+    expected = linear_kernel(x_default, queue=queue)
+    result = linear_kernel(x_numpy, queue=queue)
+    assert_allclose(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_input_format_c_contiguous_numpy(queue, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_input_format_c_contiguous_numpy(queue, dtype)
+
+
+def _test_input_format_f_contiguous_numpy(queue, dtype):
+    rng = np.random.RandomState(0)
+    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+
+    x_numpy = np.asanyarray(x_default, dtype=dtype, order="F")
+    assert not x_numpy.flags.c_contiguous
+    assert x_numpy.flags.f_contiguous
+    assert x_numpy.flags.fnc
+
+    expected = linear_kernel(x_default, queue=queue)
+    result = linear_kernel(x_numpy, queue=queue)
+    assert_allclose(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_input_format_f_contiguous_numpy(queue, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_input_format_f_contiguous_numpy(queue, dtype)
+
+
+def _test_input_format_c_not_contiguous_numpy(queue, dtype):
+    rng = np.random.RandomState(0)
+    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+
+    dummy_data = np.insert(x_default, range(1, x_default.shape[1]), 8, axis=1)
+    x_numpy = dummy_data[:, ::2]
+
+    assert_allclose(x_numpy, x_default)
+
+    assert not x_numpy.flags.c_contiguous
+    assert not x_numpy.flags.f_contiguous
+    assert not x_numpy.flags.fnc
+
+    expected = linear_kernel(x_default, queue=queue)
+    result = linear_kernel(x_numpy, queue=queue)
+    assert_allclose(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_input_format_c_not_contiguous_numpy(queue, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_input_format_c_not_contiguous_numpy(queue, dtype)
+
+
+def _test_input_format_c_contiguous_pandas(queue, dtype):
+    pd = pytest.importorskip("pandas")
+    rng = np.random.RandomState(0)
+    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+
+    x_numpy = np.asanyarray(x_default, dtype=dtype, order="C")
+    assert x_numpy.flags.c_contiguous
+    assert not x_numpy.flags.f_contiguous
+    assert not x_numpy.flags.fnc
+    x_df = pd.DataFrame(x_numpy)
+
+    expected = linear_kernel(x_df, queue=queue)
+    result = linear_kernel(x_numpy, queue=queue)
+    assert_allclose(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_input_format_c_contiguous_pandas(queue, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_input_format_c_contiguous_pandas(queue, dtype)
+
+
+def _test_input_format_f_contiguous_pandas(queue, dtype):
+    pd = pytest.importorskip("pandas")
+    rng = np.random.RandomState(0)
+    x_default = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+
+    x_numpy = np.asanyarray(x_default, dtype=dtype, order="F")
+    assert not x_numpy.flags.c_contiguous
+    assert x_numpy.flags.f_contiguous
+    assert x_numpy.flags.fnc
+    x_df = pd.DataFrame(x_numpy)
+
+    expected = linear_kernel(x_df, queue=queue)
+    result = linear_kernel(x_numpy, queue=queue)
+    assert_allclose(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_input_format_f_contiguous_pandas(queue, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_input_format_f_contiguous_pandas(queue, dtype)
+
+
+def _test_conversion_to_table(dtype):
+    np.random.seed()
+    if dtype in [np.int32, np.int64]:
+        x = np.random.randint(0, 10, (15, 3), dtype=dtype)
+    else:
+        x = np.random.uniform(-2, 2, (18, 6)).astype(dtype)
+    x_table = to_table(x)
+    x2 = from_table(x_table)
+    assert x.dtype == x2.dtype
+    assert np.array_equal(x, x2)
+
+
+@pytest.mark.parametrize("dtype", [np.int32, np.int64, np.float32, np.float64])
+def test_conversion_to_table(dtype):
+    _test_conversion_to_table(dtype)
+
+
+@pytest.mark.skipif(
+    not dpctl_available,
+    reason="dpctl is required for checks.",
+)
+@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")
+)
+@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):
+    """Checking that values ​​representing USM allocations `__sycl_usm_array_interface__`
+    are preserved during conversion to onedal table.
+    """
+    rng = np.random.RandomState(0)
+    X_np = np.array(5 * rng.random_sample((10, 59)), dtype=dtype)
+
+    X_np = np.asanyarray(X_np, dtype=dtype, order=order)
+
+    X_dp = _convert_to_dataframe(X_np, sycl_queue=queue, target_df=dataframe)
+
+    sua_iface, X_dp_namespace, _ = _get_sycl_namespace(X_dp)
+
+    X_table = to_table(X_dp)
+    _assert_sua_iface_fields(X_dp, X_table)
+
+    X_dp_from_table = from_table(
+        X_table, sycl_queue=queue, sua_iface=sua_iface, xp=X_dp_namespace
+    )
+    _assert_sua_iface_fields(X_table, X_dp_from_table)
+    _assert_tensor_attr(X_dp, X_dp_from_table, order)
+
+
+@pytest.mark.skipif(
+    not dpctl_available,
+    reason="dpctl is required for checks.",
+)
+@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")
+)
+@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):
+    """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.
+    """
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample(data_shape), dtype=dtype)
+
+    X = ORDER_DICT[order](X)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    alg = DummyEstimatorWithTableConversions()
+    X_table, result_responses_table, result_responses_df = alg.fit(X)
+
+    for obj in [X_table, result_responses_table, result_responses_df, X]:
+        assert hasattr(obj, "__sycl_usm_array_interface__"), f"{obj} has no SUA interface"
+    _assert_sua_iface_fields(X, X_table)
+
+    # Work around for saving compute-follows-data execution
+    # for CPU sycl context requires cause additional memory
+    # allocation using the same queue.
+    skip_data_0 = True if queue.sycl_device.is_cpu else False
+    # Onedal return table's syclobj is empty for CPU inputs.
+    skip_syclobj = True if queue.sycl_device.is_cpu else False
+    # TODO:
+    # investigate why __sycl_usm_array_interface__["data"][1] is changed
+    # after conversion from onedal table to sua array.
+    # Test is not turned off because of this. Only check is skipped.
+    skip_data_1 = True
+    _assert_sua_iface_fields(
+        result_responses_df,
+        result_responses_table,
+        skip_data_0=skip_data_0,
+        skip_data_1=skip_data_1,
+        skip_syclobj=skip_syclobj,
+    )
+    assert X.sycl_queue == result_responses_df.sycl_queue
+    if order == "F":
+        assert X.flags.f_contiguous == result_responses_df.flags.f_contiguous
+    else:
+        assert X.flags.c_contiguous == result_responses_df.flags.c_contiguous
+    # 1D output expected to have the same c_contiguous and f_contiguous flag values.
+    assert (
+        result_responses_df.flags.c_contiguous == result_responses_df.flags.f_contiguous
+    )
+
+
+@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")
+)
+@pytest.mark.parametrize("data_shape", unsupported_data_shapes)
+def test_sua_iface_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"
+    )
+    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")
+)
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        pytest.param(np.uint16, id=np.dtype(np.uint16).name),
+        pytest.param(np.uint32, id=np.dtype(np.uint32).name),
+        pytest.param(np.uint64, id=np.dtype(np.uint64).name),
+    ],
+)
+def test_sua_iface_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 = "Unable to convert from SUA interface: unknown data type"
+    with pytest.raises(ValueError, match=expected_err_msg):
+        to_table(X)
+
+
+@pytest.mark.parametrize(
+    "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:
+        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
+
+    # TODO:
+    # consistent error message.
+    if dataframe in "dpnp,dpctl":
+        expected_err_msg = (
+            "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
+        )
+    else:
+        expected_err_msg = "Numpy input Could not convert Python object to onedal table."
+    with pytest.raises(ValueError, match=expected_err_msg):
+        to_table(X)
+
+
+@pytest.mark.skipif(
+    _is_dpc_backend,
+    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):
+    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 = "SYCL usm array conversion to table requires the DPC backend"
+    with pytest.raises(RuntimeError, match=expected_err_msg):
+        to_table(X)