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

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

@@ -33,9 +33,6 @@ from ..utils.validation import _check_array, _check_n_features, _check_X_y, _num
 
 
 class BaseLinearRegression(metaclass=ABCMeta):
-    """
-    Base class for LinearRegression oneDAL implementation.
-    """
 
     @abstractmethod
     def __init__(self, fit_intercept, copy_X, algorithm, alpha=0.0):
@@ -114,19 +111,20 @@ class BaseLinearRegression(metaclass=ABCMeta):
 
     @supports_queue
     def predict(self, X, queue=None):
-        """
-        Predict using the linear model.
+        """Predict using the linear model.
+
         Parameters
         ----------
         X : array-like or sparse matrix, shape (n_samples, n_features)
             Samples.
 
-        queue : dpctl.SyclQueue
-            If not None, uses 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
         -------
-        C : array, shape (n_samples, n_targets)
+        y : array, shape (n_samples, n_targets)
             Returns predicted values.
         """
 
@@ -162,8 +160,7 @@ class BaseLinearRegression(metaclass=ABCMeta):
 
 
 class LinearRegression(BaseLinearRegression):
-    """
-    Linear Regression oneDAL implementation.
+    """Linear Regression oneDAL implementation.
 
     Parameters
     ----------
@@ -175,8 +172,8 @@ class LinearRegression(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__(
@@ -185,14 +182,13 @@ class LinearRegression(BaseLinearRegression):
         copy_X=False,
         *,
         algorithm="norm_eq",
-        **kwargs,
     ):
         super().__init__(fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm)
 
     @supports_queue
     def fit(self, X, y, queue=None):
-        """
-        Fit linear model.
+        """Fit linear model.
+
         Parameters
         ----------
         X : {array-like, sparse matrix} of shape (n_samples, n_features)
@@ -201,8 +197,9 @@ class LinearRegression(BaseLinearRegression):
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values. Will be cast to X's dtype if necessary.
 
-        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
         -------
@@ -256,8 +253,7 @@ class LinearRegression(BaseLinearRegression):
 
 
 class Ridge(BaseLinearRegression):
-    """
-    Ridge Regression oneDAL implementation.
+    """Ridge Regression oneDAL implementation.
 
     Parameters
     ----------
@@ -274,8 +270,8 @@ class Ridge(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__(
@@ -285,7 +281,6 @@ class Ridge(BaseLinearRegression):
         copy_X=False,
         *,
         algorithm="norm_eq",
-        **kwargs,
     ):
         super().__init__(
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
@@ -293,8 +288,8 @@ class Ridge(BaseLinearRegression):
 
     @supports_queue
     def fit(self, X, y, queue=None):
-        """
-        Fit linear model.
+        """Fit Ridge regressor.
+
         Parameters
         ----------
         X : {array-like, sparse matrix} of shape (n_samples, n_features)
@@ -303,8 +298,9 @@ class Ridge(BaseLinearRegression):
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values. Will be cast to X's dtype if necessary.
 
-        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
         -------
@@ -344,8 +340,4 @@ class Ridge(BaseLinearRegression):
             packed_coefficients[:, 0],
         )
 
-        if self.coef_.shape[0] == 1 and y.ndim == 1:
-            self.coef_ = self.coef_.ravel()
-            self.intercept_ = self.intercept_[0]
-
         return self

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

@@ -29,7 +29,6 @@ from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin
 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,
@@ -96,7 +95,15 @@ class BaseLogisticRegression(metaclass=ABCMeta):
             self.classes_, y = np.unique(y, return_inverse=True)
             y = y.astype(dtype=np.int32)
         else:
-            self.classes_ = get_unique_values_with_dpep(y)
+            _, xp, _ = _get_sycl_namespace(X)
+            # 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)
+
             n_classes = len(self.classes_)
             if n_classes != 2:
                 raise ValueError("Only binary classification is supported")
@@ -225,9 +232,6 @@ class BaseLogisticRegression(metaclass=ABCMeta):
 
 
 class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
-    """
-    Logistic Regression oneDAL implementation.
-    """
 
     def __init__(
         self,

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/primitives/kernel_functions.py

@@ -49,21 +49,33 @@ def _compute_kernel(params, submodule, X, Y):
 
 @supports_queue
 def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
-    """
-    Compute the linear kernel between X and Y:
-        K(x, y) = scale*dot(x, y^T) + shift
+    """Compute the linear kernel between X and Y.
+
+    K(x, y) = scale*dot(x, y^T) + shift
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
     scale : float, default=1.0
+        Multiplication value to scale the inner product.
+
     shift : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Scaled and shifted Gram matrix output.
     """
     X, Y = _check_inputs(X, Y)
     return _compute_kernel(
@@ -76,21 +88,30 @@ def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
 
 @supports_queue
 def rbf_kernel(X, Y=None, gamma=None, queue=None):
-    """
-    Compute the rbf (gaussian) kernel between X and Y:
-        K(x, y) = exp(-gamma ||x-y||^2)
+    """Compute the rbf (gaussian) kernel between X and Y.
+
+    K(x, y) = exp(-gamma ||x-y||^2)
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
+        An optional second feature array. If `None`, uses `Y=X`.
+
     gamma : float, default=None
         If None, defaults to 1.0 / n_features.
 
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
+
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The RBF kernel.
     """
 
     X, Y = _check_inputs(X, Y)
@@ -103,22 +124,36 @@ def rbf_kernel(X, Y=None, gamma=None, queue=None):
 
 @supports_queue
 def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
-    """
-    Compute the poly kernel between X and Y:
-        K(x, y) = (scale*dot(x, y^T) + shift)**degree
+    """Compute the polynomial kernel between X and Y.
+
+    K(x, y) = (gamma*dot(x, y^T) + coef0)**degree
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
-    scale : float, default=1.0
-    shift : float, default=0.0
-    degree : float, default=3
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    degree : int, default=3
+        Kernel degree.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        The polynomial kernel.
     """
 
     X, Y = _check_inputs(X, Y)
@@ -132,21 +167,33 @@ def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
 
 @supports_queue
 def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
-    """
-    Compute the sigmoid kernel between X and Y:
-        K(x, y) = tanh(scale*dot(x, y^T) + shift)
+    """Compute the sigmoid kernel between X and Y.
+
+        :math:`K(x, y) = \\text{tanh}(\\gamma \\mathbf{x}^T \\mathbf{y}) + \\text{coef}_0)`
     for each pair of rows x in X and y in Y.
 
     Parameters
     ----------
     X : ndarray of shape (n_samples_X, n_features)
+        A feature array.
+
     Y : ndarray of shape (n_samples_Y, n_features)
-    scale : float, default=1.0
-    shift : float, default=0.0
+        An optional second feature array. If `None`, uses `Y=X`.
+
+    gamma : float, default=1.0
+        Multiplication value to scale the inner product.
+
+    coef0 : float, default=0.0
+        Constant offset added to scaled inner product.
+
+    queue : SyclQueue or None, default=None
+        SYCL Queue object for device code execution. Default
+        value None causes computation on host.
 
     Returns
     -------
     kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+        Sigmoid kernel between two arrays.
     """
 
     X, Y = _check_inputs(X, Y)

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

@@ -334,9 +334,6 @@ class BaseSVM(metaclass=ABCMeta):
 
 
 class SVR(RegressorMixin, BaseSVM):
-    """
-    Epsilon--Support Vector Regression.
-    """
 
     def __init__(
         self,
@@ -395,9 +392,6 @@ class SVR(RegressorMixin, BaseSVM):
 
 
 class SVC(ClassifierMixin, BaseSVM):
-    """
-    C-Support Vector Classification.
-    """
 
     def __init__(
         self,
@@ -470,9 +464,6 @@ class SVC(ClassifierMixin, BaseSVM):
 
 
 class NuSVR(RegressorMixin, BaseSVM):
-    """
-    Nu-Support Vector Regression.
-    """
 
     def __init__(
         self,
@@ -530,9 +521,6 @@ class NuSVR(RegressorMixin, BaseSVM):
 
 
 class NuSVC(ClassifierMixin, BaseSVM):
-    """
-    Nu-Support Vector Classification.
-    """
 
     def __init__(
         self,

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

@@ -54,4 +54,4 @@ def test_sklearn_check_version_ban():
 
     # remove this file from the list
     output = "\n".join([i for i in output if "test_common.py" not in i])
-    assert output == "", f"sklearn versioning is occuring in: \n{output}"
+    assert output == "", f"sklearn versioning is occurring in: \n{output}"

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

@@ -13,20 +13,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ===============================================================================
+import os
 
 import pytest
 import scipy.sparse as sp
 
 from sklearnex import get_config
 
-from ...utils._dpep_helpers import dpctl_available, dpnp_available
+from ...utils._third_party import dpctl_available
 
 if dpctl_available:
     import dpctl.tensor as dpt
 
-if dpnp_available:
+try:
     import dpnp
 
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
 try:
     # This should be lazy imported in the
     # future along with other popular
@@ -49,18 +54,22 @@ import pandas as pd
 
 from onedal.tests.utils._device_selection import get_queues
 
+test_frameworks = os.environ.get(
+    "ONEDAL_PYTEST_FRAMEWORKS", "numpy,pandas,dpnp,dpctl,array_api"
+)
+
 
-def get_dataframes_and_queues(
-    dataframe_filter_="numpy,pandas,dpnp,dpctl,array_api", device_filter_="cpu,gpu"
-):
+def get_dataframes_and_queues(dataframe_filter_=None, device_filter_="cpu,gpu"):
     """Get supported dataframes for testing.
 
     This is meant to be used for testing purposes only.
+    It is to be used only for pytest test collection.
 
     Parameters
     ----------
-    dataframe_filter_ : str, default="numpy,pandas,dpnp,dpctl"
+    dataframe_filter_ : str, default=None
         Configure output pytest.params for the certain dataframe formats.
+        When it evaluates False, it will default to value of ``test_frameworks``.
     device_filter_ : str, default="cpu,gpu"
         Configure output pytest.params with certain sycl queue for the dataframe,
         where it is applicable.
@@ -83,6 +92,14 @@ def get_dataframes_and_queues(
     """
     dataframes_and_queues = []
 
+    # filter dataframe_filter_ based on available test frameworks
+    if dataframe_filter_:
+        dataframe_filter_ = ",".join(
+            [i for i in dataframe_filter_.split(",") if i in test_frameworks]
+        )
+    else:
+        dataframe_filter_ = test_frameworks
+
     if "numpy" in dataframe_filter_:
         dataframes_and_queues.append(pytest.param("numpy", None, id="numpy"))
     if "pandas" in dataframe_filter_:

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

@@ -18,7 +18,7 @@ import functools
 
 import pytest
 
-from ...utils._dpep_helpers import dpctl_available
+from ...utils._third_party import dpctl_available
 
 if dpctl_available:
     import dpctl

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -17,27 +17,11 @@
 """Tools to support array_api."""
 
 from collections.abc import Iterable
+from functools import lru_cache
 
 import numpy as np
 
-from ._dpep_helpers import dpctl_available, dpnp_available
-
-if dpctl_available:
-    from dpctl.tensor import usm_ndarray
-
-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
+from ..utils._third_party import _is_subclass_fast
 
 
 def _supports_buffer_protocol(obj):
@@ -68,7 +52,27 @@ def _asarray(data, xp, *args, **kwargs):
 
 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"}
+    return xp.__name__ in {
+        "numpy",
+        "array_api_compat.numpy",
+        "numpy.array_api",
+        "sklearn.externals.array_api_compat.numpy",
+    }
+
+
+@lru_cache(100)
+def _cls_to_sycl_namespace(cls):
+    # use caching to minimize imports, derived from array_api_compat
+    if _is_subclass_fast(cls, "dpctl.tensor", "usm_ndarray"):
+        import dpctl.tensor as dpt
+
+        return dpt
+    elif _is_subclass_fast(cls, "dpnp", "ndarray"):
+        import dpnp
+
+        return dpnp
+    else:
+        raise ValueError(f"SYCL type not recognized: {cls}")
 
 
 def _get_sycl_namespace(*arrays):
@@ -82,12 +86,10 @@ def _get_sycl_namespace(*arrays):
 
     if sua_iface:
         (X,) = sua_iface.values()
-
-        if hasattr(X, "__array_namespace__"):
-            return sua_iface, X.__array_namespace__(), True
-        elif dpnp_available and isinstance(X, dpnp.ndarray):
-            return sua_iface, dpnp, False
-        else:
-            raise ValueError(f"SYCL type not recognized: {sua_iface}")
+        return (
+            sua_iface,
+            _cls_to_sycl_namespace(type(X)),
+            hasattr(X, "__array_namespace__"),
+        )
 
     return sua_iface, np, False

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/utils/_sycl_queue_manager.py

@@ -17,14 +17,7 @@
 from contextlib import contextmanager
 
 from .._config import _get_config
-from ..utils._dpep_helpers import dpctl_available
-
-if dpctl_available:
-    from dpctl import SyclQueue
-else:
-    from onedal import _dpc_backend
-
-    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+from ._third_party import SyclQueue
 
 # This special object signifies that the queue system should be
 # disabled. It will force computation to host. This occurs when the
@@ -36,12 +29,7 @@ __global_queue = None
 
 
 def __create_sycl_queue(target):
-    if SyclQueue is None:
-        # we don't have SyclQueue support
-        return None
-    if target is None:
-        return None
-    if isinstance(target, SyclQueue):
+    if isinstance(target, SyclQueue) or target is None:
         return target
     if isinstance(target, (str, int)):
         return SyclQueue(target)
@@ -49,7 +37,16 @@ def __create_sycl_queue(target):
 
 
 def get_global_queue():
-    """Get the global queue. Retrieve it from the config if not set."""
+    """Get the global queue.
+
+    Retrieve it from the config if not set.
+
+    Returns
+    -------
+    queue: SyclQueue or None
+        SYCL Queue object for device code execution. 'None'
+        signifies computation on host.
+    """
     if (queue := __global_queue) is not None:
         if SyclQueue:
             if queue is __fallback_queue:
@@ -75,7 +72,14 @@ def remove_global_queue():
 
 
 def update_global_queue(queue):
-    """Update the global queue."""
+    """Update the global queue.
+
+    Parameters
+    ----------
+    queue : SyclQueue or None
+        SYCL Queue object for device code execution. None
+        signifies computation on host.
+    """
     global __global_queue
     queue = __create_sycl_queue(queue)
     __global_queue = queue
@@ -88,7 +92,21 @@ def fallback_to_host():
 
 
 def from_data(*data):
-    """Extract the queue from provided data. This updates the global queue as well."""
+    """Extract the queue from provided data.
+
+    This updates the global queue as well.
+
+    Parameters
+    ----------
+    *data : arguments
+        Data objects which may contain :obj:`dpctl.SyclQueue` objects.
+
+    Returns
+    -------
+    queue : SyclQueue or None
+        SYCL Queue object for device code execution. None
+        signifies computation on host.
+    """
     for item in data:
         # iterate through all data objects, extract the queue, and verify that all data objects are on the same device
         try:
@@ -131,24 +149,32 @@ def from_data(*data):
 
 @contextmanager
 def manage_global_queue(queue, *args):
-    """
-    Context manager to manage the global SyclQueue.
+    """Context manager to manage the global SyclQueue.
 
     This context manager updates the global queue with the provided queue,
     verifies that all data objects are on the same device, and restores the
     original queue after work is done.
-    Note: For most applications, the original queue should be `None`, but
-            if there are nested calls to `manage_global_queue()`, it is
-            important to restore the outer queue, rather than setting it to
-            `None`.
-
-    Parameters:
-    queue (SyclQueue or None): The queue to set as the global queue. If None,
-                                the global queue will be determined from the provided data.
-    *args: Additional data objects to verify their device placement.
-
-    Yields:
-    SyclQueue: The global queue after verification.
+
+    Parameters
+    ----------
+    queue : SyclQueue or None
+        The queue to set as the global queue. If None,
+        the global queue will be determined from the provided data.
+
+    *args : arguments
+        Additional data objects to verify their device placement.
+
+    Yields
+    ------
+    SyclQueue : SyclQueue or None
+        The global queue after verification.
+
+    Notes
+    -----
+        For most applications, the original queue should be ``None``, but
+        if there are nested calls to ``manage_global_queue()``, it is
+        important to restore the outer queue, rather than setting it to
+        ``None``.
     """
     original_queue = get_global_queue()
     try: