scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

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

@@ -19,19 +19,25 @@ import pytest
 import scipy.sparse as sp
 from numpy.testing import assert_allclose
 
-from onedal import _backend, _is_dpc_backend
+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
 
+backend = _dpc_backend or _default_backend
+
 if dpctl_available:
     from onedal.datatypes.tests.common import (
         _assert_sua_iface_fields,
         _assert_tensor_attr,
     )
 
+from daal4py.sklearn._utils import get_dtype
+from onedal.cluster.dbscan import DBSCAN
 from onedal.primitives import linear_kernel
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
+    array_api_modules,
     get_dataframes_and_queues,
 )
 from onedal.tests.utils._device_selection import get_queues
@@ -53,42 +59,61 @@ unsupported_data_shapes = [
 ORDER_DICT = {"F": np.asfortranarray, "C": np.ascontiguousarray}
 
 
-if _is_dpc_backend:
-    from daal4py.sklearn._utils import get_dtype
-    from onedal.cluster.dbscan import BaseDBSCAN
-    from onedal.common._policy import _get_policy
-
-    class DummyEstimatorWithTableConversions:
-
-        def fit(self, X, y=None):
-            sua_iface, xp, _ = _get_sycl_namespace(X)
-            policy = _get_policy(X.sycl_queue, None)
-            bs_DBSCAN = BaseDBSCAN()
-            types = [xp.float32, xp.float64]
-            if get_dtype(X) not in types:
-                X = xp.astype(X, dtype=xp.float64)
-            dtype = get_dtype(X)
-            params = bs_DBSCAN._get_onedal_params(dtype)
-            X_table = to_table(X)
-            # TODO:
-            # check other candidates for the dummy base oneDAL func.
-            # oneDAL backend func is needed to check result table checks.
-            result = _backend.dbscan.clustering.compute(
-                policy, params, X_table, to_table(None)
-            )
-            result_responses_table = result.responses
-            result_responses_df = from_table(
-                result_responses_table,
-                sua_iface=sua_iface,
-                sycl_queue=X.sycl_queue,
-                xp=xp,
-            )
-            return X_table, result_responses_table, result_responses_df
-
-else:
-
-    class DummyEstimatorWithTableConversions:
-        pass
+class DummyEstimatorWithTableConversions:
+
+    @supports_queue
+    def fit(self, X, y=None, queue=None):
+        if not backend.is_dpc:
+            raise RuntimeError("Table conversions should be done with DPC backend.")
+
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        dbscan = DBSCAN()
+        types = [xp.float32, xp.float64]
+        if get_dtype(X) not in types:
+            X = xp.astype(X, dtype=xp.float64)
+        dtype = get_dtype(X)
+        params = dbscan._get_onedal_params(dtype)
+        X_table = to_table(X)
+        # TODO:
+        # check other candidates for the dummy base oneDAL func.
+        # oneDAL backend func is needed to check result table checks.
+        result = dbscan.compute(params, X_table, to_table(None))
+        result_responses_table = result.responses
+        result_responses_df = from_table(
+            result_responses_table,
+            sua_iface=sua_iface,
+            sycl_queue=X.sycl_queue,
+            xp=xp,
+        )
+        return X_table, result_responses_table, result_responses_df
+
+
+class _OnlyDLTensor:
+    """This is a temporary class to force use of the '__dlpack__' logic branch
+    in `to_table` as `__dlpack__` conversion is lower priority by design.
+    dpctl data with CPU SyclQueues are shown as on KDLOneAPI devices, which serve
+    to test the SYCL device support in `__dlpack__` logic without GPU hardware.
+    This takes inspiration from sklearn's `_NotAnArray`."""
+
+    def __init__(self, data):
+        self.data = data
+
+    def __dlpack__(self):
+        return self.data.__dlpack__()
+
+
+def _to_table_supported(array):
+    """This function provides a quick and easy way to determine characteristics
+    or behaviors of the to_table function.  For example, returned errors are
+    tested and are firstly dependent if they are of a proper array type.  This is
+    pertinent for circumstances such as direct use of other dataframe types (e.g.
+    Pandas)."""
+    return (
+        isinstance(array, np.ndarray)
+        or hasattr(array, "__sycl_usm_ndarray_interface__")
+        or hasattr(array, "__dlpack__")
+        or sp.issparse(array)
+    )
 
 
 def _test_input_format_c_contiguous_numpy(queue, dtype):
@@ -221,7 +246,7 @@ def test_conversion_to_table(dtype):
     reason="dpctl is required for checks.",
 )
 @pytest.mark.skipif(
-    not _is_dpc_backend,
+    not backend.is_dpc,
     reason="__sycl_usm_array_interface__ support requires DPC backend.",
 )
 @pytest.mark.parametrize(
@@ -229,7 +254,7 @@ def test_conversion_to_table(dtype):
 )
 @pytest.mark.parametrize("order", ["C", "F"])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32, np.int64])
