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/sklearnex/neighbors/knn_classification.py

@@ -18,21 +18,17 @@ from sklearn.metrics import accuracy_score
 from sklearn.neighbors._classification import (
     KNeighborsClassifier as _sklearn_KNeighborsClassifier,
 )
-from sklearn.neighbors._unsupervised import NearestNeighbors as _sklearn_NearestNeighbors
-from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
+from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import KNeighborsClassifier as onedal_KNeighborsClassifier
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import check_feature_names
 from .common import KNeighborsDispatchingBase
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_KNeighborsClassifier._validate_data
-
 
 @control_n_jobs(
     decorated_methods=["fit", "predict", "predict_proba", "kneighbors", "score"]
@@ -44,58 +40,28 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
             **_sklearn_KNeighborsClassifier._parameter_constraints
         }
 
-    if sklearn_check_version("1.0"):
-
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-            )
-
-    else:
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
+    def __init__(
+        self,
+        n_neighbors=5,
+        *,
+        weights="uniform",
+        algorithm="auto",
+        leaf_size=30,
+        p=2,
+        metric="minkowski",
+        metric_params=None,
+        n_jobs=None,
+    ):
+        super().__init__(
+            n_neighbors=n_neighbors,
+            weights=weights,
+            algorithm=algorithm,
+            leaf_size=leaf_size,
+            metric=metric,
+            p=p,
+            metric_params=metric_params,
+            n_jobs=n_jobs,
+        )
 
     def fit(self, X, y):
         dispatch(
@@ -113,8 +79,7 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
     @wrap_output_data
     def predict(self, X):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "predict",
@@ -128,8 +93,7 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
     @wrap_output_data
     def predict_proba(self, X):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "predict_proba",
@@ -143,8 +107,7 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
     @wrap_output_data
     def score(self, X, y, sample_weight=None):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "score",
@@ -160,8 +123,8 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
@@ -183,13 +146,8 @@ class KNeighborsClassifier(KNeighborsDispatchingBase, _sklearn_KNeighborsClassif
             "p": self.effective_metric_params_["p"],
         }
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
         self._onedal_estimator = onedal_KNeighborsClassifier(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
+        self._onedal_estimator.requires_y = get_requires_y_tag(self)
         self._onedal_estimator.effective_metric_ = self.effective_metric_
         self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
         self._onedal_estimator.fit(X, y, queue=queue)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/neighbors/knn_regression.py

@@ -18,20 +18,17 @@ from sklearn.metrics import r2_score
 from sklearn.neighbors._regression import (
     KNeighborsRegressor as _sklearn_KNeighborsRegressor,
 )
-from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
+from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import KNeighborsRegressor as onedal_KNeighborsRegressor
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import check_feature_names
 from .common import KNeighborsDispatchingBase
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_KNeighborsRegressor._validate_data
-
 
 @control_n_jobs(decorated_methods=["fit", "predict", "kneighbors", "score"])
 class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegressor):
@@ -41,58 +38,28 @@ class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegresso
             **_sklearn_KNeighborsRegressor._parameter_constraints
         }
 
-    if sklearn_check_version("1.0"):
-
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-            )
-
-    else:
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
+    def __init__(
+        self,
+        n_neighbors=5,
+        *,
+        weights="uniform",
+        algorithm="auto",
+        leaf_size=30,
+        p=2,
+        metric="minkowski",
+        metric_params=None,
+        n_jobs=None,
+    ):
+        super().__init__(
+            n_neighbors=n_neighbors,
+            weights=weights,
+            algorithm=algorithm,
+            leaf_size=leaf_size,
+            metric=metric,
+            p=p,
+            metric_params=metric_params,
+            n_jobs=n_jobs,
+        )
 
     def fit(self, X, y):
         dispatch(
@@ -110,8 +77,7 @@ class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegresso
     @wrap_output_data
     def predict(self, X):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "predict",
@@ -125,8 +91,7 @@ class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegresso
     @wrap_output_data
     def score(self, X, y, sample_weight=None):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "score",
@@ -142,8 +107,8 @@ class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegresso
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
@@ -165,13 +130,8 @@ class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegresso
             "p": self.effective_metric_params_["p"],
         }
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
         self._onedal_estimator = onedal_KNeighborsRegressor(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
+        self._onedal_estimator.requires_y = get_requires_y_tag(self)
         self._onedal_estimator.effective_metric_ = self.effective_metric_
         self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
         self._onedal_estimator.fit(X, y, queue=queue)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/neighbors/knn_unsupervised.py

@@ -19,16 +19,13 @@ from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import NearestNeighbors as onedal_NearestNeighbors
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import check_feature_names
 from .common import KNeighborsDispatchingBase
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_NearestNeighbors._validate_data
-
 
 @control_n_jobs(decorated_methods=["fit", "kneighbors", "radius_neighbors"])
 class NearestNeighbors(KNeighborsDispatchingBase, _sklearn_NearestNeighbors):
@@ -77,8 +74,8 @@ class NearestNeighbors(KNeighborsDispatchingBase, _sklearn_NearestNeighbors):
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
@@ -139,13 +136,8 @@ class NearestNeighbors(KNeighborsDispatchingBase, _sklearn_NearestNeighbors):
             "p": self.effective_metric_params_["p"],
         }
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
         self._onedal_estimator = onedal_NearestNeighbors(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
+        self._onedal_estimator.requires_y = get_requires_y_tag(self)
         self._onedal_estimator.effective_metric_ = self.effective_metric_
         self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
         self._onedal_estimator.fit(X, y, queue=queue)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/preview/covariance/covariance.py

@@ -34,11 +34,7 @@ from ..._utils import (
     PatchingConditionsChain,
     register_hyperparameters,
 )
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_EmpiricalCovariance._validate_data
+from ...utils.validation import validate_data
 
 
 @register_hyperparameters({"fit": get_hyperparameters("covariance", "compute")})
@@ -99,10 +95,7 @@ class EmpiricalCovariance(PatchableEstimator, _sklearn_EmpiricalCovariance):
     def fit(self, X, y=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
-        if sklearn_check_version("0.23"):
-            X = validate_data(self, X, force_all_finite=False)
-        else:
-            X = check_array(X, force_all_finite=False)
+        X = validate_data(self, X, ensure_all_finite=False)
 
         dispatch(
             self,
@@ -119,10 +112,7 @@ class EmpiricalCovariance(PatchableEstimator, _sklearn_EmpiricalCovariance):
     # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
     @wrap_output_data
     def mahalanobis(self, X):
-        if sklearn_check_version("1.0"):
-            X = validate_data(self, X, reset=False)
-        else:
-            X = check_array(X)
+        X = validate_data(self, X, reset=False)
 
         precision = self.get_precision()
         with config_context(assume_finite=True):

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

@@ -22,35 +22,37 @@ from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.decomposition import IncrementalPCA as onedal_IncrementalPCA
 
+from ..._config import get_config
 from ..._device_offload import dispatch, wrap_output_data
-from ..._utils import IntelEstimator, PatchingConditionsChain
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_IncrementalPCA._validate_data
+from ..._utils import (
+    ExtensionEstimator,
+    PatchingConditionsChain,
+    _add_inc_serialization_note,
+)
+from ...utils.validation import validate_data
 
 
 @control_n_jobs(
     decorated_methods=["fit", "partial_fit", "transform", "_onedal_finalize_fit"]
 )
-class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
+class IncrementalPCA(ExtensionEstimator, _sklearn_IncrementalPCA):
+
+    _need_to_finalize_attrs = {
+        "mean_",
+        "explained_variance_",
+        "explained_variance_ratio_",
+        "n_components_",
+        "components_",
+        "noise_variance_",
+        "singular_values_",
+        "var_",
+    }
 
     def __init__(self, n_components=None, *, whiten=False, copy=True, batch_size=None):
         super().__init__(
             n_components=n_components, whiten=whiten, copy=copy, batch_size=batch_size
         )
         self._need_to_finalize = False
-        self._need_to_finalize_attrs = {
-            "mean_",
-            "explained_variance_",
-            "explained_variance_ratio_",
-            "n_components_",
-            "components_",
-            "noise_variance_",
-            "singular_values_",
-            "var_",
-        }
 
     _onedal_incremental_pca = staticmethod(onedal_IncrementalPCA)
 
@@ -58,8 +60,10 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
             self._onedal_finalize_fit()
-        X = check_array(X, dtype=[np.float64, np.float32])
-        return self._onedal_estimator.predict(X, queue)
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            X = check_array(X, dtype=[np.float64, np.float32])
+        return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_fit_transform(self, X, queue=None):
         self._onedal_fit(X, queue)
@@ -68,17 +72,11 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
     def _onedal_partial_fit(self, X, check_input=True, queue=None):
         first_pass = not hasattr(self, "_onedal_estimator")
 
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        # never check input when using raw input
+        check_input &= use_raw_input is False
         if check_input:
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self, X, dtype=[np.float64, np.float32], reset=first_pass
-                )
-            else:
-                X = check_array(
-                    X,
-                    dtype=[np.float64, np.float32],
-                    copy=self.copy,
-                )
+            X = validate_data(self, X, dtype=[np.float64, np.float32], reset=first_pass)
 
         n_samples, n_features = X.shape
 
@@ -114,23 +112,18 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
         self._onedal_estimator.partial_fit(X, queue=queue)
         self._need_to_finalize = True
 
-    def _onedal_finalize_fit(self, queue=None):
+    def _onedal_finalize_fit(self):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit(queue=queue)
+        self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
 
-        if sklearn_check_version("1.0"):
             X = validate_data(self, X, dtype=[np.float64, np.float32], copy=self.copy)
-        else:
-            X = check_array(
-                X,
-                dtype=[np.float64, np.float32],
-                copy=self.copy,
-            )
 
         n_samples, n_features = X.shape
 
@@ -147,7 +140,7 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue)
 
-        self._onedal_finalize_fit(queue=queue)
+        self._onedal_finalize_fit()
 
         return self
 
@@ -161,18 +154,20 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
     _onedal_gpu_supported = _onedal_supported
 
     def __getattr__(self, attr):
-        if attr in self._need_to_finalize_attrs:
-            if hasattr(self, "_onedal_estimator"):
-                if self._need_to_finalize:
-                    self._onedal_finalize_fit()
-                return getattr(self._onedal_estimator, attr)
-            else:
+        # finalize the fit if requested attribute requires it
+        if attr in IncrementalPCA._need_to_finalize_attrs:
+            if "_onedal_estimator" not in self.__dict__:
+                # _onedal_estimator required to finalize the fit
                 raise AttributeError(
-                    f"'{self.__class__.__name__}' object has no attribute '{attr}'"
+                    f"Requested postfit attribute '{attr}' before fitting the model."
                 )
-        if attr in self.__dict__:
-            return self.__dict__[attr]
-
+            if self.__dict__["_need_to_finalize"]:
+                self._onedal_finalize_fit()
+        # join attributes of the class and the onedal_estimator to provide common interface
+        joined = self.__dict__ | self.__dict__.get("_onedal_estimator", {}).__dict__
+        if attr in joined:
+            return joined[attr]
+        # raise AttributeError if attribute is neither in this class nor in _onedal_estimator
         raise AttributeError(
             f"'{self.__class__.__name__}' object has no attribute '{attr}'"
         )
@@ -226,17 +221,8 @@ class IncrementalPCA(IntelEstimator, _sklearn_IncrementalPCA):
             X,
         )
 
