scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/tests/utils/_dataframes_support.py

@@ -0,0 +1,179 @@
+# ===============================================================================
+# Copyright 2023 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 os
+
+import pytest
+import scipy.sparse as sp
+
+from sklearnex import get_config
+
+from ...utils._third_party import dpctl_available
+
+if dpctl_available:
+    import dpctl.tensor as dpt
+
+try:
+    import dpnp
+
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+try:
+    # This should be lazy imported in the
+    # future along with other popular
+    # array_api libraries when testing
+    # GPU-no-copy.
+    import array_api_strict
+
+    array_api_enabled = lambda: get_config()["array_api_dispatch"]
+    array_api_enabled()
+    array_api_modules = {"array_api": array_api_strict}
+
+
+except (ImportError, KeyError):
+    array_api_enabled = lambda: False
+    array_api_modules = {}
+
+
+import numpy as np
+import pandas as pd
+
+from onedal.tests.utils._device_selection import get_queues
+
+test_frameworks = os.environ.get(
+    "ONEDAL_PYTEST_FRAMEWORKS", "numpy,pandas,dpnp,dpctl,array_api"
+)
+
+
+def get_dataframes_and_queues(dataframe_filter_=None, device_filter_="cpu,gpu"):
+    """Get supported dataframes for testing.
+
+    This is meant to be used for testing purposes only.
+    It is to be used only for pytest test collection.
+
+    Parameters
+    ----------
+    dataframe_filter_ : str, default=None
+        Configure output pytest.params for the certain dataframe formats.
+        When it evaluates False, it will default to value of ``test_frameworks``.
+    device_filter_ : str, default="cpu,gpu"
+        Configure output pytest.params with certain sycl queue for the dataframe,
+        where it is applicable.
+
+    Returns
+    -------
+    list[pytest.param]
+        The list of pytest params, included dataframe name (str),
+        sycl queue, if applicable for the test case, and test
+        case id (str).
+
+    Notes
+    -----
+        Do not use filters for the test cases disabling. Use `pytest.skip`
+        or `pytest.xfail` instead.
+
+    See Also
+    --------
+    _convert_to_dataframe : Converted input object to certain dataframe format.
+    """
+    dataframes_and_queues = []
+
+    # filter dataframe_filter_ based on available test frameworks
+    if dataframe_filter_:
+        dataframe_filter_ = ",".join(
+            [i for i in dataframe_filter_.split(",") if i in test_frameworks]
+        )
+    else:
+        dataframe_filter_ = test_frameworks
+
+    if "numpy" in dataframe_filter_:
+        dataframes_and_queues.append(pytest.param("numpy", None, id="numpy"))
+    if "pandas" in dataframe_filter_:
+        dataframes_and_queues.append(pytest.param("pandas", None, id="pandas"))
+
+    def get_df_and_q(dataframe: str):
+        df_and_q = []
+        for queue in get_queues(device_filter_):
+            if queue:
+                id = "{}-{}".format(dataframe, queue.id)
+                df_and_q.append(pytest.param(dataframe, queue.values[0], id=id))
+        return df_and_q
+
+    if dpctl_available and "dpctl" in dataframe_filter_:
+        dataframes_and_queues.extend(get_df_and_q("dpctl"))
+    if dpnp_available and "dpnp" in dataframe_filter_:
+        dataframes_and_queues.extend(get_df_and_q("dpnp"))
+    if (
+        "array_api" in dataframe_filter_
+        and "array_api" in array_api_modules
+        or array_api_enabled()
+    ):
+        dataframes_and_queues.append(pytest.param("array_api", None, id="array_api"))
+
+    return dataframes_and_queues
+
+
+def _as_numpy(obj, *args, **kwargs):
+    """Converted input object to numpy.ndarray format."""
+    if dpnp_available and isinstance(obj, dpnp.ndarray):
+        return obj.asnumpy(*args, **kwargs)
+    if dpctl_available and isinstance(obj, dpt.usm_ndarray):
+        return dpt.to_numpy(obj, *args, **kwargs)
+    if isinstance(obj, pd.DataFrame) or isinstance(obj, pd.Series):
+        return obj.to_numpy(*args, **kwargs)
+    if sp.issparse(obj):
+        return obj.toarray(*args, **kwargs)
+    return np.asarray(obj, *args, **kwargs)
+
+
+def _convert_to_dataframe(obj, sycl_queue=None, target_df=None, *args, **kwargs):
+    """Converted input object to certain dataframe format."""
+    if target_df is None:
+        return obj
+    elif target_df == "numpy":
+        # Numpy ndarray.
+        # `sycl_queue` arg is ignored.
+        return np.asarray(obj, *args, **kwargs)
+    # Pandas Dataframe
+    elif target_df == "pandas":
+        if (
+            "dtype" in kwargs
+            and hasattr(obj, "astype")
+            and np.issubdtype(kwargs["dtype"], np.integer)
+        ):
+            # Pandas float to int not allowed
+            obj = obj.astype(kwargs["dtype"])
+        if hasattr(obj, "ndim") and obj.ndim == 1:
+            return pd.Series(obj, *args, **kwargs)
+        else:
+            return pd.DataFrame(obj, *args, **kwargs)
+    # DPNP ndarray.
+    elif target_df == "dpnp":
+        return dpnp.asarray(
+            obj, usm_type="device", sycl_queue=sycl_queue, *args, **kwargs
+        )
+    elif target_df == "dpctl":
+        # DPCtl tensor.
+        return dpt.asarray(obj, usm_type="device", sycl_queue=sycl_queue, *args, **kwargs)
+    elif target_df in array_api_modules:
+        # Array API input other than DPNP ndarray, DPCtl tensor or
+        # Numpy ndarray.
+
+        xp = array_api_modules[target_df]
+        return xp.asarray(obj)
+
+    raise RuntimeError("Unsupported dataframe conversion")

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/tests/utils/_device_selection.py

