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/sklearnex/spmd/neighbors/tests/test_neighbors_spmd.py

@@ -24,9 +24,9 @@ from onedal.tests.utils._dataframes_support import (
 )
 from sklearnex import config_context
 from sklearnex.tests.utils.spmd import (
-    _assert_unordered_allclose,
     _generate_classification_data,
     _generate_regression_data,
+    _generate_statistic_data,
     _get_local_tensor,
     _mpi_libs_and_gpu_available,
     _spmd_assert_allclose,
@@ -94,8 +94,8 @@ def test_knncls_spmd_gold(dataframe, queue):
     spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
-    _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
-    _assert_unordered_allclose(spmd_dists, batch_dists, localize=True)
+    _spmd_assert_allclose(spmd_indcs, batch_indcs)
+    _spmd_assert_allclose(spmd_dists, batch_dists)
     _spmd_assert_allclose(spmd_result, batch_result)
 
 
@@ -164,10 +164,8 @@ def test_knncls_spmd_synthetic(
 
     tol = 1e-4
     if dtype == np.float64:
-        _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
-        _assert_unordered_allclose(
-            spmd_dists, batch_dists, localize=True, rtol=tol, atol=tol
-        )
+        _spmd_assert_allclose(spmd_indcs, batch_indcs)
+        _spmd_assert_allclose(spmd_dists, batch_dists, rtol=tol, atol=tol)
     _spmd_assert_allclose(spmd_result, batch_result)
 
 
@@ -231,8 +229,8 @@ def test_knnreg_spmd_gold(dataframe, queue):
     spmd_result = spmd_model.predict(local_dpt_X_test)
     batch_result = batch_model.predict(X_test)
 
-    _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
-    _assert_unordered_allclose(spmd_dists, batch_dists, localize=True)
+    _spmd_assert_allclose(spmd_indcs, batch_indcs)
+    _spmd_assert_allclose(spmd_dists, batch_dists)
     _spmd_assert_allclose(spmd_result, batch_result)
 
 
@@ -303,8 +301,133 @@ def test_knnreg_spmd_synthetic(
 
     tol = 0.005 if dtype == np.float32 else 1e-4
     if dtype == np.float64:
-        _assert_unordered_allclose(spmd_indcs, batch_indcs, localize=True)
-        _assert_unordered_allclose(
-            spmd_dists, batch_dists, localize=True, rtol=tol, atol=tol
-        )
+        _spmd_assert_allclose(spmd_indcs, batch_indcs)
+        _spmd_assert_allclose(spmd_dists, batch_dists, rtol=tol, atol=tol)
     _spmd_assert_allclose(spmd_result, batch_result, rtol=tol, atol=tol)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_knnsearch_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.neighbors import NearestNeighbors as NearestNeighbors_Batch
+    from sklearnex.spmd.neighbors import NearestNeighbors as NearestNeighbors_SPMD
+
+    # Create gold data and convert to dataframe
+    X_train = np.array(
+        [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2], [10, 10], [9, 9]]
+    )
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure predictions of batch algo match spmd
+    spmd_model = NearestNeighbors_SPMD(n_neighbors=2, algorithm="brute").fit(
+        local_dpt_X_train
+    )
+    batch_model = NearestNeighbors_Batch(n_neighbors=2, algorithm="brute").fit(X_train)
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_train)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_train)
+
+    _spmd_assert_allclose(spmd_indcs, batch_indcs)
+    _spmd_assert_allclose(spmd_dists, batch_dists)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dimensions", [{"n": 100, "m": 10, "k": 2}, {"n": 100000, "m": 100, "k": 100}]
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_knnsearch_spmd_synthetic(
+    dimensions,
+    dataframe,
+    queue,
+    dtype,
+):
+    if dimensions["n"] > 10000 and dtype == np.float32:
+        pytest.skip("Skipping large float32 test due to expected precision issues")
+
+    # Import spmd and batch algo
+    from sklearnex.neighbors import NearestNeighbors as NearestNeighbors_Batch
+    from sklearnex.spmd.neighbors import NearestNeighbors as NearestNeighbors_SPMD
+
+    # Generate data and convert to dataframe
+    X_train = _generate_statistic_data(dimensions["n"], dimensions["m"], dtype=dtype)
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure search results of batch algo match spmd
+    spmd_model = NearestNeighbors_SPMD(
+        n_neighbors=dimensions["k"], algorithm="brute"
+    ).fit(local_dpt_X_train)
+    batch_model = NearestNeighbors_Batch(
+        n_neighbors=dimensions["k"], algorithm="brute"
+    ).fit(X_train)
+    spmd_dists, spmd_indcs = spmd_model.kneighbors(local_dpt_X_train)
+    batch_dists, batch_indcs = batch_model.kneighbors(X_train)
+
+    tol = 0.005 if dtype == np.float32 else 1e-6
+    _spmd_assert_allclose(spmd_indcs, batch_indcs)
+    _spmd_assert_allclose(spmd_dists, batch_dists, rtol=tol, atol=tol)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_knn_spmd_empty_kneighbors(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.neighbors import NearestNeighbors as NearestNeighbors_Batch
+    from sklearnex.spmd.neighbors import (
+        KNeighborsClassifier,
+        KNeighborsRegressor,
+        NearestNeighbors,
+    )
+
+    # Create gold data and convert to dataframe
+    X_train = np.array(
+        [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2], [10, 10], [9, 9]]
+    )
+    y_train = np.array([0, 1, 0, 1, 0, 1, 0, 1])
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_y_train = _convert_to_dataframe(
+        _get_local_tensor(y_train), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Run each estimator without an input to kneighbors() and ensure functionality and equivalence
+    for CurrentEstimator in [KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors]:
+        spmd_model = CurrentEstimator(n_neighbors=1, algorithm="brute").fit(
+            local_dpt_X_train, local_dpt_y_train
+        )
+        batch_model = NearestNeighbors_Batch(n_neighbors=1, algorithm="brute").fit(
+            X_train, y_train
+        )
+        spmd_dists, spmd_indcs = spmd_model.kneighbors()
+        batch_dists, batch_indcs = batch_model.kneighbors()
+
+        _spmd_assert_allclose(spmd_indcs, batch_indcs)
+        _spmd_assert_allclose(spmd_dists, batch_dists)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -19,20 +19,69 @@ from numbers import Number, Real
 
 import numpy as np
 from scipy import sparse as sp
-from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.base import ClassifierMixin
 from sklearn.calibration import CalibratedClassifierCV
 from sklearn.metrics import r2_score
 from sklearn.preprocessing import LabelEncoder
 
 from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.utils.validation import get_requires_y_tag
-from onedal.utils.validation import _check_array, _check_X_y, _column_or_1d
+from onedal.utils.validation import _check_array, _column_or_1d
 
 from .._config import config_context, get_config
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
+if sklearn_check_version("1.6"):
+    from sklearn.calibration import _fit_calibrator
+    from sklearn.frozen import FrozenEstimator
+    from sklearn.utils import indexable
+    from sklearn.utils._response import _get_response_values
+    from sklearn.utils.multiclass import check_classification_targets
+    from sklearn.utils.validation import check_is_fitted
+
+    def _prefit_CalibratedClassifierCV_fit(self, X, y, **fit_params):
+        # This is a stop-gap solution where the cv='prefit' of CalibratedClassifierCV
+        # was removed and the single fold solution needs to be maintained. Discussion
+        # of the mathematical and performance implications of this choice can be found
+        # here: https://github.com/uxlfoundation/scikit-learn-intelex/pull/1879
+        # This is distilled from the sklearn CalibratedClassifierCV for sklearn <1.8 for
+        # use in sklearn > 1.8 to maintain performance.
+        check_classification_targets(y)
+        X, y = indexable(X, y)
+
+        estimator = self._get_estimator()
+
+        self.calibrated_classifiers_ = []
+        check_is_fitted(self.estimator, attributes=["classes_"])
+        self.classes_ = self.estimator.classes_
+
+        predictions, _ = _get_response_values(
+            estimator,
+            X,
+            response_method=["decision_function", "predict_proba"],
+        )
+        if predictions.ndim == 1:
+            # Reshape binary output from `(n_samples,)` to `(n_samples, 1)`
+            predictions = predictions.reshape(-1, 1)
+
+        calibrated_classifier = _fit_calibrator(
+            estimator,
+            predictions,
+            y,
+            self.classes_,
+            self.method,
+        )
+        self.calibrated_classifiers_.append(calibrated_classifier)
+
+        first_clf = self.calibrated_classifiers_[0].estimator
+        if hasattr(first_clf, "n_features_in_"):
+            self.n_features_in_ = first_clf.n_features_in_
+        if hasattr(first_clf, "feature_names_in_"):
+            self.feature_names_in_ = first_clf.feature_names_in_
+        return self
+
 
 class BaseSVM(oneDALEstimator):
 
@@ -262,12 +311,26 @@ class BaseSVC(BaseSVM):
         cfg["target_offload"] = queue
         with config_context(**cfg):
             clf_base.fit(X, y)
-            self.clf_prob = CalibratedClassifierCV(
-                clf_base,
-                ensemble=False,
-                cv="prefit",
-                method="sigmoid",
-            ).fit(X, y)
+
+            # Forced use of FrozenEstimator starting in sklearn 1.6
+            if sklearn_check_version("1.6"):
+                clf_base = FrozenEstimator(clf_base)
+
+                self.clf_prob = CalibratedClassifierCV(
+                    clf_base,
+                    ensemble=False,
+                    method="sigmoid",
+                )
+                # see custom stopgap solution defined above
+                _prefit_CalibratedClassifierCV_fit(self.clf_prob, X, y)
+            else:
+
+                self.clf_prob = CalibratedClassifierCV(
+                    clf_base,
+                    ensemble=False,
+                    cv="prefit",
+                    method="sigmoid",
+                ).fit(X, y)
 
     def _save_attributes(self):
         self.support_vectors_ = self._onedal_estimator.support_vectors_

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/svm/tests/test_svm.py

@@ -18,6 +18,11 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+try:
+    from scipy.sparse import csr_array as csr_class
+except ImportError:
+    from scipy.sparse import csr_matrix as csr_class
+
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -91,3 +96,29 @@ def test_sklearnex_import_nusvr(dataframe, queue):
         _as_numpy(svc.dual_coef_), [[-1.0, 0.611111, 1.0, -0.611111]], rtol=1e-3
     )
     assert_allclose(_as_numpy(svc.support_), [1, 2, 3, 5])
