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

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

@@ -81,12 +81,7 @@ class DummyEstimatorWithTableConversions:
         # 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,
-        )
+        result_responses_df = from_table(result_responses_table, like=X)
         return X_table, result_responses_table, result_responses_df
 
 
@@ -272,9 +267,7 @@ def test_input_zero_copy_sycl_usm(dataframe, queue, order, dtype):
     X_table = to_table(X_dp)
     _assert_sua_iface_fields(X_dp, X_table)
 
-    X_dp_from_table = from_table(
-        X_table, sycl_queue=queue, sua_iface=sua_iface, xp=X_dp_namespace
-    )
+    X_dp_from_table = from_table(X_table, like=X_dp)
     _assert_sua_iface_fields(X_table, X_dp_from_table)
     _assert_tensor_attr(X_dp, X_dp_from_table, order)
 
@@ -307,8 +300,13 @@ def test_table_conversions_sycl_usm(dataframe, queue, order, data_shape, dtype):
     alg = DummyEstimatorWithTableConversions()
     X_table, result_responses_table, result_responses_df = alg.fit(X)
 
-    for obj in [X_table, result_responses_table, result_responses_df, X]:
+    for obj in [X_table, result_responses_df, X]:
         assert hasattr(obj, "__sycl_usm_array_interface__"), f"{obj} has no SUA interface"
+
+    assert (
+        hasattr(result_responses_table, "__sycl_usm_array_interface__")
+        != queue.sycl_device.is_cpu
+    )
     _assert_sua_iface_fields(X, X_table)
 
     # Work around for saving compute-follows-data execution
@@ -322,13 +320,14 @@ def test_table_conversions_sycl_usm(dataframe, queue, order, data_shape, dtype):
     # after conversion from onedal table to sua array.
     # Test is not turned off because of this. Only check is skipped.
     skip_data_1 = True
-    _assert_sua_iface_fields(
-        result_responses_df,
-        result_responses_table,
-        skip_data_0=skip_data_0,
-        skip_data_1=skip_data_1,
-        skip_syclobj=skip_syclobj,
-    )
+    if not queue.sycl_device.is_cpu:
+        _assert_sua_iface_fields(
+            result_responses_df,
+            result_responses_table,
+            skip_data_0=skip_data_0,
+            skip_data_1=skip_data_1,
+            skip_syclobj=skip_syclobj,
+        )
     assert X.sycl_queue == result_responses_df.sycl_queue
     if order == "F":
         assert X.flags.f_contiguous == result_responses_df.flags.f_contiguous
