scikit-learn-intelex 2024.7.0__py39-none-win_amd64.whl → 2025.0.0__py39-none-win_amd64.whl

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/tests/utils/_dataframes_support.py

@@ -0,0 +1,168 @@
+# ===============================================================================
+# 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 pytest
+import scipy.sparse as sp
+
+from sklearnex import get_config
+
+try:
+    import dpctl.tensor as dpt
+
+    dpctl_available = True
+except ImportError:
+    dpctl_available = False
+
+try:
+    import dpnp
+
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+try:
+    # This should be lazy imported in the
+    # future along with other popular
+    # array_api libraries when testing
+    # GPU-no-copy.
+    import array_api_strict
+
+    array_api_enabled = lambda: get_config()["array_api_dispatch"]
+    array_api_enabled()
+    array_api_modules = {"array_api": array_api_strict}
+
+
+except (ImportError, KeyError):
+    array_api_enabled = lambda: False
+    array_api_modules = {}
+
+
+import numpy as np
+import pandas as pd
+
+from onedal.tests.utils._device_selection import get_queues
+
+
+def get_dataframes_and_queues(
+    dataframe_filter_="numpy,pandas,dpnp,dpctl,array_api", device_filter_="cpu,gpu"
+):
+    """Get supported dataframes for testing.
+
+    This is meant to be used for testing purposes only.
+
+    Parameters
+    ----------
+    dataframe_filter_ : str, default="numpy,pandas,dpnp,dpctl"
+        Configure output pytest.params for the certain dataframe formats.
+    device_filter_ : str, default="cpu,gpu"
+        Configure output pytest.params with certain sycl queue for the dataframe,
+        where it is applicable.
+
+    Returns
+    -------
+    list[pytest.param]
+        The list of pytest params, included dataframe name (str),
+        sycl queue, if applicable for the test case, and test
+        case id (str).
+
+    Notes
+    -----
+        Do not use filters for the test cases disabling. Use `pytest.skip`
+        or `pytest.xfail` instead.
+
+    See Also
+    --------
+    _convert_to_dataframe : Converted input object to certain dataframe format.
+    """
+    dataframes_and_queues = []
+
+    if "numpy" in dataframe_filter_:
+        dataframes_and_queues.append(pytest.param("numpy", None, id="numpy"))
+    if "pandas" in dataframe_filter_:
+        dataframes_and_queues.append(pytest.param("pandas", None, id="pandas"))
+
+    def get_df_and_q(dataframe: str):
+        df_and_q = []
+        for queue in get_queues(device_filter_):
+            if queue:
+                id = "{}-{}".format(dataframe, queue.id)
+                df_and_q.append(pytest.param(dataframe, queue.values[0], id=id))
+        return df_and_q
+
+    if dpctl_available and "dpctl" in dataframe_filter_:
+        dataframes_and_queues.extend(get_df_and_q("dpctl"))
+    if dpnp_available and "dpnp" in dataframe_filter_:
+        dataframes_and_queues.extend(get_df_and_q("dpnp"))
+    if (
+        "array_api" in dataframe_filter_
+        and "array_api" in array_api_modules
+        or array_api_enabled()
+    ):
+        dataframes_and_queues.append(pytest.param("array_api", None, id="array_api"))
+
+    return dataframes_and_queues
+
+
+def _as_numpy(obj, *args, **kwargs):
+    """Converted input object to numpy.ndarray format."""
+    if dpnp_available and isinstance(obj, dpnp.ndarray):
+        return obj.asnumpy(*args, **kwargs)
+    if dpctl_available and isinstance(obj, dpt.usm_ndarray):
+        return dpt.to_numpy(obj, *args, **kwargs)
+    if isinstance(obj, pd.DataFrame) or isinstance(obj, pd.Series):
+        return obj.to_array(*args, **kwargs)
+    if sp.issparse(obj):
+        return obj.toarray(*args, **kwargs)
+    return np.asarray(obj, *args, **kwargs)
+
+
+def _convert_to_dataframe(obj, sycl_queue=None, target_df=None, *args, **kwargs):
+    """Converted input object to certain dataframe format."""
+    if target_df is None:
+        return obj
+    elif target_df == "numpy":
+        # Numpy ndarray.
+        # `sycl_queue` arg is ignored.
+        return np.asarray(obj, *args, **kwargs)
+    # Pandas Dataframe
+    elif target_df == "pandas":
+        if (
+            "dtype" in kwargs
+            and hasattr(obj, "astype")
+            and np.issubdtype(kwargs["dtype"], np.integer)
+        ):
+            # Pandas float to int not allowed
+            obj = obj.astype(kwargs["dtype"])
+        if hasattr(obj, "ndim") and obj.ndim == 1:
+            return pd.Series(obj, *args, **kwargs)
+        else:
+            return pd.DataFrame(obj, *args, **kwargs)
+    # DPNP ndarray.
+    elif target_df == "dpnp":
+        return dpnp.asarray(
+            obj, usm_type="device", sycl_queue=sycl_queue, *args, **kwargs
+        )
+    elif target_df == "dpctl":
+        # DPCtl tensor.
+        return dpt.asarray(obj, usm_type="device", sycl_queue=sycl_queue, *args, **kwargs)
+    elif target_df in array_api_modules:
+        # Array API input other than DPNP ndarray, DPCtl tensor or
+        # Numpy ndarray.
+
+        xp = array_api_modules[target_df]
+        return xp.asarray(obj)
+
+    raise RuntimeError("Unsupported dataframe conversion")

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/tests/utils/_device_selection.py

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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 functools
+
+import pytest
+
+
+def get_queues(filter_="cpu,gpu"):
+    """Get available dpctl.SycQueues for testing.
+
+    This is meant to be used for testing purposes only.
+
+    Parameters
+    ----------
+    filter_ : str, default="cpu,gpu"
+        Configure output list with available dpctl.SycQueues for testing.
+
+    Returns
+    -------
+    list[dpctl.SycQueue]
+        The list of dpctl.SycQueue.
+
+    Notes
+    -----
+        Do not use filters for the test cases disabling. Use `pytest.skip`
+        or `pytest.xfail` instead.
+    """
+    queues = [None] if "cpu" in filter_ else []
+
+    try:
+        import dpctl
+
+        if dpctl.has_cpu_devices() and "cpu" in filter_:
+            queues.append(pytest.param(dpctl.SyclQueue("cpu"), id="SyclQueue_CPU"))
+        if dpctl.has_gpu_devices() and "gpu" in filter_:
+            queues.append(pytest.param(dpctl.SyclQueue("gpu"), id="SyclQueue_GPU"))
+    finally:
+        return queues
+
+
+def get_memory_usm():
+    try:
+        from dpctl.memory import MemoryUSMDevice, MemoryUSMShared
+
+        return [MemoryUSMDevice, MemoryUSMShared]
+    except ImportError:
+        return []
+
+
+def is_dpctl_available(targets=None):
+    try:
+        import dpctl
+
+        if targets is None:
+            return True
+        for device in targets:
+            if device == "cpu" and not dpctl.has_cpu_devices():
+                return False
+            if device == "gpu" and not dpctl.has_gpu_devices():
+                return False
+        return True
+    except ImportError:
+        return False
+
+
+def device_type_to_str(queue):
+    if queue is None:
+        return "cpu"
+
+    from dpctl import device_type
+
+    if queue.sycl_device.device_type == device_type.cpu:
+        return "cpu"
+    if queue.sycl_device.device_type == device_type.gpu:
+        return "gpu"
+    return "unknown"
+
+
+def pass_if_not_implemented_for_gpu(reason=""):
+    assert reason
+
+    def decorator(test):
+        @functools.wraps(test)
+        def wrapper(queue, *args, **kwargs):
+            if queue is not None and queue.sycl_device.is_gpu:
+                with pytest.raises(RuntimeError, match="is not implemented for GPU"):
+                    test(queue, *args, **kwargs)
+            else:
+                test(queue, *args, **kwargs)
+
+        return wrapper
+
+    return decorator

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/utils/__init__.py

@@ -0,0 +1,49 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from .validation import (
+    _check_array,
+    _check_classification_targets,
+    _check_n_features,
+    _check_X_y,
+    _column_or_1d,
+    _is_arraylike,
+    _is_arraylike_not_scalar,
+    _is_csr,
+    _is_integral_float,
+    _is_multilabel,
+    _num_features,
+    _num_samples,
+    _type_of_target,
+    _validate_targets,
+)
+
+__all__ = [
+    "_column_or_1d",
+    "_validate_targets",
+    "_check_X_y",
+    "_check_array",
+    "_check_classification_targets",
+    "_type_of_target",
+    "_is_integral_float",
+    "_is_multilabel",
+    "_check_n_features",
+    "_num_features",
+    "_num_samples",
+    "_is_arraylike",
+    "_is_arraylike_not_scalar",
+    "_is_csr",
+]

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -0,0 +1,91 @@
+# ==============================================================================
+# 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."""
+
+from collections.abc import Iterable
+
+try:
+    from dpctl.tensor import usm_ndarray
+
+    dpctl_available = True
+except ImportError:
+    dpctl_available = False
+
+try:
+    import dpnp
+
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+
+if dpnp_available:
+    import dpnp
+
+    def _convert_to_dpnp(array):
+        """Converted input object to dpnp.ndarray format."""
+        # Will be removed and `onedal.utils._array_api._asarray` will be
+        # used instead after DPNP Array API enabling.
+        if isinstance(array, usm_ndarray):
+            return dpnp.array(array, copy=False)
+        elif isinstance(array, Iterable):
+            for i in range(len(array)):
+                array[i] = _convert_to_dpnp(array[i])
+        return array
+
+
+def _asarray(data, xp, *args, **kwargs):
+    """Converted input object to array format of xp namespace provided."""
+    if hasattr(data, "__array_namespace__"):
+        return xp.asarray(data, *args, **kwargs)
+    elif isinstance(data, Iterable):
+        if isinstance(data, tuple):
+            result_data = []
+            for i in range(len(data)):
+                result_data.append(_asarray(data[i], xp, *args, **kwargs))
+            data = tuple(result_data)
+        else:
+            for i in range(len(data)):
+                data[i] = _asarray(data[i], xp, *args, **kwargs)
+    return data
+
+
+def _is_numpy_namespace(xp):
+    """Return True if xp is backed by NumPy."""
+    return xp.__name__ in {"numpy", "array_api_compat.numpy", "numpy.array_api"}
+
+
+def _get_sycl_namespace(*arrays):
+    """Get namespace of sycl arrays."""
+
+    # sycl support designed to work regardless of array_api_dispatch sklearn global value
+    sycl_type = {type(x): x for x in arrays if hasattr(x, "__sycl_usm_array_interface__")}
+
+    if len(sycl_type) > 1:
+        raise ValueError(f"Multiple SYCL types for array inputs: {sycl_type}")
+
+    if sycl_type:
+        (X,) = sycl_type.values()
+
+        if hasattr(X, "__array_namespace__"):
+            return sycl_type, X.__array_namespace__(), True
+        elif dpnp_available and isinstance(X, dpnp.ndarray):
+            return sycl_type, dpnp, False
+        else:
+            raise ValueError(f"SYCL type not recognized: {sycl_type}")
+
+    return sycl_type, None, False