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

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.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.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -15,5 +15,12 @@
 # ==============================================================================
 
 from ._data_conversion import from_table, to_table
+from ._sycl_usm import copy_to_dpnp, copy_to_usm, usm_to_numpy
 
-__all__ = ["from_table", "to_table"]
+__all__ = [
+    "copy_to_dpnp",
+    "copy_to_usm",
+    "from_table",
+    "to_table",
+    "usm_to_numpy",
+]

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -14,6 +14,8 @@
 # limitations under the License.
 # ==============================================================================
 
+from types import ModuleType
+
 import numpy as np
 
 from onedal import _default_backend as backend
@@ -33,50 +35,34 @@ def _convert_one_to_table(arg, queue=None):
 def to_table(*args, queue=None):
     """Create oneDAL tables from scalars and/or arrays.
 
-    Note: this implementation can be used with scipy.sparse, numpy ndarrays,
-    DPCTL/DPNP usm_ndarrays and scalars. 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. This works
-    for data located on CPU and SYCL-enabled Intel GPUs. Each array may only
-    be of a single datatype (i.e. each must be homogeneous).
-
     Parameters
     ----------
     *args : {scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array}
-        arg1, arg2... The arrays should be given as arguments.
+        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 tables}
+        Converted oneDAL tables.
+
+    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)
 
 
 if backend.is_dpc:
 
-    try:
-        # try/catch is used here instead of dpep_helpers because
-        # of circular import issues of _data_conversion.py and
-        # utils/validation.py. This is a temporary fix until the
-        # issue with dpnp is addressed, at which point this can
-        # be removed entirely.
-        import dpnp
-
-        def _table_to_array(table, xp=None):
-            # By default DPNP ndarray created with a copy.
-            # TODO:
-            # investigate why dpnp.array(table, copy=False) doesn't work.
-            # Work around with using dpctl.tensor.asarray.
-            if xp == dpnp:
-                return dpnp.array(dpnp.dpctl.tensor.asarray(table), copy=False)
-            else:
-                return xp.asarray(table)
-
-    except ImportError:
-
-        def _table_to_array(table, xp=None):
-            return xp.asarray(table)
-
     def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
         # Currently only `__sycl_usm_array_interface__` protocol used to
         # convert into dpnp/dpctl tensors.
@@ -95,7 +81,14 @@ if backend.is_dpc:
                     backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
                 )
             else:
-                return _table_to_array(table, xp=xp)
+                # By default DPNP ndarray created with a copy.
+                # TODO:
+                # investigate why dpnp.array(table, copy=False) doesn't work.
+                # Work around with using dpctl.tensor.asarray.
+                if isinstance(xp, ModuleType) and xp.__name__ == "dpnp":
+                    return xp.array(xp.dpctl.tensor.asarray(table), copy=False)
+                else:
+                    return xp.asarray(table)
 
         return backend.from_table(table)
 

scikit_learn_intelex-2025.7.0.data/data/Lib/site-packages/onedal/datatypes/_sycl_usm.py

@@ -0,0 +1,78 @@
+# ==============================================================================
+# 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 ..utils._third_party import lazy_import
+
+
+@lazy_import("dpctl.memory", "dpctl.tensor")
+def array_to_usm(memory, tensor, queue, array):
+    try:
+        mem = memory.MemoryUSMDevice(array.nbytes, queue=queue)
+        mem.copy_from_host(array.tobytes())
+        return tensor.usm_ndarray(array.shape, array.dtype, buffer=mem)
+    except ValueError as e:
+        # ValueError will raise if device does not support the dtype
+        # retry with float32 (needed for fp16 and fp64 support issues)
+        # try again as float32, if it is a float32 just raise the error.
+        if array.dtype == np.float32:
+            raise e
+        return _array_to_usm(queue, array.astype(np.float32))
+
+
+@lazy_import("dpnp", "dpctl.tensor")
+def to_dpnp(dpnp, tensor, array):
+    if isinstance(array, tensor.usm_ndarray):
+        return dpnp.array(array, copy=False)
+    else:
+        return array
+
+
+def copy_to_usm(queue, array):
+    if hasattr(array, "__array__"):
+        return array_to_usm(queue, array)
+    else:
+        if isinstance(array, Iterable):
+            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))
+    else:
+        if isinstance(array, Iterable):
+            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

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

@@ -14,11 +14,16 @@
 # limitations under the License.
 # ===============================================================================
 
-from onedal.utils._dpep_helpers import dpctl_available, dpnp_available
+from onedal.utils._third_party import dpctl_available
 
-if dpnp_available:
+try:
     import dpnp
 
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+
 if dpctl_available:
     import dpctl
     from dpctl.tensor import usm_ndarray
@@ -99,7 +104,7 @@ if dpctl_available:
         if not skip_data_1:
             assert actual_sua_iface["data"][1] == desired_sua_iface["data"][1]
         # shape: a tuple of integers describing dimensions of an N-dimensional array.
-        # Reformating shapes for check cases (r,) vs (r,1). Contiguous flattened array
+        # Reformatting shapes for check cases (r,) vs (r,1). Contiguous flattened array
         # shape (r,) becoming (r,1) just for the check, since oneDAL supports only (r,1)
         # for 1-D arrays. In code after from_table conversion for 1-D expected outputs
         # xp.ravel or reshape(-1) is used.

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/datatypes/tests/test_data.py

@@ -14,15 +14,17 @@
 # limitations under the License.
 # ==============================================================================
 
+import gc
+
 import numpy as np
 import pytest
 import scipy.sparse as sp
-from numpy.testing import assert_allclose
+from numpy.testing import assert_allclose, assert_array_equal
 
 from onedal import _default_backend, _dpc_backend
 from onedal._device_offload import supports_queue
 from onedal.datatypes import from_table, to_table
-from onedal.utils._dpep_helpers import dpctl_available
+from onedal.utils._third_party import dpctl_available
 
 backend = _dpc_backend or _default_backend
 
@@ -574,3 +576,44 @@ def test_table_conversions_dlpack(dataframe, queue, order, data_shape, dtype):
     # oneDAL table construction sets 1d arrays to 2d arrays with 1 col
     # this is counter the numpy strategy, and requires numpy's squeeze
     assert_allclose(np.squeeze(X), np.squeeze(X_out))
+
+
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy,array_api", "cpu,gpu")
+)
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
+def test_table___dlpack__(dataframe, queue, order, data_shape, dtype):
+    """Test if __dlpack__ attribute can be properly consumed by other frameworks
+    This tests kDLOneAPI devices as well as kDLCPU devices.
+    """
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample(data_shape), dtype=dtype)
+
+    X = ORDER_DICT[order](X)
+
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    X_table = to_table(X_df)
+    if hasattr(X_df, "__dlpack_device__"):
+        assert X_df.__dlpack_device__() == X_table.__dlpack_device__()
+
+    if xp := getattr(X_df, "__array_namespace__", lambda: None)():
+        X_out = xp.from_dlpack(X_table)
+        X_temp = xp.asnumpy(X_out) if hasattr(xp, "asnumpy") else np.asarray(X)
+        if X_temp.dtype == X.dtype:
+            assert_array_equal(np.squeeze(X_temp), np.squeeze(X))
+        else:
+            assert_allclose(np.squeeze(X_temp), np.squeeze(X))
+    else:
+        # only some numpy versions support array_api and from_dlpack
+        pytest.skip(f"{dataframe} does not have an __array_namespace__ attribute")
+
+    # test capsule deletion, should have no impact on underlying memory
+    # important for testing ``dlpack::free_capsule``
+    capsule = X_table.__dlpack__()
+    assert_allclose(np.squeeze(from_table(X_table)), np.squeeze(X))
+    del capsule
+    gc.collect()
+    assert_allclose(np.squeeze(from_table(X_table)), np.squeeze(X))

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/decomposition/incremental_pca.py

@@ -28,9 +28,7 @@ from .pca import BasePCA
 
 
 class IncrementalPCA(BasePCA):
-    """
-    Incremental estimator for PCA based on oneDAL implementation.
-    Allows to compute PCA if data are splitted into batches.
+    """Incremental oneDAL PCA estimator.
 
     Parameters
     ----------
@@ -42,8 +40,8 @@ class IncrementalPCA(BasePCA):
         When True the ``components_`` vectors are chosen in deterministic
         way, otherwise some of them can be oppositely directed.
 
-    method : string, default='cov'
-        Method used on oneDAL side to compute result.
+    method : str, default='cov'
+        Method used in oneDAL computation.
 
     whiten : bool, default=False
         When True the ``components_`` vectors are divided
@@ -86,7 +84,6 @@ class IncrementalPCA(BasePCA):
         noise_variance_ : float
             Equal to the average of (min(n_features, n_samples) - n_components)
             smallest eigenvalues of the covariance matrix of X.
-
     """
 
     def __init__(
@@ -131,7 +128,7 @@ class IncrementalPCA(BasePCA):
 
     @supports_queue
     def partial_fit(self, X, queue=None):
-        """Incremental fit with X. All of X is processed as a single batch.
+        """Generate partial PCA from batch data in `_partial_result`.
 
         Parameters
         ----------
@@ -139,8 +136,9 @@ class IncrementalPCA(BasePCA):
             Training data, where `n_samples` is the number of samples and
             `n_features` is the number of features.
 
-        y : Ignored
-            Not used, present 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
         -------
@@ -190,14 +188,7 @@ class IncrementalPCA(BasePCA):
         return self
 
     def finalize_fit(self):
-        """
-        Finalizes principal components computation and obtains resulting
-        attributes from the current `_partial_result`.
-
-        Parameters
-        ----------
-        queue : dpctl.SyclQueue
-            Not used here, added for API conformance
+        """Finalize statistics from the current `_partial_result`.
 
         Returns
         -------

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -25,14 +25,12 @@ from onedal._device_offload import supports_queue
 from onedal.common._backend import bind_default_backend
 
 from .._config import _get_config
+from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
 from ..utils._array_api import _get_sycl_namespace
 
 
 class BasePCA(metaclass=ABCMeta):
-    """
-    Base class for PCA oneDAL implementation.
-    """
 
     def __init__(
         self,
@@ -172,7 +170,11 @@ class PCA(BasePCA):
 
         X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
-        result = self.train(params, X)
+        hparams = get_hyperparameters("pca", "train")
+        if hparams is not None and not hparams.is_default:
+            result = self.train(params, hparams.backend, X)
+        else:
+            result = self.train(params, X)
 
         self.mean_ = from_table(result.means).ravel()
         self.variances_ = from_table(result.variances)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/ensemble/forest.py

@@ -34,7 +34,6 @@ from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
 from ..datatypes import from_table, to_table
 from ..utils._array_api import _get_sycl_namespace
-from ..utils._dpep_helpers import get_unique_values_with_dpep
 from ..utils.validation import (
     _check_array,
     _check_n_features,
@@ -315,7 +314,13 @@ class BaseForest(BaseEnsemble, metaclass=ABCMeta):
         else:
             if sua_iface is not None:
                 queue = X.sycl_queue
-            self.classes_ = get_unique_values_with_dpep(y)
+            # try catch needed for raw_inputs + array_api data where unlike
+            # numpy the way to yield unique values is via `unique_values`
+            # This should be removed when refactored for gpu zero-copy
+            try:
+                self.classes_ = xp.unique(y)
+            except AttributeError:
+                self.classes_ = xp.unique_values(y)
 
         self.n_features_in_ = X.shape[1]
 
@@ -361,7 +366,7 @@ class BaseForest(BaseEnsemble, metaclass=ABCMeta):
 
     def _create_model(self, module):
         # TODO:
-        # upate error msg.
+        # update error msg.
         raise NotImplementedError("Creating model is not supported.")
 
     def _predict(self, X, hparams=None):
@@ -424,7 +429,9 @@ class BaseForest(BaseEnsemble, metaclass=ABCMeta):
         else:
             result = self.infer(params, model, X)
 
-        return from_table(result.probabilities)
+        # TODO: fix probabilities out of [0, 1] interval on oneDAL side
+        pred = from_table(result.probabilities)
+        return pred.clip(0.0, 1.0)
 
 
 class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
@@ -515,7 +522,8 @@ class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
 
         try:
             return xp.take(
-                xp.asarray(self.classes_), xp.astype(xp.reshape(pred, (-1,)), xp.int64)
+                xp.asarray(self.classes_, device=pred.sycl_queue),
+                xp.astype(xp.reshape(pred, (-1,)), xp.int64),
             )
         except AttributeError:
             return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -29,8 +29,7 @@ from .linear_model import BaseLinearRegression
 
 
 class IncrementalLinearRegression(BaseLinearRegression):
-    """
-    Incremental Linear Regression oneDAL implementation.
+    """Incremental Linear Regression oneDAL implementation.
 
     Parameters
     ----------
@@ -42,8 +41,8 @@ class IncrementalLinearRegression(BaseLinearRegression):
     copy_X : bool, default=True
         If True, X will be copied; else, it may be overwritten.
 
-    algorithm : string, default="norm_eq"
-        Algorithm used for computation on oneDAL side
+    algorithm : str, default="norm_eq"
+        Algorithm used for oneDAL computation.
     """
 
     def __init__(self, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
@@ -79,21 +78,23 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
     @supports_queue
     def partial_fit(self, X, y, queue=None):
-        """
-        Computes partial data for linear regression
-        from data batch X and saves it to `_partial_result`.
+        """Prepare regression from batch data as `_partial_result`.
+
+        Computes partial data for linear regression from data batch X.
+
         Parameters
         ----------
         X : array-like of shape (n_samples, n_features)
             Training data batch, where `n_samples` is the number of samples
             in the batch, and `n_features` is the number of features.
 
-        y: array-like of shape (n_samples,) or (n_samples, n_targets) in
-            case of multiple targets
+        y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Responses for training data.
 
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        queue : SyclQueue or None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         self : object
@@ -136,14 +137,15 @@ class IncrementalLinearRegression(BaseLinearRegression):
         return self
 
     def finalize_fit(self, queue=None):
-        """
-        Finalizes linear regression computation and obtains coefficients
-        from the current `_partial_result`.
+        """Finalize linear regression from the current `_partial_result`.
+
+        Results are stored as `coef_` and `intercept_`.
 
         Parameters
         ----------
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        queue : SyclQueue or None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
 
         Returns
         -------
@@ -176,8 +178,7 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
 
 class IncrementalRidge(BaseLinearRegression):
-    """
-    Incremental Ridge Regression oneDAL implementation.
+    """Incremental Ridge Regression oneDAL implementation.
 
     Parameters
     ----------
@@ -194,8 +195,8 @@ class IncrementalRidge(BaseLinearRegression):
     copy_X : bool, default=True
         If True, X will be copied; else, it may be overwritten.
 
-    algorithm : string, default="norm_eq"
-        Algorithm used for computation on oneDAL side
+    algorithm : str, default="norm_eq"
+        Algorithm used for oneDAL computation.
     """
 
     def __init__(self, alpha=1.0, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
@@ -232,21 +233,23 @@ class IncrementalRidge(BaseLinearRegression):
 
     @supports_queue
     def partial_fit(self, X, y, queue=None):
-        """
-        Computes partial data for ridge regression
-        from data batch X and saves it to `_partial_result`.
+        """Prepare regression from batch data as `_partial_result`.
+
+        Computes partial data for ridge regression from data batch X.
+
         Parameters
         ----------
         X : array-like of shape (n_samples, n_features)
             Training data batch, where `n_samples` is the number of samples
             in the batch, and `n_features` is the number of features.
 
-        y: array-like of shape (n_samples,) or (n_samples, n_targets) in
-            case of multiple targets
+        y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Responses for training data.
 
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         self : object
@@ -280,14 +283,13 @@ class IncrementalRidge(BaseLinearRegression):
         return self
 
     def finalize_fit(self, queue=None):
-        """
-        Finalizes ridge regression computation and obtains coefficients
-        from the current `_partial_result`.
+        """Finalize ridge regression from the current ``_partial_result``.
 
         Parameters
         ----------
-        queue : dpctl.SyclQueue
-            If available, uses provided queue for computations.
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
 
         Returns
         -------