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

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.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:

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/cluster/tests/test_dbscan_spmd.py

@@ -21,6 +21,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_clustering_data,
     _get_local_tensor,
@@ -69,9 +70,17 @@ def test_dbscan_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_dbscan_spmd_synthetic(
-    n_samples, n_features_and_eps, centers, min_samples, dataframe, queue, dtype
+    n_samples,
+    n_features_and_eps,
+    centers,
+    min_samples,
+    dataframe,
+    queue,
+    dtype,
+    use_raw_input,
 ):
     n_features, eps = n_features_and_eps
     # Import spmd and batch algo
@@ -87,7 +96,9 @@ def test_dbscan_spmd_synthetic(
     )
 
     # Ensure labels from fit of batch algo matches spmd
-    spmd_model = DBSCAN_SPMD(eps=eps, min_samples=min_samples).fit(local_dpt_data)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model = DBSCAN_SPMD(eps=eps, min_samples=min_samples).fit(local_dpt_data)
     batch_model = DBSCAN_Batch(eps=eps, min_samples=min_samples).fit(data)
 
     _spmd_assert_allclose(spmd_model.labels_, batch_model.labels_)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/cluster/tests/test_kmeans_spmd.py

@@ -22,6 +22,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 (
     _assert_kmeans_labels_allclose,
     _assert_unordered_allclose,
@@ -108,9 +109,10 @@ def test_kmeans_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_kmeans_spmd_synthetic(
-    n_samples, n_features, n_clusters, dataframe, queue, dtype
+    n_samples, n_features, n_clusters, dataframe, queue, dtype, use_raw_input
 ):
     # Import spmd and batch algo
     from sklearnex.cluster import KMeans as KMeans_Batch
@@ -141,7 +143,10 @@ def test_kmeans_spmd_synthetic(
     # Ensure labels from fit of batch algo matches spmd, using same init
     spmd_model = KMeans_SPMD(
         n_clusters=n_clusters, init=spmd_model_init.cluster_centers_, random_state=0
-    ).fit(local_dpt_X_train)
+    )
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train)
     batch_model = KMeans_Batch(
         n_clusters=n_clusters, init=spmd_model_init.cluster_centers_, random_state=0
     ).fit(X_train)
