scikit-learn-intelex 2025.7.0__py39-none-win_amd64.whl → 2025.9.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/common/hyperparameters.py

@@ -15,7 +15,7 @@
 # ==============================================================================
 
 import logging
-from typing import Any, Dict, Tuple
+from typing import Callable, Dict, Tuple
 from warnings import warn
 
 from daal4py.sklearn._utils import daal_check_version
@@ -94,22 +94,26 @@ else:
             for method in filter(lambda f: f.startswith(prefix), dir(obj))
         }
 
-    hyperparameters_backend: Dict[Tuple[str, str], Any] = {
+    hyperparameters_backend: Dict[Tuple[str, str], Callable] = {
         (
             "linear_regression",
             "train",
-        ): backend.linear_model.regression.train_hyperparameters(),
-        ("covariance", "compute"): backend.covariance.compute_hyperparameters(),
+        ): lambda: backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): lambda: backend.covariance.compute_hyperparameters(),
     }
     if daal_check_version((2024, "P", 300)):
-        df_infer_hp = backend.decision_forest.infer_hyperparameters
-        hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
+        hyperparameters_backend[("decision_forest", "infer")] = (
+            lambda: backend.decision_forest.infer_hyperparameters()
+        )
     if daal_check_version((2025, "P", 700)):
-        pca_train_hp = backend.decomposition.dim_reduction.train_hyperparameters
-        hyperparameters_backend[("pca", "train")] = pca_train_hp()
-    hyperparameters_map = {}
+        hyperparameters_backend[("pca", "train")] = (
+            lambda: backend.decomposition.dim_reduction.train_hyperparameters()
+        )
+
+    hyperparameters_map: Dict[Tuple[str, str], HyperParameters] = {}
 
-    for (algorithm, op), hyperparameters in hyperparameters_backend.items():
+    for (algorithm, op), hyperparameters_lambda in hyperparameters_backend.items():
+        hyperparameters = hyperparameters_lambda()
         setters = get_methods_with_prefix(hyperparameters, "set_")
         getters = get_methods_with_prefix(hyperparameters, "get_")
 
@@ -123,6 +127,22 @@ else:
             algorithm, op, setters, getters, hyperparameters
         )
 
+    def get_hyperparameters_backend(algorithm, op):
+        """Get hyperparameters for a specific algorithm and operation."""
+        if (algorithm, op) in hyperparameters_backend:
+            return hyperparameters_backend[(algorithm, op)]()
+        else:
+            raise ValueError(f"Hyperparameters for '{algorithm}.{op}' are not defined.")
 
-def get_hyperparameters(algorithm, op):
+
+def get_hyperparameters(algorithm: str, op: str) -> HyperParameters:
     return hyperparameters_map.get((algorithm, op), None)
+
+
+def reset_hyperparameters(algorithm: str, op: str) -> None:
+    new_hyperparameters_backend = get_hyperparameters_backend(algorithm, op)
+    new_setters = get_methods_with_prefix(new_hyperparameters_backend, "set_")
+    new_getters = get_methods_with_prefix(new_hyperparameters_backend, "get_")
+    hyperparameters_map[(algorithm, op)] = HyperParameters(
+        algorithm, op, new_setters, new_getters, new_hyperparameters_backend
+    )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -117,6 +117,8 @@ def test_backend_queue():
     q2 = backend.SyclQueue(q._get_capsule())
     # verify copying via the _get_capsule attribute
     q3 = backend.SyclQueue(q)
+    # create new queue on the same device for device checks
+    q4 = backend.SyclQueue("cpu")
 
     q_array = [q, q2, q3]
 
@@ -125,6 +127,9 @@ def test_backend_queue():
     assert all([queue.sycl_device.is_cpu for queue in q_array])
     assert all([not queue.sycl_device.is_gpu for queue in q_array])
     assert all(["cpu" in queue.sycl_device.filter_string for queue in q_array])
+    assert q.sycl_device == q4.sycl_device  # verify that __eq__ operator works
+    assert not (q.sycl_device != q4.sycl_device)  # verify that __ne__ operator works
+    assert q != q4  # verify two separate cpu queues created
 
 
 @pytest.mark.skipif(

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/covariance/covariance.py

@@ -20,7 +20,6 @@ import numpy as np
 from daal4py.sklearn._utils import daal_check_version
 from onedal._device_offload import supports_queue
 from onedal.common._backend import bind_default_backend
-from onedal.utils.validation import _check_array
 
 from .._config import _get_config
 from ..common.hyperparameters import get_hyperparameters
@@ -101,30 +100,22 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        use_raw_input = _get_config()["use_raw_input"] is True
-        sua_iface, _, _ = _get_sycl_namespace(X)
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
 
-        if not use_raw_input:
-            X = _check_array(X, dtype=[np.float64, np.float32])
-        X = to_table(X, queue=queue)
+        X_table = to_table(X, queue=queue)
 
-        params = self._get_onedal_params(X.dtype)
+        params = self._get_onedal_params(X_table.dtype)
         hparams = get_hyperparameters("covariance", "compute")
         if hparams is not None and not hparams.is_default:
-            result = self.compute(params, hparams.backend, X)
+            result = self.compute(params, hparams.backend, X_table)
         else:
-            result = self.compute(params, X)
+            result = self.compute(params, X_table)
         if daal_check_version((2024, "P", 1)) or (not self.bias):
-            self.covariance_ = from_table(result.cov_matrix, sycl_queue=queue)
+            self.covariance_ = from_table(result.cov_matrix, like=X)
         else:
             self.covariance_ = (
-                from_table(result.cov_matrix, sycl_queue=queue)
-                * (X.shape[0] - 1)
-                / X.shape[0]
+                from_table(result.cov_matrix, like=X) * (X.shape[0] - 1) / X.shape[0]
             )
 
-        self.location_ = from_table(result.means, sycl_queue=queue).ravel()
+        self.location_ = from_table(result.means, like=X)[0, ...]
 
         return self

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/covariance/incremental_covariance.py

@@ -17,12 +17,12 @@
 import numpy as np
 
 from daal4py.sklearn._utils import daal_check_version
-from onedal._device_offload import supports_queue
-from onedal.common._backend import bind_default_backend
-from onedal.utils import _sycl_queue_manager as QM
 
 from .._config import _get_config
-from ..datatypes import from_table, to_table
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
 from ..utils._array_api import _get_sycl_namespace
 from ..utils.validation import _check_array
 from .covariance import BaseEmpiricalCovariance
@@ -74,6 +74,7 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
     def _reset(self):
         self._need_to_finalize = False
         self._queue = None
+        self._outtype = None
         self._partial_result = self.partial_compute_result()
 
     def __getstate__(self):
@@ -108,15 +109,10 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        use_raw_input = _get_config()["use_raw_input"] is True
-        sua_iface, _, _ = _get_sycl_namespace(X)
-
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
-        if not use_raw_input:
-            X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
 
         self._queue = queue
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
@@ -125,8 +121,6 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         params = self._get_onedal_params(self._dtype)
         self._partial_result = self.partial_compute(params, self._partial_result, X_table)
         self._need_to_finalize = True
-        # store the queue for when we finalize
-        self._queue = queue
 
     def finalize_fit(self):
         """Finalize covariance matrix from the current `_partial_result`.
@@ -143,13 +137,14 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
             with QM.manage_global_queue(self._queue):
                 result = self.finalize_compute(params, self._partial_result)
 
-            if daal_check_version((2024, "P", 1)) or (not self.bias):
-                self.covariance_ = from_table(result.cov_matrix)
-            else:
+            self.covariance_ = from_table(result.cov_matrix, like=self._outtype)
+
+            if self.bias and not daal_check_version((2024, "P", 1)):
                 n_rows = self._partial_result.partial_n_rows
-                self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
+                self.covariance_ *= (n_rows - 1) / n_rows
 
-            self.location_ = from_table(result.means).ravel()
+            self.location_ = from_table(result.means, like=self._outtype)[0, ...]
+            self._outtype = None
 
             self._need_to_finalize = False
 

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/covariance/tests/test_covariance.py

@@ -25,7 +25,7 @@ from onedal.tests.utils._device_selection import get_queues
 def test_onedal_import_covariance(queue):
     from onedal.covariance import EmpiricalCovariance
 
-    X = np.array([[0, 1], [0, 1]])
+    X = np.array([[0, 1], [0, 1]], dtype=np.float64)
     result = EmpiricalCovariance().fit(X, queue=queue)
     expected_covariance = np.array([[0, 0], [0, 0]])
     expected_means = np.array([0, 1])
@@ -33,7 +33,7 @@ def test_onedal_import_covariance(queue):
     assert_allclose(expected_covariance, result.covariance_)
     assert_allclose(expected_means, result.location_)
 
-    X = np.array([[1, 2], [3, 6]])
+    X = np.array([[1, 2], [3, 6]], dtype=np.float64)
     result = EmpiricalCovariance().fit(X, queue=queue)
     expected_covariance = np.array([[2, 4], [4, 8]])
     expected_means = np.array([2, 4])
@@ -41,7 +41,7 @@ def test_onedal_import_covariance(queue):
     assert_allclose(expected_covariance, result.covariance_)
     assert_allclose(expected_means, result.location_)
 
-    X = np.array([[1, 2], [3, 6]])
+    X = np.array([[1, 2], [3, 6]], dtype=np.float64)
     result = EmpiricalCovariance(bias=True).fit(X, queue=queue)
     expected_covariance = np.array([[1, 2], [2, 4]])
     expected_means = np.array([2, 4])

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -14,13 +14,16 @@
 # limitations under the License.
 # ==============================================================================
 
-from ._data_conversion import from_table, to_table
-from ._sycl_usm import copy_to_dpnp, copy_to_usm, usm_to_numpy
+from ._data_conversion import from_table, return_type_constructor, to_table
+from ._dlpack import dlpack_to_numpy, get_torch_queue
+from ._sycl_usm import copy_to_dpnp, copy_to_usm
 
 __all__ = [
     "copy_to_dpnp",
     "copy_to_usm",
+    "dlpack_to_numpy",
     "from_table",
+    "get_torch_queue",
     "to_table",
-    "usm_to_numpy",
+    "return_type_constructor",
 ]

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -0,0 +1,158 @@
+# ==============================================================================
+# 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 numpy as np
+import scipy.sparse as sp
+
+from onedal import _default_backend as backend
+
+from ..utils._third_party import is_dpctl_tensor, is_dpnp_ndarray, lazy_import
+
+
+def _apply_and_pass(func, *args, **kwargs):
+    if len(args) == 1:
+        return func(args[0], **kwargs)
+    return tuple(map(lambda arg: func(arg, **kwargs), args))
+
+
+def _convert_one_to_table(arg, queue=None):
+    # All inputs for table conversion must be array-like or sparse, not scalars
+    return backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
+
+
+def to_table(*args, queue=None):
+    """Create oneDAL tables from scalars and/or arrays.
+
+    Parameters
+    ----------
+    *args : scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array
+        Arguments to be individually converted to oneDAL tables.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object to be associated with the oneDAL tables. Default
+        value None causes no change in data location or queue.
+
+    Returns
+    -------
+    tables : oneDAL homogeneous or csr tables
+        Converted oneDAL tables for scalar, numpy array, sycl_usm_ndarray
+        and dlpack inputs; oneDAL csr_table for csr_matrix, csr_array.
+
+    Notes
+    -----
+        Tables will use pointers to the original array data. Scalars
+        and non-contiguous arrays will be copies. Arrays may be
+        modified in-place by oneDAL during computation. Transformation
+        is possible only for data located on CPU and SYCL-enabled Intel
+        GPUs. Each array may only be of a single data type (i.e. each
+        must be homogeneous).
+    """
+    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
+
+
+@lazy_import("array_api_compat")
+def _compat_convert(array_api_compat, array):
+    return array_api_compat.get_namespace(array).from_dlpack
+
+
+def return_type_constructor(array):
+    """Generate a function for converting oneDAL tables to arrays.
+
+    Parameters
+    ----------
+    array : array-like or None
+        Python object representing an array instance of the return type
+        for converting oneDAL tables. Arrays are queried for conversion
+        namespace when of sycl_usm_array type or array API standard type.
+        When set to None, will return numpy arrays or scipy csr arrays.
+
+    Returns
+    -------
+    func : callable
+        A function which takes in a single table input and returns an array.
+    """
+    if isinstance(array, np.ndarray) or array is None or sp.issparse(array):
+        func = backend.from_table
+    elif hasattr(array, "__sycl_usm_array_interface__"):
+        # oneDAL returns tables without sycl queues for CPU sycl queue inputs.
+        # This workaround is necessary for the functional preservation
+        # of the compute-follows-data execution.
+        device = array.sycl_queue
+        # Its important to note why the __sycl_usm_array_interface__ is
+        # prioritized: it provides finer-grained control of SYCL queues and the
+        # related SYCL devices which are generally unavailable via DLPack
+        # representations (such as SYCL contexts, SYCL sub-devices, etc.).
+        xp = array.__array_namespace__()
+        # array api support added in dpnp starting in 0.19, will fail for
+        # older versions
+        if is_dpctl_tensor(array):
+            func = lambda x: (
+                xp.asarray(x)
+                if hasattr(x, "__sycl_usm_array_interface__")
+                else xp.asarray(backend.from_table(x), device=device)
+            )
+        elif is_dpnp_ndarray(array):
+            func = lambda x: (
+                xp.asarray(xp.as_usm_ndarray(x))
+                if hasattr(x, "__sycl_usm_array_interface__")
+                else xp.asarray(backend.from_table(x), device=device)
+            )
+
+    elif hasattr(array, "__array_namespace__"):
+        xp = array.__array_namespace__()
+        device = array.device
+        func = lambda inp: xp.from_dlpack(inp, device=device)
+    else:
+        try:
+            func = _compat_convert(array)
+        except ImportError:
+            raise TypeError(
+                "array type is unsupported, but may be made compatible by installing `array_api_compat`"
+            ) from None
+    return func
+
+
+def from_table(*args, like=None):
+    """Create 2 dimensional arrays from oneDAL tables.
+
+    oneDAL tables are converted to numpy ndarrays, dpctl tensors, dpnp
+    ndarrays, or array API standard arrays of designated type.
+
+    Parameters
+    ----------
+    *args : single or multiple python oneDAL tables
+        The tables should given as individual arguments.
+
+    like : callable, array-like or None, default=None
+        Python object representing an array instance of the return type
+        or function capable of converting oneDAL tables into arrays of
+        desired type. Arrays are queried for conversion namespace when
+        of sycl_usm_array type or array API standard type. When set to
+        None, will return numpy arrays or scipy csr arrays.
+
+    Returns
+    -------
+    arrays : numpy arrays, sycl_usm_ndarrays, or array API standard arrays
+        Array or tuple of arrays generated from the input oneDAL tables.
+
+    Notes
+    -----
+    Support for other array types via array_api_compat is possible (e.g.
+    PyTorch), but requires its installation specifically, as it is imported
+    only when necessary.
+    """
+    func = like if callable(like) else return_type_constructor(like)
+    return _apply_and_pass(func, *args)

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/onedal/datatypes/_dlpack.py

@@ -0,0 +1,64 @@
+# ==============================================================================
+# 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 collections.abc import Iterable
+
+import numpy as np
+
+from onedal import _default_backend as backend
+
+from ..utils._third_party import convert_sklearnex_queue, lazy_import
+
+cpu_dlpack_device = (backend.kDLCPU, 0)
+
+
+@lazy_import("torch.xpu")
+@convert_sklearnex_queue
+def get_torch_queue(torchxpu, array):
+    return backend.SyclQueue(torchxpu.current_stream(array.get_device()).sycl_queue)
+
+
+def dlpack_to_numpy(obj):
+    # check dlpack data location.
+    if obj.__dlpack_device__() != cpu_dlpack_device:
+        if hasattr(obj, "to_device"):
+            # use of the "cpu" string as device not officially part of
+            # the array api standard but widely supported
+            obj = obj.to_device("cpu")
+        elif hasattr(obj, "to"):
+            # pytorch-specific fix as it is not array api compliant
+            obj = obj.to("cpu")
+        else:
+            raise TypeError(f"cannot move {type(obj)} to cpu")
+
+    # convert to numpy
+    try:
+        # Some frameworks implement an __array__ method just to
+        # throw a RuntimeError when used (array_api_strict, dpctl),
+        # or a TypeError (array_api-strict) rather than an AttributeError
+        # therefore a try catch is necessary (logic is essentially a
+        # getattr call + some)
+        obj = obj.__array__()
+    except (AttributeError, RuntimeError, TypeError):
+        # requires numpy 1.23
+        try:
+            obj = np.from_dlpack(obj)
+        except AttributeError:
+            raise NotImplementedError(
+                "Upgrade NumPy >= 1.23 for dlpack support"
+            ) from None
+
+    return obj

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/datatypes/_sycl_usm.py

@@ -17,12 +17,13 @@
 from collections.abc import Iterable
 
 import numpy as np
+import scipy.sparse as sp
 
 from ..utils._third_party import lazy_import
 
 
 @lazy_import("dpctl.memory", "dpctl.tensor")
-def array_to_usm(memory, tensor, queue, array):
+def _array_to_usm(memory, tensor, queue, array):
     try:
         mem = memory.MemoryUSMDevice(array.nbytes, queue=queue)
         mem.copy_from_host(array.tobytes())
@@ -37,7 +38,7 @@ def array_to_usm(memory, tensor, queue, array):
 
 
 @lazy_import("dpnp", "dpctl.tensor")
-def to_dpnp(dpnp, tensor, array):
+def _to_dpnp(dpnp, tensor, array):
     if isinstance(array, tensor.usm_ndarray):
         return dpnp.array(array, copy=False)
     else:
@@ -45,34 +46,18 @@ def to_dpnp(dpnp, tensor, array):
 
 
 def copy_to_usm(queue, array):
-    if hasattr(array, "__array__"):
-        return array_to_usm(queue, array)
+    if hasattr(array, "tobytes"):
+        return _array_to_usm(queue, array)
     else:
-        if isinstance(array, Iterable):
+        if isinstance(array, Iterable) and not sp.issparse(array):
             array = [copy_to_usm(queue, i) for i in array]
         return array
 
 
 def copy_to_dpnp(queue, array):
-    if hasattr(array, "__array__"):
-        return to_dpnp(array_to_usm(queue, array))
+    if hasattr(array, "tobytes"):
+        return _to_dpnp(_array_to_usm(queue, array))
     else:
-        if isinstance(array, Iterable):
+        if isinstance(array, Iterable) and not sp.issparse(array):
             array = [copy_to_dpnp(queue, i) for i in array]
         return array
-
-
-@lazy_import("dpctl.memory")
-def usm_to_numpy(memorymod, item, usm_iface):
-    buffer = memorymod.as_usm_memory(item).copy_to_host()
-    order = "C"
-    if usm_iface["strides"] is not None and len(usm_iface["strides"]) > 1:
-        if usm_iface["strides"][0] < usm_iface["strides"][1]:
-            order = "F"
-    item = np.ndarray(
-        shape=usm_iface["shape"],
-        dtype=usm_iface["typestr"],
-        buffer=buffer,
-        order=order,
-    )
-    return item