scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.9.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -14,10 +14,8 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
 from sklearn.base import BaseEstimator
-from sklearn.utils import check_array, gen_batches
-from sklearn.utils.validation import _check_sample_weight
+from sklearn.utils import gen_batches
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
@@ -29,7 +27,8 @@ from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain, _add_inc_serialization_note
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval, StrOptions
@@ -38,6 +37,7 @@ import numbers
 import warnings
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
 class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     """
@@ -159,12 +159,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         }
 
     def __init__(self, result_options="all", batch_size=None):
-        if result_options == "all":
-            self.result_options = (
-                self._onedal_incremental_basic_statistics.get_all_result_options()
-            )
-        else:
-            self.result_options = result_options
+        self.result_options = result_options
         self._need_to_finalize = False
         self.batch_size = batch_size
 
@@ -177,15 +172,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     _onedal_cpu_supported = _onedal_supported
     _onedal_gpu_supported = _onedal_supported
 
-    def _get_onedal_result_options(self, options):
-        if isinstance(options, list):
-            onedal_options = "|".join(self.result_options)
-        else:
-            onedal_options = options
-        assert isinstance(onedal_options, str)
-        return options
-
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
         self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
@@ -193,19 +180,20 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     def _onedal_partial_fit(self, X, sample_weight=None, queue=None, check_input=True):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
-        use_raw_input = get_config().get("use_raw_input", False) is True
         # never check input when using raw input
-        check_input &= use_raw_input is False
-        if check_input:
+        if check_input and not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
             )
 
-        if not use_raw_input and sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -213,28 +201,25 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         else:
             self.n_samples_seen_ += X.shape[0]
 
-        onedal_params = {
-            "result_options": self._get_onedal_result_options(self.result_options)
-        }
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_basic_statistics(
-                **onedal_params
+                result_options=self.result_options
             )
-        self._onedal_estimator.partial_fit(X, weights=sample_weight, queue=queue)
+
+        self._onedal_estimator.partial_fit(X, sample_weight=sample_weight, queue=queue)
         self._need_to_finalize = True
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        if not use_raw_input:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
-
-            X = validate_data(self, X, dtype=[np.float64, np.float32])
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, sample_weight)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32])
 
             if sample_weight is not None:
-                sample_weight = _check_sample_weight(sample_weight, X)
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
-        n_samples, n_features = X.shape
+        _, n_features = X.shape
         if self.batch_size is None:
             self.batch_size_ = 5 * n_features
         else:
@@ -258,11 +243,12 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         return self
 
     def __getattr__(self, attr):
-        result_options = self.__dict__["result_options"]
         sattr = attr.removesuffix("_")
         is_statistic_attr = (
-            isinstance(result_options, str) and (sattr == result_options)
-        ) or (isinstance(result_options, list) and (sattr in result_options))
+            sattr in self._onedal_estimator.options
+            if "_onedal_estimator" in self.__dict__
+            else False
+        )
         if is_statistic_attr:
             if self._need_to_finalize:
                 self._onedal_finalize_fit()
@@ -270,7 +256,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
                 warnings.warn(
                     "Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0"
                 )
-            return getattr(self._onedal_estimator, sattr)
+                attr += "_"
+            return getattr(self._onedal_estimator, attr)
         if attr in self.__dict__:
             return self.__dict__[attr]
 
@@ -301,6 +288,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
         dispatch(
             self,
             "partial_fit",
@@ -334,6 +323,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -14,42 +14,30 @@
 # limitations under the License.
 # ===============================================================================
 
-import numbers
-from abc import ABC
-
 from scipy import sparse as sp
 from sklearn.cluster import DBSCAN as _sklearn_DBSCAN
-from sklearn.utils.validation import _check_sample_weight
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.cluster import DBSCAN as onedal_DBSCAN
+from onedal.utils._array_api import _is_numpy_namespace
 
 from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
-    from sklearn.utils import check_scalar
-
-
-class BaseDBSCAN(oneDALEstimator):
-    def _onedal_dbscan(self, **onedal_params):
-        return onedal_DBSCAN(**onedal_params)
+    import numbers
 
-    def _save_attributes(self):
-        assert hasattr(self, "_onedal_estimator")
-
-        self.labels_ = self._onedal_estimator.labels_
-        self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
-        self.components_ = self._onedal_estimator.components_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
+    from sklearn.utils import check_scalar
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
+class DBSCAN(oneDALEstimator, _sklearn_DBSCAN):
     __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
@@ -86,9 +74,18 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self.p = p
         self.n_jobs = n_jobs
 
+    _onedal_dbscan = staticmethod(onedal_DBSCAN)
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if get_config()["use_raw_input"] is False:
-            X = validate_data(self, X, ensure_all_finite=False)
+        xp, _ = get_namespace(X, y, sample_weight)
+        if not get_config()["use_raw_input"]:
+            X = validate_data(
+                self, X, accept_sparse="csr", dtype=[xp.float64, xp.float32]
+            )
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         onedal_params = {
             "eps": self.eps,
@@ -103,7 +100,17 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self._onedal_estimator = self._onedal_dbscan(**onedal_params)
 
         self._onedal_estimator.fit(X, y=y, sample_weight=sample_weight, queue=queue)
-        self._save_attributes()
+        if self._onedal_estimator.core_sample_indices_ is None:
+            kwargs = {"dtype": xp.int32}  # always the same
+            if not _is_numpy_namespace(xp):
+                kwargs["device"] = X.device
+            self.core_sample_indices_ = xp.empty((0,), **kwargs)
+        else:
+            self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
+
+        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
+        self.labels_ = self._onedal_estimator.labels_
+        self.n_features_in_ = X.shape[1]
 
     def _onedal_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -111,7 +118,7 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
             f"sklearn.cluster.{class_name}.{method_name}"
         )
         if method_name == "fit":
-            X, y, sample_weight = data
+            X = data[0]
             patching_status.and_conditions(
                 [
                     (
@@ -175,10 +182,6 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         else:
             if self.eps <= 0.0:
                 raise ValueError(f"eps == {self.eps}, must be > 0.0.")
-
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        if not use_raw_input and sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -334,6 +334,7 @@ if daal_check_version((2023, "P", 200)):
             return X
 
         _transform = support_input_format(_sklearn_KMeans._transform)
+        transform = support_input_format(_sklearn_KMeans.transform)
 
         @wrap_output_data
         def score(self, X, y=None, sample_weight=None):

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

@@ -16,39 +16,40 @@
 
 import numbers
 import warnings
+from functools import partial
 
 import numpy as np
 from scipy import linalg
 from sklearn.base import BaseEstimator, clone
 from sklearn.covariance import EmpiricalCovariance as _sklearn_EmpiricalCovariance
-from sklearn.covariance import log_likelihood
-from sklearn.utils import check_array, gen_batches
+from sklearn.utils import gen_batches
 from sklearn.utils.validation import _num_features, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from daal4py.sklearn.metrics import pairwise_distances
+from onedal._device_offload import support_input_format, support_sycl_format
 from onedal.covariance import (
     IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
 )
 from onedal.utils._array_api import _is_numpy_namespace
-from sklearnex import config_context
 
-from .._config import get_config
+from .._config import config_context, get_config
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import (
-    PatchingConditionsChain,
-    _add_inc_serialization_note,
-    register_hyperparameters,
-)
+from .._utils import PatchingConditionsChain, _add_inc_serialization_note
 from ..base import oneDALEstimator
-from ..metrics import pairwise_distances
-from ..utils._array_api import get_namespace
-from ..utils.validation import check_feature_names, validate_data
+from ..utils._array_api import _pinvh, enable_array_api, get_namespace, log_likelihood
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
+# This is a temporary workaround for issues with sklearnex._device_offload._get_host_inputs
+# passing kwargs with sycl queues with other host data will cause failures
+_mahalanobis = support_input_format(partial(pairwise_distances, metric="mahalanobis"))
+
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
 class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     """