-def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
+def test_input_zero_copy_sycl_usm(dataframe, queue, order, dtype):
     """Checking that values ​​representing USM allocations `__sycl_usm_array_interface__`
     are preserved during conversion to onedal table.
     """
@@ -257,7 +282,7 @@ def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
     reason="dpctl is required for checks.",
 )
 @pytest.mark.skipif(
-    not _is_dpc_backend,
+    not backend.is_dpc,
     reason="__sycl_usm_array_interface__ support requires DPC backend.",
 )
 @pytest.mark.parametrize(
@@ -266,7 +291,7 @@ def test_input_sua_iface_zero_copy(dataframe, queue, order, dtype):
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_table_conversions(dataframe, queue, order, data_shape, dtype):
+def test_table_conversions_sycl_usm(dataframe, queue, order, data_shape, dtype):
     """Checking that values ​​representing USM allocations `__sycl_usm_array_interface__`
     are preserved during conversion to onedal table and from onedal table to
     sycl usm array dataformat.
@@ -313,32 +338,25 @@ def test_table_conversions(dataframe, queue, order, data_shape, dtype):
     )
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend,
-    reason="__sycl_usm_array_interface__ support requires DPC backend.",
-)
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("data_shape", unsupported_data_shapes)
-def test_sua_iface_interop_invalid_shape(dataframe, queue, data_shape):
+def test_interop_invalid_shape(dataframe, queue, data_shape):
     X = np.zeros(data_shape)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    sua_iface, _, _ = _get_sycl_namespace(X)
 
-    expected_err_msg = (
-        "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
-    )
+    expected_err_msg = r"Input array has wrong dimensionality \(must be 2d\)."
+    if dataframe in "dpctl,dpnp":
+        expected_err_msg = (
+            "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
+        )
     with pytest.raises(ValueError, match=expected_err_msg):
         to_table(X)
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend,
-    reason="__sycl_usm_array_interface__ support requires DPC backend.",
-)
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize(
     "dtype",
@@ -348,17 +366,16 @@ def test_sua_iface_interop_invalid_shape(dataframe, queue, data_shape):
         pytest.param(np.uint64, id=np.dtype(np.uint64).name),
     ],
 )
-def test_sua_iface_interop_unsupported_dtypes(dataframe, queue, dtype):
+def test_interop_unsupported_dtypes(dataframe, queue, dtype):
     # sua iface interobility supported only for oneDAL supported dtypes
     # for input data: int32, int64, float32, float64.
     # Checking some common dtypes supported by dpctl, dpnp for exception
     # raise.
     X = np.zeros((10, 20), dtype=dtype)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
-    sua_iface, _, _ = _get_sycl_namespace(X)
+    expected_err_msg = r"Found unsupported (array|tensor) type"
 
-    expected_err_msg = "Unable to convert from SUA interface: unknown data type"
-    with pytest.raises(ValueError, match=expected_err_msg):
+    with pytest.raises(TypeError, match=expected_err_msg):
         to_table(X)
 
 
@@ -366,27 +383,25 @@ def test_sua_iface_interop_unsupported_dtypes(dataframe, queue, dtype):
     "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,dpnp", "cpu,gpu")
 )
 def test_to_table_non_contiguous_input(dataframe, queue):
-    if dataframe in "dpnp,dpctl" and not _is_dpc_backend:
+    if dataframe in "dpnp,dpctl" and not backend.is_dpc:
         pytest.skip("__sycl_usm_array_interface__ support requires DPC backend.")
     X, _ = np.mgrid[:10, :10]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     X = X[:, :3]
-    sua_iface, _, _ = _get_sycl_namespace(X)
-    # X expected to be non-contiguous.
     assert not X.flags.c_contiguous and not X.flags.f_contiguous
     X_t = to_table(X)
     assert X_t and X_t.shape == (10, 3) and X_t.has_data
 
 
 @pytest.mark.skipif(
-    _is_dpc_backend,
+    backend.is_dpc,
     reason="Required check should be done if no DPC backend.",
 )
 @pytest.mark.parametrize(
     "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-def test_sua_iface_interop_if_no_dpc_backend(dataframe, queue, dtype):
+def test_interop_if_no_dpc_backend_sycl_usm(dataframe, queue, dtype):
     X = np.zeros((10, 20), dtype=dtype)
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     sua_iface, _, _ = _get_sycl_namespace(X)
@@ -396,12 +411,7 @@ def test_sua_iface_interop_if_no_dpc_backend(dataframe, queue, dtype):
         to_table(X)
 
 
-@pytest.mark.skipif(
-    not _is_dpc_backend, reason="Requires DPC backend for dtype conversion"
-)
-@pytest.mark.parametrize("dtype", [np.float32, np.float64])
-@pytest.mark.parametrize("sparse", [True, False])
-def test_low_precision_gpu_conversion(dtype, sparse):
+def _test_low_precision_gpu_conversion(dtype, sparse, dataframe):
     # Use a dummy queue as fp32 hardware is not in public testing
 
     class DummySyclQueue:
@@ -418,7 +428,9 @@ def test_low_precision_gpu_conversion(dtype, sparse):
     if sparse:
         X = sp.random(100, 100, format="csr", dtype=dtype)
     else:
-        X = np.random.rand(100, 100).astype(dtype)
+        X = _convert_to_dataframe(
+            np.random.rand(100, 100).astype(dtype), target_df=dataframe
+        )
 
     if dtype == np.float64:
         with pytest.warns(
@@ -434,21 +446,51 @@ def test_low_precision_gpu_conversion(dtype, sparse):
         assert_allclose(X, from_table(X_table))
 
 
+@pytest.mark.skipif(
+    not backend.is_dpc, reason="Requires DPC backend for dtype conversion"
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("sparse", [True, False])
+def test_low_precision_gpu_conversion_numpy(dtype, sparse):
+    _test_low_precision_gpu_conversion(dtype, sparse, "numpy")
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or "array_api" not in array_api_modules,
+    reason="Requires DPC backend and array_api_strict for the test",
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_low_precision_gpu_conversion_array_api(dtype):
+    _test_low_precision_gpu_conversion(dtype, False, "array_api")
+
+
 @pytest.mark.parametrize("X", [None, 5, "test", True, [], np.pi, lambda: None])
 @pytest.mark.parametrize("queue", get_queues())
 def test_non_array(X, queue):
     # Verify that to and from table doesn't raise errors
     # no guarantee is made about type or content
+    error = ValueError
     err_str = ""
 
+    xp = X.__array_namespace__() if hasattr(X, "__array_namespace__") else np
+    types = [xp.float64, xp.float32, xp.int64, xp.int32]
+
     if np.isscalar(X):
-        if np.atleast_2d(X).dtype not in [np.float64, np.float32, np.int64, np.int32]:
-            err_str = "Found unsupported array type"
-    elif not (X is None or isinstance(X, np.ndarray)):
+        if np.atleast_2d(X).dtype not in types:
+            error = TypeError
+            err_str = r"Found unsupported array type"
+    elif _to_table_supported(X):
+        if X.dtype not in types:
+            error = TypeError
+            err_str = r"Found unsupported (array|tensor) type"
+        if 0 in X.shape:
+            # not set to a consistent string between the various conversions
+            err_str = r".*"
+    elif X is not None:
         err_str = r"\[convert_to_table\] Not available input format for convert Python object to onedal table."
 
     if err_str:
-        with pytest.raises(ValueError, match=err_str):
+        with pytest.raises(error, match=err_str):
             to_table(X)
     else:
         X_table = to_table(X, queue=queue)
@@ -456,10 +498,10 @@ def test_non_array(X, queue):
 
 
 @pytest.mark.skipif(
-    not _is_dpc_backend, reason="Requires DPC backend for dtype conversion"
+    not backend.is_dpc, reason="Requires DPC backend for dtype conversion"
 )
 @pytest.mark.parametrize("X", [None, 5, "test", True, [], np.pi, lambda: None])
-def test_low_precision_non_array(X):
+def test_low_precision_non_array_numpy(X):
     # Use a dummy queue as fp32 hardware is not in public testing
 
     class DummySyclQueue:
@@ -473,3 +515,62 @@ def test_low_precision_non_array(X):
 
     queue = DummySyclQueue()
     test_non_array(X, queue)
+
+
+@pytest.mark.parametrize("X", [5, True, np.pi])
+def test_basic_ndarray_types_numpy(X):
+    # Verify that the various supported basic types can go in and out of tables
+    test_non_array(np.asarray(X), None)
+
+
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy", "cpu,gpu")
+)
+@pytest.mark.parametrize("can_copy", [True, False])
+def test_to_table_non_contiguous_input_dlpack(dataframe, queue, can_copy):
+    X, _ = np.mgrid[:10, :10]
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, dataframe=dataframe)
+    if not hasattr(X_df, "__dlpack__"):
+        pytest.skip("underlying array doesn't support dlpack")
+
+    X_tens = _OnlyDLTensor(X_df[:, :3])
+
+    # give the _OnlyDLTensor the ability to copy
+    if can_copy:
+        X_tens.copy = lambda: _OnlyDLTensor(
+            X_tens.data.__array_namespace__().copy(X_tens.data)
+            if hasattr(X_tens.data, "__array_namespace__")
+            else X_tens.data.copy()
+        )
+        X_table = to_table(X_tens)
+        X_out = from_table(X_table)
+        assert_allclose(X[:, :3], X_out)
+    else:
+        with pytest.raises(RuntimeError, match="Wrong strides"):
+            to_table(X_tens)
+
+
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy", "cpu,gpu")
+)
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_table_conversions_dlpack(dataframe, queue, order, data_shape, dtype):
+    """Test if __dlpack__ data can be properly consumed when only __dlpack__ attribute is exposed.
+    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_tens = _OnlyDLTensor(X_df)
+
+    X_table = to_table(X_tens)
+    X_out = from_table(X_table)
+    print(X_table.shape, X_tens.data.shape)
+    # 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))

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/decomposition/incremental_pca.py

@@ -16,10 +16,14 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import get_dtype
+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 ..utils import _check_array
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 from .pca import BasePCA
 
 
@@ -96,14 +100,24 @@ class IncrementalPCA(BasePCA):
         self.method = method
         self.is_deterministic = is_deterministic
         self.whiten = whiten
+        self._queue = None
         self._reset()
 
+    @bind_default_backend("decomposition.dim_reduction")
+    def finalize_train(self, params, partial_result): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train_result(self): ...
+
     def _reset(self):
         self._need_to_finalize = False
-        module = self._get_backend("decomposition", "dim_reduction")
+        self._queue = None
+        self._partial_result = self.partial_train_result()
         if hasattr(self, "components_"):
             del self.components_
-        self._partial_result = module.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -113,10 +127,10 @@ class IncrementalPCA(BasePCA):
         self.finalize_fit()
         data = self.__dict__.copy()
         data.pop("_queue", None)
-
         return data
 
-    def partial_fit(self, X, queue):
+    @supports_queue
+    def partial_fit(self, X, queue=None):
         """Incremental fit with X. All of X is processed as a single batch.
 
         Parameters
@@ -133,9 +147,17 @@ class IncrementalPCA(BasePCA):
         self : object
             Returns the instance itself.
         """
-        X = _check_array(X)
-        n_samples, n_features = X.shape
 
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+
+        # All data should use the same sycl queue
+        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)
+
+        n_samples, n_features = X.shape
         first_pass = not hasattr(self, "components_")
         if first_pass:
             self.components_ = None
