scikit-learn-intelex 2025.6.1__py39-none-win_amd64.whl → 2025.8.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/primitives/kernel_functions.py

@@ -49,21 +49,33 @@ def _compute_kernel(params, submodule, X, Y):
 
 @supports_queue
 def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
-    """
-    Compute the linear kernel between X and Y:
-        K(x, y) = scale*dot(x, y^T) + shift
+    """Compute the linear kernel between X and Y.
+
+    K(x, y) = scale*dot(x, y^T) + shift
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
     scale : float, default=1.0
+        Multiplication value to scale the inner product.
+
     shift : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Scaled and shifted Gram matrix output.
     """
     X, Y = _check_inputs(X, Y)
     return _compute_kernel(
@@ -76,21 +88,30 @@ def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
 
 @supports_queue
 def rbf_kernel(X, Y=None, gamma=None, queue=None):
-    """
-    Compute the rbf (gaussian) kernel between X and Y:
-        K(x, y) = exp(-gamma ||x-y||^2)
+    """Compute the rbf (gaussian) kernel between X and Y.
+
+    K(x, y) = exp(-gamma ||x-y||^2)
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
     gamma : float, default=None
         If None, defaults to 1.0 / n_features.
 
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The RBF kernel.
     """
 
     X, Y = _check_inputs(X, Y)
@@ -103,22 +124,36 @@ def rbf_kernel(X, Y=None, gamma=None, queue=None):
 
 @supports_queue
 def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
-    """
-    Compute the poly kernel between X and Y:
-        K(x, y) = (scale*dot(x, y^T) + shift)**degree
+    """Compute the polynomial kernel between X and Y.
+
+    K(x, y) = (gamma*dot(x, y^T) + coef0)**degree
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
-    scale : float, default=1.0
-    shift : float, default=0.0
-    degree : float, default=3
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    degree : int, default=3
+        Kernel degree.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The polynomial kernel.
     """
 
     X, Y = _check_inputs(X, Y)
@@ -132,21 +167,33 @@ def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
 
 @supports_queue
 def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
-    """
-    Compute the sigmoid kernel between X and Y:
-        K(x, y) = tanh(scale*dot(x, y^T) + shift)
+    """Compute the sigmoid kernel between X and Y.
+
+        :math:`K(x, y) = \\text{tanh}(\\gamma \\mathbf{x}^T \\mathbf{y}) + \\text{coef}_0)`
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
-    scale : float, default=1.0
-    shift : float, default=0.0
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Sigmoid kernel between two arrays.
     """
 
     X, Y = _check_inputs(X, Y)

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/svm/svm.py

@@ -334,9 +334,6 @@ class BaseSVM(metaclass=ABCMeta):
 
 
 class SVR(RegressorMixin, BaseSVM):
