scikit-learn-intelex 2025.6.1__py39-none-win_amd64.whl → 2025.8.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/tests/test_incremental_basic_statistics.py

@@ -49,16 +49,16 @@ def test_multiple_options_on_gold_data(queue, weighted, dtype):
         expected_weighted_mean = np.array([0.25, 0.25])
         expected_weighted_min = np.array([0, 0])
         expected_weighted_max = np.array([0.5, 0.5])
-        assert_allclose(expected_weighted_mean, result.mean)
-        assert_allclose(expected_weighted_max, result.max)
-        assert_allclose(expected_weighted_min, result.min)
+        assert_allclose(expected_weighted_mean, result.mean_)
+        assert_allclose(expected_weighted_max, result.max_)
+        assert_allclose(expected_weighted_min, result.min_)
     else:
         expected_mean = np.array([0.5, 0.5])
         expected_min = np.array([0, 0])
         expected_max = np.array([1, 1])
-        assert_allclose(expected_mean, result.mean)
-        assert_allclose(expected_max, result.max)
-        assert_allclose(expected_min, result.min)
+        assert_allclose(expected_mean, result.mean_)
+        assert_allclose(expected_max, result.max_)
+        assert_allclose(expected_min, result.min_)
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -91,7 +91,7 @@ def test_single_option_on_random_data(
             incbs.partial_fit(data_split[i], queue=queue)
     result = incbs.finalize_fit()
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr = function(weighted_data)
@@ -129,7 +129,7 @@ def test_multiple_options_on_random_data(
             incbs.partial_fit(data_split[i], queue=queue)
     result = incbs.finalize_fit()
 
-    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    res_mean, res_max, res_sum = result.mean_, result.max_, result.sum_
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr_mean, gtr_max, gtr_sum = (
@@ -183,7 +183,7 @@ def test_all_option_on_random_data(
     for result_option in options_and_tests:
         function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(result, result_option)
+        res = getattr(result, result_option + "_")
         if weighted:
             gtr = function(weighted_data)
         else:
@@ -273,7 +273,7 @@ def test_incremental_estimator_pickle(queue, dtype):
     for result_option in options_and_tests:
         _, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(incbs, result_option)
-        res_loaded = getattr(incbs_loaded, result_option)
+        res = getattr(incbs, result_option + "_")
+        res_loaded = getattr(incbs_loaded, result_option + "_")
         tol = fp32tol if res.dtype == np.float32 else fp64tol
         assert_allclose(res, res_loaded, atol=tol)

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/cluster/dbscan.py

@@ -16,15 +16,11 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import make2d
 from onedal._device_offload import supports_queue
 
-from .._config import _get_config
 from ..common._backend import bind_default_backend
 from ..common._mixin import ClusterMixin
 from ..datatypes import from_table, to_table
-from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array
 
 
 class DBSCAN(ClusterMixin):
@@ -64,35 +60,21 @@ class DBSCAN(ClusterMixin):
 
     @supports_queue
     def fit(self, X, y=None, sample_weight=None, queue=None):
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        sua_iface, xp, _ = _get_sycl_namespace(X)
-
-        if not use_raw_input:
-            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
-            X = make2d(X)
-        elif sua_iface is not None:
-            queue = X.sycl_queue
-
         X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
         params = self._get_onedal_params(X_table.dtype)
         result = self.compute(params, X_table, sample_weight_table)
 
-        self.labels_ = from_table(result.responses, sycl_queue=queue).ravel()
+        # 2d table but only 1d of information
+        self.labels_ = from_table(result.responses, like=X)[:, 0]
         if (
             result.core_observation_indices is not None
-            and not result.core_observation_indices.kind == "empty"
+            and result.core_observation_indices.kind != "empty"
         ):
+            # 2d table to 1d
             self.core_sample_indices_ = from_table(
-                result.core_observation_indices,
-                sycl_queue=queue,
-            ).ravel()
+                result.core_observation_indices, like=X
+            )[:, 0]
         else:
-            # construct keyword arguments for different namespaces (dptcl takes sycl_queue)
-            kwargs = {"dtype": xp.int32}  # always the same
-            if xp is not np:
-                kwargs["sycl_queue"] = queue
-            self.core_sample_indices_ = xp.empty((0,), **kwargs)
-        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
-        self.n_features_in_ = X.shape[1]
+            self.core_sample_indices_ = None
         return self

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/cluster/kmeans.py

@@ -105,7 +105,7 @@ class _BaseKMeans(TransformerMixin, ClusterMixin, ABC):
         bs = self._get_basic_statistics_backend("variance")
 
         res = bs._compute_raw(X_table, dummy, dtype, is_csr)
-        mean_var = from_table(res["variance"]).mean()
+        mean_var = from_table(res.variance).mean()
 
         return mean_var * rtol
 
@@ -449,6 +449,10 @@ class KMeans(_BaseKMeans):
         X : array-like of shape (n_samples, n_features)
             New data to predict.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         labels : ndarray of shape (n_samples,)
@@ -470,6 +474,10 @@ class KMeans(_BaseKMeans):
         y : Ignored
             Not used, present here for API consistency by convention.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         labels : ndarray of shape (n_samples,)
@@ -490,6 +498,10 @@ class KMeans(_BaseKMeans):
         y : Ignored
             Not used, present here for API consistency by convention.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         X_new : ndarray of shape (n_samples, n_clusters)
@@ -523,9 +535,13 @@ class KMeans(_BaseKMeans):
 
         Parameters
         ----------
-        X: {array-like, sparse matrix} of shape (n_samples, n_features)
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
             New data.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         score: float

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/common/_backend.py

@@ -42,12 +42,18 @@ class BackendManager:
     def get_backend_component(self, module_name: str, component_name: str):
         """Get a component of the backend module.
 
-        Args:
-            module(str): The module to get the component from.
-            component: The component to get from the module.
-
-        Returns:
-            The component of the module.
+        Parameters
+        ----------
+            module_name : str
+                The module to get the component from.
+
+            component_name : str
+                The component to get from the module.
+
+        Returns
+        -------
+            result : method, attribute or module
+                The component of the module.
         """
         submodules = module_name.split(".")
         module = getattr(self.backend, submodules[0])
@@ -68,7 +74,22 @@ spmd_manager = BackendManager(_spmd_backend)
 
 
 class BackendFunction:
-    """Wrapper around backend function to allow setting auxiliary information"""
+    """Wrapper around backend function to allow setting auxiliary information.
+
+    Parameters
+    ----------
+    method : callable
+        Pybind11 backend function.
+
+    backend : Backend
+        Encapsulated oneDAL pybind11 interface.
+
+    name : str
+        Name of function.
+
+    no_policy : bool
+       Flag that a oneDAL policy is not required for function evaluation.
+    """
 
     def __init__(
         self,
@@ -101,14 +122,7 @@ class BackendFunction:
             raise RuntimeError("Executing functions from SPMD backend requires a queue")
 
         # craft the correct policy including the device queue
-        if queue is None:
-            policy = self.backend.host_policy()
-        elif self.backend.is_spmd:
-            policy = self.backend.spmd_data_parallel_policy(queue)
-        elif self.backend.is_dpc:
-            policy = self.backend.data_parallel_policy(queue)
-        else:
-            policy = self.backend.host_policy()
+        policy = self.backend.get_policy(queue)
 
         logger.debug(
             f"Dispatching function '{self.name}' with policy {policy} to {self.backend}"
@@ -128,7 +142,7 @@ def __decorator(
     lookup_name: Optional[str],
     no_policy: bool,
 ) -> Callable[..., Any]:
-    """Decorator to bind a method to the specified backend"""
+    """Decorator to bind a method to the specified backend."""
     if lookup_name is None:
         lookup_name = method.__name__
 
@@ -157,24 +171,30 @@ def bind_default_backend(
     """
     Decorator to bind a method from the default backend to a class.
 
-    This decorator binds a method implementation from the default backend (host/dpc).
-    If the default backend is unavailable, the method is returned without modification.
+    This decorator binds a method implementation from the default backend
+    (host/dpc). If the default backend is unavailable, the method is
+    returned without modification.
 
-    Parameters:
+    Parameters
     ----------
     module_name : str
-        The name of the module where the target function is located (e.g. `covariance`).
+        The name of the module where the target function is located (e.g.
+        `covariance`).
+
     lookup_name : Optional[str], optional
-        The name of the method to look up in the backend module. If not provided,
-        the name of the decorated method is used.
+        The name of the method to look up in the backend module. If not
+        provided, the name of the decorated method is used.
+
     no_policy : bool, optional
-        If True, the method will be decorated without a policy. Default is False.
+        If 'True', the method will be decorated without a policy. Default is
+        False.
 
-    Returns:
+    Returns
     -------
-    Callable[..., Any]
-        The decorated method bound to the implementation in default backend, or the original
-        method if the default backend is unavailable.
+    func : Callable[..., Any]
+        The decorated method bound to the implementation in default
+        backend, or the original method if the default backend is
+        unavailable.
     """
 
     def decorator(method: Callable[..., Any]):
@@ -199,23 +219,28 @@ def bind_spmd_backend(
     Decorator to bind a method from the SPMD backend to a class.
 
     This decorator binds a method implementation from the SPMD backend.
-    If the SPMD backend is unavailable, the method is returned without modification.
+    If the SPMD backend is unavailable, the method is returned without
+    modification.
 
-    Parameters:
+    Parameters
     ----------
     module_name : str
-        The name of the module where the target function is located (e.g. `covariance`).
+        The name of the module where the target function is located (e.g.
+        `covariance`).
+
     lookup_name : Optional[str], optional
-        The name of the method to look up in the backend module. If not provided,
-        the name of the decorated method is used.
+        The name of the method to look up in the backend module. If not
+        provided, the name of the decorated method is used.
+
     no_policy : bool, optional
-        If True, the method will be decorated without a policy. Default is False.
+        If 'True', the method will be decorated without a policy. Default is
+        False.
 
-    Returns:
+    Returns
     -------
-    Callable[..., Any]
-        The decorated method bound to the implementation in SPMD backend, or the original
-        method if the SPMD backend is unavailable.
+    func : Callable[..., Any]
+        The decorated method bound to the implementation in SPMD backend,
+        or the original method if the SPMD backend is unavailable.
     """
 
     def decorator(method: Callable[..., Any]):

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.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,19 +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_map = {}
+        hyperparameters_backend[("decision_forest", "infer")] = (
+            lambda: backend.decision_forest.infer_hyperparameters()
+        )
+    if daal_check_version((2025, "P", 700)):
+        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_")
 
@@ -120,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.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -18,7 +18,7 @@ import pytest
 
 from onedal import _default_backend as backend
 from onedal.tests.utils._device_selection import get_queues
-from onedal.utils._dpep_helpers import dpctl_available
+from onedal.utils._third_party import dpctl_available
 
 
 @pytest.mark.skipif(
@@ -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.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/covariance/covariance.py

@@ -58,10 +58,10 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
 
     Parameters
     ----------
-    method : string, default="dense"
+    method : str, default="dense"
         Specifies computation method. Available methods: "dense".
 
-    bias: bool, default=False
+    bias : bool, default=False
         If True biased estimation of covariance is computed which equals to
         the unbiased one multiplied by (n_samples - 1) / n_samples.
 
@@ -102,29 +102,27 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
             Returns the instance itself.
         """
         use_raw_input = _get_config()["use_raw_input"] is True
-        sua_iface, _, _ = _get_sycl_namespace(X)
+        sua_iface, xp, _ = _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_ = xp.squeeze(from_table(result.means, like=X))
 
         return self

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/covariance/incremental_covariance.py

@@ -29,17 +29,16 @@ from .covariance import BaseEmpiricalCovariance
 
 
 class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
-    """
-    Covariance estimator based on oneDAL implementation.
+    """Covariance estimator based on oneDAL implementation.
 
     Computes sample covariance matrix.
 
     Parameters
     ----------
-    method : string, default="dense"
+    method : str, default="dense"
         Specifies computation method. Available methods: "dense".
 
-    bias: bool, default=False
+    bias : bool, default=False
         If True biased estimation of covariance is computed which equals to
         the unbiased one multiplied by (n_samples - 1) / n_samples.
 
@@ -90,9 +89,7 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
 
     @supports_queue
     def partial_fit(self, X, y=None, queue=None):
-        """
-        Computes partial data for the covariance matrix
-        from data batch X and saves it to `_partial_result`.
+        """Generate partial covariance from batch data in `_partial_result`.
 
         Parameters
         ----------
@@ -103,8 +100,8 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         y : Ignored
             Not used, present for API consistency by convention.
 
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        queue : SyclQueue or None, default=None
+            If not None, use this queue for computation.
 
         Returns
         -------
@@ -132,14 +129,9 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self._queue = queue
 
     def finalize_fit(self):
-        """
-        Finalizes covariance matrix and obtains `covariance_` and `location_`
-        attributes from the current `_partial_result`.
+        """Finalize covariance matrix from the current `_partial_result`.
 
-        Parameters
-        ----------
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        Results are stored in `location_` and `covariance_` attributes.
 
         Returns
         -------

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -14,6 +14,16 @@
 # limitations under the License.
 # ==============================================================================
 
-from ._data_conversion import from_table, to_table
+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__ = ["from_table", "to_table"]
+__all__ = [
+    "copy_to_dpnp",
+    "copy_to_usm",
+    "dlpack_to_numpy",
+    "from_table",
+    "get_torch_queue",
+    "to_table",
+    "return_type_constructor",
+]