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

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

@@ -0,0 +1,217 @@
+# ==============================================================================
+# 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."""
+
+import math
+from collections.abc import Callable
+from typing import Union
+
+import numpy as np
+import scipy.linalg as linalg
+from sklearn.covariance import log_likelihood as _sklearn_log_likelihood
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.utils._array_api import _get_sycl_namespace, _is_numpy_namespace
+
+from ..base import oneDALEstimator
+
+if sklearn_check_version("1.6"):
+    from ..base import Tags
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._array_api import get_namespace as sklearn_get_namespace
+
+
+def get_namespace(*arrays):
+    """Get namespace of arrays.
+
+    Introspect `arrays` arguments and return their common Array API
+    compatible namespace object, if any. NumPy 1.22 and later can
+    construct such containers using the `numpy.array_api` namespace
+    for instance.
+
+    This function will return the namespace of SYCL-related arrays
+    which define the __sycl_usm_array_interface__ attribute
+    regardless of array_api support, the configuration of
+    array_api_dispatch, or scikit-learn version.
+
+    See: https://numpy.org/neps/nep-0047-array-api-standard.html
+
+    If `arrays` are regular numpy arrays, an instance of the
+    `_NumPyApiWrapper` compatibility wrapper is returned instead.
+
+    Namespace support is not enabled by default. To enabled it
+    call:
+
+      sklearn.set_config(array_api_dispatch=True)
+
+    or:
+
+      with sklearn.config_context(array_api_dispatch=True):
+          # your code here
+
+    Otherwise an instance of the `_NumPyApiWrapper`
+    compatibility wrapper is always returned irrespective of
+    the fact that arrays implement the `__array_namespace__`
+    protocol or not.
+
+    Parameters
+    ----------
+    *arrays : array objects
+        Array objects.
+
+    Returns
+    -------
+    namespace : module
+        Namespace shared by array objects.
+
+    is_array_api : bool
+        True of the arrays are containers that implement the Array API spec.
+    """
+
+    sycl_type, xp, is_array_api_compliant = _get_sycl_namespace(*arrays)
+
+    if sycl_type:
+        return xp, is_array_api_compliant
+    elif sklearn_check_version("1.2"):
+        return sklearn_get_namespace(*arrays)
+    else:
+        return np, False
+
+
+def _enable_array_api(original_class: type[oneDALEstimator]) -> type[oneDALEstimator]:
+    if sklearn_check_version("1.6"):
+
+        def __sklearn_tags__(self) -> Tags:
+            sktags = super(original_class, self).__sklearn_tags__()
+            sktags.onedal_array_api = True
+            return sktags
+
+        original_class.__sklearn_tags__ = __sklearn_tags__
+
+    elif sklearn_check_version("1.3"):
+
+        def _more_tags(self) -> dict[str, bool]:
+            return {"onedal_array_api": True}
+
+        original_class._more_tags = _more_tags
+
+    return original_class
+
+
+def enable_array_api(
+    class_or_str: Union[type[oneDALEstimator], str],
+) -> Union[type[oneDALEstimator], Callable]:
+    """Enable sklearnex to use dpctl, dpnp or array API inputs in oneDAL offloading.
+
+    This wrapper sets the proper flags/tags for the sklearnex infrastructure
+    to maintain the data framework, as the estimator can use it natively.
+
+    Parameters
+    ----------
+    class_or_str : oneDALEstimator subclass or str
+        Class which should enable data zero-copy support in sklearnex. By
+        default it will enable for sklearn versions >1.3. If the wrapper is
+        decorated with an argument, it must be a string defining the oldest
+        sklearn version where array API support begins.
+
+    Returns
+    -------
+    cls or wrapper : modified oneDALEstimator subclass or wrapper
+        Estimator class or wrapper.
+
+    Examples
+    --------
+    @enable_array_api  # default array API support
+    class PCA():
+        ...
+
+    @enable_array_api("1.5")  # array API support for sklearn > 1.5
+    class Ridge():
+        ...
+    """
+    if isinstance(class_or_str, str):
+        # enable array_api for the estimator for a given sklearn version str
+        if sklearn_check_version(class_or_str):
+            return _enable_array_api
+        else:
+            # do not apply the wrapper as it is not supported
+            return lambda x: x
+    else:
+        # default setting (apply array_api enablement for sklearn >=1.3)
+        return _enable_array_api(class_or_str)
+
+
+def _pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, check_finite=True):
+    # array API enabled pinvh implementation, via direct translation of scipy.linalg.pinhv
+    # this should be considered a temporary stopgap until implemented in oneDAL
+    xp, _ = get_namespace(a)
+    # fall back to scipy if the namespace is of a numpy origin
+    if _is_numpy_namespace(xp):
+        return linalg.pinvh(
+            a,
+            atol=atol,
+            rtol=rtol,
+            lower=lower,
+            return_rank=return_rank,
+            check_finite=check_finite,
+        )
+
+    if check_finite:
+        raise NotImplementedError("finite checking does not occur in sklearnex's pinvh")
+
+    s, u = xp.linalg.eigh(a)
+    maxS = xp.max(xp.abs(s))
+
+    atol = 0.0 if atol is None else atol
+    rtol = max(a.shape) * xp.finfo(u.dtype).eps if (rtol is None) else rtol
+
+    if (atol < 0.0) or (rtol < 0.0):
+        raise ValueError("atol and rtol values must be positive.")
+
+    val = atol + maxS * rtol
+    above_cutoff = xp.nonzero(abs(s) > val)[0]
+
+    psigma_diag = 1.0 / xp.take(s, above_cutoff)
+    u = xp.take(u, above_cutoff, axis=1)
+
+    uconj = xp.conj(u) if xp.isdtype(u.dtype, kind="complex floating") else u
+
+    B = (u * psigma_diag) @ uconj.T
+
+    if return_rank:
+        return B, len(psigma_diag)
+    else:
+        return B
+
+
+def log_likelihood(emp_cov, precision):
+    # this is to compensate for a lack of array API support in sklearn
+    # even though it exists for ``fast_logdet``
+    xp, _ = get_namespace(emp_cov, precision)
+    p = precision.shape[0]
+    # extract sklearn.utils.extmath.fast_logdet for dpnp/dpctl support
+    sign, ld = xp.linalg.slogdet(precision)
+    if not sign > 0:
+        ld = -xp.inf
+    log_likelihood_ = -xp.sum(emp_cov * precision) + ld
+    log_likelihood_ -= p * math.log(2 * math.pi)
+    log_likelihood_ /= 2.0
+    return log_likelihood_
+
+
+log_likelihood.__doc__ = _sklearn_log_likelihood.__doc__

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/utils/class_weight.py

