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

scikit_learn_intelex-2025.7.0.data/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -0,0 +1,115 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+
+
+# Note: this is arranged as a fixture with a finalizer instead of as a parameter
+# 'True' / 'False' in order to undo the changes later so that it doesn't affect
+# other tests afterwards. It returns a function instead of making the change
+# directly, in order to avoid importing the estimator class before the import test
+# itself, but it still needs to import the class inside the the function that it
+# returns due to serialization logic in pytest causing differences w.r.t. current
+# closure where the function is called.
+@pytest.fixture(params=[False, True])
+def hyperparameters_route(request):
+    def change_parameters(queue, macro_block, grain_size):
+        from sklearnex.decomposition import PCA
+
+        if request.param and daal_check_version((2025, "P", 700)):
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+
+            hparams = PCA.get_hyperparameters("fit")
+            if macro_block is not None:
+                hyperparameters_route.curr_cpu_macro_block = hparams.cpu_macro_block
+                hparams.cpu_macro_block = macro_block
+            else:
+                hyperparameters_route.curr_cpu_macro_block = None
+            if grain_size is not None:
+                hyperparameters_route.curr_cpu_grain_size = hparams.cpu_grain_size
+                hparams.cpu_grain_size = grain_size
+            else:
+                hyperparameters_route.curr_cpu_grain_size = None
+        elif request.param and not daal_check_version((2025, "P", 700)):
+            pytest.skip("Functionality introduced in later versions")
+
+    def restore_params():
+        from sklearnex.decomposition import PCA
+
+        if request.param and daal_check_version((2025, "P", 500)):
+            hparams = PCA.get_hyperparameters("fit")
+            if (
+                hasattr(hyperparameters_route, "curr_cpu_macro_block")
+                and hyperparameters_route.curr_cpu_macro_block is not None
+            ):
+                hparams.cpu_macro_block = hyperparameters_route.curr_cpu_macro_block
+            if (
+                hasattr(hyperparameters_route, "curr_cpu_grain_size")
+                and hyperparameters_route.curr_cpu_grain_size is not None
+            ):
+                hparams.cpu_grain_size = hyperparameters_route.curr_cpu_grain_size
+
+    request.addfinalizer(restore_params)
+    return change_parameters
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("macro_block", [None, 2])
+@pytest.mark.parametrize("grain_size", [None, 2])
+def test_sklearnex_import(
+    dataframe, queue, macro_block, grain_size, hyperparameters_route
+):
+    from sklearnex.decomposition import PCA
+
+    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_transformed_expected = [
+        [-1.38340578, -0.2935787],
+        [-2.22189802, 0.25133484],
+        [-3.6053038, -0.04224385],
+        [1.38340578, 0.2935787],
+        [2.22189802, -0.25133484],
+        [3.6053038, 0.04224385],
+    ]
+
+    pca = PCA(n_components=2, svd_solver="covariance_eigh")
+
+    hyperparameters_route(queue, macro_block, grain_size)
+
+    pca.fit(X)
+    X_transformed = pca.transform(X)
+    X_fit_transformed = PCA(n_components=2, svd_solver="covariance_eigh").fit_transform(X)
+
+    if daal_check_version((2024, "P", 100)):
+        assert "sklearnex" in pca.__module__
+        assert hasattr(pca, "_onedal_estimator")
+    else:
+        assert "daal4py" in pca.__module__
+
+    tol = 1e-5 if _as_numpy(X_transformed).dtype == np.float32 else 1e-7
+    assert_allclose([6.30061232, 0.54980396], _as_numpy(pca.singular_values_))
+    assert_allclose(X_transformed_expected, _as_numpy(X_transformed), rtol=tol)
+    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed), rtol=tol)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -529,6 +529,17 @@ def sklearn_is_patched(name=None, return_map=False):
 
 
 def is_patched_instance(instance: object) -> bool:
-    """Returns True if the `instance` is patched with scikit-learn-intelex"""
+    """Check if given instance is patched with scikit-learn-intelex.
+
+    Parameters
+    ----------
+    instance : object
+        Python object, usually a scikit-learn estimator instance.
+
+    Returns
+    -------
+    Check : bool
+        Boolean whether instance is a daal4py or sklearnex estimator.
+    """
     module = getattr(instance, "__module__", "")
     return ("daal4py" in module) or ("sklearnex" in module)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -57,7 +57,6 @@ from onedal.ensemble import ExtraTreesRegressor as onedal_ExtraTreesRegressor
 from onedal.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 from onedal.primitives import get_tree_state_cls, get_tree_state_reg
-from onedal.utils._dpep_helpers import get_unique_values_with_dpep
 from onedal.utils.validation import _num_features, _num_samples
 from sklearnex import get_hyperparameters
 from sklearnex._utils import register_hyperparameters
@@ -123,7 +122,13 @@ class BaseForest(oneDALEstimator, ABC):
             if sample_weight is not None:
                 sample_weight = [sample_weight]
         else:
-            self.classes_ = get_unique_values_with_dpep(y)
+            # try catch needed for raw_inputs + array_api data where unlike
+            # numpy the way to yield unique values is via `unique_values`
+            # This should be removed when refactored for gpu zero-copy
+            try:
+                self.classes_ = xp.unique(y)
+            except AttributeError:
+                self.classes_ = xp.unique_values(y)
             self.n_classes_ = len(self.classes_)
         self.n_features_in_ = X.shape[1]
 
@@ -826,7 +831,8 @@ class ForestClassifier(BaseForest, _sklearn_ForestClassifier):
         res = self._onedal_estimator.predict(X, queue=queue)
         try:
             return xp.take(
-                xp.asarray(self.classes_), xp.astype(xp.reshape(res, (-1,)), xp.int64)
+                xp.asarray(self.classes_, device=res.sycl_queue),
+                xp.astype(xp.reshape(res, (-1,)), xp.int64),
             )
         except AttributeError:
             return np.take(self.classes_, res.ravel().astype(np.int64, casting="unsafe"))

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -60,8 +60,11 @@ class IncrementalLinearRegression(
     MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator
 ):
     """
-    Trains a linear regression model, allows for computation if the data are split into
-    batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
+    Incremental Ordinary least squares Linear Regression.
+
+    Trains a linear regression model, allows for computation if the data
+    are split into batches. The user can use the ``partial_fit`` method
+    to provide a single batch of data or use the ``fit`` method to provide
     the entire dataset.
 
     Parameters
@@ -107,6 +110,10 @@ class IncrementalLinearRegression(
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
 
     Examples
@@ -311,8 +318,7 @@ class IncrementalLinearRegression(
 
     def partial_fit(self, X, y, check_input=True):
         """
-        Incremental fit linear model with X and y. All of X and y is
-        processed as a single batch.
+        Incremental fit with X and y. X and y are processed as a single batch.
 
         Parameters
         ----------
@@ -324,6 +330,9 @@ class IncrementalLinearRegression(
             Target values, where ``n_samples`` is the number of samples and
             ``n_targets`` is the number of targets.
 
+        check_input : bool, default=True
+            Run validate_data on X and y.
+
         Returns
         -------
         self : IncrementalLinearRegression
@@ -354,7 +363,7 @@ class IncrementalLinearRegression(
             ``n_features`` is the number of features. It is necessary for
             ``n_samples`` to be not less than ``n_features`` if ``fit_intercept``
             is False and not less than ``n_features + 1`` if ``fit_intercept``
-            is True
+            is 'True'.
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values, where ``n_samples`` is the number of samples and

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -45,7 +45,8 @@ from ..base import oneDALEstimator
 class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator):
     """
     Incremental estimator for Ridge Regression.
-    Allows to train Ridge Regression if data is splitted into batches.
+
+    Allows to train Ridge Regression if data is split into batches.
 
     Parameters
     ----------
@@ -96,6 +97,10 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
     batch_size_ : int
         Inferred batch size from ``batch_size``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
     """
 
@@ -240,8 +245,7 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
 
     def partial_fit(self, X, y, check_input=True):
         """
-        Incrementally fits the linear model with X and y. All of X and y is
-        processed as a single batch.
+        Incrementally fits with X and y. X and y are processed as a single batch.
 
         Parameters
         ----------
@@ -253,6 +257,9 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
             Target values, where `n_samples` is the number of samples and
             `n_targets` is the number of targets.
 
+        check_input : bool, default=True
+            Run validate_data on X and y.
+
         Returns
         -------
         self : IncrementalRidge
@@ -280,10 +287,10 @@ class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEs
         ----------
         X : array-like of shape (n_samples, n_features)
             Training data, where `n_samples` is the number of samples and
-            `n_features` is the number of features. It is necessary for
-            `n_samples` to be not less than `n_features` if `fit_intercept`
-            is False and not less than `n_features` + 1 if `fit_intercept`
-            is True
+            ``n_features`` is the number of features. It is necessary for
+            ``n_samples`` to be not less than ``n_features`` if ``fit_intercept``
+            is False and not less than ``n_features`` + 1 if ``fit_intercept``
+            is True.
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values, where `n_samples` is the number of samples and

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -208,12 +208,11 @@ if daal_check_version((2024, "P", 1)):
                     ),
                     (self.class_weight is None, "Class weight is not supported"),
                     (self.solver == "newton-cg", "Only newton-cg solver is supported."),
+                    (self.warm_start == False, "Warm start is not supported."),
                     (
-                        self.multi_class != "multinomial",
-                        "multi_class parameter is not supported.",
+                        not self.l1_ratio,
+                        "l1 ratio is not supported.",
                     ),
-                    (self.warm_start == False, "Warm start is not supported."),
-                    (self.l1_ratio is None, "l1 ratio is not supported."),
                     (sample_weight is None, "Sample weight is not supported."),
                     (
                         target_type == "binary",

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/linear_model/ridge.py

@@ -325,6 +325,15 @@ if daal_check_version((2024, "P", 600)):
             self._onedal_estimator.fit(X, y, queue=queue)
             self._save_attributes()
 
+            if sklearn_check_version("1.6"):
+                if y.ndim == 1 or y.shape[1] == 1:
+                    self.coef_ = self.coef_.ravel()
+                    self.intercept_ = self.intercept_[0]
+            else:
+                if self.coef_.shape[0] == 1 and y.ndim == 1:
+                    self.coef_ = self.coef_.ravel()
+                    self.intercept_ = self.intercept_[0]
+
         def _onedal_predict(self, X, queue=None):
             X = validate_data(self, X, accept_sparse=False, reset=False)
 

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/manifold/tests/test_tsne.py

@@ -190,7 +190,7 @@ def test_tsne_reproducibility(dataframe, queue, dtype):
     X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     tsne_1 = TSNE(n_components=2, random_state=42).fit_transform(X_df)
     tsne_2 = TSNE(n_components=2, random_state=42).fit_transform(X_df)
-    # in case of dpctl.tensor.usm_ndarray covert to numpy array
+    # in case of dpctl.tensor.usm_ndarray convert to numpy array
     tsne_1 = _as_numpy(tsne_1)
     tsne_2 = _as_numpy(tsne_2)
     assert_allclose(tsne_1, tsne_2, rtol=1e-5)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/neighbors/_lof.py

@@ -141,7 +141,7 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor)
     # This had to be done because predict loses the queue when no
     # argument is given and it is a dpctl tensor or dpnp array.
     # This would cause issues in fit_predict. Also, available_if
-    # is hard to unwrap, and this is the most straighforward way.
+    # is hard to unwrap, and this is the most straightforward way.
     @available_if(_sklearn_LocalOutlierFactor._check_novelty_fit_predict)
     @wraps(_sklearn_LocalOutlierFactor.fit_predict, assigned=["__doc__"])
     @wrap_output_data

scikit_learn_intelex-2025.7.0.data/data/Lib/site-packages/sklearnex/preview/covariance/tests/test_covariance.py

@@ -0,0 +1,119 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+
+
+# Note: this is arranged as a fixture with a finalizer instead of as a parameter
+# 'True' / 'False' in order to undo the changes later so that it doesn't affect
+# other tests afterwards. It returns a function instead of making the change
+# directly, in order to avoid importing the estimator class before the import test
+# itself, but it still needs to import the class inside the the function that it
+# returns due to serialization logic in pytest causing differences w.r.t. current
+# closure where the function is called.
+@pytest.fixture(params=[False, True])
+def hyperparameters_route(request):
+    def change_parameters(queue, macro_block, grain_size):
+        from sklearnex.preview.covariance import EmpiricalCovariance
+
+        if request.param and daal_check_version((2025, "P", 700)):
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+
+            hparams = EmpiricalCovariance.get_hyperparameters("fit")
+            if macro_block is not None:
+                hyperparameters_route.curr_cpu_macro_block = hparams.cpu_macro_block
+                hparams.cpu_macro_block = macro_block
+            else:
+                hyperparameters_route.curr_cpu_macro_block = None
+            if grain_size is not None:
+                hyperparameters_route.curr_cpu_grain_size = hparams.cpu_grain_size
+                hparams.cpu_grain_size = grain_size
+            else:
+                hyperparameters_route.curr_cpu_grain_size = None
+        elif request.param and not daal_check_version((2025, "P", 700)):
+            pytest.skip("Functionality introduced in later versions")
+
+    def restore_params():
+        from sklearnex.preview.covariance import EmpiricalCovariance
+
+        if request.param and daal_check_version((2025, "P", 500)):
+            hparams = EmpiricalCovariance.get_hyperparameters("fit")
+            if (
+                hasattr(hyperparameters_route, "curr_cpu_macro_block")
+                and hyperparameters_route.curr_cpu_macro_block is not None
+            ):
+                hparams.cpu_macro_block = hyperparameters_route.curr_cpu_macro_block
+            if (
+                hasattr(hyperparameters_route, "curr_cpu_grain_size")
+                and hyperparameters_route.curr_cpu_grain_size is not None
+            ):
+                hparams.cpu_grain_size = hyperparameters_route.curr_cpu_grain_size
+
+    request.addfinalizer(restore_params)
+    return change_parameters
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("macro_block", [None, 2])
+@pytest.mark.parametrize("grain_size", [None, 2])
+@pytest.mark.parametrize("assume_centered", [True, False])
+def test_sklearnex_import_covariance(
+    dataframe, queue, macro_block, grain_size, assume_centered, hyperparameters_route
+):
+    from sklearnex.preview.covariance import EmpiricalCovariance
+
+    X = np.array([[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]])
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    empcov = EmpiricalCovariance(assume_centered=assume_centered)
+
+    hyperparameters_route(queue, macro_block, grain_size)
+
+    result = empcov.fit(X)
+
+    expected_covariance = np.array([[0, 0], [0, 0]])
+    expected_means = np.array([0, 0])
+
+    if assume_centered:
+        expected_covariance = np.array([[0, 0], [0, 1]])
+    else:
+        expected_means = np.array([0, 1])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)
+
+    X = np.array([[1, 2], [3, 6]])
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    result = empcov.fit(X)
+
+    if assume_centered:
+        expected_covariance = np.array([[5, 10], [10, 20]])
+    else:
+        expected_covariance = np.array([[1, 2], [2, 4]])
+        expected_means = np.array([2, 4])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/incremental_covariance.py

@@ -24,14 +24,6 @@ from ...covariance import (
 
 
 class IncrementalEmpiricalCovariance(base_IncrementalEmpiricalCovariance):
-    """
-    Incremental distributed estimator for covariance.
-    Allows to distributely compute empirical covariance estimated by maximum
-    likelihood method if data are splitted into batches.
-
-    API is the same as for `sklearnex.covariance.IncrementalEmpiricalCovariance`
-    """
-
     _onedal_incremental_covariance = staticmethod(
         onedalSPMD_IncrementalEmpiricalCovariance
     )

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/incremental_pca.py

@@ -20,11 +20,4 @@ from ...preview.decomposition import IncrementalPCA as base_IncrementalPCA
 
 
 class IncrementalPCA(base_IncrementalPCA):
-    """
-    Distributed incremental estimator for PCA based on sklearnex implementation.
-    Allows for distributed PCA computation if data is split into batches.
-
-    API is the same as for `sklearnex.decomposition.IncrementalPCA`
-    """
-
     _onedal_incremental_pca = staticmethod(onedalSPMD_IncrementalPCA)

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/incremental_linear_model.py

@@ -25,11 +25,4 @@ from ...linear_model import (
 
 
 class IncrementalLinearRegression(base_IncrementalLinearRegression):
-    """
-    Distributed incremental estimator for linear regression.
-    Allows for distributed training of linear regression if data is split into batches.
-
-    API is the same as for `sklearnex.linear_model.IncrementalLinearRegression`.
-    """
-
     _onedal_incremental_linear = staticmethod(onedalSPMD_IncrementalLinearRegression)

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

@@ -233,7 +233,7 @@ class BaseSVC(BaseSVM):
 
         le = LabelEncoder()
         y_ind = le.fit_transform(y_)
-        if not all(np.in1d(classes, le.classes_)):
+        if not np.isin(classes, le.classes_).all():
             raise ValueError("classes should have valid labels that are in y")
 
         recip_freq = len(y_) / (len(le.classes_) * np.bincount(y_ind).astype(np.float64))

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

@@ -20,6 +20,7 @@ import os
 import pathlib
 import pkgutil
 import re
+import subprocess
 import sys
 import trace
 from contextlib import redirect_stdout
@@ -31,6 +32,7 @@ from sklearn.utils import all_estimators
 
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.tests.test_common import _check_primitive_usage_ban
+from onedal.tests.utils._dataframes_support import test_frameworks
 from sklearnex.base import oneDALEstimator
 from sklearnex.tests.utils import (
     PATCHED_MODELS,
@@ -118,7 +120,7 @@ def test_target_offload_ban():
         allowed_locations=TARGET_OFFLOAD_ALLOWED_LOCATIONS,
     )
     output = "\n".join(output)
-    assert output == "", f"target offloading is occuring in: \n{output}"
+    assert output == "", f"target offloading is occurring in: \n{output}"
 
 
 def _sklearnex_walk(func):
@@ -146,7 +148,7 @@ def test_class_trailing_underscore_ban(monkeypatch):
     estimators = all_estimators()  # list of tuples
     for name, obj in estimators:
         if "preview" not in obj.__module__ and "daal4py" not in obj.__module__:
-            # propeties also occur in sklearn, especially in deprecations and are expected
+            # properties also occur in sklearn, especially in deprecations and are expected
             # to error if queried and the estimator is not fitted
             assert all(
                 [
@@ -201,6 +203,43 @@ def test_oneDALEstimator_inheritance(monkeypatch):
                 ), f"oneDALEstimator should be inherited just before BaseEstimator in {name}"
 
 
+def test_frameworks_lazy_import(monkeypatch):
+    """Check that all estimators defined in sklearnex do not actively
+    load data frameworks which are not numpy or pandas.
+    """
+    active = ["numpy", "pandas", "dpctl.tensor"]
+    # handle naming conventions for data frameworks in testing
+    frameworks = test_frameworks.replace("dpctl", "dpctl.tensor")
+    frameworks = frameworks.replace("array_api", "array_api_strict")
+    lazy = ",".join([i for i in frameworks.split(",") if i not in active])
+    if not lazy:
+        pytest.skip("No lazily-imported data frameworks available in testing")
+
+    monkeypatch.setattr(pkgutil, "walk_packages", _sklearnex_walk(pkgutil.walk_packages))
+    estimators = all_estimators()  # list of tuples
+
+    filtered_modules = []
+    for name, obj in estimators:
+        # do not test spmd or preview, as they are exempt
+        if "preview" not in obj.__module__ and "spmd" not in obj.__module__:
+            filtered_modules += [obj.__module__]
+
+    modules = ",".join(filtered_modules)
+
+    # import all modules with estimators and check sys.modules for the lazily-imported data
+    # frameworks. It is done in a subprocess to isolate the impact of testing infrastructure
+    # on sys.modules, which may have actively loaded those frameworks into the test env
+    teststr = (
+        "import sys,{mod};assert all([i not in sys.modules for i in '{l}'.split(',')])"
+    )
+    cmd = [sys.executable, "-c", teststr.format(mod=modules, l=lazy)]
+
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        raise AssertionError(f"a framework in '{lazy}' is being actively loaded") from e
+
+
 def _fullpath(path):
     return os.path.realpath(os.path.expanduser(path))
 

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

@@ -16,6 +16,7 @@
 
 import logging
 
+import numpy as np
 import pytest
 import sklearn
 
@@ -127,6 +128,27 @@ def test_config_context_works():
         assert onedal_default_config_after_cc[param] == onedal_default_config[param]
 
 
+@pytest.mark.skipif(
+    onedal._default_backend.is_dpc, reason="requires host default backend"
+)
+@pytest.mark.parametrize("target", ["auto", "cpu", "cpu:0", "gpu", 3])
+def test_host_backend_target_offload(target):
+    from sklearnex.neighbors import NearestNeighbors
+
+    err_msg = (
+        r"device use via \`target_offload\` is only supported with the DPC\+\+ backend"
+    )
+
+    est = NearestNeighbors()
+    if target != "auto":
+        with pytest.raises(ValueError, match=err_msg):
+            with sklearnex.config_context(target_offload=target):
+                est.fit(np.eye(5, 8))
+    else:
+        with sklearnex.config_context(target_offload=target):
+            est.fit(np.eye(5, 8))
+
+
 @pytest.mark.skipif(
     not is_dpctl_device_available(["gpu"]), reason="Requires a gpu for fallback testing"
 )

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

@@ -35,7 +35,6 @@ from onedal.tests.utils._dataframes_support import (
 )
 from onedal.tests.utils._device_selection import get_queues, is_dpctl_device_available
 from onedal.utils._array_api import _get_sycl_namespace
-from onedal.utils._dpep_helpers import dpctl_available, dpnp_available
 from sklearnex import config_context
 from sklearnex.tests.utils import (
     PATCHED_FUNCTIONS,
@@ -44,13 +43,6 @@ from sklearnex.tests.utils import (
     DummyEstimator,
 )
 
-if dpctl_available:
-    from dpctl.tensor import usm_ndarray
-
-if dpnp_available:
-    import dpnp
-
-
 CPU_SKIP_LIST = (
     "TSNE",  # too slow for using in testing on common data size
     "config_context",  # does not malloc

{scikit_learn_intelex-2025.6.0.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py

@@ -95,7 +95,7 @@ def test_n_jobs_support(estimator, n_jobs, caplog):
             "NearestNeighbors" in estimator and "radius" in method_name
         ):
             # radius_neighbors and radius_neighbors_graph violate sklearn fallback guard
-            # but use sklearnex interally, additional development must be done to those
+            # but use sklearnex internally, additional development must be done to those
             # functions to bring them to design compliance.
             continue
         try:

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

@@ -153,7 +153,7 @@ def gen_models_info(algorithms, required_inputs=["X", "y"], fit=False, daal4py=T
     required_inputs : list, tuple of strings or None
         list of required args/kwargs for callable attribute (only non-private,
         non-BaseEstimator attributes).  Only one must be present, None
-        signifies taking all non-private attribues, callable or not.
+        signifies taking all non-private attributes, callable or not.
 
     fit: bool (default False)
         Include "fit" method as an estimator-attribute pair