+
+
+# https://github.com/uxlfoundation/scikit-learn-intelex/issues/1880
+def test_works_with_unsorted_indices():
+    from sklearnex.svm import SVC
+
+    X = csr_class(
+        (
+            np.array(
+                [0.44943642, 0.6316672, 0.6316672, 0.44943642, 0.6316672, 0.6316672]
+            ),
+            np.array([1, 4, 3, 1, 2, 0], dtype=np.int32),
+            np.array([0, 3, 6], dtype=np.int32),
+        ),
+        shape=(2, 5),
+    )
+    y = np.array([1, 0])
+    X_test_single = np.array([[1, 0, 0, 0, 0]], dtype=np.float64)
+    X_test_multi = np.array([[1, 0, 0, 0, 0], [1, 0, 0, 0, 0]], dtype=np.float64)
+    model = SVC(probability=True).fit(X, y)
+    pred_single = model.predict_proba(X_test_single)
+    pred_multi = model.predict_proba(X_test_multi)[0]
+    np.testing.assert_array_equal(
+        pred_single.reshape(-1),
+        pred_multi.reshape(-1),
+    )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -52,7 +52,6 @@ TARGET_OFFLOAD_ALLOWED_LOCATIONS = [
 ]
 
 _DESIGN_RULE_VIOLATIONS = {
-    "PCA-fit_transform-call_validate_data": "calls both 'fit' and 'transform'",
     "IncrementalEmpiricalCovariance-score-call_validate_data": "must call clone of itself",
     "SVC(probability=True)-fit-call_validate_data": "SVC fit can use sklearn estimator",
     "NuSVC(probability=True)-fit-call_validate_data": "NuSVC fit can use sklearn estimator",

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -15,6 +15,8 @@
 # ==============================================================================
 
 import logging
+from contextlib import nullcontext
+from unittest.mock import patch
 
 import numpy as np
 import pytest
@@ -160,6 +162,11 @@ def test_fallback_to_host(caplog):
     from sklearnex._device_offload import dispatch
     from sklearnex._utils import PatchingConditionsChain
 
+    # This is done due to the use of name mangling in _sycl_queue_manager which
+    # doesn't operate in classes directly. This impacts sklearnex's ``dispatch``
+    # routine, which expects class methods rather than instance methods.
+    is_fallback = lambda: QM.__global_queue == QM.__fallback_queue
+
     class _Estimator:
         def _onedal_gpu_supported(self, method_name, *data):
             patching_status = PatchingConditionsChain("")
@@ -172,11 +179,7 @@ def test_fallback_to_host(caplog):
 
         def _onedal_test(self, *args, queue=None):
             if args[0] == "cpu":
-                assert (
-                    queue is None
-                    and QM.__global_queue == QM.__fallback_queue
-                    and QM.get_global_queue() is None
-                )
+                assert queue is None and is_fallback() and QM.get_global_queue() is None
             elif args[0] == "gpu":
                 assert queue is not None and QM.get_global_queue() is not None
 
@@ -194,7 +197,7 @@ def test_fallback_to_host(caplog):
                 dispatch(
                     est,
                     "test",
-                    {"onedal": est._onedal_test, "sklearn": None},
+                    {"onedal": _Estimator._onedal_test, "sklearn": None},
                     "cpu" if fallback else "gpu",
                 )
 
@@ -205,3 +208,49 @@ def test_fallback_to_host(caplog):
                 in caplog.messages[start:]
             )
             start = len(caplog.messages)
+
+
+def test_other_device_fallback():
+    # force a fallback to cpu with direct use of dispatch and PatchingConditionsChain
+    # it should complete with allow_fallback_to_host. The data should be moved to cpu
+    # by calling ``to_device``.
+    from onedal.utils import _sycl_queue_manager as QM
+    from sklearnex._device_offload import dispatch
+    from sklearnex._utils import PatchingConditionsChain
+
+    class FakeCUDA:
+        def __init__(self, data):
+            self.__data = data
+
+        def to_device(self, *args):
+            return self.__data
+
+        def __dlpack_device__(self):
+            return (2, 0)
+
+    class _CPUEstimator:
+        def _onedal_cpu_supported(self, method_name, *data):
+            patching_status = PatchingConditionsChain("")
+            return patching_status
+
+        def _onedal_test(self, data, queue=None):
+            assert queue is None and QM.get_global_queue() is None
+            assert isinstance(data, np.ndarray)
+
+    est = _CPUEstimator()
+    err_msg = "Device support is not implemented for the supplied data type."
+    data = FakeCUDA(np.eye(5, 8))
+
+    for fallback in [True, False]:
+        ctx = nullcontext() if fallback else pytest.raises(RuntimeError, match=err_msg)
+        _mock = patch.object(FakeCUDA, "to_device", wraps=data.to_device)
+        with sklearnex.config_context(allow_fallback_to_host=fallback), ctx, _mock as spy:
+            dispatch(
+                est,
+                "test",
+                {"onedal": _CPUEstimator._onedal_test, "sklearn": None},
+                data,
+            )
+            if fallback:
+                # verify ``FakeCUDA.to_device`` was used
+                spy.assert_called_once_with("cpu")

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/tests/test_hyperparameters.py

@@ -0,0 +1,111 @@
+# ==============================================================================
+# Copyright 2024 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 numpy as np
+import pytest
+from sklearn.datasets import make_classification, make_regression
+
+from daal4py.sklearn._utils import daal_check_version
+from sklearnex.decomposition import PCA
+from sklearnex.ensemble import RandomForestClassifier
+from sklearnex.linear_model import IncrementalLinearRegression, LinearRegression
+from sklearnex.preview.covariance import EmpiricalCovariance
+
+# Table of estimators to test hyperparameter reset functionality.
+# Each row contains the following elements:
+#
+# [estimator, estimator_type, operation, hyperparameter_name, non_default_value]
+#
+# estimator:            the estimator class to test. For example, EmpiricalCovariance.
+# estimator_type:       the type of operation to get.
+#                       Possible values: "compute", "regression", "classification".
+# operation:            the argument used in get_hyperparameters() and reset_hyperparameters()
+#                       methods of the estimator.
+# hyperparameter_name:  the name of the hyperparameter to test.
+# non_default_value:    the value to set for the hyperparameter before resetting it.
+#                       This value should be different from the default value of the hyperparameter.
+test_estimators = [
+    [EmpiricalCovariance, "compute", "fit", "cpu_macro_block", 10],
+    [IncrementalLinearRegression, "regression", "fit", "cpu_macro_block", 10],
+    [IncrementalLinearRegression, "regression", "partial_fit", "cpu_macro_block", 10],
+    [LinearRegression, "regression", "fit", "cpu_macro_block", 10],
+]
+
+if daal_check_version((2024, "P", 300)):
+    test_estimators.append(
+        [RandomForestClassifier, "classification", "predict", "block_size", 8]
+    )
+
+if daal_check_version((2025, "P", 700)):
+    test_estimators.append([EmpiricalCovariance, "compute", "fit", "cpu_grain_size", 2])
+    test_estimators.append([PCA, "compute", "fit", "cpu_macro_block", 10])
+
+
+def call_estimator(estimator_object, estimator_type, op, X, y=None):
+    if estimator_type == "compute":
+        return estimator_object.fit(X)
+    elif estimator_type == "regression" or estimator_type == "classification":
+        if y is None:
+            raise ValueError("y must be provided for regression or classification tasks")
+        if op == "partial_fit":
+            result = estimator_object.partial_fit(X, y)
+        else:
+            result = estimator_object.fit(X, y)
+        if op == "predict":
+            return estimator_object.predict(X)
+        else:
+            return result
+    else:
+        raise ValueError(f"Unknown estimator type: {estimator_type}")
+
+
+def test_reset_hyperparameters():
+    for estimator, estimator_type, op, param_name, non_default_value in test_estimators:
+
+        if estimator_type == "compute":
+            X = np.random.rand(100, 5)
+            y = None
+        elif estimator_type == "regression":
+            X, y = make_regression(n_features=5, n_informative=5, random_state=777)
+        elif estimator_type == "classification":
+            X, y = make_classification(n_features=5, random_state=777)
+
+        # Create an instance of the estimator
+        est_object = estimator()
+
+        # Fit the model to the data with the default hyperparameters
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Get the hyperparameters before resetting
+        hparams_before = estimator.get_hyperparameters(op)
+        default_hparam_value = getattr(hparams_before, param_name)
+
+        # Fit the model to the data with non-default hyperparameters
+        setattr(hparams_before, param_name, non_default_value)
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Check if the hyperparameters have been set to non-default values
+        assert getattr(hparams_before, param_name) == non_default_value
+        assert getattr(estimator.get_hyperparameters(op), param_name) == non_default_value
+
+        # Reset the hyperparameters
+        estimator.reset_hyperparameters(op)
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Check if the hyperparameters have been reset to default values
+        assert (
+            getattr(estimator.get_hyperparameters(op), param_name) == default_hparam_value
+        )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -273,7 +273,7 @@ def _kfold_function_template(
 
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues("numpy,pandas,dpctl", "cpu")
+    "dataframe,queue", get_dataframes_and_queues("numpy,pandas", "cpu")
 )
 @pytest.mark.parametrize("estimator", CPU_ESTIMATORS.keys())
 @pytest.mark.parametrize("data_shape", data_shapes)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -27,7 +27,7 @@ import numpy.random as nprnd
 import pytest
 from sklearn.base import BaseEstimator
 
-from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn._utils import _package_check_version, sklearn_check_version
 from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
@@ -168,25 +168,29 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
         )
     elif method and not hasattr(est, method):
         pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
-    elif dataframe == "array_api" and estimator == "PCA" and "score" in method:
-        pytest.skip(
-            f"PCA.{method} has sklearn array_api support which breaks with array_api_dispatching"
-        )
-    elif (
-        dataframe == "array_api"
-        and not sklearn_check_version("1.3")
-        and estimator == "IncrementalEmpiricalCovariance"
-        and method == "score"
-    ):
-        pytest.skip(
-            f"array checking in sklearn <1.3 does not fully support array_api inputs, causes sklearnex-only estimator failure"
-        )
 
     if dataframe == "array_api":
         # as array_api dispatching is experimental, sklearn support isn't guaranteed.
         # the infrastructure from sklearn that sklearnex depends on is also susceptible
         # to failure. In this case compare to sklearn for the same failure. By design
         # the patching of sklearn should act similarly. Technically this is conformance.
+        if (
+            (estimator == "PCA" and "transform" in method)
+            or (estimator == "IncrementalEmpiricalCovariance" and method == "mahalanobis")
+        ) and not _package_check_version("2.0", np.__version__):
+            # issue not to be observed with normal numpy usage
+            pytest.skip(
+                f"numpy backend does not properly handle the __dlpack__ attribute."
+            )
+        elif (
+            not sklearn_check_version("1.3")
+            and estimator == "IncrementalEmpiricalCovariance"
+            and method == "score"
+        ):
+            pytest.skip(
+                f"array checking in sklearn <1.3 does not fully support array_api inputs, causes sklearnex-only estimator failure"
+            )
+
         with config_context(array_api_dispatch=True):
             try:
                 _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/tests/utils/base.py

@@ -398,25 +398,13 @@ def _get_processor_info():
 class DummyEstimator(BaseEstimator):
 
     def fit(self, X, y=None):
-        sua_iface, xp, _ = _get_sycl_namespace(X)
         X_table = to_table(X)
         y_table = to_table(y)
         # The presence of the fitted attributes (ending with a trailing
         # underscore) is required for the correct check. The cleanup of
         # the memory will occur at the estimator instance deletion.
-        if sua_iface:
-            self.x_attr_ = from_table(
-                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
-            )
-            self.y_attr_ = from_table(
-                y_table,
-                sua_iface=sua_iface,
-                sycl_queue=X.sycl_queue if y is None else y.sycl_queue,
-                xp=xp,
-            )
-        else:
-            self.x_attr_ = from_table(X_table)
-            self.y_attr_ = from_table(y_table)
+        self.x_attr_ = from_table(X_table, like=X)
+        self.y_attr_ = from_table(y_table, like=X if y is None else y)
 
         return self
 
@@ -424,13 +412,7 @@ class DummyEstimator(BaseEstimator):
         # Checks if the estimator is fitted by verifying the presence of
         # fitted attributes (ending with a trailing underscore).
         check_is_fitted(self)
-        sua_iface, xp, _ = _get_sycl_namespace(X)
         X_table = to_table(X)
-        if sua_iface:
-            returned_X = from_table(
-                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
-            )
-        else:
-            returned_X = from_table(X_table)
+        returned_X = from_table(X_table, like=X)
 
         return returned_X