-    __doc__ = (
-        _sklearn_IncrementalPCA.__doc__
-        + """
-
-    Note
-    ----
-    Serializing instances of this class will trigger a forced finalization of calculations.
-    Since finalize_fit can't be dispatched without directly provided queue
-    and the dispatching policy can't be serialized, the computation is finalized
-    during serialization call and the policy is not saved in serialized data.
-    """
+    __doc__ = _add_inc_serialization_note(
+        _sklearn_IncrementalPCA.__doc__ + "\n" + r"%incremental_serialization_note%"
     )
     fit.__doc__ = _sklearn_IncrementalPCA.fit.__doc__
     fit_transform.__doc__ = _sklearn_IncrementalPCA.fit_transform.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_basic_statistics_spmd.py

@@ -23,6 +23,7 @@ from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
+from sklearnex import config_context
 from sklearnex.tests.utils.spmd import (
     _generate_statistic_data,
     _get_local_tensor,
@@ -62,7 +63,8 @@ def test_basic_stats_spmd_gold(dataframe, queue):
     )
 
     # Ensure results of batch algo match spmd
-    spmd_result = BasicStatistics_SPMD().fit(local_dpt_data)
+    spmd = BasicStatistics_SPMD()
+    spmd_result = spmd.fit(local_dpt_data)
     batch_result = BasicStatistics_Batch().fit(data)
 
     for option in options_and_tests:
@@ -80,8 +82,11 @@ def test_basic_stats_spmd_gold(dataframe, queue):
     "dataframe,queue",
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
-def test_basic_stats_spmd_synthetic(n_samples, n_features, dataframe, queue, dtype):
+def test_basic_stats_spmd_synthetic(
+    n_samples, n_features, dataframe, queue, dtype, use_raw_input
+):
     # Import spmd and batch algo
     from onedal.basic_statistics import BasicStatistics as BasicStatistics_Batch
     from sklearnex.spmd.basic_statistics import BasicStatistics as BasicStatistics_SPMD
@@ -94,7 +99,9 @@ def test_basic_stats_spmd_synthetic(n_samples, n_features, dataframe, queue, dty
     )
 
     # Ensure results of batch algo match spmd
-    spmd_result = BasicStatistics_SPMD().fit(local_dpt_data)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = BasicStatistics_SPMD().fit(local_dpt_data)
     batch_result = BasicStatistics_Batch().fit(data)
 
     tol = 1e-5 if dtype == np.float32 else 1e-7

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_incremental_basic_statistics_spmd.py

@@ -23,6 +23,7 @@ from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
+from sklearnex import config_context
 from sklearnex.tests.utils.spmd import (
     _generate_statistic_data,
     _get_local_tensor,
@@ -250,9 +251,10 @@ def test_incremental_basic_statistics_single_option_partial_fit_spmd_gold(
 @pytest.mark.parametrize("n_samples", [100, 10000])
 @pytest.mark.parametrize("n_features", [10, 100])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_incremental_basic_statistics_partial_fit_spmd_synthetic(
-    dataframe, queue, num_blocks, weighted, n_samples, n_features, dtype
+    dataframe, queue, num_blocks, weighted, n_samples, n_features, dtype, use_raw_input
 ):
     # Import spmd and batch algo
     from sklearnex.basic_statistics import IncrementalBasicStatistics
@@ -292,9 +294,11 @@ def test_incremental_basic_statistics_partial_fit_spmd_synthetic(
             dpt_weights = _convert_to_dataframe(
                 split_weights[i], sycl_queue=queue, target_df=dataframe
             )
-        incbs_spmd.partial_fit(
-            local_dpt_data, sample_weight=local_dpt_weights if weighted else None
-        )
+        # Configure raw input status for spmd estimator
+        with config_context(use_raw_input=use_raw_input):
+            incbs_spmd.partial_fit(
+                local_dpt_data, sample_weight=local_dpt_weights if weighted else None
+            )
         incbs.partial_fit(dpt_data, sample_weight=dpt_weights if weighted else None)
 
     for option in options_and_tests: