scikit-learn-intelex 2025.4.0__py312-none-win_amd64.whl → 2025.6.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -18,6 +18,8 @@
 
 from collections.abc import Iterable
 
+import numpy as np
+
 from ._dpep_helpers import dpctl_available, dpnp_available
 
 if dpctl_available:
@@ -38,9 +40,19 @@ if dpnp_available:
         return array
 
 
+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__"):
+    if hasattr(data, "__array_namespace__") or _supports_buffer_protocol(data):
         return xp.asarray(data, *args, **kwargs)
     elif isinstance(data, Iterable):
         if isinstance(data, tuple):
@@ -78,4 +90,4 @@ def _get_sycl_namespace(*arrays):
         else:
             raise ValueError(f"SYCL type not recognized: {sua_iface}")
 
-    return sua_iface, None, False
+    return sua_iface, np, False

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/utils/_dpep_helpers.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
-""" Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
+"""Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
 See `Data Parallel Extensions for Python <https://github.com/IntelPython/DPEP>`__
 """
 
@@ -54,3 +54,18 @@ def is_dpnp_available(version=None):
 
 dpctl_available = is_dpctl_available()
 dpnp_available = is_dpnp_available()
+
+
+if dpnp_available:
+    import dpnp
+if dpctl_available:
+    import dpctl.tensor as dpt
+
+
+def get_unique_values_with_dpep(X):
+    if dpnp_available:
+        return dpnp.unique(X)
+    elif dpctl_available:
+        return dpt.unique_values(X)
+    else:
+        raise RuntimeError("No DPEP package available to provide `unique` function.")

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

@@ -0,0 +1,161 @@
+# ==============================================================================
+# 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 .._config import _get_config
+from ..utils._dpep_helpers import dpctl_available
+
+if dpctl_available:
+    from dpctl import SyclQueue
+else:
+    from onedal import _dpc_backend
+
+    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+
+# 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
+
+
+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):
+        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."""
+    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.")
+        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."""
+    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 from_data(*data):
+    """Extract the queue from provided data. This updates the global queue as well."""
+    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
+            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)
+            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:
+            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.
+    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.
+    """
+    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)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/utils/tests/test_validation.py

@@ -40,7 +40,7 @@ from onedal.utils.validation import assert_all_finite
 )
 @pytest.mark.parametrize("allow_nan", [False, True])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_sum_infinite_actually_finite(dtype, shape, allow_nan, dataframe, queue):
     X = np.empty(shape, dtype=dtype)
@@ -65,7 +65,7 @@ def test_sum_infinite_actually_finite(dtype, shape, allow_nan, dataframe, queue)
 @pytest.mark.parametrize("check", ["inf", "NaN", None])
 @pytest.mark.parametrize("seed", [0, 123456])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_assert_finite_random_location(
     dtype, shape, allow_nan, check, seed, dataframe, queue
@@ -92,7 +92,7 @@ def test_assert_finite_random_location(
 @pytest.mark.parametrize("check", ["inf", "NaN", None])
 @pytest.mark.parametrize("seed", [0, 123456])
 @pytest.mark.parametrize(
-    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl,array_api")
 )
 def test_assert_finite_random_shape_and_location(
     dtype, allow_nan, check, seed, dataframe, queue

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/utils/validation.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+import inspect
 import warnings
 from collections.abc import Sequence
 from numbers import Integral
@@ -21,6 +22,9 @@ from numbers import Integral
 import numpy as np
 from scipy import sparse as sp
 
+from onedal.common._backend import BackendFunction
+from onedal.utils import _sycl_queue_manager as QM
+
 if np.lib.NumpyVersion(np.__version__) >= np.lib.NumpyVersion("2.0.0a0"):
     # numpy_version >= 2.0
     from numpy.exceptions import VisibleDeprecationWarning
@@ -34,8 +38,7 @@ from sklearn.utils.validation import check_array
 from daal4py.sklearn.utils.validation import (
     _assert_all_finite as _daal4py_assert_all_finite,
 )
-from onedal import _backend
-from onedal.common._policy import _get_policy
+from onedal import _default_backend as backend
 from onedal.datatypes import to_table
 
 
@@ -127,6 +130,16 @@ def _validate_targets(y, class_weight, dtype):
     return np.asarray(y, dtype=dtype, order="C"), class_weight_res, classes
 
 
+def get_finite_keyword():
+    """Gets the argument name for scikit-learn's validation functions compatible with
+    the current version of scikit-learn and using function inspection instead of
+    version check due to `onedal` design rule: sklearn versioning should occur
+    in `sklearnex` module."""
+    if "ensure_all_finite" in inspect.signature(check_array).parameters:
+        return "ensure_all_finite"
+    return "force_all_finite"
+
+
 def _check_array(
     array,
     dtype="numeric",
@@ -136,6 +149,7 @@ def _check_array(
     force_all_finite=True,
     ensure_2d=True,
     accept_large_sparse=True,
+    _finite_keyword=get_finite_keyword(),
 ):
     if force_all_finite:
         if sp.issparse(array):
@@ -145,15 +159,19 @@ def _check_array(
         else:
             _daal4py_assert_all_finite(array)
             force_all_finite = False
+    check_kwargs = {
+        "array": array,
+        "dtype": dtype,
+        "accept_sparse": accept_sparse,
+        "order": order,
+        "copy": copy,
+        "ensure_2d": ensure_2d,
+        "accept_large_sparse": accept_large_sparse,
+    }
+    check_kwargs[_finite_keyword] = force_all_finite
+
     array = check_array(
-        array=array,
-        dtype=dtype,
-        accept_sparse=accept_sparse,
-        order=order,
-        copy=copy,
-        force_all_finite=force_all_finite,
-        ensure_2d=ensure_2d,
-        accept_large_sparse=accept_large_sparse,
+        **check_kwargs,
     )
 
     if sp.issparse(array):
@@ -437,18 +455,22 @@ def _is_csr(x):
 
 
 def _assert_all_finite(X, allow_nan=False, input_name=""):
-    policy = _get_policy(None, X)
+    backend_method = BackendFunction(
+        backend.finiteness_checker.compute.compute, backend, "compute", no_policy=False
+    )
     X_t = to_table(X)
     params = {
         "fptype": X_t.dtype,
         "method": "dense",
         "allow_nan": allow_nan,
     }
-    if not _backend.finiteness_checker.compute.compute(policy, params, X_t).finite:
-        type_err = "infinity" if allow_nan else "NaN, infinity"
-        padded_input_name = input_name + " " if input_name else ""
-        msg_err = f"Input {padded_input_name}contains {type_err}."
-        raise ValueError(msg_err)
+    with QM.manage_global_queue(None, X):
+        # Must use the queue provided by X
+        if not backend_method(params, X_t).finite:
+            type_err = "infinity" if allow_nan else "NaN, infinity"
+            padded_input_name = input_name + " " if input_name else ""
+            msg_err = f"Input {padded_input_name}contains {type_err}."
+            raise ValueError(msg_err)
 
 
 def assert_all_finite(
@@ -462,3 +484,12 @@ def assert_all_finite(
         allow_nan=allow_nan,
         input_name=input_name,
     )
+
+
+def is_contiguous(X):
+    if hasattr(X, "flags"):
+        return X.flags["C_CONTIGUOUS"] or X.flags["F_CONTIGUOUS"]
+    elif hasattr(X, "__dlpack__"):
+        return backend.dlpack_memory_order(X) is not None
+    else:
+        return False

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/__init__.py

@@ -52,12 +52,13 @@ __all__ = [
     "unpatch_sklearn",
     "utils",
 ]
+__version__ = "2199.9.9"
 onedal_iface_flag = os.environ.get("OFF_ONEDAL_IFACE", "0")
 if onedal_iface_flag == "0":
-    from onedal import _is_spmd_backend
+    from onedal import _spmd_backend
     from onedal.common.hyperparameters import get_hyperparameters
 
-    if _is_spmd_backend:
+    if _spmd_backend is not None:
         __all__.append("spmd")
 
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/__main__.py

@@ -25,9 +25,9 @@ def _main():
     parser = argparse.ArgumentParser(
         prog="python -m sklearnex",
         description="""
-            Run your Python script with Intel(R) Extension for
+            Run your Python script with Extension for
             scikit-learn, optimizing solvers of
-            scikit-learn with Intel(R) oneAPI Data Analytics Library.
+            scikit-learn with oneAPI Data Analytics Library.
             """,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/_config.py

@@ -26,10 +26,12 @@ from onedal._config import _get_config as onedal_get_config
 
 def get_config():
     """Retrieve current values for configuration set by :func:`set_config`
+
     Returns
     -------
     config : dict
         Keys are parameter names that can be passed to :func:`set_config`.
+
     See Also
     --------
     config_context : Context manager for global configuration.
@@ -44,28 +46,45 @@ def set_config(
     target_offload=None,
     allow_fallback_to_host=None,
     allow_sklearn_after_onedal=None,
+    use_raw_input=None,
     **sklearn_configs,
 ):
     """Set global configuration
+
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue, default=None
+    target_offload : string or dpctl.SyclQueue or None, default=None
         The device primarily used to perform computations.
         If string, expected to be "auto" (the execution context
         is deduced from input data location),
         or SYCL* filter selector string. Global default: "auto".
-    allow_fallback_to_host : bool, default=None
+
+    allow_fallback_to_host : bool or None, default=None
         If True, allows to fallback computation to host device
         in case particular estimator does not support the selected one.
         Global default: False.
-    allow_sklearn_after_onedal : bool, default=None
+
+    allow_sklearn_after_onedal : bool or None, default=None
         If True, allows to fallback computation to sklearn after onedal
         backend in case of runtime error on onedal backend computations.
         Global default: True.
+
+    use_raw_input : bool or None, default=None
+        .. deprecated:: 2026.0
+        If True, uses the raw input data in some SPMD onedal backend computations
+        without any checks on data consistency or validity.
+        Not recommended for general use.
+        Global default: False.
+
     See Also
     --------
     config_context : Context manager for global configuration.
     get_config : Retrieve current values of the global configuration.
+
+    Warnings
+    --------
+    Using ``use_raw_input=True`` is not recommended for general use as it
+    bypasses data consistency checks, which may lead to unexpected behavior.
     """
 
     array_api_dispatch = sklearn_configs.get("array_api_dispatch", False)
@@ -82,30 +101,53 @@ def set_config(
         local_config["allow_fallback_to_host"] = allow_fallback_to_host
     if allow_sklearn_after_onedal is not None:
         local_config["allow_sklearn_after_onedal"] = allow_sklearn_after_onedal
+    if use_raw_input is not None:
+        local_config["use_raw_input"] = use_raw_input
 
 
 @contextmanager
 def config_context(**new_config):
     """Context manager for global scikit-learn configuration
+
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue, default=None
+    target_offload : string or dpctl.SyclQueue or None, default=None
         The device primarily used to perform computations.
         If string, expected to be "auto" (the execution context
         is deduced from input data location),
         or SYCL* filter selector string. Global default: "auto".
-    allow_fallback_to_host : bool, default=None
+
+    allow_fallback_to_host : bool or None, default=None
         If True, allows to fallback computation to host device
         in case particular estimator does not support the selected one.
         Global default: False.
-    Notes
+
+    allow_sklearn_after_onedal : bool or None, default=None
+        If True, allows to fallback computation to sklearn after onedal
+        backend in case of runtime error on onedal backend computations.
+        Global default: True.
+
+    use_raw_input : bool or None, default=None
+        .. deprecated:: 2026.0
+        If True, uses the raw input data in some SPMD onedal backend computations
+        without any checks on data consistency or validity.
+        Not recommended for general use.
+        Global default: False.
+
+    Note
     -----
     All settings, not just those presently modified, will be returned to
     their previous values when the context manager is exited.
+
     See Also
     --------
     set_config : Set global scikit-learn configuration.
     get_config : Retrieve current values of the global configuration.
+
+    Warnings
+    --------
+    Using ``use_raw_input=True`` is not recommended for general use as it
+    bypasses data consistency checks, which may lead to unexpected behavior.
     """
     old_config = get_config()
     set_config(**new_config)