scikit-learn-intelex 2025.1.0__py311-none-win_amd64.whl → 2025.4.0__py311-none-win_amd64.whl

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

@@ -16,6 +16,7 @@
 
 import numpy as np
 import pytest
+import scipy.sparse as sp
 from numpy.testing import assert_allclose
 
 from onedal import _backend, _is_dpc_backend
@@ -107,8 +108,6 @@ def _test_input_format_c_contiguous_numpy(queue, dtype):
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_input_format_c_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
     _test_input_format_c_contiguous_numpy(queue, dtype)
 
 
@@ -129,8 +128,6 @@ def _test_input_format_f_contiguous_numpy(queue, dtype):
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_input_format_f_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
     _test_input_format_f_contiguous_numpy(queue, dtype)
 
 
@@ -155,8 +152,6 @@ def _test_input_format_c_not_contiguous_numpy(queue, dtype):
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_input_format_c_not_contiguous_numpy(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
     _test_input_format_c_not_contiguous_numpy(queue, dtype)
 
 
@@ -179,8 +174,6 @@ def _test_input_format_c_contiguous_pandas(queue, dtype):
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_input_format_c_contiguous_pandas(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
     _test_input_format_c_contiguous_pandas(queue, dtype)
 
 
@@ -203,8 +196,6 @@ def _test_input_format_f_contiguous_pandas(queue, dtype):
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 def test_input_format_f_contiguous_pandas(queue, dtype):
-    if queue and queue.sycl_device.is_gpu:
-        pytest.skip("Sporadic failures on GPU sycl_queue.")
     _test_input_format_f_contiguous_pandas(queue, dtype)
 
 
@@ -377,23 +368,14 @@ def test_sua_iface_interop_unsupported_dtypes(dataframe, queue, dtype):
 def test_to_table_non_contiguous_input(dataframe, queue):
     if dataframe in "dpnp,dpctl" and not _is_dpc_backend:
         pytest.skip("__sycl_usm_array_interface__ support requires DPC backend.")
-    X = np.mgrid[:10, :10]
+    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
-
-    # TODO:
-    # consistent error message.
-    if dataframe in "dpnp,dpctl":
-        expected_err_msg = (
-            "Unable to convert from SUA interface: only 1D & 2D tensors are allowed"
-        )
-    else:
-        expected_err_msg = "Numpy input Could not convert Python object to onedal table."
-    with pytest.raises(ValueError, match=expected_err_msg):
-        to_table(X)
+    X_t = to_table(X)
+    assert X_t and X_t.shape == (10, 3) and X_t.has_data
 
 
 @pytest.mark.skipif(
@@ -412,3 +394,82 @@ def test_sua_iface_interop_if_no_dpc_backend(dataframe, queue, dtype):
     expected_err_msg = "SYCL usm array conversion to table requires the DPC backend"
     with pytest.raises(RuntimeError, match=expected_err_msg):
         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):
+    # Use a dummy queue as fp32 hardware is not in public testing
+
+    class DummySyclQueue:
+        """This class is designed to act like dpctl.SyclQueue
+        to force dtype conversion"""
+
+        class DummySyclDevice:
+            has_aspect_fp64 = False
+
+        sycl_device = DummySyclDevice()
+
+    queue = DummySyclQueue()
+
+    if sparse:
+        X = sp.random(100, 100, format="csr", dtype=dtype)
+    else:
+        X = np.random.rand(100, 100).astype(dtype)
+
+    if dtype == np.float64:
+        with pytest.warns(
+            RuntimeWarning,
+            match="Data will be converted into float32 from float64 because device does not support it",
+        ):
+            X_table = to_table(X, queue=queue)
+    else:
+        X_table = to_table(X, queue=queue)
+
+    assert X_table.dtype == np.float32
+    if dtype == np.float32 and not sparse:
+        assert_allclose(X, from_table(X_table))
+
+
+@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
+    err_str = ""
+
+    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)):
+        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):
+            to_table(X)
+    else:
+        X_table = to_table(X, queue=queue)
+        from_table(X_table)
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend, 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):
+    # Use a dummy queue as fp32 hardware is not in public testing
+
+    class DummySyclQueue:
+        """This class is designed to act like dpctl.SyclQueue
+        to force dtype conversion"""
+
+        class DummySyclDevice:
+            has_aspect_fp64 = False
+
+        sycl_device = DummySyclDevice()
+
+    queue = DummySyclQueue()
+    test_non_array(X, queue)

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