@@ -0,0 +1,100 @@
+# ==============================================================================
+# Copyright contributors to the oneDAL Project
+#
+# 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 sklearn.preprocessing import LabelEncoder as _sklearn_LabelEncoder
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+from ._array_api import get_namespace
+from .validation import _check_sample_weight
+
+if not sklearn_check_version("1.7"):
+    from sklearn.utils.class_weight import (
+        compute_class_weight as _sklearn_compute_class_weight,
+    )
+
+    def compute_class_weight(class_weight, *, classes, y, sample_weight=None):
+        return _sklearn_compute_class_weight(class_weight, classes=classes, y=y)
+
+else:
+    from sklearn.utils.class_weight import compute_class_weight
+
+
+def _compute_class_weight(class_weight, *, classes, y, sample_weight=None):
+    # this duplicates sklearn code in order to enable it for array API.
+    # Note for the use of LabelEncoder this is only valid for sklearn
+    # versions >= 1.6.
+    xp, is_array_api_compliant = get_namespace(classes, y, sample_weight)
+
+    if not is_array_api_compliant:
+        # use the sklearn version for standard use.
+        return compute_class_weight(class_weight, classes, y, sample_weight=sample_weight)
+
+    sety = xp.unique_values(y)
+    if class_weight is None or len(class_weight) == 0:
+        # uniform class weights
+        weight = xp.ones((classes.shape[0],), dtype=xp.float64, device=classes.device)
+    elif class_weight == "balanced":
+        if not sklearn_check_version("1.6"):
+            raise RuntimeError(
+                "array API support with 'balanced' keyword not supported for sklearn <1.6"
+            )
+        # Find the weight of each class as present in y.
+        le = _sklearn_LabelEncoder()
+        y_ind = le.fit_transform(y)
+        if not all([item in le.classes_ for item in classes]):
+            raise ValueError("classes should have valid labels that are in y")
+
+        sample_weight = _check_sample_weight(sample_weight, y)
+        # scikit-learn implementation uses numpy.bincount, which does a combined
+        # min and max search, only erroring when a value < 0. Replicating this
+        # exactly via array API would cause another O(n) evaluation (by doing
+        # min and max separately). However this check can be removed due to the
+        # nature of the LabelEncoder. Therefore only the maximum is found, and
+        # then core logic of bincount is replicated:
+        # https://github.com/numpy/numpy/blob/main/numpy/_core/src/multiarray/compiled_base.c
+        weighted_class_counts = xp.zeros(
+            (xp.max(y_ind) + 1,), dtype=sample_weight.dtype, device=y.device
+        )
+
+        # use a more GPU-friendly summation approach for collecting weighted_class_counts
+        for w_idx in range(weighted_class_counts.shape[0]):
+            weighted_class_counts[w_idx] = xp.sum(sample_weight[y_ind == w_idx])
+
+        recip_freq = xp.sum(weighted_class_counts) / (
+            le.classes_.shape[0] * weighted_class_counts
+        )
+
+        weight = xp.take(recip_freq, le.transform(classes))
+    else:
+        # user-defined dictionary
+        weight = xp.ones((classes.shape[0],), dtype=xp.float64, device=classes.device)
+        unweighted_classes = []
+        for i, c in enumerate(classes):
+            if (fc := float(c)) in class_weight:
+                # array API has only numeric datatypes, convert to float for generality
+                # complex values should never be observed by this function
+                weight[i] = class_weight[fc]
+            else:
+                unweighted_classes.append(c)
+
+        n_weighted_classes = classes.shape[0] - len(unweighted_classes)
+        if unweighted_classes and n_weighted_classes != len(class_weight):
+            raise ValueError(
+                f"The classes, {unweighted_classes}, are not in" " class_weight"
+            )
+
+    return weight

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/utils/parallel.py

@@ -0,0 +1,97 @@
+# ===============================================================================
+# 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 warnings
+from functools import update_wrapper
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+from .._config import config_context, get_config
+
+# Replacement of _FuncWrapper is required to correctly propagate
+# the scikit-learn-intelex configuration functions to the joblib workers.
+if sklearn_check_version("1.7"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config_and_warning_filters(self, config, warning_filters):
+            self.config = config
+            self.warning_filters = warning_filters
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", {})
+            warning_filters = getattr(self, "warning_filters", [])
+            if not config or not warning_filters:
+                warnings.warn(
+                    (
+                        "`sklearn.utils.parallel.delayed` should be used with"
+                        " `sklearn.utils.parallel.Parallel` to make it possible to"
+                        " propagate the scikit-learn configuration of the current thread to"
+                        " the joblib workers."
+                    ),
+                    UserWarning,
+                )
+
+            with config_context(**config), warnings.catch_warnings():
+                warnings.filters = warning_filters
+                return self.function(*args, **kwargs)
+
+elif sklearn_check_version("1.2.1"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config(self, config):
+            self.config = config
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", None)
+            if config is None:
+                warnings.warn(
+                    "`sklearn.utils.parallel.delayed` should be used with "
+                    "`sklearn.utils.parallel.Parallel` to make it possible to propagate "
+                    "the scikit-learn configuration of the current thread to the "
+                    "joblib workers.",
+                    UserWarning,
+                )
+                config = {}
+            with config_context(**config):
+                return self.function(*args, **kwargs)
+
+else:
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            self.config = get_config()
+            update_wrapper(self, self.function)
+
+        def __call__(self, *args, **kwargs):
+            with config_context(**self.config):
+                return self.function(*args, **kwargs)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/utils/tests/test_class_weight.py

@@ -0,0 +1,69 @@
+# ==============================================================================
+# Copyright contributors to the oneDAL Project
+#
+# 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 numpy as np
+import pytest
+from sklearn.datasets import load_iris
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex import config_context
+from sklearnex.utils.class_weight import _compute_class_weight
+from sklearnex.utils.class_weight import compute_class_weight as sk_compute_class_weight
+
+
+@pytest.mark.skipif(not sklearn_check_version("1.6"), reason="lacks array API support")
+@pytest.mark.parametrize("class_weight", [None, "balanced", "ramp"])
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("array_api,dpctl"))
+def test_compute_class_weight_array_api(class_weight, dataframe, queue):
+    # This verifies that array_api functionality matches sklearn
+
+    _, y = load_iris(return_X_y=True)
+    classes = np.unique(y)
+
+    y_xp = _convert_to_dataframe(y, target_df=dataframe, device=queue)
+    classes_xp = _convert_to_dataframe(classes, target_df=dataframe, device=queue)
+
+    rng = np.random.default_rng(seed=42)
+
+    # support of sample_weights added in sklearn 1.7
+    set_sample_weight = class_weight == "balanced" and sklearn_check_version("1.7")
+
+    sample_weight = rng.random(y.shape).astype(np.float64) if set_sample_weight else None
+
+    if class_weight == "ramp":
+        class_weight = {int(i): int(i) for i in np.unique(y)}
+
+    weight_np = sk_compute_class_weight(
+        class_weight, classes=classes, y=y, sample_weight=sample_weight
+    )
+
+    if set_sample_weight:
+        sample_weight = _convert_to_dataframe(
+            sample_weight, target_df=dataframe, device=queue
+        )
+
+    # evaluate custom sklearnex array API functionality
+    with config_context(array_api_dispatch=True):
+        weight_xp = _compute_class_weight(
+            class_weight, classes=classes_xp, y=y_xp, sample_weight=sample_weight
+        )
+
+    np.testing.assert_allclose(_as_numpy(weight_xp), weight_np)