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

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

@@ -0,0 +1,170 @@
+# ==============================================================================
+# 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
+
+
+@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 dpnp 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")

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.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.7.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.7.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
@@ -77,6 +74,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 +82,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
     -------
@@ -139,7 +137,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 +162,40 @@ 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())
+            data = (*args, *kwargs.values())[0]
 
-            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
+            if usm_iface := getattr(data, "__sycl_usm_array_interface__", None):
+                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.7.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -120,11 +120,33 @@ def get_sklearnex_version(rule):
 
 def register_hyperparameters(hyperparameters_map):
     """Decorator for hyperparameters support in estimator class.
+
     Adds `get_hyperparameters` method to class.
+
+    Parameters
+    ----------
+    hyperparameters_map : dict
+       Dictionary containing the operator-hyperparameter mapping.
+
+    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."""

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.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.
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -40,11 +40,12 @@ if sklearn_check_version("1.2"):
 class BasicStatistics(oneDALEstimator, BaseEstimator):
     """
     Estimator for basic statistics.
-    Allows to compute basic statistics for provided data.
+
+    Compute low order moments and related statistics for given data.
 
     Parameters
     ----------
-    result_options: string or list, default='all'
+    result_options : str or list, default=str('all')
         Used to set statistics to calculate. Possible values are ``'min'``, ``'max'``, ``'sum'``, ``'mean'``, ``'variance'``,
         ``'variation'``, ``sum_squares'``, ``sum_squares_centered'``, ``'standard_deviation'``, ``'second_order_raw_moment'``
         or a list containing any of these values. If set to ``'all'`` then all possible statistics will be
@@ -73,17 +74,13 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         second_order_raw_moment_ : ndarray of shape (n_features,)
             Second order moment of each feature over all samples.
 
-    Note
-    ----
+    Notes
+    -----
     Attribute exists only if corresponding result option has been provided.
 
-    Note
-    ----
     Names of attributes without the trailing underscore are
     supported currently but deprecated in 2025.1 and will be removed in 2026.0
 
-    Note
-    ----
     Some results can exhibit small variations due to
     floating point error accumulation and multithreading.
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -41,14 +41,17 @@ import warnings
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
 class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     """
-    Calculates basic statistics on the given data, allows for computation when the data are split into
-    batches. The user can use ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
-    the entire dataset.
+    Incremental estimator for basic statistics.
+
+    Calculates basic statistics on the given data, allows for computation
+    when the data are split into batches. The user can use ``partial_fit``
+    method to provide a single batch of data or use the ``fit`` method to
+    provide the entire dataset.
 
     Parameters
     ----------
-    result_options: string or list, default='all'
-        List of statistics to compute
+    result_options : str or list, default=str('all')
+        List of statistics to compute.
 
     batch_size : int, default=None
         The number of samples to use for each batch. Only used when calling
@@ -88,8 +91,9 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
             Second order moment of each feature over all samples.
 
         n_samples_seen_ : int
-            The number of samples processed by the estimator. Will be reset on
-            new calls to ``fit``, but increments across ``partial_fit`` calls.
+            The number of samples processed by the estimator. Will be reset
+            on new calls to ``fit``, but increments across ``partial_fit``
+            calls.
 
         batch_size_ : int
             Inferred batch size from ``batch_size``.
@@ -97,14 +101,14 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         n_features_in_ : int
             Number of features seen during ``fit`` or  ``partial_fit``.
 
-    Note
-    ----
+    Notes
+    -----
     Attribute exists only if corresponding result option has been provided.
 
-    Note
-    ----
-    Names of attributes without the trailing underscore are
-    supported currently but deprecated in 2025.1 and will be removed in 2026.0
+    Names of attributes without the trailing underscore are supported
+    currently but deprecated in 2025.1 and will be removed in 2026.0.
+
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
 
     %incremental_serialization_note%
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -52,9 +52,12 @@ if sklearn_check_version("1.2"):
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
 class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     """
-    Maximum likelihood covariance estimator that allows for the estimation when the data are split into
-    batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
-    the entire dataset.
+    Incremental maximum likelihood covariance estimator.
+
+    Estimator that allows for the estimation when the data are split into
+    batches. The user can use the ``partial_fit`` method to provide a
+    single batch of data or use the ``fit`` method to provide the entire
+    dataset.
 
     Parameters
     ----------
@@ -70,8 +73,8 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     batch_size : int, default=None
         The number of samples to use for each batch. Only used when calling
         ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
-        is inferred from the data and set to ``5 * n_features``, to provide a
-        balance between approximation accuracy and memory consumption.
+        is inferred from the data and set to ``5 * n_features``, to provide
+        a balance between approximation accuracy and memory consumption.
 
     copy : bool, default=True
         If False, X will be overwritten. ``copy=False`` can be used to
@@ -95,6 +98,10 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
 
     Examples

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -31,7 +31,7 @@ if daal_check_version((2024, "P", 100)):
     from daal4py.sklearn._utils import sklearn_check_version
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchingConditionsChain
+    from .._utils import PatchingConditionsChain, register_hyperparameters
     from ..base import oneDALEstimator
     from ..utils._array_api import get_namespace
     from ..utils.validation import validate_data
@@ -44,8 +44,11 @@ if daal_check_version((2024, "P", 100)):
 
     from sklearn.decomposition import PCA as _sklearn_PCA
 
+    from onedal.common.hyperparameters import get_hyperparameters
     from onedal.decomposition import PCA as onedal_PCA
+    from onedal.utils._array_api import _is_numpy_namespace
 
+    @register_hyperparameters({"fit": get_hyperparameters("pca", "train")})
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
     class PCA(oneDALEstimator, _sklearn_PCA):
         __doc__ = _sklearn_PCA.__doc__
@@ -212,9 +215,17 @@ if daal_check_version((2024, "P", 100)):
                 # Scikit-learn PCA["covariance_eigh"] was fit
                 return self._transform(X_fit, xp, x_is_centered=x_is_centered)
 
-        @wrap_output_data
         def inverse_transform(self, X):
-            xp, _ = get_namespace(X)
+            # sklearn does not properly input check inverse_transform using
+            # ``validate_data`` (as of sklearn 1.7). Yielding the namespace
+            # in this way will conform to sklearn and various inputs without
+            # causing issues with dimensionality checks, array api support,
+            # etc. evaluated in ``validate_data``. This is a special solution.
+            xp = (
+                func()
+                if (func := getattr(X, "__array_namespace__", None))
+                else get_namespace(X)[0]
+            )
 
             mean = self.mean_
             if self.whiten:
@@ -224,12 +235,8 @@ if daal_check_version((2024, "P", 100)):
             else:
                 components = self.components_
 
-            if "numpy" not in xp.__name__:
-                # DPCtl and dpnp require inputs to be on the same device for
-                # matrix multiplication and division. The type and location
-                # of the components and mean are dependent on the sklearn
-                # version, this makes sure it is of the same type and on the
-                # same device as the data (compute follows data).
+            if not _is_numpy_namespace(xp):
+                # Force matching type to input data if possible
                 components = xp.asarray(components, device=X.device)
                 mean = xp.asarray(mean, device=X.device)