@@ -135,9 +136,6 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
             "copy": ["boolean"],
         }
 
-    get_precision = _sklearn_EmpiricalCovariance.get_precision
-    error_norm = wrap_output_data(_sklearn_EmpiricalCovariance.error_norm)
-
     def __init__(
         self, *, store_precision=False, assume_centered=False, batch_size=None, copy=True
     ):
@@ -158,11 +156,12 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         self._need_to_finalize = False
 
         if not daal_check_version((2024, "P", 400)) and self.assume_centered:
+            xp, _ = get_namespace(self._onedal_estimator.location_)
             location = self._onedal_estimator.location_[None, :]
-            self._onedal_estimator.covariance_ += np.dot(location.T, location)
-            self._onedal_estimator.location_ = np.zeros_like(np.squeeze(location))
+            self._onedal_estimator.covariance_ += xp.dot(location.T, location)
+            self._onedal_estimator.location_ = xp.zeros_like(xp.squeeze(location))
         if self.store_precision:
-            self.precision_ = linalg.pinvh(
+            self.precision_ = _pinvh(
                 self._onedal_estimator.covariance_, check_finite=False
             )
         else:
@@ -193,21 +192,14 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     def _onedal_partial_fit(self, X, queue=None, check_input=True):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        # never check input when using raw input
-        check_input &= use_raw_input is False
-        # finite check occurs on onedal side
-        if check_input:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
-
+        if check_input and not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
                 copy=self.copy,
-                ensure_all_finite=False,
             )
 
         onedal_params = {
@@ -230,38 +222,12 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
 
         return self
 
-    @wrap_output_data
-    def score(self, X_test, y=None):
-        xp, _ = get_namespace(X_test)
-
-        check_is_fitted(self)
-        location = self.location_
-        X = validate_data(
-            self,
-            X_test,
-            dtype=[xp.float64, xp.float32],
-            reset=False,
-        )
-
-        if not _is_numpy_namespace(xp):
-            location = xp.asarray(location, device=X_test.device)
-            # depending on the sklearn version, check_array
-            # and validate_data will return only numpy arrays
-            # which will break dpnp/dpctl support. If the
-            # array namespace isn't from numpy and the data
-            # is now a numpy array, it has been validated and
-            # the original can be used.
-            if isinstance(X, np.ndarray):
-                X = X_test
-
-        est = clone(self)
-        est.set_params(**{"assume_centered": True})
-
-        # test_cov is a numpy array, but calculated on device
-        test_cov = est.fit(X - location).covariance_
-        res = log_likelihood(test_cov, self.get_precision())
-
-        return res
+    def get_precision(self):
+        if self.store_precision:
+            precision = self.precision_
+        else:
+            precision = _pinvh(self.covariance_, check_finite=False)
+        return precision
 
     def partial_fit(self, X, y=None, check_input=True):
         """
@@ -284,6 +250,8 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         self : IncrementalEmpiricalCovariance
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
         return dispatch(
             self,
             "partial_fit",
@@ -313,7 +281,8 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         self : IncrementalEmpiricalCovariance
             Returns the instance itself.
         """
-
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         return dispatch(
             self,
             "fit",
@@ -329,19 +298,9 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator._reset()
 
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        if not use_raw_input:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
-
-            # finite check occurs on onedal side
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                copy=self.copy,
-                ensure_all_finite=False,
-            )
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32], copy=self.copy)
 
         self.batch_size_ = self.batch_size if self.batch_size else 5 * self.n_features_in_
 
