scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.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.10.0.data/data/Lib/site-packages/onedal/utils/tests/test_validation.py

@@ -0,0 +1,142 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import numpy as np
+import numpy.random as rand
+import pytest
+import scipy.sparse as sp
+
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from onedal.utils.validation import assert_all_finite
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [65539],  # 2**16 + 3,
+        [1000, 1000],
+        [
+            3,
+        ],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize(
+    "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)
+    X.fill(np.finfo(dtype).max)
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [65539],  # 2**16 + 3,
+        [1000, 1000],
+        [
+            3,
+        ],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+@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,array_api")
+)
+def test_assert_finite_random_location(
+    dtype, shape, allow_nan, check, seed, dataframe, queue
+):
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=shape).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X.reshape((-1,))[loc] = float(check)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("allow_nan", [False, True])
+@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,array_api")
+)
+def test_assert_finite_random_shape_and_location(
+    dtype, allow_nan, check, seed, dataframe, queue
+):
+    lb, ub = 2, 1048576  # ub is 2^20
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=rand.randint(lb, ub)).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X[loc] = float(check)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, 123456])
+def test_assert_finite_sparse(dtype, allow_nan, check, seed):
+    lb, ub = 2, 2056
+    rand.seed(seed)
+    X = sp.random(
+        rand.randint(lb, ub),
+        rand.randint(lb, ub),
+        format="csr",
+        dtype=dtype,
+        random_state=rand.default_rng(seed),
+    )
+
+    if check:
+        locx = rand.randint(0, X.data.shape[0] - 1)
+        X.data[locx] = float(check)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)