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

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/onedal/utils/_third_party.py

@@ -0,0 +1,220 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+"""Utilities for accessing third party packages such as DPNP, DPCtl.
+
+Notes
+-----
+See `Data Parallel Extensions for Python <https://github.com/IntelPython/DPEP>`__
+"""
+
+import functools
+import importlib
+import sys
+from typing import Callable
+
+from daal4py.sklearn._utils import _package_check_version
+
+
+@functools.lru_cache(maxsize=256, typed=False)
+def is_dpctl_available(version=None):
+    """Check availability of DPCtl package.
+
+    Parameters
+    ----------
+    version : str or None, default=None
+        Minimum supported dpctl version if installed.
+        Secondary version check skipped if set to None.
+
+    Returns
+    -------
+    dpctl_available : bool
+        Flag describing import success.
+    """
+    try:
+        import dpctl
+
+        dpctl_available = True
+    except ImportError:
+        dpctl_available = False
+    if dpctl_available and version is not None:
+        dpctl_available = _package_check_version(version, dpctl.__version__)
+    return dpctl_available
+
+
+# Note: The dpctl package contains both SYCL infrastructure as well as a
+# data framework (dpctl.tensor). dpctl.tensor is not imported when dpctl is
+# imported. All data frameworks are to be lazy-loaded, but aspects of dpctl
+# (e.g. SyclQueue) are loaded as normal as it is preferred over included
+# backend replacements in the core onedal python module.
+dpctl_available = is_dpctl_available()
+
+if dpctl_available:
+    from dpctl import SyclQueue
+else:
+    from onedal import _default_backend as backend
+
+    SyclQueue = backend.SyclQueue
+
+
+def lazy_import(*module_names: str) -> Callable:
+    """Lazy load python modules for use in a function.
+
+    Decorator which uses dependency injection with monkeypatching to import
+    python modules when called. This is done only once on first usage of
+    the wrapped function to minimize overhead and reduce branching.
+
+    Parameters
+    ----------
+    *module_names : strings
+        Arguments are names of modules to be imported via importlib.
+
+    Returns
+    -------
+    decorator : callable
+        Flag describing import success.
+
+    Notes
+    -----
+    The wrapped original function should have the modules as the first
+    arguments. This will be hidden to the user. Lazy imports cannot be
+    stacked, instead pass multiple arguments to the decorator.
+    """
+
+    # func should have leading arguments which are following a dependency
+    # injection paradigm
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        def wrapper(*first_args, **first_kwargs):
+            modules = tuple(importlib.import_module(i) for i in module_names)
+
+            # hide dependency injection of the original function
+            # onedal/sklearnex will call the underlying function
+            # via ``public_func``
+            def public_func(*args, **kwargs):
+                return func(*modules, *args, **kwargs)
+
+            # Monkeypatch the original in a general fashion (cannot use
+            # globals())
+            modname = func.__module__
+            funcname = func.__name__
+            setattr(sys.modules[modname], funcname, public_func)
+
+            return public_func(*first_args, **first_kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def convert_sklearnex_queue(func: Callable) -> Callable:
+    """Convert sklearnex pybind11-defined SyclQueue to a dpctl SyclQueue.
+
+    There are circumstances where the internal sklearnex pybind-11-defined
+    SyclQueue generation is required due to gaps in ``dpctl.SyclQueue``
+    initializer. This will change the return value of the function to a
+    ``dpctl.SyclQueue`` if dpctl is available, otherwise it will not wrap
+    the function whatsoever (the function will return an internal SyclQueue).
+
+    Parameters
+    ----------
+    func : callable
+        Function or method to be wrapped.
+
+    Returns
+    -------
+    wrapped : callable
+        Wrapped or original function depending on ``dpctl_available``.
+    """
+    if dpctl_available:
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return SyclQueue(func(*args, **kwargs)._get_capsule())
+
+        return wrapper
+
+    else:
+        return func
+
+
+@functools.lru_cache(100)
+def _is_subclass_fast(cls: type, modname: str, clsname: str) -> bool:
+    # Taken directly from array_api_compat.common._helpers to use for
+    # general use (not just array_api)
+    try:
+        mod = sys.modules[modname]
+    except KeyError:
+        return False
+    parent_cls = getattr(mod, clsname)
+    return issubclass(cls, parent_cls)
+
+
+def is_dpnp_ndarray(x: object) -> bool:
+    """Return True if 'x' is a dpnp ndarray.
+
+    This function does not import dpnp if it has not already been imported
+    and is therefore cheap to use.
+
+    Parameters
+    ----------
+    x : object
+        Any python object.
+
+    Returns
+    -------
+    is_dpnp : bool
+        Flag if subclass of dpnp.ndarray.
+    """
+    return _is_subclass_fast(type(x), "dpnp", "ndarray")
+
+
+def is_dpctl_tensor(x: object) -> bool:
+    """Return True if 'x' is a dpctl usm_ndarray.
+
+    This function does not import dpctl.tensor if it has not already been
+    imported and is therefore cheap to use.
+
+    Parameters
+    ----------
+    x : object
+        Any python object.
+
+    Returns
+    -------
+    is_dpctl : bool
+        Flag if subclass of dpctl.tensor.usm_ndarray.
+    """
+    return _is_subclass_fast(type(x), "dpctl.tensor", "usm_ndarray")
+
+
+def is_torch_tensor(x: object) -> bool:
+    """Return True if 'x' is a PyTorch Tensor.
+
+    This function does not import PyTorch if it has not already been imported
+    and is therefore cheap to use.
+
+    Parameters
+    ----------
+    x : object
+        Any python object.
+
+    Returns
+    -------
+    is_torch : bool
+        Flag if subclass of torch.Tensor.
+    """
+    return _is_subclass_fast(type(x), "torch", "Tensor")

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

@@ -93,7 +93,7 @@ def _compute_class_weight(class_weight, classes, y):
 
         le = LabelEncoder()
         y_ind = le.fit_transform(y_)
-        if not all(np.in1d(classes, le.classes_)):
+        if not np.isin(classes, le.classes_).all():
             raise ValueError("classes should have valid labels that are in y")
 
         y_bin = np.bincount(y_ind).astype(np.float64)
@@ -131,10 +131,18 @@ def _validate_targets(y, class_weight, dtype):
 
 
 def get_finite_keyword():
-    """Gets the argument name for scikit-learn's validation functions compatible with
+    """Return scikit-learn-matching finite check enabling 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."""
+    in ``sklearnex`` module.
+
+    Returns
+    -------
+    finite_keyword : str
+        Keyword string used to enable finiteness checking.
+    """
     if "ensure_all_finite" in inspect.signature(check_array).parameters:
         return "ensure_all_finite"
     return "force_all_finite"

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/__init__.py

@@ -46,6 +46,7 @@ __all__ = [
     "model_selection",
     "neighbors",
     "patch_sklearn",
+    "reset_hyperparameters",
     "set_config",
     "sklearn_is_patched",
     "svm",
@@ -56,7 +57,7 @@ __version__ = "2199.9.9"
 onedal_iface_flag = os.environ.get("OFF_ONEDAL_IFACE", "0")
 if onedal_iface_flag == "0":
     from onedal import _spmd_backend
-    from onedal.common.hyperparameters import get_hyperparameters
+    from onedal.common.hyperparameters import get_hyperparameters, reset_hyperparameters
 
     if _spmd_backend is not None:
         __all__.append("spmd")

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/_config.py

@@ -25,7 +25,7 @@ from onedal._config import _get_config as onedal_get_config
 
 
 def get_config():
-    """Retrieve current values for configuration set by :func:`set_config`
+    """Retrieve current values for configuration set by :func:`set_config`.
 
     Returns
     -------
@@ -49,11 +49,11 @@ def set_config(
     use_raw_input=None,
     **sklearn_configs,
 ):
-    """Set global configuration
+    """Set global configuration.
 
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue or None, default=None
+    target_offload : str or 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),
@@ -70,12 +70,17 @@ def set_config(
         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.
 
+        .. deprecated:: 2026.0
+
+    **sklearn_configs : kwargs
+        Scikit-learn configuration settings dependent on the installed version
+        of scikit-learn.
+
     See Also
     --------
     config_context : Context manager for global configuration.
@@ -85,6 +90,10 @@ def set_config(
     --------
     Using ``use_raw_input=True`` is not recommended for general use as it
     bypasses data consistency checks, which may lead to unexpected behavior.
+
+    Use of ``target_offload`` requires the DPC++ backend. Setting a
+    non-default value (e.g ``cpu`` or ``gpu``) without this backend active
+    will raise an error.
     """
 
     array_api_dispatch = sklearn_configs.get("array_api_dispatch", False)
@@ -106,12 +115,12 @@ def set_config(
 
 
 @contextmanager
-def config_context(**new_config):
-    """Context manager for global scikit-learn configuration
+def config_context(**new_config):  # numpydoc ignore=PR01,PR07
+    """Context manager for global scikit-learn configuration.
 
     Parameters
     ----------
-    target_offload : string or dpctl.SyclQueue or None, default=None
+    target_offload : str or 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),
@@ -134,7 +143,7 @@ def config_context(**new_config):
         Not recommended for general use.
         Global default: False.
 
-    Note
+    Notes
     -----
     All settings, not just those presently modified, will be returned to
     their previous values when the context manager is exited.

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -18,14 +18,11 @@ from collections.abc import Callable
 from functools import wraps
 from typing import Any, Union
 
-from onedal._device_offload import _copy_to_usm, _transfer_to_host
+from onedal._device_offload import _transfer_to_host
+from onedal.datatypes import copy_to_dpnp, copy_to_usm
 from onedal.utils import _sycl_queue_manager as QM
 from onedal.utils._array_api import _asarray, _is_numpy_namespace
-from onedal.utils._dpep_helpers import dpnp_available
-
-if dpnp_available:
-    import dpnp
-    from onedal.utils._array_api import _convert_to_dpnp
+from onedal.utils._third_party import is_dpnp_ndarray
 
 from ._config import config_context, get_config, set_config
 from ._utils import PatchingConditionsChain, get_tags
@@ -52,14 +49,16 @@ def _get_backend(
 
     if gpu_device:
         patching_status = obj._onedal_gpu_supported(method_name, *data)
-        if (
-            not patching_status.get_status()
-            and (config := get_config())["allow_fallback_to_host"]
-        ):
+        if not patching_status.get_status() and get_config()["allow_fallback_to_host"]:
             QM.fallback_to_host()
             return None, patching_status
         return patching_status.get_status(), patching_status
 
+    if get_config()["allow_fallback_to_host"]:
+        # This may trigger if the ``onedal.utils._sycl_queue_manager.__non_queue``
+        # object is the queue (e.g. if non-SYCL device data is encountered)
+        QM.fallback_to_host()
+        return None, None
     raise RuntimeError("Device support is not implemented for the supplied data type.")
 
 
@@ -77,6 +76,7 @@ def dispatch(
     **kwargs,
 ) -> Any:
     """Dispatch object method call to oneDAL if conditionally possible.
+
     Depending on support conditions, oneDAL will be called, otherwise it will
     fall back to calling scikit-learn.  Dispatching to oneDAL can be influenced
     by the 'use_raw_input' or 'allow_fallback_to_host' config parameters.
@@ -84,25 +84,25 @@ def dispatch(
     Parameters
     ----------
     obj : object
-        sklearnex object which inherits from oneDALEstimator and contains
+        Sklearnex object which inherits from oneDALEstimator and contains
         ``onedal_cpu_supported`` and ``onedal_gpu_supported`` methods which
         evaluate oneDAL support.
 
-    method_name : string
-        name of method to be evaluated for oneDAL support
+    method_name : str
+        Name of method to be evaluated for oneDAL support.
 
     branches : dict
-        dictionary containing functions to be called. Only keys 'sklearn' and
+        Dictionary containing functions to be called. Only keys 'sklearn' and
         'onedal' are used which should contain the relevant scikit-learn and
         onedal object methods respectively. All functions should accept the
         inputs from *args and **kwargs. Additionally, the onedal object method
         must accept a 'queue' keyword.
 
     *args : tuple
-        arguments to be supplied to the dispatched method
+        Arguments to be supplied to the dispatched method.
 
     **kwargs : dict
-        keyword arguments to be supplied to the dispatched method
+        Keyword arguments to be supplied to the dispatched method.
 
     Returns
     -------
@@ -121,12 +121,9 @@ def dispatch(
     # backend can only be a boolean or None, None signifies an unverified backend
     backend: "bool | None" = None
 
-    # config context needs to be saved, as the sycl_queue_manager interacts with
-    # target_offload, which can regenerate a GPU queue later on. Therefore if a
-    # fallback occurs, then the state of target_offload must be set to default
-    # so that later use of get_global_queue only sends to host. We must modify
-    # the target offload settings, but we must also set the original value at the
-    # end, hence the need of a contextmanager.
+    # The _sycl_queue_manager verifies all arguments are on a single SYCL device or
+    # cpu and will otherwise throw an error. If located on a non-SYCL, non-CPU
+    # device, a special queue is set which will cause a failure in ``_get_backend``
     with QM.manage_global_queue(None, *args):
         if onedal_array_api:
             backend, patching_status = _get_backend(obj, method_name, *args)
@@ -139,7 +136,7 @@ def dispatch(
                 return branches["sklearn"](obj, *args, **kwargs)
 
         # move data to host because of multiple reasons: array_api fallback to host,
-        # non array_api supporing oneDAL code, issues with usm support in sklearn.
+        # non array_api supporting oneDAL code, issues with usm support in sklearn.
         has_usm_data_for_args, hostargs = _transfer_to_host(*args)
         has_usm_data_for_kwargs, hostvalues = _transfer_to_host(*kwargs.values())
 
@@ -164,28 +161,42 @@ def dispatch(
 
 
 def wrap_output_data(func: Callable) -> Callable:
-    """
+    """Transform function output to match input format.
+
     Converts and moves the output arrays of the decorated function
     to match the input array type and device.
+
+    Parameters
+    ----------
+    func : callable
+       Function or method which has array data as input.
+
+    Returns
+    -------
+    wrapper : callable
+        Wrapped function or method which will return matching format.
     """
 
     @wraps(func)
     def wrapper(self, *args, **kwargs) -> Any:
         result = func(self, *args, **kwargs)
         if not (len(args) == 0 and len(kwargs) == 0):
-            data = (*args, *kwargs.values())
-
-            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
-            if usm_iface is not None:
-                result = _copy_to_usm(usm_iface["syclobj"], result)
-                if dpnp_available and isinstance(data[0], dpnp.ndarray):
-                    result = _convert_to_dpnp(result)
-                return result
+            data = (*args, *kwargs.values())[0]
+            # Remove check for result __sycl_usm_array_interface__ on deprecation of use_raw_inputs
+            if (
+                usm_iface := getattr(data, "__sycl_usm_array_interface__", None)
+            ) and not hasattr(result, "__sycl_usm_array_interface__"):
+                queue = usm_iface["syclobj"]
+                return (
+                    copy_to_dpnp(queue, result)
+                    if is_dpnp_ndarray(data)
+                    else copy_to_usm(queue, result)
+                )
 
             if get_config().get("transform_output") in ("default", None):
-                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+                input_array_api = getattr(data, "__array_namespace__", lambda: None)()
                 if input_array_api and not _is_numpy_namespace(input_array_api):
-                    input_array_api_device = data[0].device
+                    input_array_api_device = data.device
                     result = _asarray(
                         result, input_array_api, device=input_array_api_device
                     )

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -27,6 +27,12 @@ from daal4py.sklearn._utils import (
     PatchingConditionsChain as daal4py_PatchingConditionsChain,
 )
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.common.hyperparameters import (
+    get_hyperparameters as onedal_get_hyperparameters,
+)
+from onedal.common.hyperparameters import (
+    reset_hyperparameters as onedal_reset_hyperparameters,
+)
 
 # Not an ideal solution, but this allows for access to the outputs of older
 # sklearnex tag dictionaries in a way similar to the sklearn >=1.6 tag
@@ -120,11 +126,36 @@ def get_sklearnex_version(rule):
 
 def register_hyperparameters(hyperparameters_map):
     """Decorator for hyperparameters support in estimator class.
-    Adds `get_hyperparameters` method to class.
+
+    Adds `get_hyperparameters` and `reset_hyperparameters` methods to class.
+
+    Parameters
+    ----------
+    hyperparameters_map : Dict[str, Tuple[str, str]]
+       Dictionary containing the mapping of the operator name in the sklearnex API
+       to the tuple (algorithm name, operation name) that contains the arguments to
+       onedal.common.hyperparameters.get_hyperparameters and
+       onedal.common.hyperparameters.reset_hyperparameters functions.
+
+    Returns
+    -------
+    decorator : function
+        Function which adds `get_hyperparameters` method to classes.
     """
 
     def decorator(cls):
-        """Add `get_hyperparameters()` static method"""
+        """Add ``get_hyperparameters()` static method to a class.
+
+        Parameters
+        ----------
+        cls : class
+            Class to be modified.
+
+        Returns
+        -------
+        cls : class
+            Class with added `get_hyperparameters` method.
+        """
 
         class StaticHyperparametersAccessor:
             """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
@@ -137,9 +168,27 @@ def register_hyperparameters(hyperparameters_map):
                 return self.get_hyperparameters
 
             def get_hyperparameters(self, op):
-                return hyperparameters_map[op]
+                return onedal_get_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
+
+        class StaticHyperparametersResetter:
+            """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
+
+            def __get__(self, instance, _):
+                if instance is not None:
+                    warnings.warn(
+                        "Hyperparameters are static variables and can not be modified per instance."
+                    )
+                return self.reset_hyperparameters
+
+            def reset_hyperparameters(self, op):
+                return onedal_reset_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
 
         cls.get_hyperparameters = StaticHyperparametersAccessor()
+        cls.reset_hyperparameters = StaticHyperparametersResetter()
         return cls
 
     return decorator

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/base.py

@@ -88,7 +88,7 @@ class oneDALEstimator:
             }
 
         def _get_doc_link(self) -> str:
-            # This method is meant to generate a clickable doc link for classses
+            # This method is meant to generate a clickable doc link for classes
             # in sklearnex including those that are not part of base scikit-learn.
             # It should be inherited before inheriting from a scikit-learn estimator.