@@ -18,7 +18,7 @@ import numpy as np
 
 from daal4py.sklearn._utils import get_dtype
 
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 from .pca import BasePCA
 
@@ -99,11 +99,22 @@ class IncrementalPCA(BasePCA):
         self._reset()
 
     def _reset(self):
-        self._partial_result = self._get_backend(
-            "decomposition", "dim_reduction", "partial_train_result"
-        )
+        self._need_to_finalize = False
+        module = self._get_backend("decomposition", "dim_reduction")
         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
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
 
     def partial_fit(self, X, queue):
         """Incremental fit with X. All of X is processed as a single batch.
@@ -144,13 +155,12 @@ class IncrementalPCA(BasePCA):
         self._queue = queue
 
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(X)
+            self._dtype = X_table.dtype
+            self._params = self._get_onedal_params(X_table)
 
-        X_table = to_table(X)
         self._partial_result = self._get_backend(
             "decomposition",
             "dim_reduction",
@@ -160,6 +170,7 @@ class IncrementalPCA(BasePCA):
             self._partial_result,
             X_table,
         )
+        self._need_to_finalize = True
         return self
 
     def finalize_fit(self, queue=None):
@@ -177,28 +188,27 @@ class IncrementalPCA(BasePCA):
         self : object
             Returns the instance itself.
         """
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-        result = self._get_backend(
-            "decomposition",
-            "dim_reduction",
-            "finalize_train",
-            policy,
-            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_)
-        )
-
+        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)
+            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_)
+            )
+        self._need_to_finalize = False
         return self

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

@@ -22,7 +22,7 @@ from sklearn.decomposition._pca import _infer_dimension
 from sklearn.utils.extmath import stable_cumsum
 
 from ..common._base import BaseEstimator
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 
 
 class BasePCA(BaseEstimator, metaclass=ABCMeta):
@@ -48,7 +48,7 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         elif stage == "predict":
             n_components = self.n_components_
         return {
-            "fptype": "float" if data.dtype == np.float32 else "double",
+            "fptype": data.dtype,
             "method": self.method,
             "n_components": n_components,
             "is_deterministic": self.is_deterministic,
@@ -130,11 +130,11 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
     def predict(self, X, queue=None):
         policy = self._get_policy(queue, X)
         model = self._create_model()
-        X = _convert_to_supported(policy, X)
-        params = self._get_onedal_params(X, stage="predict")
+        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, to_table(X)
+            "decomposition", "dim_reduction", "infer", policy, params, model, X_table
         )
         return from_table(result.transformed_data)
 
@@ -151,11 +151,11 @@ class PCA(BasePCA):
         # fails to be converted to oneDAL table
         if isinstance(X, np.ndarray) and not X.flags["OWNDATA"]:
             X = X.copy()
-        X = _convert_to_supported(policy, X)
 
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         result = self._get_backend(
-            "decomposition", "dim_reduction", "train", policy, params, to_table(X)
+            "decomposition", "dim_reduction", "train", policy, params, X
         )
 
         self.mean_ = from_table(result.means).ravel()

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

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from daal4py.sklearn._utils import daal_check_version
+from onedal.datatypes import from_table
 from onedal.decomposition import IncrementalPCA
 from onedal.tests.utils._device_selection import get_queues
 
