scikit-learn-intelex 2024.1.0__py312-none-win_amd64.whl → 2025.1.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/onedal/utils/validation.py

@@ -0,0 +1,440 @@
+# ==============================================================================
+# Copyright 2021 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 collections.abc import Sequence
+from numbers import Integral
+
+import numpy as np
+from scipy import sparse as sp
+
+if np.lib.NumpyVersion(np.__version__) >= np.lib.NumpyVersion("2.0.0a0"):
+    # numpy_version >= 2.0
+    from numpy.exceptions import VisibleDeprecationWarning
+else:
+    # numpy_version < 2.0
+    from numpy import VisibleDeprecationWarning
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.utils.validation import check_array
+
+from daal4py.sklearn.utils.validation import _assert_all_finite
+
+
+class DataConversionWarning(UserWarning):
+    """Warning used to notify implicit data conversions happening in the code."""
+
+
+def _is_arraylike(x):
+    """Returns whether the input is array-like."""
+    return hasattr(x, "__len__") or hasattr(x, "shape") or hasattr(x, "__array__")
+
+
+def _is_arraylike_not_scalar(array):
+    """Return True if array is array-like and not a scalar"""
+    return _is_arraylike(array) and not np.isscalar(array)
+
+
+def _column_or_1d(y, warn=False):
+    y = np.asarray(y)
+
+    # TODO: Convert this kind of arrays to a table like in daal4py
+    if not y.flags.aligned and not y.flags.writeable:
+        y = np.array(y.tolist())
+
+    shape = np.shape(y)
+    if len(shape) == 1:
+        return np.ravel(y)
+    if len(shape) == 2 and shape[1] == 1:
+        if warn:
+            warnings.warn(
+                "A column-vector y was passed when a 1d array was"
+                " expected. Please change the shape of y to "
+                "(n_samples, ), for example using ravel().",
+                DataConversionWarning,
+                stacklevel=2,
+            )
+        return np.ravel(y)
+
+    raise ValueError(
+        "y should be a 1d array, " "got an array of shape {} instead.".format(shape)
+    )
+
+
+def _compute_class_weight(class_weight, classes, y):
+    if set(y) - set(classes):
+        raise ValueError("classes should include all valid labels that can " "be in y")
+    if class_weight is None or len(class_weight) == 0:
+        weight = np.ones(classes.shape[0], dtype=np.float64, order="C")
+    elif class_weight == "balanced":
+        y_ = _column_or_1d(y)
+        classes, _ = np.unique(y_, return_inverse=True)
+
+        le = LabelEncoder()
+        y_ind = le.fit_transform(y_)
+        if not all(np.in1d(classes, le.classes_)):
+            raise ValueError("classes should have valid labels that are in y")
+
+        y_bin = np.bincount(y_ind).astype(np.float64)
+        weight = len(y_) / (len(le.classes_) * y_bin)
+    else:
+        # user-defined dictionary
+        weight = np.ones(classes.shape[0], dtype=np.float64, order="C")
+        if not isinstance(class_weight, dict):
+            raise ValueError(
+                "class_weight must be dict, 'balanced', or None,"
+                " got: %r" % class_weight
+            )
+        for c in class_weight:
+            i = np.searchsorted(classes, c)
+            if i >= len(classes) or classes[i] != c:
+                raise ValueError("Class label {} not present.".format(c))
+            weight[i] = class_weight[c]
+
+    return weight
+
+
+def _validate_targets(y, class_weight, dtype):
+    y_ = _column_or_1d(y, warn=True)
+    _check_classification_targets(y)
+    classes, y = np.unique(y_, return_inverse=True)
+    class_weight_res = _compute_class_weight(class_weight, classes=classes, y=y_)
+
+    if len(classes) < 2:
+        raise ValueError(
+            "The number of classes has to be greater than one; got %d"
+            " class" % len(classes)
+        )
+
+    return np.asarray(y, dtype=dtype, order="C"), class_weight_res, classes
+
+
+def _check_array(
+    array,
+    dtype="numeric",
+    accept_sparse=False,
+    order=None,
+    copy=False,
+    force_all_finite=True,
+    ensure_2d=True,
+    accept_large_sparse=True,
+):
+    if force_all_finite:
+        if sp.issparse(array):
+            if hasattr(array, "data"):
+                _assert_all_finite(array.data)
+                force_all_finite = False
+        else:
+            _assert_all_finite(array)
+            force_all_finite = False
+    array = check_array(
+        array=array,
+        dtype=dtype,
+        accept_sparse=accept_sparse,
+        order=order,
+        copy=copy,
+        force_all_finite=force_all_finite,
+        ensure_2d=ensure_2d,
+        accept_large_sparse=accept_large_sparse,
+    )
+
+    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
+
+
+def _check_X_y(
+    X,
+    y,
+    dtype="numeric",
+    accept_sparse=False,
+    order=None,
+    copy=False,
+    force_all_finite=True,
+    ensure_2d=True,
+    accept_large_sparse=True,
+    y_numeric=False,
+    accept_2d_y=False,
+):
+    if y is None:
+        raise ValueError("y cannot be None")
+
+    X = _check_array(
+        X,
+        accept_sparse=accept_sparse,
+        dtype=dtype,
+        order=order,
+        copy=copy,
+        force_all_finite=force_all_finite,
+        ensure_2d=ensure_2d,
+        accept_large_sparse=accept_large_sparse,
+    )
+
+    if not accept_2d_y:
+        y = _column_or_1d(y, warn=True)
+    else:
+        y = np.ascontiguousarray(y)
+
+    if y_numeric and y.dtype.kind == "O":
+        y = y.astype(np.float64)
+    if force_all_finite:
+        _assert_all_finite(y)
+
+    lengths = [X.shape[0], y.shape[0]]
+    uniques = np.unique(lengths)
+    if len(uniques) > 1:
+        raise ValueError(
+            "Found input variables with inconsistent numbers of"
+            " samples: %r" % [int(length) for length in lengths]
+        )
+
+    return X, y
+
+
+def _check_classification_targets(y):
+    y_type = _type_of_target(y)
+    if y_type not in [
+        "binary",
+        "multiclass",
+        "multiclass-multioutput",
+        "multilabel-indicator",
+        "multilabel-sequences",
+    ]:
+        raise ValueError("Unknown label type: %r" % y_type)
+
+
+def _type_of_target(y):
+    is_sequence, is_array = isinstance(y, Sequence), hasattr(y, "__array__")
+    is_not_string, is_sparse = not isinstance(y, str), sp.issparse(y)
+    valid = (is_sequence or is_array or is_sparse) and is_not_string
+
+    if not valid:
+        raise ValueError(
+            "Expected array-like (array or non-string sequence), " "got %r" % y
+        )
+
+    sparse_pandas = y.__class__.__name__ in ["SparseSeries", "SparseArray"]
+    if sparse_pandas:
+        raise ValueError("y cannot be class 'SparseSeries' or 'SparseArray'")
+
+    if _is_multilabel(y):
+        return "multilabel-indicator"
+
+    # DeprecationWarning will be replaced by ValueError, see NEP 34
+    # https://numpy.org/neps/nep-0034-infer-dtype-is-object.html
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", VisibleDeprecationWarning)
+        try:
+            y = np.asarray(y)
+        except VisibleDeprecationWarning:
+            # dtype=object should be provided explicitly for ragged arrays,
+            # see NEP 34
+            y = np.asarray(y, dtype=object)
+
+    # The old sequence of sequences format
+    try:
+        if (
+            not hasattr(y[0], "__array__")
+            and isinstance(y[0], Sequence)
+            and not isinstance(y[0], str)
+        ):
+            raise ValueError(
+                "You appear to be using a legacy multi-label data"
+                " representation. Sequence of sequences are no"
+                " longer supported; use a binary array or sparse"
+                " matrix instead - the MultiLabelBinarizer"
+                " transformer can convert to this format."
+            )
+    except IndexError:
+        pass
+
+    # Invalid inputs
+    if y.ndim > 2 or (y.dtype == object and len(y) and not isinstance(y.flat[0], str)):
+        return "unknown"  # [[[1, 2]]] or [obj_1] and not ["label_1"]
+
+    if y.ndim == 2 and y.shape[1] == 0:
+        return "unknown"  # [[]]
+
+    if y.ndim == 2 and y.shape[1] > 1:
+        suffix = "-multioutput"  # [[1, 2], [1, 2]]
+    else:
+        suffix = ""  # [1, 2, 3] or [[1], [2], [3]]
+
+    # 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)
+        return "continuous" + suffix
+
+    if (len(np.unique(y)) > 2) or (y.ndim >= 2 and len(y[0]) > 1):
+        return "multiclass" + suffix  # [1, 2, 3] or [[1., 2., 3]] or [[1, 2]]
+    return "binary"  # [1, 2] or [["a"], ["b"]]
+
+
+def _is_integral_float(y):
+    return y.dtype.kind == "f" and np.all(y.astype(int) == y)
+
+
+def _is_multilabel(y):
+    if hasattr(y, "__array__") or isinstance(y, Sequence):
+        # DeprecationWarning will be replaced by ValueError, see NEP 34
+        # https://numpy.org/neps/nep-0034-infer-dtype-is-object.html
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", VisibleDeprecationWarning)
+            try:
+                y = np.asarray(y)
+            except VisibleDeprecationWarning:
+                # dtype=object should be provided explicitly for ragged arrays,
+                # see NEP 34
+                y = np.array(y, dtype=object)
+
+    if not (hasattr(y, "shape") and y.ndim == 2 and y.shape[1] > 1):
+        return False
+
+    if sp.issparse(y):
+        if isinstance(y, (sp.dok_matrix, sp.lil_matrix)):
+            y = y.tocsr()
+        return (
+            len(y.data) == 0
+            or np.unique(y.data).size == 1
+            and (y.dtype.kind in "biu" or _is_integral_float(np.unique(y.data)))
+        )
+    labels = np.unique(y)
+
+    return len(labels) < 3 and (y.dtype.kind in "biu" or _is_integral_float(labels))
+
+
+def _check_n_features(self, X, reset):
+    try:
+        n_features = _num_features(X)
+    except TypeError as e:
+        if not reset and hasattr(self, "n_features_in_"):
+            raise ValueError(
+                "X does not contain any features, but "
+                f"{self.__class__.__name__} is expecting "
+                f"{self.n_features_in_} features"
+            ) from e
+        # If the number of features is not defined and reset=True,
+        # then we skip this check
+        return
+
+    if reset:
+        self.n_features_in_ = n_features
+        return
+
+    if not hasattr(self, "n_features_in_"):
+        # Skip this check if the expected number of expected input features
+        # was not recorded by calling fit first. This is typically the case
+        # for stateless transformers.
+        return
+
+    if n_features != self.n_features_in_:
+        raise ValueError(
+            f"X has {n_features} features, but {self.__class__.__name__} "
+            f"is expecting {self.n_features_in_} features as input."
+        )
+
+
+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__
+    else:
+        type_name = f"{type_.__module__}.{type_.__qualname__}"
+    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 ValueError(message)
+        # Only convert X to a numpy array if there is no cheaper, heuristic
+        # option.
+        X = np.asarray(X)
+
+    if hasattr(X, "shape"):
+        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 ValueError(message)
+        if len(X.shape) <= 1:
+            return 1
+        else:
+            return X.shape[-1]
+
+    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 ValueError(message)
+
+    try:
+        # If X is a list of lists, for instance, we assume that all nested
+        # lists have the same length without checking or converting to
+        # a numpy array to keep this function call as cheap as possible.
+        if (not fallback_1d) or hasattr(first_sample, "__len__"):
+            return len(first_sample)
+        else:
+            return 1
+    except Exception as err:
+        raise ValueError(message) from err
+
+
+def _num_samples(x):
+    message = "Expected sequence or array-like, got %s" % type(x)
+    if hasattr(x, "fit") and callable(x.fit):
+        # Don't get num_samples from an ensembles length!
+        raise TypeError(message)
+
+    if not hasattr(x, "__len__") and not hasattr(x, "shape"):
+        if hasattr(x, "__array__"):
+            x = np.asarray(x)
+        else:
+            raise TypeError(message)
+
+    if hasattr(x, "shape") and x.shape is not None:
+        if len(x.shape) == 0:
+            raise TypeError(
+                "Singleton array %r cannot be considered a valid collection." % x
+            )
+    # Check that shape is returning an integer or default to len
+    # Dask dataframes may not return numeric shape[0] value
+    if hasattr(x, "shape") and isinstance(x.shape[0], Integral):
+        return x.shape[0]
+
+    try:
+        return len(x)
+    except TypeError as type_error:
+        raise TypeError(message) from type_error
+
+
+def _is_csr(x):
+    """Return True if x is scipy.sparse.csr_matrix or scipy.sparse.csr_array"""
+    return isinstance(x, sp.csr_matrix) or (
+        hasattr(sp, "csr_array") and isinstance(x, sp.csr_array)
+    )

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2025.1.0.data}/data/Lib/site-packages/sklearnex/__init__.py