@@ -0,0 +1,94 @@
+# ==============================================================================
+# 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 functools
+
+import pytest
+
+from ...utils._third_party import dpctl_available
+
+if dpctl_available:
+    import dpctl
+    from dpctl.memory import MemoryUSMDevice, MemoryUSMShared
+
+
+def get_queues(filter_="cpu,gpu"):
+    """Get available dpctl.SycQueues for testing.
+
+    This is meant to be used for testing purposes only.
+
+    Parameters
+    ----------
+    filter_ : str, default="cpu,gpu"
+        Configure output list with available dpctl.SycQueues for testing.
+
+    Returns
+    -------
+    list[dpctl.SycQueue]
+        The list of dpctl.SycQueue.
+
+    Notes
+    -----
+        Do not use filters for the test cases disabling. Use `pytest.skip`
+        or `pytest.xfail` instead.
+    """
+    queues = [None] if "cpu" in filter_ else []
+
+    if dpctl_available:
+        if dpctl.has_cpu_devices() and "cpu" in filter_:
+            queues.append(pytest.param(dpctl.SyclQueue("cpu"), id="SyclQueue_CPU"))
+        if dpctl.has_gpu_devices() and "gpu" in filter_:
+            queues.append(pytest.param(dpctl.SyclQueue("gpu"), id="SyclQueue_GPU"))
+
+    return queues
+
+
+def get_memory_usm():
+    if dpctl_available:
+        return [MemoryUSMDevice, MemoryUSMShared]
+    return []
+
+
+def is_dpctl_device_available(targets):
+    if not isinstance(targets, (list, tuple)):
+        raise TypeError("`targets` should be a list or tuple of strings.")
+    if dpctl_available:
+        for device in targets:
+            if device == "cpu" and not dpctl.has_cpu_devices():
+                return False
+            if device == "gpu" and not dpctl.has_gpu_devices():
+                return False
+        return True
+    return False
+
+
+def pass_if_not_implemented_for_gpu(reason=""):
+    """Decorator for test functions. Asserts the test fails with the specified `reason` when running on GPU.
+    Used to ensure that a meaningful error message is provided by the backend."""
+    assert reason
+
+    def decorator(test):
+        @functools.wraps(test)
+        def wrapper(queue, *args, **kwargs):
+            if queue is not None and queue.sycl_device.is_gpu:
+                with pytest.raises(RuntimeError, match=reason):
+                    test(queue, *args, **kwargs)
+            else:
+                test(queue, *args, **kwargs)
+
+        return wrapper
+
+    return decorator

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -0,0 +1,98 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+"""Tools to support array_api."""
+
+from collections.abc import Iterable
+from functools import lru_cache
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..utils._third_party import _is_subclass_fast
+
+
+def _supports_buffer_protocol(obj):
+    # the array_api standard mandates conversion with the buffer protocol,
+    # which can only be checked via a try-catch in native python
+    try:
+        memoryview(obj)
+    except TypeError:
+        return False
+    return True
+
+
+def _asarray(data, xp, *args, **kwargs):
+    """Converted input object to array format of xp namespace provided."""
+    if hasattr(data, "__array_namespace__") or _supports_buffer_protocol(data):
+        return xp.asarray(data, *args, **kwargs)
+    elif isinstance(data, Iterable):
+        if isinstance(data, tuple):
+            result_data = []
+            for i in range(len(data)):
+                result_data.append(_asarray(data[i], xp, *args, **kwargs))
+            data = tuple(result_data)
+        elif sp.issparse(data):
+            pass
+        else:
+            for i in range(len(data)):
+                data[i] = _asarray(data[i], xp, *args, **kwargs)
+    return data
+
+
+def _is_numpy_namespace(xp):
+    """Return True if xp is backed by NumPy."""
+    return xp.__name__ in {
+        "numpy",
+        "array_api_compat.numpy",
+        "numpy.array_api",
+        "sklearn.externals.array_api_compat.numpy",
+    }
+
+
+@lru_cache(100)
+def _cls_to_sycl_namespace(cls):
+    # use caching to minimize imports, derived from array_api_compat
+    if _is_subclass_fast(cls, "dpctl.tensor", "usm_ndarray"):
+        import dpctl.tensor as dpt
+
+        return dpt
+    elif _is_subclass_fast(cls, "dpnp", "ndarray"):
+        import dpnp
+
+        return dpnp
+    else:
+        raise ValueError(f"SYCL type not recognized: {cls}")
+
+
+def _get_sycl_namespace(*arrays):
+    """Get namespace of sycl arrays."""
+
+    # sycl support designed to work regardless of array_api_dispatch sklearn global value
+    sua_iface = {type(x): x for x in arrays if hasattr(x, "__sycl_usm_array_interface__")}
+
+    if len(sua_iface) > 1:
+        raise ValueError(f"Multiple SYCL types for array inputs: {sua_iface}")
+
+    if sua_iface:
+        (X,) = sua_iface.values()
+        return (
+            sua_iface,
+            _cls_to_sycl_namespace(type(X)),
+            hasattr(X, "__array_namespace__"),
+        )
+
+    return sua_iface, np, False

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/utils/_sycl_queue_manager.py