@@ -161,7 +166,9 @@ def test_kmeans_spmd_synthetic(
     # assert_allclose(spmd_model.n_iter_, batch_model.n_iter_, atol=1)
 
     # Ensure predictions of batch algo match spmd
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     _assert_kmeans_labels_allclose(

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_covariance_spmd.py

@@ -22,6 +22,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,
@@ -80,9 +81,10 @@ def test_covariance_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_covariance_spmd_synthetic(
-    n_samples, n_features, assume_centered, dataframe, queue, dtype
+    n_samples, n_features, assume_centered, dataframe, queue, dtype, use_raw_input
 ):
     # Import spmd and batch algo
     # TODO: Align sklearnex spmd to sklearnex estimator with bias and swap onedal with sklearnex
@@ -97,9 +99,10 @@ def test_covariance_spmd_synthetic(
     )
 
     # Ensure results of batch algo match spmd
-    spmd_result = EmpiricalCovariance_SPMD(assume_centered=assume_centered).fit(
-        local_dpt_data
-    )
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = EmpiricalCovariance_SPMD(assume_centered=assume_centered).fit(
+            local_dpt_data
+        )
     batch_result = EmpiricalCovariance_Batch(assume_centered=assume_centered).fit(data)
 
     atol = 1e-5 if dtype == np.float32 else 1e-7

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_incremental_covariance_spmd.py

@@ -22,6 +22,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,
@@ -149,9 +150,17 @@ def test_incremental_covariance_partial_fit_spmd_gold(
     "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_incremental_covariance_partial_fit_spmd_synthetic(
-    n_samples, n_features, num_blocks, assume_centered, dataframe, queue, dtype
+    n_samples,
+    n_features,
+    num_blocks,
+    assume_centered,
+    dataframe,
+    queue,
+    dtype,
+    use_raw_input,
 ):
     # Import spmd and batch algo
     from sklearnex.covariance import IncrementalEmpiricalCovariance
@@ -174,7 +183,9 @@ def test_incremental_covariance_partial_fit_spmd_synthetic(
         local_dpt_data = _convert_to_dataframe(
             split_local_data[i], sycl_queue=queue, target_df=dataframe
         )
-        inccov_spmd.partial_fit(local_dpt_data)
+        # Configure raw input status for spmd estimator
+        with config_context(use_raw_input=use_raw_input):
+            inccov_spmd.partial_fit(local_dpt_data)
 
     inccov.fit(dpt_data)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_incremental_pca_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,
@@ -218,6 +219,7 @@ def test_incremental_pca_fit_spmd_random(
 @pytest.mark.parametrize("num_samples", [200, 400])
 @pytest.mark.parametrize("num_features", [10, 20])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_incremental_pca_partial_fit_spmd_random(
     dataframe,
@@ -228,6 +230,7 @@ def test_incremental_pca_partial_fit_spmd_random(
     num_samples,
     num_features,
     dtype,
+    use_raw_input,
 ):
     # Import spmd and non-SPMD algo
     from sklearnex.preview.decomposition import IncrementalPCA
@@ -252,7 +255,9 @@ def test_incremental_pca_partial_fit_spmd_random(
             split_local_X[i], sycl_queue=queue, target_df=dataframe
         )
         dpt_X = _convert_to_dataframe(X_split[i], sycl_queue=queue, target_df=dataframe)
-        incpca_spmd.partial_fit(local_dpt_X)
+        # Configure raw input status for spmd estimator
+        with config_context(use_raw_input=use_raw_input):
+            incpca_spmd.partial_fit(local_dpt_X)
         incpca.partial_fit(dpt_X)
 
     for attribute in attributes_to_compare:
@@ -263,7 +268,9 @@ def test_incremental_pca_partial_fit_spmd_random(
             err_msg=f"{attribute} is incorrect",
         )
 
-    y_trans_spmd = incpca_spmd.transform(dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        y_trans_spmd = incpca_spmd.transform(dpt_X_test)
     y_trans = incpca.transform(dpt_X_test)
 
     assert_allclose(_as_numpy(y_trans_spmd), _as_numpy(y_trans), atol=tol)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_pca_spmd.py

@@ -22,6 +22,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,
@@ -91,9 +92,10 @@ def test_pca_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_pca_spmd_synthetic(
-    n_samples, n_features, n_components, whiten, dataframe, queue, dtype
+    n_samples, n_features, n_components, whiten, dataframe, queue, dtype, use_raw_input
 ):
     # TODO: Resolve issues with batch fallback and lack of support for n_rows_rank < n_cols
     if n_components == "mle" or n_components == 3:
@@ -113,7 +115,10 @@ def test_pca_spmd_synthetic(
     )
 
     # Ensure results of batch algo match spmd
-    spmd_result = PCA_SPMD(n_components=n_components, whiten=whiten).fit(local_dpt_data)
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = PCA_SPMD(n_components=n_components, whiten=whiten).fit(
+            local_dpt_data
+        )
     batch_result = PCA_Batch(n_components=n_components, whiten=whiten).fit(data)
 
     tol = 1e-3 if dtype == np.float32 else 1e-7

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/ensemble/tests/test_forest_spmd.py

@@ -22,6 +22,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_classification_data,
     _generate_regression_data,
@@ -108,9 +109,17 @@ def test_rfcls_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_rfcls_spmd_synthetic(
-    n_samples, n_features_and_classes, n_estimators, max_depth, dataframe, queue, dtype
+    n_samples,
+    n_features_and_classes,
+    n_estimators,
+    max_depth,
+    dataframe,
+    queue,
+    dtype,
+    use_raw_input,
 ):
     n_features, n_classes = n_features_and_classes
     # Import spmd and batch algo
@@ -137,11 +146,16 @@ def test_rfcls_spmd_synthetic(
     # Ensure predictions of batch algo match spmd
     spmd_model = RandomForestClassifier_SPMD(
         n_estimators=n_estimators, max_depth=max_depth, random_state=0
-    ).fit(local_dpt_X_train, local_dpt_y_train)
+    )
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = RandomForestClassifier_Batch(
         n_estimators=n_estimators, max_depth=max_depth, random_state=0
     ).fit(X_train, y_train)
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     pytest.skip("SPMD and batch random forest results not aligned")
@@ -225,9 +239,10 @@ def test_rfreg_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_rfreg_spmd_synthetic(
-    n_samples, n_features, n_estimators, max_depth, dataframe, queue, dtype
+    n_samples, n_features, n_estimators, max_depth, dataframe, queue, dtype, use_raw_input
 ):
     # Import spmd and batch algo
     from sklearnex.ensemble import RandomForestRegressor as RandomForestRegressor_Batch
@@ -251,13 +266,15 @@ def test_rfreg_spmd_synthetic(
     )
 
     # Ensure predictions of batch algo match spmd
-    spmd_model = RandomForestRegressor_Batch(
-        n_estimators=n_estimators, max_depth=max_depth, random_state=0
-    ).fit(local_dpt_X_train, local_dpt_y_train)
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model = RandomForestRegressor_Batch(
+            n_estimators=n_estimators, max_depth=max_depth, random_state=0
+        ).fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = RandomForestRegressor_Batch(
         n_estimators=n_estimators, max_depth=max_depth, random_state=0
     ).fit(X_train, y_train)
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     # TODO: remove skips when SPMD and batch are aligned

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_incremental_linear_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_regression_data,
     _get_local_tensor,
@@ -115,9 +116,10 @@ def test_incremental_linear_regression_fit_spmd_gold(
 @pytest.mark.parametrize("num_blocks", [1, 2])
 @pytest.mark.parametrize("macro_block", [None, 1024])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_incremental_linear_regression_partial_fit_spmd_gold(
-    dataframe, queue, fit_intercept, num_blocks, macro_block, dtype
+    dataframe, queue, fit_intercept, num_blocks, macro_block, dtype, use_raw_input
 ):
     # Import spmd and non-SPMD algo
     from sklearnex.linear_model import IncrementalLinearRegression
@@ -175,7 +177,9 @@ def test_incremental_linear_regression_partial_fit_spmd_gold(
         local_dpt_y = _convert_to_dataframe(
             split_local_y[i], sycl_queue=queue, target_df=dataframe
         )
-        inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
+        # Configure raw input status for spmd estimator
+        with config_context(use_raw_input=use_raw_input):
+            inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
 
     inclin.fit(dpt_X, dpt_y)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_linear_regression_spmd.py

@@ -22,6 +22,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_regression_data,
     _get_local_tensor,
@@ -103,8 +104,11 @@ def test_linear_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
-def test_linear_spmd_synthetic(n_samples, n_features, dataframe, queue, dtype):
+def test_linear_spmd_synthetic(
+    n_samples, n_features, dataframe, queue, dtype, use_raw_input
+):
     # Import spmd and batch algo
     from sklearnex.linear_model import LinearRegression as LinearRegression_Batch
     from sklearnex.spmd.linear_model import LinearRegression as LinearRegression_SPMD
@@ -131,7 +135,10 @@ def test_linear_spmd_synthetic(n_samples, n_features, dataframe, queue, dtype):
         )
 
     # ensure trained model of batch algo matches spmd
-    spmd_model = LinearRegression_SPMD().fit(local_dpt_X_train, local_dpt_y_train)
+    # Configure raw input status for spmd estimator
+    spmd_model = LinearRegression_SPMD()
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = LinearRegression_Batch().fit(X_train, y_train)
 
     tol = 1e-3 if dtype == np.float32 else 1e-7
@@ -139,7 +146,9 @@ def test_linear_spmd_synthetic(n_samples, n_features, dataframe, queue, dtype):
     assert_allclose(spmd_model.intercept_, batch_model.intercept_, rtol=tol, atol=tol)
 
     # ensure predictions of batch algo match spmd
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     _spmd_assert_allclose(spmd_result, batch_result, rtol=tol, atol=tol)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_logistic_regression_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_classification_data,
     _get_local_tensor,
@@ -114,8 +115,11 @@ def test_logistic_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
-def test_logistic_spmd_synthetic(n_samples, n_features, C, tol, dataframe, queue, dtype):
+def test_logistic_spmd_synthetic(
+    n_samples, n_features, C, tol, dataframe, queue, dtype, use_raw_input
+):
     # TODO: Resolve numerical issues when n_rows_rank < n_cols
     if n_samples <= n_features:
         pytest.skip("Numerical issues when rank rows < columns")
@@ -143,9 +147,10 @@ def test_logistic_spmd_synthetic(n_samples, n_features, C, tol, dataframe, queue
     dpt_X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
 
     # Ensure trained model of batch algo matches spmd
-    spmd_model = LogisticRegression_SPMD(
-        random_state=0, solver="newton-cg", C=C, tol=tol
-    ).fit(local_dpt_X_train, local_dpt_y_train)
+    spmd_model = LogisticRegression_SPMD(random_state=0, solver="newton-cg", C=C, tol=tol)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = LogisticRegression_Batch(
         random_state=0, solver="newton-cg", C=C, tol=tol
     ).fit(dpt_X_train, dpt_y_train)
@@ -156,7 +161,9 @@ def test_logistic_spmd_synthetic(n_samples, n_features, C, tol, dataframe, queue
     assert_allclose(spmd_model.intercept_, batch_model.intercept_, rtol=tol, atol=tol)
 
     # Ensure predictions of batch algo match spmd
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(dpt_X_test)
 
     _spmd_assert_allclose(spmd_result, _as_numpy(batch_result))

{scikit_learn_intelex-2025.4.0.data/data/Lib/site-packages/daal4py/mb → scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/sklearnex/spmd/neighbors}/__init__.py

@@ -14,6 +14,6 @@
 # limitations under the License.
 # ==============================================================================
 
-from .model_builders import GBTDAALBaseModel, convert_model
+from onedal.spmd.neighbors import KNeighborsClassifier, KNeighborsRegressor
 
-__all__ = ["GBTDAALBaseModel", "convert_model"]
+__all__ = ["KNeighborsClassifier", "KNeighborsRegressor"]

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/spmd/neighbors/tests/test_neighbors_spmd.py

@@ -22,6 +22,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 (
     _assert_unordered_allclose,
     _generate_classification_data,
@@ -111,6 +112,7 @@ def test_knncls_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_knncls_spmd_synthetic(
     n_samples,
@@ -120,6 +122,7 @@ def test_knncls_spmd_synthetic(
     dataframe,
     queue,
     dtype,
+    use_raw_input,
     metric="euclidean",
 ):
     n_features, n_classes = n_features_and_classes
@@ -145,13 +148,18 @@ def test_knncls_spmd_synthetic(
     # Ensure predictions of batch algo match spmd
     spmd_model = KNeighborsClassifier_SPMD(
         n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
-    ).fit(local_dpt_X_train, local_dpt_y_train)
+    )
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = KNeighborsClassifier_Batch(
         n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
     ).fit(X_train, y_train)
     spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
     batch_dists, batch_indcs = batch_model.kneighbors(X_test)
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     tol = 1e-4
@@ -244,9 +252,18 @@ def test_knnreg_spmd_gold(dataframe, queue):
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_knnreg_spmd_synthetic(
-    n_samples, n_features, n_neighbors, weights, metric, dataframe, queue, dtype
+    n_samples,
+    n_features,
+    n_neighbors,
+    weights,
+    metric,
+    dataframe,
+    queue,
+    dtype,
+    use_raw_input,
 ):
     # Import spmd and batch algo
     from sklearnex.neighbors import KNeighborsRegressor as KNeighborsRegressor_Batch
@@ -270,13 +287,18 @@ def test_knnreg_spmd_synthetic(
     # Ensure predictions of batch algo match spmd
     spmd_model = KNeighborsRegressor_SPMD(
         n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
-    ).fit(local_dpt_X_train, local_dpt_y_train)
+    )
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_model.fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = KNeighborsRegressor_Batch(
         n_neighbors=n_neighbors, weights=weights, metric=metric, algorithm="brute"
     ).fit(X_train, y_train)
     spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_test)
     batch_dists, batch_indcs = batch_model.kneighbors(X_test)
-    spmd_result = spmd_model.predict(local_dpt_X_test)
+    # Configure raw input status for spmd estimator
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
     tol = 0.005 if dtype == np.float32 else 1e-4

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -15,7 +15,6 @@
 # ==============================================================================
 
 import warnings
-from abc import ABC
 from numbers import Number, Real
 
 import numpy as np
@@ -26,18 +25,16 @@ from sklearn.metrics import r2_score
 from sklearn.preprocessing import LabelEncoder
 
 from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils import _check_array, _check_X_y, _column_or_1d
+from daal4py.sklearn.utils.validation import get_requires_y_tag
+from onedal.utils.validation import _check_array, _check_X_y, _column_or_1d
 
 from .._config import config_context, get_config
-from .._utils import PatchableEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
+from ..utils.validation import validate_data
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
 
-
-class BaseSVM(PatchableEstimator, BaseEstimator, ABC):
+class BaseSVM(oneDALEstimator):
 
     @property
     def _dual_coef_(self):
@@ -156,30 +153,20 @@ class BaseSVM(PatchableEstimator, BaseEstimator, ABC):
                 )
 
         if y is None:
-            if self._get_tags()["requires_y"]:
+            if get_requires_y_tag(self):
                 raise ValueError(
                     f"This {self.__class__.__name__} estimator "
                     f"requires y to be passed, but the target y is None."
                 )
-        # using onedal _check_X_y to insure X and y are contiguous
         # finite check occurs in onedal estimator
-        if sklearn_check_version("1.0"):
-            X, y = validate_data(
-                self,
-                X,
-                y,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
-        else:
-            X, y = _check_X_y(
-                X,
-                y,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-                accept_sparse="csr",
-            )
+        X, y = validate_data(
+            self,
+            X,
+            y,
+            dtype=[np.float64, np.float32],
+            ensure_all_finite=False,
+            accept_sparse="csr",
+        )
         y = self._validate_targets(y)
         sample_weight = self._get_sample_weight(X, y, sample_weight)
         return X, y, sample_weight