@@ -196,3 +197,89 @@ def test_on_random_data(
         whiten and queue is not None and queue.sycl_device.device_type.name == "gpu"
     ):
         assert_allclose(transformed_data, expected_transformed_data, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.decomposition import IncrementalPCA
+
+    incpca = IncrementalPCA()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(incpca)
+    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 = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    incpca.partial_fit(X_split[0], queue=queue)
+    incpca_loaded.partial_fit(X_split[0], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(incpca)
+    incpca_loaded = pickle.loads(dump)
+    assert incpca._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert incpca_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(incpca._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(incpca_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(incpca._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        incpca_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sum = from_table(incpca._partial_result.partial_sum)
+    partial_sum_loaded = from_table(incpca_loaded._partial_result.partial_sum)
+    assert_allclose(partial_sum, partial_sum_loaded)
+
+    auxiliary_table_count = incpca._partial_result.auxiliary_table_count
+    auxiliary_table_count_loaded = incpca_loaded._partial_result.auxiliary_table_count
+    assert_allclose(auxiliary_table_count, auxiliary_table_count_loaded)
+
+    for i in range(auxiliary_table_count):
+        aux_table = incpca._partial_result.get_auxiliary_table(i)
+        aux_table_loaded = incpca_loaded._partial_result.get_auxiliary_table(i)
+        assert_allclose(from_table(aux_table), from_table(aux_table_loaded))
+
+    incpca.partial_fit(X_split[1], queue=queue)
+    incpca_loaded.partial_fit(X_split[1], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == False
+
+    incpca.finalize_fit()
+    incpca_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert_allclose(incpca.singular_values_, incpca_loaded.singular_values_, atol=1e-6)
+    assert_allclose(incpca.n_samples_seen_, incpca_loaded.n_samples_seen_, atol=1e-6)
+    assert_allclose(incpca.n_features_in_, incpca_loaded.n_features_in_, atol=1e-6)
+    assert_allclose(incpca.mean_, incpca_loaded.mean_, atol=1e-6)
+    assert_allclose(incpca.var_, incpca_loaded.var_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_, incpca_loaded.explained_variance_, atol=1e-6
+    )
+    assert_allclose(incpca.components_, incpca_loaded.components_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_ratio_,
+        incpca_loaded.explained_variance_ratio_,
+        atol=1e-6,
+    )

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/onedal/ensemble/forest.py

@@ -29,7 +29,7 @@ from sklearnex import get_hyperparameters
 from ..common._base import BaseEstimator
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import (
     _check_array,
     _check_n_features,
@@ -158,7 +158,7 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         seed = rs.randint(0, np.iinfo("i").max)
 
         onedal_params = {
-            "fptype": "float" if data.dtype == np.float32 else "double",
+            "fptype": data.dtype,
             "method": self.algorithm,
             "infer_mode": self.infer_mode,
             "voting_mode": self.voting_mode,
@@ -306,9 +306,9 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         else:
             data = (X, y)
         policy = self._get_policy(queue, *data)
-        data = _convert_to_supported(policy, *data)
+        data = to_table(*data, queue=queue)
         params = self._get_onedal_params(data[0])
-        train_result = module.train(policy, params, *to_table(*data))
+        train_result = module.train(policy, params, *data)
 
         self._onedal_model = train_result.model
 
@@ -354,29 +354,33 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         policy = self._get_policy(queue, X)
 
         model = self._onedal_model
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         if hparams is not None and not hparams.is_default:
-            result = module.infer(policy, params, hparams.backend, model, to_table(X))
+            result = module.infer(policy, params, hparams.backend, model, X)
         else:
-            result = module.infer(policy, params, model, to_table(X))
+            result = module.infer(policy, params, model, X)
 
         y = from_table(result.responses)
         return y
 
-    def _predict_proba(self, X, module, queue):
+    def _predict_proba(self, X, module, queue, hparams=None):
         _check_is_fitted(self)
         X = _check_array(
             X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse=False
         )
         _check_n_features(self, X, False)
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         params["infer_mode"] = "class_probabilities"
 
         model = self._onedal_model
-        result = module.infer(policy, params, model, to_table(X))
+        if hparams is not None and not hparams.is_default:
+            result = module.infer(policy, params, hparams.backend, model, X)
+        else:
+            result = module.infer(policy, params, model, X)
+
         y = from_table(result.probabilities)
         return y
 
@@ -472,8 +476,13 @@ class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
         return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))
 
     def predict_proba(self, X, queue=None):
+        hparams = get_hyperparameters("decision_forest", "infer")
+
         return super()._predict_proba(
-            X, self._get_backend("decision_forest", "classification", None), queue
+            X,
+            self._get_backend("decision_forest", "classification", None),
+            queue,
+            hparams,
         )