scikit-learn-intelex 2025.0.1__py312-none-win_amd64.whl → 2025.2.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.2.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")
+)
+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")
+)
+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")
+)
+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)

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/utils/validation.py

@@ -31,7 +31,12 @@ else:
 from sklearn.preprocessing import LabelEncoder
 from sklearn.utils.validation import check_array
 
-from daal4py.sklearn.utils.validation import _assert_all_finite
+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.datatypes import to_table
 
 
 class DataConversionWarning(UserWarning):
@@ -135,10 +140,10 @@ def _check_array(
     if force_all_finite:
         if sp.issparse(array):
             if hasattr(array, "data"):
-                _assert_all_finite(array.data)
+                _daal4py_assert_all_finite(array.data)
                 force_all_finite = False
         else:
-            _assert_all_finite(array)
+            _daal4py_assert_all_finite(array)
             force_all_finite = False
     array = check_array(
         array=array,
@@ -153,15 +158,6 @@ def _check_array(
 
     if sp.issparse(array):
         return array
-
-    # TODO: Convert this kind of arrays to a table like in daal4py
-    if not array.flags.aligned and not array.flags.writeable:
-        array = np.array(array.tolist())
-
-    # TODO: If data is not contiguous copy to contiguous
-    # Need implemeted numpy table in oneDAL
-    if not array.flags.c_contiguous and not array.flags.f_contiguous:
-        array = np.ascontiguousarray(array, array.dtype)
     return array
 
 
@@ -200,7 +196,7 @@ def _check_X_y(
     if y_numeric and y.dtype.kind == "O":
         y = y.astype(np.float64)
     if force_all_finite:
-        _assert_all_finite(y)
+        _daal4py_assert_all_finite(y)
 
     lengths = [X.shape[0], y.shape[0]]
     uniques = np.unique(lengths)
@@ -285,7 +281,7 @@ def _type_of_target(y):
     # check float and contains non-integer float values
     if y.dtype.kind == "f" and np.any(y != y.astype(int)):
         # [.1, .2, 3] or [[.1, .2, 3]] or [[1., .2]] and not [1., 2., 3.]
-        _assert_all_finite(y)
+        _daal4py_assert_all_finite(y)
         return "continuous" + suffix
 
     if (len(np.unique(y)) > 2) or (y.ndim >= 2 and len(y[0]) > 1):
@@ -358,6 +354,8 @@ def _check_n_features(self, X, reset):
 
 
 def _num_features(X, fallback_1d=False):
+    if X is None:
+        raise ValueError("Expected array-like (array or non-string sequence), got None")
     type_ = type(X)
     if type_.__module__ == "builtins":
         type_name = type_.__qualname__
@@ -366,7 +364,7 @@ def _num_features(X, fallback_1d=False):
     message = "Unable to find the number of features from X of type " f"{type_name}"
     if not hasattr(X, "__len__") and not hasattr(X, "shape"):
         if not hasattr(X, "__array__"):
-            raise TypeError(message)
+            raise ValueError(message)
         # Only convert X to a numpy array if there is no cheaper, heuristic
         # option.
         X = np.asarray(X)
@@ -375,15 +373,21 @@ def _num_features(X, fallback_1d=False):
         ndim_thr = 1 if fallback_1d else 2
         if not hasattr(X.shape, "__len__") or len(X.shape) < ndim_thr:
             message += f" with shape {X.shape}"
-            raise TypeError(message)
-        return X.shape[-1]
+            raise ValueError(message)
+        if len(X.shape) <= 1:
+            return 1
+        else:
+            return X.shape[-1]
 
-    first_sample = X[0]
+    try:
+        first_sample = X[0]
+    except IndexError:
+        raise ValueError("Passed empty data.")
 
     # Do not consider an array-like of strings or dicts to be a 2D array
     if isinstance(first_sample, (str, bytes, dict)):
         message += f" where the samples are of type " f"{type(first_sample).__qualname__}"
-        raise TypeError(message)
+        raise ValueError(message)
 
     try:
         # If X is a list of lists, for instance, we assume that all nested
@@ -394,7 +398,7 @@ def _num_features(X, fallback_1d=False):
         else:
             return 1
     except Exception as err:
-        raise TypeError(message) from err
+        raise ValueError(message) from err
 
 
 def _num_samples(x):
@@ -430,3 +434,31 @@ def _is_csr(x):
     return isinstance(x, sp.csr_matrix) or (
         hasattr(sp, "csr_array") and isinstance(x, sp.csr_array)
     )
+
+
+def _assert_all_finite(X, allow_nan=False, input_name=""):
+    policy = _get_policy(None, X)
+    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)
+
+
+def assert_all_finite(
+    X,
+    *,
+    allow_nan=False,
+    input_name="",
+):
+    _assert_all_finite(
+        X.data if sp.issparse(X) else X,
+        allow_nan=allow_nan,
+        input_name=input_name,
+    )

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/__init__.py

@@ -32,6 +32,7 @@ __all__ = [
     "basic_statistics",
     "cluster",
     "config_context",
+    "covariance",
     "decomposition",
     "ensemble",
     "get_config",

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/_config.py

@@ -15,10 +15,12 @@
 # ==============================================================================
 
 from contextlib import contextmanager
+from os import environ
 
 from sklearn import get_config as skl_get_config
 from sklearn import set_config as skl_set_config
 
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal._config import _get_config as onedal_get_config
 
 
@@ -38,7 +40,12 @@ def get_config():
     return {**sklearn, **sklearnex}
 
 
-def set_config(target_offload=None, allow_fallback_to_host=None, **sklearn_configs):
+def set_config(
+    target_offload=None,
+    allow_fallback_to_host=None,
+    allow_sklearn_after_onedal=None,
+    **sklearn_configs,
+):
     """Set global configuration
     Parameters
     ----------
@@ -51,11 +58,20 @@ def set_config(target_offload=None, allow_fallback_to_host=None, **sklearn_confi
         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
+        If True, allows to fallback computation to sklearn after onedal
+        backend in case of runtime error on onedal backend computations.
+        Global default: True.
     See Also
     --------
     config_context : Context manager for global configuration.
     get_config : Retrieve current values of the global configuration.
     """
+
+    array_api_dispatch = sklearn_configs.get("array_api_dispatch", False)
+    if array_api_dispatch and sklearn_check_version("1.6"):
+        environ["SCIPY_ARRAY_API"] = "1"
+
     skl_set_config(**sklearn_configs)
 
     local_config = onedal_get_config(copy=False)
@@ -64,6 +80,8 @@ def set_config(target_offload=None, allow_fallback_to_host=None, **sklearn_confi
         local_config["target_offload"] = target_offload
     if allow_fallback_to_host is not None:
         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
 
 
 @contextmanager

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -16,13 +16,9 @@
 
 from functools import wraps
 
-from onedal._device_offload import (
-    _copy_to_usm,
-    _get_global_queue,
-    _transfer_to_host,
-    dpnp_available,
-)
-from onedal.utils._array_api import _asarray, _is_numpy_namespace
+from onedal._device_offload import _copy_to_usm, _get_global_queue, _transfer_to_host
+from onedal.utils._array_api import _asarray
+from onedal.utils._dpep_helpers import dpnp_available
 
 if dpnp_available:
     import dpnp
@@ -63,14 +59,16 @@ def _get_backend(obj, queue, method_name, *data):
 
 def dispatch(obj, method_name, branches, *args, **kwargs):
     q = _get_global_queue()
-    q, hostargs = _transfer_to_host(q, *args)
-    q, hostvalues = _transfer_to_host(q, *kwargs.values())
+    has_usm_data_for_args, q, hostargs = _transfer_to_host(q, *args)
+    has_usm_data_for_kwargs, q, hostvalues = _transfer_to_host(q, *kwargs.values())
     hostkwargs = dict(zip(kwargs.keys(), hostvalues))
 
     backend, q, patching_status = _get_backend(obj, q, method_name, *hostargs)
-
+    has_usm_data = has_usm_data_for_args or has_usm_data_for_kwargs
     if backend == "onedal":
-        patching_status.write_log(queue=q)
+        # Host args only used before onedal backend call.
+        # Device will be offloaded when onedal backend will be called.
+        patching_status.write_log(queue=q, transferred_to_host=False)
         return branches[backend](obj, *hostargs, **hostkwargs, queue=q)
     if backend == "sklearn":
         if (
@@ -78,10 +76,17 @@ def dispatch(obj, method_name, branches, *args, **kwargs):
             and get_config()["array_api_dispatch"]
             and "array_api_support" in obj._get_tags()
             and obj._get_tags()["array_api_support"]
+            and not has_usm_data
         ):
+            # USM ndarrays are also excluded for the fallback Array API. Currently, DPNP.ndarray is
+            # not compliant with the Array API standard, and DPCTL usm_ndarray Array API is compliant,
+            # except for the linalg module. There is no guarantee that stock scikit-learn will
+            # work with such input data. The condition will be updated after DPNP.ndarray and
+            # DPCTL usm_ndarray enabling for conformance testing and these arrays supportance
+            # of the fallback cases.
             # If `array_api_dispatch` enabled and array api is supported for the stock scikit-learn,
             # then raw inputs are used for the fallback.
-            patching_status.write_log()
+            patching_status.write_log(transferred_to_host=False)
             return branches[backend](obj, *args, **kwargs)
         else:
             patching_status.write_log()

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -16,8 +16,8 @@
 
 import logging
 import os
-import sys
 import warnings
+from abc import ABC
 
 from daal4py.sklearn._utils import (
     PatchingConditionsChain as daal4py_PatchingConditionsChain,
@@ -29,10 +29,10 @@ class PatchingConditionsChain(daal4py_PatchingConditionsChain):
     def get_status(self):
         return self.patching_is_enabled
 
-    def write_log(self, queue=None):
+    def write_log(self, queue=None, transferred_to_host=True):
         if self.patching_is_enabled:
             self.logger.info(
-                f"{self.scope_name}: {get_patch_message('onedal', queue=queue)}"
+                f"{self.scope_name}: {get_patch_message('onedal', queue=queue, transferred_to_host=transferred_to_host)}"
             )
         else:
             self.logger.debug(
@@ -43,7 +43,9 @@ class PatchingConditionsChain(daal4py_PatchingConditionsChain):
                 self.logger.debug(
                     f"{self.scope_name}: patching failed with cause - {message}"
                 )
-            self.logger.info(f"{self.scope_name}: {get_patch_message('sklearn')}")
+            self.logger.info(
+                f"{self.scope_name}: {get_patch_message('sklearn', transferred_to_host=transferred_to_host)}"
+            )
 
 
 def set_sklearn_ex_verbose():
@@ -66,7 +68,7 @@ def set_sklearn_ex_verbose():
         )
 
 
-def get_patch_message(s, queue=None):
+def get_patch_message(s, queue=None, transferred_to_host=True):
     if s == "onedal":
         message = "running accelerated version on "
         if queue is not None:
@@ -87,6 +89,10 @@ def get_patch_message(s, queue=None):
             f"Invalid input - expected one of 'onedal','sklearn',"
             f" 'sklearn_after_onedal', got {s}"
         )
+    if transferred_to_host:
+        message += (
+            ". All input data transferred to host for further backend computations."
+        )
     return message
 
 
@@ -99,11 +105,39 @@ def register_hyperparameters(hyperparameters_map):
     Adds `get_hyperparameters` method to class.
     """
 
-    def wrap_class(estimator_class):
-        def get_hyperparameters(self, op):
-            return hyperparameters_map[op]
+    def decorator(cls):
+        """Add `get_hyperparameters()` static method"""
+
+        class StaticHyperparametersAccessor:
+            """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.get_hyperparameters
+
+            def get_hyperparameters(self, op):
+                return hyperparameters_map[op]
+
+        cls.get_hyperparameters = StaticHyperparametersAccessor()
+        return cls
+
+    return decorator
+
 
-        estimator_class.get_hyperparameters = get_hyperparameters
-        return estimator_class
+# This abstract class is meant to generate a clickable doc link for classses
+# in sklearnex that are not part of base scikit-learn. It should be inherited
+# before inheriting from a scikit-learn estimator, otherwise will get overriden
+# by the estimator's original.
+class IntelEstimator(ABC):
+    @property
+    def _doc_link_module(self) -> str:
+        return "sklearnex"
 
-    return wrap_class
+    @property
+    def _doc_link_template(self) -> str:
+        module_path, _ = self.__class__.__module__.rsplit(".", 1)
+        class_name = self.__class__.__name__
+        return f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"