@@ -579,7 +578,7 @@ def test_table_conversions_dlpack(dataframe, queue, order, data_shape, dtype):
 
 
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("dpctl,numpy,array_api", "cpu,gpu")
+    "dataframe,queue", get_dataframes_and_queues("numpy,dpctl,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
@@ -617,3 +616,71 @@ def test_table___dlpack__(dataframe, queue, order, data_shape, dtype):
     del capsule
     gc.collect()
     assert_allclose(np.squeeze(from_table(X_table)), np.squeeze(X))
+
+
+@pytest.mark.skipif(
+    not hasattr(np, "from_dlpack"), reason="no dlpack support in installed numpy"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("dpctl", "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_convert_to_host_dlpack(dataframe, queue, order, data_shape, dtype):
+    """Test if __dlpack__ attribute can be properly consumed by moving data
+    to host from a SYCL device.
+    """
+    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)
+    # verify that it is on a kDLOneAPI device
+    assert X_df.__dlpack_device__() == X_table.__dlpack_device__()
+
+    # extract to numpy (which should move to host)
+    try:
+        X_out = np.from_dlpack(X_table)
+    except RuntimeError as e:
+        if "Unsupported device in DLTensor." in str(e):
+            pytest.skip("Numpy version cannot request device conversion")
+        else:
+            raise e
+    assert X_out.__dlpack_device__() != X_table.__dlpack_device__()
+
+    if X_out.dtype == X.dtype:
+        assert_array_equal(np.squeeze(X_out), np.squeeze(X))
+    else:
+        assert_allclose(np.squeeze(X_out), np.squeeze(X))
+
+    # verify that table immutability is gone and copy behavior has been followed
+    assert X_out.flags.writeable
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_table_writable_dlpack(queue):
+    """Test if __dlpack__ attribute can be properly consumed by moving data
+    to host from a SYCL device.
+    """
+    xp = pytest.importorskip("dpctl.tensor")
+    X = xp.eye(5, 8, dtype=xp.float32, device=queue)
+    X.flags["W"] = False
+    X_table = to_table(X)
+
+    cpu_device = (backend.kDLCPU, 0)
+    # verify that it is on a kDLOneAPI device
+    assert X.__dlpack_device__() == X_table.__dlpack_device__()
+    assert X_table.__dlpack_device__() != cpu_device
+
+    # verify move to host
+    X_table.__dlpack__(dl_device=cpu_device)
+    # verify error is raised when copy=False
+    with pytest.raises(BufferError, match="Cannot transfer data to requested device"):
+        X_table.__dlpack__(dl_device=cpu_device, copy=False)
+
+    for copy_bool in [True, False]:
+        X_out = xp.from_dlpack(X_table, copy=copy_bool)
+        # verify that table immutability is gone and copy behavior has been followed
+        assert X_out.flags["W"] is copy_bool

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

@@ -21,13 +21,11 @@ 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._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array
-from .pca import BasePCA
+from ..datatypes import from_table, return_type_constructor, to_table
+from .pca import PCA
 
 
-class IncrementalPCA(BasePCA):
+class IncrementalPCA(PCA):
     """Incremental oneDAL PCA estimator.
 
     Parameters
@@ -110,11 +108,11 @@ class IncrementalPCA(BasePCA):
     def partial_train_result(self): ...
 
     def _reset(self):
+        self._onedal_model = None
         self._need_to_finalize = False
         self._queue = None
+        self._outtype = None
         self._partial_result = self.partial_train_result()
-        if hasattr(self, "components_"):
-            del self.components_
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -130,6 +128,8 @@ class IncrementalPCA(BasePCA):
     def partial_fit(self, X, queue=None):
         """Generate partial PCA from batch data in `_partial_result`.
 
+        Computes partial data for PCA on from data batch X.
+
         Parameters
         ----------
         X : array-like of shape (n_samples, n_features)
@@ -146,32 +146,18 @@ class IncrementalPCA(BasePCA):
             Returns the instance itself.
         """
 
-        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_")
+        first_pass = not self._need_to_finalize
         if first_pass:
             self.components_ = None
             self.n_samples_seen_ = n_samples
             self.n_features_in_ = n_features
+            self.n_components_ = self.n_components if self.n_components else X.shape[0]
         else:
             self.n_samples_seen_ += n_samples
 
-        if self.n_components is None:
-            if self.components_ is None:
-                self.n_components_ = min(n_samples, n_features)
-            else:
-                self.n_components_ = self.components_.shape[0]
-        else:
-            self.n_components_ = self.n_components
-
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
         self._queue = queue
 
         X_table = to_table(X, queue=queue)
@@ -183,8 +169,9 @@ class IncrementalPCA(BasePCA):
         self._partial_result = self.partial_train(
             self._params, self._partial_result, X_table
         )
+        if self._onedal_model is not None:
+            self._onedal_model = None
         self._need_to_finalize = True
-        self._queue = queue
         return self
 
     def finalize_fit(self):
@@ -198,22 +185,34 @@ class IncrementalPCA(BasePCA):
         if self._need_to_finalize:
             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)
-            self.singular_values_ = np.nan_to_num(
-                from_table(result.singular_values).ravel()
-            )
-            self.explained_variance_ = np.maximum(
-                from_table(result.eigenvalues).ravel(), 0
-            )
-            self.explained_variance_ratio_ = from_table(
-                result.explained_variances_ratio
-            ).ravel()
-            self.noise_variance_ = self._compute_noise_variance(
-                self.n_components_, min(self.n_samples_seen_, self.n_features_in_)
+
+            (
+                mean_,
+                var_,
+                self.components_,
+                sing_vals_,
+                eigenvalues_,
+                var_ratio,
+            ) = from_table(
+                result.means,
+                result.variances,
+                result.eigenvectors,
+                result.singular_values,
+                result.eigenvalues,
+                result.explained_variances_ratio,
+                like=self._outtype,
             )
+
+            # tables are 2d, but outputs are inherently 1d, reduce dimensions
+            self.mean_ = mean_[0, ...]
+            self.var_ = var_[0, ...]
+            self.singular_values_ = sing_vals_[0, ...]
+            self.explained_variance_ = eigenvalues_[0, ...]
+            self.explained_variance_ratio_ = var_ratio[0, ...]
+
+            # set partial result attributes to defaults
             self._need_to_finalize = False
+            self._outtype = None
             self._queue = None
 
         return self

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -0,0 +1,124 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numbers
+from abc import ABCMeta
+
+import numpy as np
+
+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 PCA(metaclass=ABCMeta):
+
+    def __init__(
+        self,
+        n_components=None,
+        is_deterministic=True,
+        method="cov",
+        whiten=False,
+    ):
+        self.n_components = n_components
+        self.method = method
+        self.is_deterministic = is_deterministic
+        self.whiten = whiten
+        self._onedal_model = None
+
+    # 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):
+        return {
+            "fptype": data.dtype,
+            "method": self.method,
+            "n_components": self.n_components_,
+            "is_deterministic": self.is_deterministic,
+            "whiten": self.whiten,
+        }
+
+    def _create_model(self, queue=None):
+        m = self.model()
+        m.eigenvectors = to_table(self.components_, queue=queue)
+        m.means = to_table(self.mean_, queue=queue)
+        if self.whiten:
+            m.eigenvalues = to_table(self.explained_variance_, queue=queue)
+        return m
+
+    @supports_queue
+    def predict(self, X, queue=None):
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table)
+        if self._onedal_model is None:
+            self._onedal_model = self._create_model(queue)
+        result = self.infer(params, self._onedal_model, X_table)
+        return from_table(result.transformed_data, like=X)
+
+    @supports_queue
+    def fit(self, X, y=None, queue=None):
+
+        X_table = to_table(X, queue=queue)
+        # define n_components_ to allow for external modification of
+        # transforms
+        self.n_components_ = self.n_components
+
+        params = self._get_onedal_params(X_table)
+        hparams = get_hyperparameters("pca", "train")
+        if hparams is not None and not hparams.is_default:
+            result = self.train(params, hparams.backend, X_table)
+        else:
+            result = self.train(params, X_table)
+
+        (
+            mean_,
+            var_,
+            self.components_,
+            sing_vals_,
+            eigenvalues_,
+            var_ratio,
+        ) = from_table(
+            result.means,
+            result.variances,
+            result.eigenvectors,
+            result.singular_values,
+            result.eigenvalues,
+            result.explained_variances_ratio,
+            like=X,
+        )
+
+        # tables are 2d, but outputs are inherently 1d, reduce dimensions
+        self.mean_ = mean_[0, ...]
+        self.var_ = var_[0, ...]
+        self.singular_values_ = sing_vals_[0, ...]
+        self.explained_variance_ = eigenvalues_[0, ...]
+        self.explained_variance_ratio_ = var_ratio[0, ...]
+
+        if self._onedal_model is not None:
+            self._onedal_model = None
+
+        return self

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

@@ -33,14 +33,16 @@ def test_on_gold_data(queue, is_deterministic, whiten, num_blocks, dtype):
     X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
     X = X.astype(dtype=dtype)
     X_split = np.array_split(X, num_blocks)
-    incpca = IncrementalPCA(is_deterministic=is_deterministic, whiten=whiten)
+    incpca = IncrementalPCA(
+        is_deterministic=is_deterministic, whiten=whiten, n_components=2
+    )
 
     for i in range(num_blocks):
         incpca.partial_fit(X_split[i], queue=queue)
 
     result = incpca.finalize_fit()
 
-    transformed_data = incpca.transform(X, queue=queue)
+    transformed_data = incpca.predict(X, queue=queue)
 
     expected_n_components_ = 2
     expected_components_ = np.array([[0.83849224, 0.54491354], [-0.54491354, 0.83849224]])
@@ -118,9 +120,13 @@ def test_on_random_data(
 ):
     seed = 78
     gen = np.random.default_rng(seed)
-    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = gen.uniform(low=-0.3, high=0.7, size=(row_count, column_count))
     X = X.astype(dtype=dtype)
     X_split = np.array_split(X, num_blocks)
+    # it is necessary to limit n_components by the nature of using
+    # np.linalg.eig to verify PCA computation
+    if n_components is None and X_split[0].shape[0] > column_count:
+        n_components = column_count
     incpca = IncrementalPCA(n_components=n_components, whiten=whiten)
 
     for i in range(num_blocks):
@@ -128,7 +134,7 @@ def test_on_random_data(
 
     incpca.finalize_fit()
 
-    transformed_data = incpca.transform(X, queue=queue)
+    transformed_data = incpca.predict(X, queue=queue)
     tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
 
     n_components = incpca.n_components_
@@ -213,7 +219,7 @@ def test_incremental_estimator_pickle(queue, dtype):
     incpca_loaded = pickle.loads(dump)
     seed = 77
     gen = np.random.default_rng(seed)
-    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = gen.uniform(low=-0.3, high=0.7, size=(10, 10))
     X = X.astype(dtype)
     X_split = np.array_split(X, 2)
     incpca.partial_fit(X_split[0], queue=queue)

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

@@ -390,14 +390,14 @@ class BaseForest(BaseEnsemble, metaclass=ABCMeta):
 
         model = self._onedal_model
         queue = QM.get_global_queue()
-        X = to_table(X, queue=queue)
-        params = self._get_onedal_params(X)
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table)
         if hparams is not None and not hparams.is_default:
-            result = self.infer(params, hparams.backend, model, X)
+            result = self.infer(params, hparams.backend, model, X_table)
         else:
-            result = self.infer(params, model, X)
+            result = self.infer(params, model, X_table)
 
-        y = from_table(result.responses, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
+        y = from_table(result.responses, like=X)
         return y
 
     def _predict_proba(self, X, hparams=None):