@@ -1,5 +1,6 @@
 # ==============================================================================
 # Copyright 2021 Intel Corporation
+# Copyright 2024 Fujitsu Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,7 +15,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.common.hyperparameters import get_hyperparameters
+import os
 
 from . import utils
 from ._config import config_context, get_config, set_config
@@ -31,6 +32,7 @@ __all__ = [
     "basic_statistics",
     "cluster",
     "config_context",
+    "covariance",
     "decomposition",
     "ensemble",
     "get_config",
@@ -41,21 +43,22 @@ __all__ = [
     "linear_model",
     "manifold",
     "metrics",
+    "model_selection",
     "neighbors",
     "patch_sklearn",
     "set_config",
     "sklearn_is_patched",
-    "sklearn_is_patchedget_patch_map",
     "svm",
     "unpatch_sklearn",
     "utils",
 ]
+onedal_iface_flag = os.environ.get("OFF_ONEDAL_IFACE", "0")
+if onedal_iface_flag == "0":
+    from onedal import _is_spmd_backend
+    from onedal.common.hyperparameters import get_hyperparameters
 
-
-from onedal import _is_dpc_backend
-
-if _is_dpc_backend:
-    __all__.append("spmd")
+    if _is_spmd_backend:
+        __all__.append("spmd")
 
 
 from ._utils import set_sklearn_ex_verbose

{scikit_learn_intelex-2024.1.0.data → scikit_learn_intelex-2025.1.0.data}/data/Lib/site-packages/sklearnex/_config.py

@@ -14,24 +14,14 @@
 # limitations under the License.
 # ==============================================================================
 
-import threading
 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
 
-_default_global_config = {
-    "target_offload": "auto",
-    "allow_fallback_to_host": False,
-}
-
-_threadlocal = threading.local()
-
-
-def _get_sklearnex_threadlocal_config():
-    if not hasattr(_threadlocal, "global_config"):
-        _threadlocal.global_config = _default_global_config.copy()
-    return _threadlocal.global_config
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal._config import _get_config as onedal_get_config
 
 
 def get_config():
@@ -46,11 +36,16 @@ def get_config():
     set_config : Set global configuration.
     """
     sklearn = skl_get_config()
-    sklearnex = _get_sklearnex_threadlocal_config().copy()
+    sklearnex = onedal_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
     ----------
@@ -63,19 +58,30 @@ 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 = _get_sklearnex_threadlocal_config()
+    local_config = onedal_get_config(copy=False)
 
     if target_offload is not None:
         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.1.0.data/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -0,0 +1,126 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+from functools import wraps
+
+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
+    from onedal.utils._array_api import _convert_to_dpnp
+
+from ._config import get_config
+
+
+def _get_backend(obj, queue, method_name, *data):
+    cpu_device = queue is None or queue.sycl_device.is_cpu
+    gpu_device = queue is not None and queue.sycl_device.is_gpu
+
+    if cpu_device:
+        patching_status = obj._onedal_cpu_supported(method_name, *data)
+        if patching_status.get_status():
+            return "onedal", queue, patching_status
+        else:
+            return "sklearn", None, patching_status
+
+    allow_fallback_to_host = get_config()["allow_fallback_to_host"]
+
+    if gpu_device:
+        patching_status = obj._onedal_gpu_supported(method_name, *data)
+        if patching_status.get_status():
+            return "onedal", queue, patching_status
+        else:
+            if allow_fallback_to_host:
+                patching_status = obj._onedal_cpu_supported(method_name, *data)
+                if patching_status.get_status():
+                    return "onedal", None, patching_status
+                else:
+                    return "sklearn", None, patching_status
+            else:
+                return "sklearn", None, patching_status
+
+    raise RuntimeError("Device support is not implemented")
+
+
+def dispatch(obj, method_name, branches, *args, **kwargs):
+    q = _get_global_queue()
+    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":
+        # 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 (
+            "array_api_dispatch" in get_config()
+            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(transferred_to_host=False)
+            return branches[backend](obj, *args, **kwargs)
+        else:
+            patching_status.write_log()
+            return branches[backend](obj, *hostargs, **hostkwargs)
+    raise RuntimeError(
+        f"Undefined backend {backend} in " f"{obj.__class__.__name__}.{method_name}"
+    )
+
+
+def wrap_output_data(func):
+    """
+    Converts and moves the output arrays of the decorated function
+    to match the input array type and device.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        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
+            config = get_config()
+            if not ("transform_output" in config and config["transform_output"]):
+                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+                if input_array_api:
+                    input_array_api_device = data[0].device
+                    result = _asarray(
+                        result, input_array_api, device=input_array_api_device
+                    )
+        return result
+
+    return wrapper