@@ -351,40 +310,121 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
             )
 
         for batch in gen_batches(X.shape[0], self.batch_size_):
-            X_batch = X[batch]
+            X_batch = X[batch, ...]
             self._onedal_partial_fit(X_batch, queue=queue, check_input=False)
 
         self._onedal_finalize_fit()
 
         return self
 
-    # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
-    def mahalanobis(self, X):
-        check_feature_names(self, X, reset=False)
+    @wrap_output_data
+    @support_sycl_format
+    def score(self, X_test, y=None):
 
-        xp, _ = get_namespace(X)
+        check_is_fitted(self)
+        # Only covariance evaluated for get_namespace due to dpnp/dpctl
+        # support without array_api_dispatch
+        xp, _ = get_namespace(X_test, self.covariance_)
+
+        X = validate_data(
+            self,
+            X_test,
+            dtype=[xp.float64, xp.float32],
+            reset=False,
+        )
+
+        location = self.location_
         precision = self.get_precision()
-        # compute mahalanobis distances
-        # pairwise_distances will check n_features (via n_feature matching with
-        # self.location_) , and will check for finiteness via check array
-        # check_feature_names will match _validate_data functionally
-        location = self.location_[np.newaxis, :]
+
+        est = clone(self)
+        est.set_params(assume_centered=True)
+
+        # test_cov is a numpy array, but calculated on device
+        test_cov = est.fit(X - self.location_).covariance_
         if not _is_numpy_namespace(xp):
-            # Guarantee that inputs to pairwise_distances match in type and location
-            location = xp.asarray(location, device=X.device)
+            test_cov = xp.asarray(test_cov, device=X_test.device)
+        res = log_likelihood(test_cov, self.get_precision())
 
-        try:
-            dist = pairwise_distances(X, location, metric="mahalanobis", VI=precision)
-
-        except ValueError as e:
-            # Throw the expected sklearn error in an n_feature length violation
-            if "Incompatible dimension for X and Y matrices: X.shape[1] ==" in str(e):
-                raise ValueError(
-                    f"X has {_num_features(X)} features, but {self.__class__.__name__} "
-                    f"is expecting {self.n_features_in_} features as input."
-                )
-            else:
-                raise e
+        return res
+
+    @wrap_output_data
+    @support_sycl_format
+    def error_norm(self, comp_cov, norm="frobenius", scaling=True, squared=True):
+        # equivalent to the sklearn implementation but written for array API
+        # in the case of numpy-like inputs it will use sklearn's version instead.
+        # This can be deprecated if/when sklearn makes the equivalent array API enabled.
+        # This includes a validate_data call and an unusual call to get_namespace in
+        # order to also support dpnp/dpctl without array_api_dispatch.
+        check_is_fitted(self)
+        # Only covariance evaluated for get_namespace due to dpnp/dpctl
+        # support without array_api_dispatch
+        xp, _ = get_namespace(self.covariance_)
+        c_cov = validate_data(
+            self,
+            comp_cov,
+            dtype=[xp.float64, xp.float32],
+            reset=False,
+        )
+
+        if _is_numpy_namespace(xp):
+            # must be done this way is it does not inherit from sklearn
+            return _sklearn_EmpiricalCovariance.error_norm(
+                self, c_cov, norm=norm, scaling=scaling, squared=squared
+            )
+
+        # compute the error
+        error = c_cov - self.covariance_
+        # compute the error norm
+        if norm == "frobenius":
+            # variance from sklearn version to leverage BLAS GEMM
+            # squared_norm = xp.sum(error**2)
+            squared_norm = xp.matmul(xp.reshape(error, (-1)), xp.reshape(error, (-1)))
+        elif norm == "spectral":
+            squared_norm = xp.max(xp.linalg.svdvals(xp.matmul(error.T, error)))
+        else:
+            raise NotImplementedError("Only spectral and frobenius norms are implemented")
+        # optionally scale the error norm
+        if scaling:
+            squared_norm = squared_norm / error.shape[0]
+        # finally get either the squared norm or the norm
+        if squared:
+            result = squared_norm
+        else:
+            result = xp.sqrt(squared_norm)
+
+        return result
+
+    # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
+    @support_sycl_format
+    def mahalanobis(self, X):
+        # This must be done as ```support_input_format``` is insufficient for array API
+        # support when attributes are non-numpy.
+        check_is_fitted(self)
+        precision = self.get_precision()
+        loc = self.location_[None, :]
+        xp, _ = get_namespace(X, precision, loc)
+        # do not check dtype, done in pairwise_distances
+        X_in = validate_data(self, X, reset=False)
+
+        if not _is_numpy_namespace(xp) and isinstance(X_in, np.ndarray):
+            # corrects issues with respect to dpnp/dpctl support without array_api_dispatch
+            X_in = X
+            loc = xp.asarray(loc, device=X.device)
+            precision = xp.asarray(precision, device=X.device)
+
+        with config_context(assume_finite=True):
+            try:
+                dist = _mahalanobis(X_in, loc, VI=precision)
+
+            except ValueError as e:
+                # Throw the expected sklearn error in an n_feature length violation
+                if "Incompatible dimension for X and Y matrices: X.shape[1] ==" in str(e):
+                    raise ValueError(
+                        f"X has {_num_features(X)} features, but {self.__class__.__name__} "
+                        f"is expecting {self.n_features_in_} features as input."
+                    ) from None
+                else:
+                    raise e
 
         if not _is_numpy_namespace(xp):
             dist = xp.asarray(dist, device=X.device)
@@ -397,3 +437,4 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     mahalanobis.__doc__ = _sklearn_EmpiricalCovariance.mahalanobis.__doc__
     error_norm.__doc__ = _sklearn_EmpiricalCovariance.error_norm.__doc__
     score.__doc__ = _sklearn_EmpiricalCovariance.score.__doc__
+    get_precision.__doc__ = _sklearn_EmpiricalCovariance.get_precision.__doc__

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

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ===============================================================================
 
+from contextlib import nullcontext
 from os import environ
 
 from daal4py.sklearn._utils import sklearn_check_version
@@ -285,3 +286,32 @@ def test_IncrementalEmpiricalCovariance_against_sklearn(monkeypatch, sklearn_tes
     class_name = ".".join([sklearn_test.__module__, "EmpiricalCovariance"])
     monkeypatch.setattr(class_name, IncrementalEmpiricalCovariance)
     sklearn_test()
+
+
+@pytest.mark.skipif(
+    not sklearn_check_version("1.4"), reason="requires array_api_support sklearn config"
+)
+@pytest.mark.parametrize("dispatch", [True, False])
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("dpnp"))
+def test_score_verify_namespace(dispatch, dataframe, queue):
+    from sklearnex import config_context
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+
+    est = IncrementalEmpiricalCovariance()
+
+    rng = np.random.seed(42)
+    X = np.random.rand(5, 10)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    if dispatch:
+        cfg_context = config_context(array_api_dispatch=True)
+        err = pytest.raises(TypeError)
+    else:
+        # support_sycl_format will cause it to function
+        cfg_context = nullcontext()
+        err = nullcontext()
+
+    # calculate and store data on SYCL device (CPU or GPU)
+    with cfg_context, err:
+        est.fit(X_df)
+        est.score(X + 3)