@@ -0,0 +1,213 @@
+# ==============================================================================
+# Copyright 2025 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 contextlib import contextmanager
+from types import SimpleNamespace
+
+from onedal import _default_backend as backend
+
+from .._config import _get_config
+from ..datatypes import get_torch_queue
+from ._third_party import SyclQueue, is_torch_tensor
+
+# This special object signifies that the queue system should be
+# disabled. It will force computation to host. This occurs when the
+# global queue is set to this value (and therefore should not be
+# modified).
+__fallback_queue = object()
+# single instance of global queue
+__global_queue = None
+# dictionary of generic SYCL queues with default SYCL contexts for
+# reuse
+__dlpack_queue = {}
+# Special queue for non-CPU, non-SYCL data associated with dlpack
+__non_queue = SimpleNamespace(sycl_device=SimpleNamespace(is_cpu=False))
+
+
+def __create_sycl_queue(target):
+    if isinstance(target, SyclQueue) or target is None or target is __non_queue:
+        return target
+    if isinstance(target, (str, int)):
+        return SyclQueue(target)
+    raise ValueError(f"Invalid queue or device selector {target=}.")
+
+
+def get_global_queue():
+    """Get the global queue.
+
+    Retrieve it from the config if not set.
+
+    Returns
+    -------
+    queue: SyclQueue or None
+        SYCL Queue object for device code execution. 'None'
+        signifies computation on host.
+    """
+    if (queue := __global_queue) is not None:
+        if queue is __fallback_queue:
+            return None
+        return queue
+
+    target = _get_config()["target_offload"]
+    if target == "auto":
+        # queue will be created from the provided data to each function call
+        return None
+
+    q = __create_sycl_queue(target)
+    update_global_queue(q)
+    return q
+
+
+def remove_global_queue():
+    """Remove the global queue."""
+    global __global_queue
+    __global_queue = None
+
+
+def update_global_queue(queue):
+    """Update the global queue.
+
+    Parameters
+    ----------
+    queue : SyclQueue or None
+        SYCL Queue object for device code execution. None
+        signifies computation on host.
+    """
+    global __global_queue
+    queue = __create_sycl_queue(queue)
+    __global_queue = queue
+
+
+def fallback_to_host():
+    """Enforce a host queue."""
+    global __global_queue
+    __global_queue = __fallback_queue
+
+
+def _get_dlpack_queue(obj: object) -> SyclQueue:
+    # users should not require direct use of this
+    device_type, device_id = obj.__dlpack_device__()
+    if device_type == backend.kDLCPU:
+        return None
+    elif device_type != backend.kDLOneAPI:
+        # Data exists on a non-SYCL, non-CPU device. This will trigger an error
+        # or a fallback if "fallback_to_host" is set in the config
+        return __non_queue
+
+    if is_torch_tensor(obj):
+        return get_torch_queue(obj)
+    else:
+        # no specialized queue can be extracted. Use or generate a generic. Note,
+        # this will behave in unexpected ways for non-default SYCL contexts or
+        # with SYCL sub-devices due to limitations in the dlpack standard (not
+        # enough info).
+        try:
+            queue = __dlpack_queue[device_id]
+        except KeyError:
+            # use filter string capability to yield a queue
+            queue = SyclQueue(str(device_id))
+            __dlpack_queue[device_id] = queue
+        return queue
+
+
+def from_data(*data):
+    """Extract the queue from provided data.
+
+    This updates the global queue as well.
+
+    Parameters
+    ----------
+    *data : arguments
+        Data objects which may contain :obj:`dpctl.SyclQueue` objects.
+
+    Returns
+    -------
+    queue : SyclQueue or None
+        SYCL Queue object for device code execution. None
+        signifies computation on host.
+    """
+    for item in data:
+        # iterate through all data objects, extract the queue, and verify that all data objects are on the same device
+        if usm_iface := getattr(item, "__sycl_usm_array_interface__", None):
+            data_queue = usm_iface["syclobj"]
+        elif hasattr(item, "__dlpack_device__"):
+            data_queue = _get_dlpack_queue(item)
+        else:
+            data_queue = None
+
+        # no queue, i.e. host data, no more work to do
+        if data_queue is None:
+            continue
+
+        global_queue = get_global_queue()
+        # update the global queue if not set
+        if global_queue is None:
+            update_global_queue(data_queue)
+            global_queue = data_queue
+
+        # if either queue points to a device, assert it's always the same device
+        data_dev = data_queue.sycl_device
+        global_dev = global_queue.sycl_device
+        if (data_dev and global_dev) is not None and data_dev != global_dev:
+            # when all data exists on other devices (e.g. not CPU or SYCL devices)
+            # failure will come in backend selection occurring in
+            # sklearnex._device_offload._get_backend when using __non_queue
+            raise ValueError(
+                "Data objects are located on different target devices or not on selected device."
+            )
+
+    # after we went through the data, global queue is updated and verified (if any queue found)
+    return get_global_queue()
+
+
+@contextmanager
+def manage_global_queue(queue, *args):
+    """Context manager to manage the global SyclQueue.
+
+    This context manager updates the global queue with the provided queue,
+    verifies that all data objects are on the same device, and restores the
+    original queue after work is done.
+
+    Parameters
+    ----------
+    queue : SyclQueue or None
+        The queue to set as the global queue. If None,
+        the global queue will be determined from the provided data.
+
+    *args : arguments
+        Additional data objects to verify their device placement.
+
+    Yields
+    ------
+    SyclQueue : SyclQueue or None
+        The global queue after verification.
+
+    Notes
+    -----
+        For most applications, the original queue should be ``None``, but
+        if there are nested calls to ``manage_global_queue()``, it is
+        important to restore the outer queue, rather than setting it to
+        ``None``.
+    """
+    original_queue = get_global_queue()
+    try:
+        # update the global queue with what is provided, it can be None, then we will get it from provided data
+        update_global_queue(queue)
+        # find the queues in data to verify that all data objects are on the same device
+        yield from_data(*args)
+    finally:
+        # restore the original queue
+        update_global_queue(original_queue)