scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

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

@@ -0,0 +1,158 @@
+# ==============================================================================
+# 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 scipy.sparse as sp
+
+from onedal import _default_backend as backend
+
+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)
+    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.).
+        xp = array.__array_namespace__()
+        # array api support added in dpnp starting in 0.19, will fail for
+        # older versions
+        if is_dpctl_tensor(array):
+            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):
+            func = lambda x: (
+                xp.asarray(xp.as_usm_ndarray(x))
+                if hasattr(x, "__sycl_usm_array_interface__")
+                else xp.asarray(backend.from_table(x), device=device)
+            )
+
+    elif hasattr(array, "__array_namespace__"):
+        xp = array.__array_namespace__()
+        device = array.device
+        func = lambda inp: xp.from_dlpack(inp, device=device)
+    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)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/datatypes/_dlpack.py

@@ -0,0 +1,64 @@
+# ==============================================================================
+# Copyright Contributors to the oneDAL Project
+#
+# 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 collections.abc import Iterable
+
+import numpy as np
+
+from onedal import _default_backend as backend
+
+from ..utils._third_party import convert_sklearnex_queue, lazy_import
+
+cpu_dlpack_device = (backend.kDLCPU, 0)
+
+
+@lazy_import("torch.xpu")
+@convert_sklearnex_queue
+def get_torch_queue(torchxpu, array):
+    return backend.SyclQueue(torchxpu.current_stream(array.get_device()).sycl_queue)
+
+
+def dlpack_to_numpy(obj):
+    # check dlpack data location.
+    if obj.__dlpack_device__() != cpu_dlpack_device:
+        if hasattr(obj, "to_device"):
+            # use of the "cpu" string as device not officially part of
+            # the array api standard but widely supported
+            obj = obj.to_device("cpu")
+        elif hasattr(obj, "to"):
+            # pytorch-specific fix as it is not array api compliant
+            obj = obj.to("cpu")
+        else:
+            raise TypeError(f"cannot move {type(obj)} to cpu")
+
+    # convert to numpy
+    try:
+        # Some frameworks implement an __array__ method just to
+        # throw a RuntimeError when used (array_api_strict, dpctl),
+        # or a TypeError (array_api-strict) rather than an AttributeError
+        # therefore a try catch is necessary (logic is essentially a
+        # getattr call + some)
+        obj = obj.__array__()
+    except (AttributeError, RuntimeError, TypeError):
+        # requires numpy 1.23
+        try:
+            obj = np.from_dlpack(obj)
+        except AttributeError:
+            raise NotImplementedError(
+                "Upgrade NumPy >= 1.23 for dlpack support"
+            ) from None
+
+    return obj

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/datatypes/_sycl_usm.py

@@ -0,0 +1,63 @@
+# ==============================================================================
+# Copyright Contributors to the oneDAL Project
+#
+# 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 collections.abc import Iterable
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..utils._third_party import lazy_import
+
+
+@lazy_import("dpctl.memory", "dpctl.tensor")
+def _array_to_usm(memory, tensor, queue, array):
+    try:
+        mem = memory.MemoryUSMDevice(array.nbytes, queue=queue)
+        mem.copy_from_host(array.tobytes())
+        return tensor.usm_ndarray(array.shape, array.dtype, buffer=mem)
+    except ValueError as e:
+        # ValueError will raise if device does not support the dtype
+        # retry with float32 (needed for fp16 and fp64 support issues)
+        # try again as float32, if it is a float32 just raise the error.
+        if array.dtype == np.float32:
+            raise e
+        return _array_to_usm(queue, array.astype(np.float32))
+
+
+@lazy_import("dpnp", "dpctl.tensor")
+def _to_dpnp(dpnp, tensor, array):
+    if isinstance(array, tensor.usm_ndarray):
+        return dpnp.array(array, copy=False)
+    else:
+        return array
+
+
+def copy_to_usm(queue, array):
+    if hasattr(array, "tobytes"):
+        return _array_to_usm(queue, array)
+    else:
+        if isinstance(array, Iterable) and not sp.issparse(array):
+            array = [copy_to_usm(queue, i) for i in array]
+        return array
+
+
+def copy_to_dpnp(queue, array):
+    if hasattr(array, "tobytes"):
+        return _to_dpnp(_array_to_usm(queue, array))
+    else:
+        if isinstance(array, Iterable) and not sp.issparse(array):
+            array = [copy_to_dpnp(queue, i) for i in array]
+        return array

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

@@ -0,0 +1,131 @@
+# ===============================================================================
+# 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._third_party import dpctl_available
+
+try:
+    import dpnp
+
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+
+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.
+        # Reformatting 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