samir-nasibli
diff --git a/‎deselected_tests.yaml‎
Lines changed: 130 additions & 344 deletions b/‎deselected_tests.yaml‎
Lines changed: 130 additions & 344 deletions
diff --git a/‎onedal/cluster/dbscan.py‎
Lines changed: 43 additions & 53 deletions b/‎onedal/cluster/dbscan.py‎
Lines changed: 43 additions & 53 deletions
diff --git a/‎onedal/datatypes/_data_conversion.py‎
Lines changed: 132 additions & 76 deletions b/‎onedal/datatypes/_data_conversion.py‎
Lines changed: 132 additions & 76 deletions
@@ -16,15 +16,18 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import get_dtype, make2d
+from daal4py.sklearn._utils import make2d
+from onedal._device_offload import supports_queue
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
+from ..common._backend import bind_default_backend
 from ..common._mixin import ClusterMixin
-from ..datatypes import _convert_to_supported, from_table, to_table
-from ..utils import _check_array
+from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 
 
-class BaseDBSCAN(BaseEstimator, ClusterMixin):
+class DBSCAN(ClusterMixin):
     def __init__(
         self,
         eps=0.5,
@@ -46,65 +49,52 @@ def __init__(
         self.p = p
         self.n_jobs = n_jobs
 
+    @bind_default_backend("dbscan.clustering")
+    def compute(self, params, data_table, weights_table): ...
+
     def _get_onedal_params(self, dtype=np.float32):
         return {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "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)
+    @supports_queue
+    def fit(self, X, y=None, sample_weight=None, queue=None):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+
+        if not use_raw_input:
+            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+            X = make2d(X)
+        elif sua_iface is not None:
+            queue = X.sycl_queue
+
+        X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
-        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))
+        params = self._get_onedal_params(X_table.dtype)
+        result = self.compute(params, X_table, sample_weight_table)
 
-        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()
+        self.labels_ = xp.squeeze(from_table(result.responses, like=X))
+        if (
+            result.core_observation_indices is not None
+            and not result.core_observation_indices.kind == "empty"
+        ):
+            self.core_sample_indices_ = xp.squeeze(
+                from_table(
+                    result.core_observation_indices,
+                    like=X,
+                )
+            )
         else:
-            self.core_sample_indices_ = np.array([], dtype=np.intc)
-        self.components_ = np.take(X, self.core_sample_indices_, axis=0)
+            # construct keyword arguments for different namespaces (dptcl takes sycl_queue)
+            kwargs = {"dtype": xp.int32}  # always the same
+            if xp is not np:
+                kwargs["sycl_queue"] = queue
+            self.core_sample_indices_ = xp.empty((0,), **kwargs)
+        self.components_ = xp.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
-        )
@@ -14,86 +14,142 @@
 # limitations under the License.
 # ==============================================================================
 
-import warnings
-
 import numpy as np
+import scipy.sparse as sp
 
-from daal4py.sklearn._utils import make2d
-from onedal import _backend, _is_dpc_backend
-
-from ..utils import _is_csr
-
-try:
-    import dpctl
-    import dpctl.tensor as dpt
+from onedal import _default_backend as backend
 
-    dpctl_available = dpctl.__version__ >= "0.14"
-except ImportError:
-    dpctl_available = False
+from ..utils._third_party import is_dpctl_tensor, is_dpnp_ndarray, lazy_import
 
 
 def _apply_and_pass(func, *args, **kwargs):
     if len(args) == 1:
-        return func(args[0], **kwargs) if len(kwargs) > 0 else func(args[0])
-    return (
-        tuple(func(arg, **kwargs) for arg in args)
-        if len(kwargs) > 0
-        else tuple(func(arg) for arg in args)
-    )
-
-
-def from_table(*args):
-    return _apply_and_pass(_backend.from_table, *args)
-
-
-def convert_one_to_table(arg):
-    if dpctl_available:
-        if isinstance(arg, dpt.usm_ndarray):
-            return _backend.dpctl_to_table(arg)
-
-    if not _is_csr(arg):
-        arg = make2d(arg)
-    return _backend.to_table(arg)
-
-
-def to_table(*args):
-    return _apply_and_pass(convert_one_to_table, *args)
-
-
-if _is_dpc_backend:
-    from ..common._policy import _HostInteropPolicy
-
-    def _convert_to_supported(policy, *data, xp=np):
-        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 == xp.float64):
-                warnings.warn(
-                    "Data will be converted into float32 from "
-                    "float64 because device does not support it",
-                    RuntimeWarning,
-                )
-                return xp.astype(x, dtype=xp.float32)
-            else:
-                return x
-
-        if not device.has_aspect_fp64:
-            func = convert_or_pass
-
-        return _apply_and_pass(func, *data)
-
-else:
-
-    def _convert_to_supported(policy, *data, xp=np):
-        def func(x):
-            return x
-
-        return _apply_and_pass(func, *data)
+        return func(args[0], **kwargs)
+    return tuple(map(lambda arg: func(arg, **kwargs), args))
+
+
+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)
+
+
+def to_table(*args, queue=None):
+    """Create oneDAL tables from scalars and/or arrays.
+
+    Parameters
+    ----------
+    *args : scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array
+        Arguments to be individually converted to oneDAL tables.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object to be associated with the oneDAL tables. Default
+        value None causes no change in data location or queue.
+
+    Returns
+    -------
+    tables : oneDAL homogeneous or csr tables
+        Converted oneDAL tables for scalar, numpy array, sycl_usm_ndarray
+        and dlpack inputs; oneDAL csr_table for csr_matrix, csr_array.
+
+    Notes
+    -----
+        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. Transformation
+        is possible only for data located on CPU and SYCL-enabled Intel
+        GPUs. Each array may only be of a single data type (i.e. each
+        must be homogeneous).
+    """
+    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
+
+
+@lazy_import("array_api_compat")
+def _compat_convert(array_api_compat, array):
+    return array_api_compat.get_namespace(array).from_dlpack
+
+
+def return_type_constructor(array):
+    """Generate a function for converting oneDAL tables to arrays.
+
+    Parameters
+    ----------
+    array : array-like or None
+        Python object representing an array instance of the return type
+        for converting oneDAL tables. Arrays are queried for conversion
+        namespace when of sycl_usm_array type or array API standard type.
+        When set to None, will return numpy arrays or scipy csr arrays.
+
+    Returns
+    -------
+    func : callable
+        A function which takes in a single table input and returns an array.
+    """
+    if isinstance(array, np.ndarray) or array is None or sp.issparse(array):
+        func = backend.from_table
+    elif hasattr(array, "__sycl_usm_array_interface__"):
+        # oneDAL returns tables without sycl queues for CPU sycl queue inputs.
+        # This workaround is necessary for the functional preservation
+        # of the compute-follows-data execution.
+        device = array.sycl_queue
+        # Its important to note why the __sycl_usm_array_interface__ is
+        # prioritized: it provides finer-grained control of SYCL queues and the
+        # related SYCL devices which are generally unavailable via DLPack
+        # representations (such as SYCL contexts, SYCL sub-devices, etc.).
+        if is_dpctl_tensor(array):
+            xp = array.__array_namespace__()
+            func = lambda x: (
+                xp.asarray(x)
+                if hasattr(x, "__sycl_usm_array_interface__")
+                else xp.asarray(backend.from_table(x), device=device)
+            )
+        elif is_dpnp_ndarray(array):
+            xp = array._array_obj.__array_namespace__()
+            from_usm = array._create_from_usm_ndarray
+            func = lambda x: from_usm(
+                xp.asarray(x)
+                if hasattr(x, "__sycl_usm_array_interface__")
+                else xp.asarray(backend.from_table(x), device=device)
+            )
+    elif hasattr(array, "__array_namespace__"):
+        func = array.__array_namespace__().from_dlpack
+    else:
+        try:
+            func = _compat_convert(array)
+        except ImportError:
+            raise TypeError(
+                "array type is unsupported, but may be made compatible by installing `array_api_compat`"
+            ) from None
+    return func
+
+
+def from_table(*args, like=None):
+    """Create 2 dimensional arrays from oneDAL tables.
+
+    oneDAL tables are converted to numpy ndarrays, dpctl tensors, dpnp
+    ndarrays, or array API standard arrays of designated type.
+
+    Parameters
+    ----------
+    *args : single or multiple python oneDAL tables
+        The tables should given as individual arguments.
+
+    like : callable, array-like or None, default=None
+        Python object representing an array instance of the return type
+        or function capable of converting oneDAL tables into arrays of
+        desired type. Arrays are queried for conversion namespace when
+        of sycl_usm_array type or array API standard type. When set to
+        None, will return numpy arrays or scipy csr arrays.
+
+    Returns
+    -------
+    arrays : numpy arrays, sycl_usm_ndarrays, or array API standard arrays
+        Array or tuple of arrays generated from the input oneDAL tables.
+
+    Notes
+    -----
+    Support for other array types via array_api_compat is possible (e.g.
+    PyTorch), but requires its installation specifically, as it is imported
+    only when necessary.
+    """
+    func = like if callable(like) else return_type_constructor(like)
+    return _apply_and_pass(func, *args)