-    """
-    Epsilon--Support Vector Regression.
-    """
 
     def __init__(
         self,
@@ -395,9 +392,6 @@ class SVR(RegressorMixin, BaseSVM):
 
 
 class SVC(ClassifierMixin, BaseSVM):
-    """
-    C-Support Vector Classification.
-    """
 
     def __init__(
         self,
@@ -470,9 +464,6 @@ class SVC(ClassifierMixin, BaseSVM):
 
 
 class NuSVR(RegressorMixin, BaseSVM):
-    """
-    Nu-Support Vector Regression.
-    """
 
     def __init__(
         self,
@@ -530,9 +521,6 @@ class NuSVR(RegressorMixin, BaseSVM):
 
 
 class NuSVC(ClassifierMixin, BaseSVM):
-    """
-    Nu-Support Vector Classification.
-    """
 
     def __init__(
         self,

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/tests/test_common.py

@@ -18,6 +18,8 @@ import importlib
 import os
 from glob import glob
 
+from onedal.tests.utils._dataframes_support import test_frameworks
+
 
 def _check_primitive_usage_ban(primitive_name, package, allowed_locations=None):
     """This test blocks the usage of the primitive in
@@ -54,4 +56,16 @@ def test_sklearn_check_version_ban():
 
     # remove this file from the list
     output = "\n".join([i for i in output if "test_common.py" not in i])
-    assert output == "", f"sklearn versioning is occuring in: \n{output}"
+    assert output == "", f"sklearn versioning is occurring in: \n{output}"
+
+
+def test_frameworks_intentionality():
+    """Only silent skip frameworks which are not installed"""
+    fmwks = test_frameworks.replace("array_api", "array_api_strict").split(",")
+    for module in fmwks:
+        try:
+            importlib.import_module(module)
+        # If a module isn't installed, working as intended.
+        # If an ImportError occurs, then something is wrong.
+        except ModuleNotFoundError:
+            pass

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/tests/utils/_dataframes_support.py

@@ -13,20 +13,25 @@
 # 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._dpep_helpers import dpctl_available, dpnp_available
+from ...utils._third_party import dpctl_available
 
 if dpctl_available:
     import dpctl.tensor as dpt
 
-if dpnp_available:
+try:
     import dpnp
 
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
 try:
     # This should be lazy imported in the
     # future along with other popular
@@ -49,18 +54,22 @@ 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_="numpy,pandas,dpnp,dpctl,array_api", device_filter_="cpu,gpu"
-):
+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="numpy,pandas,dpnp,dpctl"
+    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.
@@ -83,6 +92,14 @@ def get_dataframes_and_queues(
     """
     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_:

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/tests/utils/_device_selection.py

@@ -18,7 +18,7 @@ import functools
 
 import pytest
 
-from ...utils._dpep_helpers import dpctl_available
+from ...utils._third_party import dpctl_available
 
 if dpctl_available:
     import dpctl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -17,27 +17,12 @@
 """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 ._dpep_helpers import dpctl_available, dpnp_available
-
-if dpctl_available:
-    from dpctl.tensor import usm_ndarray
-
-if dpnp_available:
-    import dpnp
-
-    def _convert_to_dpnp(array):
-        """Converted input object to dpnp.ndarray format."""
-        # Will be removed and `onedal.utils._array_api._asarray` will be
-        # used instead after DPNP Array API enabling.
-        if isinstance(array, usm_ndarray):
-            return dpnp.array(array, copy=False)
-        elif isinstance(array, Iterable):
-            for i in range(len(array)):
-                array[i] = _convert_to_dpnp(array[i])
-        return array
+from ..utils._third_party import _is_subclass_fast
 
 
 def _supports_buffer_protocol(obj):
@@ -60,6 +45,8 @@ def _asarray(data, xp, *args, **kwargs):
             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)
@@ -76,6 +63,21 @@ def _is_numpy_namespace(xp):
     }
 
 
+@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."""
 
@@ -87,12 +89,10 @@ def _get_sycl_namespace(*arrays):
 
     if sua_iface:
         (X,) = sua_iface.values()
-
-        if hasattr(X, "__array_namespace__"):
-            return sua_iface, X.__array_namespace__(), True
-        elif dpnp_available and isinstance(X, dpnp.ndarray):
-            return sua_iface, dpnp, False
-        else:
-            raise ValueError(f"SYCL type not recognized: {sua_iface}")
+        return (
+            sua_iface,
+            _cls_to_sycl_namespace(type(X)),
+            hasattr(X, "__array_namespace__"),
+        )
 
     return sua_iface, np, False

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/utils/_sycl_queue_manager.py

@@ -15,16 +15,13 @@
 # ==============================================================================
 
 from contextlib import contextmanager
+from types import SimpleNamespace
 
-from .._config import _get_config
-from ..utils._dpep_helpers import dpctl_available
-
-if dpctl_available:
-    from dpctl import SyclQueue
-else:
-    from onedal import _dpc_backend
+from onedal import _default_backend as backend
 
-    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+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
@@ -33,15 +30,15 @@ else:
 __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 SyclQueue is None:
-        # we don't have SyclQueue support
-        return None
-    if target is None:
-        return None
-    if isinstance(target, SyclQueue):
+    if isinstance(target, SyclQueue) or target is None or target is __non_queue:
         return target
     if isinstance(target, (str, int)):
         return SyclQueue(target)
@@ -49,13 +46,19 @@ def __create_sycl_queue(target):
 
 
 def get_global_queue():
-    """Get the global queue. Retrieve it from the config if not set."""
+    """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 SyclQueue:
-            if queue is __fallback_queue:
-                return None
-            elif not isinstance(queue, SyclQueue):
-                raise ValueError("Global queue is not a SyclQueue object.")
+        if queue is __fallback_queue:
+            return None
         return queue
 
     target = _get_config()["target_offload"]
@@ -75,7 +78,14 @@ def remove_global_queue():
 
 
 def update_global_queue(queue):
-    """Update the global 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
@@ -87,31 +97,62 @@ def fallback_to_host():
     __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."""
+    """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
-        try:
-            usm_iface = getattr(item, "__sycl_usm_array_interface__", None)
-        except RuntimeError as e:
-            if "SUA interface" in str(e):
-                # ignore SUA interface errors and move on
-                continue
-            else:
-                # unexpected, re-raise
-                raise e
-
-        if usm_iface is None:
-            # no interface found - try next data object
+        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
 
-        # extract the queue
         global_queue = get_global_queue()
-        data_queue = usm_iface["syclobj"]
-        if not data_queue:
-            # no queue, i.e. host data, no more work to do
-            continue
-
         # update the global queue if not set
         if global_queue is None:
             update_global_queue(data_queue)
@@ -121,6 +162,9 @@ def from_data(*data):
         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."
             )
@@ -131,24 +175,32 @@ def from_data(*data):
 
 @contextmanager
 def manage_global_queue(queue, *args):
-    """
-    Context manager to manage the global SyclQueue.
+    """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.
-    Note: 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`.
-
-    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: Additional data objects to verify their device placement.
-
-    Yields:
-    SyclQueue: The global queue after verification.
+
+    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: