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

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/preview/decomposition/tests/test_incremental_pca.py

@@ -16,9 +16,12 @@
 
 import numpy as np
 import pytest
+import scipy.sparse as sp
 from numpy.testing import assert_allclose
+from sklearn.base import clone
+from sklearn.datasets import load_iris
 
-from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -334,3 +337,54 @@ def test_sklearnex_incremental_estimatior_pickle(dataframe, queue, dtype):
         incpca_loaded.explained_variance_ratio_,
         atol=1e-6,
     )
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("numpy,dpctl"))
+def test_changed_estimated_attributes(with_array_api, dataframe, queue):
+    # check that attributes necessary for the PCA onedal estimator match
+    # changes occurring in the sklearnex estimator
+    X, y = load_iris(return_X_y=True)
+
+    X_0 = _convert_to_dataframe(X[y == 0], sycl_queue=queue, target_df=dataframe)
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    est0 = IncrementalPCA(n_components=4).fit(X_0)
+    est = clone(est0)
+    assert not hasattr(est, "_onedal_estimator")
+    est.fit(X)
+    assert not np.array_equal(_as_numpy(est.transform(X)), _as_numpy(est0.transform(X)))
+
+    # copy over parameters necessary for transform
+    est.mean_ = est0.mean_
+    est.components_ = est0.components_
+    est.explained_variance_ = est0.explained_variance_
+    est.n_components_ = est0.n_components_  # is trivial but exercises the logic
+
+    assert np.array_equal(_as_numpy(est.transform(X)), _as_numpy(est0.transform(X)))
+
+
+@pytest.mark.skipif(
+    not sklearn_check_version("1.5"),
+    reason='svd_solver="auto" does not support sparse inputs',
+)
+@pytest.mark.allow_sklearn_fallback
+def test_create_model_behavior():
+    # verify that fit fallbacks does not break ``transform`` as the oneDAL
+    # model is generated JIT
+
+    X, _ = load_iris(return_X_y=True)
+    # generate a onedal estimator
+    est = IncrementalPCA(n_components=3)
+    X_trans = est.fit_transform(X)
+
+    # force data to sparse for a fallback to sklearn
+    X_sp = sp.csr_matrix(X)
+    est.fit(X_sp)
+    # In the case of a fallback, the model should be set to none by clobbered
+    # fitted attributes
+    assert est._onedal_estimator._onedal_model is None
+
+    X_trans_sparse = est.transform(X)
+    # use allclose as data was fit with sklearn and onedal on the same data
+    # but using different backends
+    assert_allclose(X_trans, X_trans_sparse)

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/covariance.py

@@ -14,8 +14,11 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.spmd.covariance import EmpiricalCovariance
+from onedal.spmd.covariance import EmpiricalCovariance as onedal_EmpiricalCovariance
 
-# TODO:
-# Currently it uses `onedal` module interface.
-# Add sklearnex dispatching.
+from ...preview.covariance import EmpiricalCovariance as EmpiricalCovariance_Batch
+
+
+class EmpiricalCovariance(EmpiricalCovariance_Batch):
+    __doc__ = EmpiricalCovariance_Batch.__doc__
+    _onedal_covariance = staticmethod(onedal_EmpiricalCovariance)

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

@@ -42,7 +42,9 @@ from sklearnex.tests.utils.spmd import (
 @pytest.mark.mpi
 def test_covariance_spmd_gold(dataframe, queue):
     # Import spmd and batch algo
-    from onedal.covariance import EmpiricalCovariance as EmpiricalCovariance_Batch
+    from sklearnex.preview.covariance import (
+        EmpiricalCovariance as EmpiricalCovariance_Batch,
+    )
     from sklearnex.spmd.covariance import EmpiricalCovariance as EmpiricalCovariance_SPMD
 
     # Create gold data and convert to dataframe
@@ -81,7 +83,7 @@ def test_covariance_spmd_gold(dataframe, queue):
 @pytest.mark.parametrize("assume_centered", [True, False])
 @pytest.mark.parametrize(
     "dataframe,queue",
-    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+    get_dataframes_and_queues(dataframe_filter_="dpnp", device_filter_="gpu"),
 )
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("use_raw_input", [True, False])
@@ -90,8 +92,9 @@ def test_covariance_spmd_synthetic(
     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
-    from onedal.covariance import EmpiricalCovariance as EmpiricalCovariance_Batch
+    from sklearnex.preview.covariance import (
+        EmpiricalCovariance as EmpiricalCovariance_Batch,
+    )
     from sklearnex.spmd.covariance import EmpiricalCovariance as EmpiricalCovariance_SPMD
 
     # Generate data and convert to dataframe

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

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -191,5 +192,9 @@ def test_incremental_covariance_partial_fit_spmd_synthetic(
 
     tol = 1e-7
 
-    assert_allclose(inccov_spmd.covariance_, inccov.covariance_, atol=tol)
-    assert_allclose(inccov_spmd.location_, inccov.location_, atol=tol)
+    assert_allclose(
+        _as_numpy(inccov_spmd.covariance_), _as_numpy(inccov.covariance_), atol=tol
+    )
+    assert_allclose(
+        _as_numpy(inccov_spmd.location_), _as_numpy(inccov.location_), atol=tol
+    )

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/pca.py

@@ -14,8 +14,10 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.spmd.decomposition import PCA
+from onedal.spmd.decomposition import PCA as onedal_PCA
 
-# TODO:
-# Currently it uses `onedal` module interface.
-# Add sklearnex dispatching.
+from ...decomposition import PCA as base_PCA
+
+
+class PCA(base_PCA):
+    _onedal_PCA = staticmethod(onedal_PCA)

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_incremental_pca_spmd.py

@@ -262,8 +262,8 @@ def test_incremental_pca_partial_fit_spmd_random(
 
     for attribute in attributes_to_compare:
         assert_allclose(
-            getattr(incpca, attribute),
-            getattr(incpca_spmd, attribute),
+            _as_numpy(getattr(incpca, attribute)),
+            _as_numpy(getattr(incpca_spmd, attribute)),
             atol=tol,
             err_msg=f"{attribute} is incorrect",
         )

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

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -122,12 +123,24 @@ def test_pca_spmd_synthetic(
     batch_result = PCA_Batch(n_components=n_components, whiten=whiten).fit(data)
 
     tol = 1e-3 if dtype == np.float32 else 1e-7
-    assert_allclose(spmd_result.mean_, batch_result.mean_, atol=tol)
-    assert_allclose(spmd_result.components_, batch_result.components_, atol=tol, rtol=tol)
-    assert_allclose(spmd_result.singular_values_, batch_result.singular_values_, atol=tol)
-    assert_allclose(spmd_result.noise_variance_, batch_result.noise_variance_, atol=tol)
     assert_allclose(
-        spmd_result.explained_variance_ratio_,
-        batch_result.explained_variance_ratio_,
+        _as_numpy(spmd_result.components_),
+        _as_numpy(batch_result.components_),
+        atol=tol,
+        rtol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.singular_values_),
+        _as_numpy(batch_result.singular_values_),
+        atol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.noise_variance_),
+        _as_numpy(batch_result.noise_variance_),
+        atol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.explained_variance_ratio_),
+        _as_numpy(batch_result.explained_variance_ratio_),
         atol=tol,
     )

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/spmd/neighbors/__init__.py

@@ -0,0 +1,23 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from onedal.spmd.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    NearestNeighbors,
+)
+
+__all__ = ["KNeighborsClassifier", "KNeighborsRegressor", "NearestNeighbors"]

{scikit_learn_intelex-2025.8.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.8.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.8.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.8.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.8.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,
@@ -174,9 +174,13 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
         # 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 "score" in method:
+        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"PCA.{method} has sklearn array_api support which breaks with array_api_dispatching"
+                f"numpy backend does not properly handle the __dlpack__ attribute."
             )
         elif (
             not sklearn_check_version("1.3")

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/utils/_array_api.py

@@ -16,13 +16,16 @@
 
 """Tools to support array_api."""
 
+import math
 from collections.abc import Callable
 from typing import Union
 
 import numpy as np
+import scipy.linalg as linalg
+from sklearn.covariance import log_likelihood as _sklearn_log_likelihood
 
 from daal4py.sklearn._utils import sklearn_check_version
-from onedal.utils._array_api import _get_sycl_namespace
+from onedal.utils._array_api import _get_sycl_namespace, _is_numpy_namespace
 
 from ..base import oneDALEstimator
 
@@ -151,3 +154,64 @@ def enable_array_api(
     else:
         # default setting (apply array_api enablement for sklearn >=1.3)
         return _enable_array_api(class_or_str)
+
+
+def _pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, check_finite=True):
+    # array API enabled pinvh implementation, via direct translation of scipy.linalg.pinhv
+    # this should be considered a temporary stopgap until implemented in oneDAL
+    xp, _ = get_namespace(a)
+    # fall back to scipy if the namespace is of a numpy origin
+    if _is_numpy_namespace(xp):
+        return linalg.pinvh(
+            a,
+            atol=atol,
+            rtol=rtol,
+            lower=lower,
+            return_rank=return_rank,
+            check_finite=check_finite,
+        )
+
+    if check_finite:
+        raise NotImplementedError("finite checking does not occur in sklearnex's pinvh")
+
+    s, u = xp.linalg.eigh(a)
+    maxS = xp.max(xp.abs(s))
+
+    atol = 0.0 if atol is None else atol
+    rtol = max(a.shape) * xp.finfo(u.dtype).eps if (rtol is None) else rtol
+
+    if (atol < 0.0) or (rtol < 0.0):
+        raise ValueError("atol and rtol values must be positive.")
+
+    val = atol + maxS * rtol
+    above_cutoff = xp.nonzero(abs(s) > val)[0]
+
+    psigma_diag = 1.0 / xp.take(s, above_cutoff)
+    u = xp.take(u, above_cutoff, axis=1)
+
+    uconj = xp.conj(u) if xp.isdtype(u.dtype, kind="complex floating") else u
+
+    B = (u * psigma_diag) @ uconj.T
+
+    if return_rank:
+        return B, len(psigma_diag)
+    else:
+        return B
+
+
+def log_likelihood(emp_cov, precision):
+    # this is to compensate for a lack of array API support in sklearn
+    # even though it exists for ``fast_logdet``
+    xp, _ = get_namespace(emp_cov, precision)
+    p = precision.shape[0]
+    # extract sklearn.utils.extmath.fast_logdet for dpnp/dpctl support
+    sign, ld = xp.linalg.slogdet(precision)
+    if not sign > 0:
+        ld = -xp.inf
+    log_likelihood_ = -xp.sum(emp_cov * precision) + ld
+    log_likelihood_ -= p * math.log(2 * math.pi)
+    log_likelihood_ /= 2.0
+    return log_likelihood_
+
+
+log_likelihood.__doc__ = _sklearn_log_likelihood.__doc__