@@ -154,26 +176,20 @@ class IncrementalPCA(BasePCA):
 
         self._queue = queue
 
-        policy = self._get_policy(queue, X)
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
             self._dtype = X_table.dtype
             self._params = self._get_onedal_params(X_table)
 
-        self._partial_result = self._get_backend(
-            "decomposition",
-            "dim_reduction",
-            "partial_train",
-            policy,
-            self._params,
-            self._partial_result,
-            X_table,
+        self._partial_result = self.partial_train(
+            self._params, self._partial_result, X_table
         )
         self._need_to_finalize = True
+        self._queue = queue
         return self
 
-    def finalize_fit(self, queue=None):
+    def finalize_fit(self):
         """
         Finalizes principal components computation and obtains resulting
         attributes from the current `_partial_result`.
@@ -189,12 +205,8 @@ class IncrementalPCA(BasePCA):
             Returns the instance itself.
         """
         if self._need_to_finalize:
-            module = self._get_backend("decomposition", "dim_reduction")
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-            result = module.finalize_train(policy, self._params, self._partial_result)
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_train(self._params, self._partial_result)
             self.mean_ = from_table(result.means).ravel()
             self.var_ = from_table(result.variances).ravel()
             self.components_ = from_table(result.eigenvectors)
@@ -210,5 +222,7 @@ class IncrementalPCA(BasePCA):
             self.noise_variance_ = self._compute_noise_variance(
                 self.n_components_, min(self.n_samples_seen_, self.n_features_in_)
             )
-        self._need_to_finalize = False
+            self._need_to_finalize = False
+            self._queue = None
+
         return self

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -21,11 +21,15 @@ import numpy as np
 from sklearn.decomposition._pca import _infer_dimension
 from sklearn.utils.extmath import stable_cumsum
 
-from ..common._base import BaseEstimator
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+
+from .._config import _get_config
 from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
 
 
-class BasePCA(BaseEstimator, metaclass=ABCMeta):
+class BasePCA(metaclass=ABCMeta):
     """
     Base class for PCA oneDAL implementation.
     """
@@ -42,6 +46,16 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         self.is_deterministic = is_deterministic
         self.whiten = whiten
 
+    # provides direct access to the backend model constructor
+    @bind_default_backend("decomposition.dim_reduction")
+    def model(self): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def train(self, params, X): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def infer(self, params, X, model): ...
+
     def _get_onedal_params(self, data, stage=None):
         if stage is None:
             n_components = self._resolve_n_components_for_training(data.shape)
@@ -119,7 +133,7 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
             return 0.0
 
     def _create_model(self):
-        m = self._get_backend("decomposition", "dim_reduction", "model")
+        m = self.model()
         m.eigenvectors = to_table(self.components_)
         m.means = to_table(self.mean_)
         if self.whiten:
@@ -127,26 +141,30 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         self._onedal_model = m
         return m
 
+    @supports_queue
     def predict(self, X, queue=None):
-        policy = self._get_policy(queue, X)
         model = self._create_model()
         X_table = to_table(X, queue=queue)
         params = self._get_onedal_params(X_table, stage="predict")
-
-        result = self._get_backend(
-            "decomposition", "dim_reduction", "infer", policy, params, model, X_table
-        )
+        result = self.infer(params, model, X_table)
         return from_table(result.transformed_data)
 
+    transform = predict
+
 
 class PCA(BasePCA):
 
+    @supports_queue
     def fit(self, X, y=None, queue=None):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+
         n_samples, n_features = X.shape
         n_sf_min = min(n_samples, n_features)
         self._validate_n_components(self.n_components, n_samples, n_features)
 
-        policy = self._get_policy(queue, X)
         # TODO: investigate why np.ndarray with OWNDATA=FALSE flag
         # fails to be converted to oneDAL table
         if isinstance(X, np.ndarray) and not X.flags["OWNDATA"]:
@@ -154,9 +172,7 @@ class PCA(BasePCA):
 
         X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
-        result = self._get_backend(
-            "decomposition", "dim_reduction", "train", policy, params, X
-        )
+        result = self.train(params, X)
 
         self.mean_ = from_table(result.means).ravel()
         self.variances_ = from_table(result.variances)
@@ -169,10 +185,6 @@ class PCA(BasePCA):
         self.n_samples_ = n_samples
         self.n_features_ = n_features
 
-        U = None
-        S = self.singular_values_
-        Vt = self.components_
-
         n_components = self._resolve_n_components_for_result(X.shape)
         self.n_components_ = n_components
         self.noise_variance_ = self._compute_noise_variance(n_components, n_sf_min)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/decomposition/tests/test_incremental_pca.py

@@ -40,7 +40,7 @@ def test_on_gold_data(queue, is_deterministic, whiten, num_blocks, dtype):
 
     result = incpca.finalize_fit()
 
-    transformed_data = incpca.predict(X, queue=queue)
+    transformed_data = incpca.transform(X, queue=queue)
 
     expected_n_components_ = 2
     expected_components_ = np.array([[0.83849224, 0.54491354], [-0.54491354, 0.83849224]])
@@ -128,7 +128,7 @@ def test_on_random_data(
 
     incpca.finalize_fit()
 
-    transformed_data = incpca.predict(X, queue=queue)
+    transformed_data = incpca.transform(X, queue=queue)
     tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
 
     n_components = incpca.n_components_