scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/neighbors/knn_regression.py

@@ -14,80 +14,52 @@
 # limitations under the License.
 # ==============================================================================
 
+from sklearn.metrics import r2_score
 from sklearn.neighbors._regression import (
-    KNeighborsRegressor as sklearn_KNeighborsRegressor,
+    KNeighborsRegressor as _sklearn_KNeighborsRegressor,
 )
-from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestNeighbors
-from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
+from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import KNeighborsRegressor as onedal_KNeighborsRegressor
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import check_feature_names
 from .common import KNeighborsDispatchingBase
 
 
-@control_n_jobs(decorated_methods=["fit", "predict", "kneighbors"])
-class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase):
-    __doc__ = sklearn_KNeighborsRegressor.__doc__
+@control_n_jobs(decorated_methods=["fit", "predict", "kneighbors", "score"])
+class KNeighborsRegressor(KNeighborsDispatchingBase, _sklearn_KNeighborsRegressor):
+    __doc__ = _sklearn_KNeighborsRegressor.__doc__
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_KNeighborsRegressor._parameter_constraints
+            **_sklearn_KNeighborsRegressor._parameter_constraints
         }
 
-    if sklearn_check_version("1.0"):
-
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-            )
-
-    else:
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_neighbors=5,
-            *,
-            weights="uniform",
-            algorithm="auto",
-            leaf_size=30,
-            p=2,
-            metric="minkowski",
-            metric_params=None,
-            n_jobs=None,
-            **kwargs,
-        ):
-            super().__init__(
-                n_neighbors=n_neighbors,
-                weights=weights,
-                algorithm=algorithm,
-                leaf_size=leaf_size,
-                metric=metric,
-                p=p,
-                metric_params=metric_params,
-                n_jobs=n_jobs,
-                **kwargs,
-            )
+    def __init__(
+        self,
+        n_neighbors=5,
+        *,
+        weights="uniform",
+        algorithm="auto",
+        leaf_size=30,
+        p=2,
+        metric="minkowski",
+        metric_params=None,
+        n_jobs=None,
+    ):
+        super().__init__(
+            n_neighbors=n_neighbors,
+            weights=weights,
+            algorithm=algorithm,
+            leaf_size=leaf_size,
+            metric=metric,
+            p=p,
+            metric_params=metric_params,
+            n_jobs=n_jobs,
+        )
 
     def fit(self, X, y):
         dispatch(
@@ -95,7 +67,7 @@ class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_KNeighborsRegressor.fit,
+                "sklearn": _sklearn_KNeighborsRegressor.fit,
             },
             X,
             y,
@@ -105,53 +77,50 @@ class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase
     @wrap_output_data
     def predict(self, X):
         check_is_fitted(self)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "predict",
             {
                 "onedal": self.__class__._onedal_predict,
-                "sklearn": sklearn_KNeighborsRegressor.predict,
+                "sklearn": _sklearn_KNeighborsRegressor.predict,
+            },
+            X,
+        )
+
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        check_is_fitted(self)
+        check_feature_names(self, X, reset=False)
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": _sklearn_KNeighborsRegressor.score,
             },
             X,
+            y,
+            sample_weight=sample_weight,
         )
 
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
             {
                 "onedal": self.__class__._onedal_kneighbors,
-                "sklearn": sklearn_KNeighborsRegressor.kneighbors,
+                "sklearn": _sklearn_KNeighborsRegressor.kneighbors,
             },
             X,
             n_neighbors=n_neighbors,
             return_distance=return_distance,
         )
 
-    @wrap_output_data
-    def radius_neighbors(
-        self, X=None, radius=None, return_distance=True, sort_results=False
-    ):
-        _onedal_estimator = getattr(self, "_onedal_estimator", None)
-
-        if (
-            _onedal_estimator is not None
-            or getattr(self, "_tree", 0) is None
-            and self._fit_method == "kd_tree"
-        ):
-            sklearn_NearestNeighbors.fit(self, self._fit_X, getattr(self, "_y", None))
-        result = sklearn_NearestNeighbors.radius_neighbors(
-            self, X, radius, return_distance, sort_results
-        )
-
-        return result
-
     def _onedal_fit(self, X, y, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
@@ -161,13 +130,8 @@ class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase
             "p": self.effective_metric_params_["p"],
         }
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
         self._onedal_estimator = onedal_KNeighborsRegressor(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
+        self._onedal_estimator.requires_y = get_requires_y_tag(self)
         self._onedal_estimator.effective_metric_ = self.effective_metric_
         self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
         self._onedal_estimator.fit(X, y, queue=queue)
@@ -184,6 +148,11 @@ class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase
             X, n_neighbors, return_distance, queue=queue
         )
 
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return r2_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
     def _save_attributes(self):
         self.n_features_in_ = self._onedal_estimator.n_features_in_
         self.n_samples_fit_ = self._onedal_estimator.n_samples_fit_
@@ -192,7 +161,7 @@ class KNeighborsRegressor(sklearn_KNeighborsRegressor, KNeighborsDispatchingBase
         self._fit_method = self._onedal_estimator._fit_method
         self._tree = self._onedal_estimator._tree
 
-    fit.__doc__ = sklearn_KNeighborsRegressor.__doc__
-    predict.__doc__ = sklearn_KNeighborsRegressor.predict.__doc__
-    kneighbors.__doc__ = sklearn_KNeighborsRegressor.kneighbors.__doc__
-    radius_neighbors.__doc__ = sklearn_NearestNeighbors.radius_neighbors.__doc__
+    fit.__doc__ = _sklearn_KNeighborsRegressor.__doc__
+    predict.__doc__ = _sklearn_KNeighborsRegressor.predict.__doc__
+    kneighbors.__doc__ = _sklearn_KNeighborsRegressor.kneighbors.__doc__
+    score.__doc__ = _sklearn_KNeighborsRegressor.score.__doc__

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/neighbors/knn_unsupervised.py

@@ -14,22 +14,26 @@
 # limitations under the License.
 # ===============================================================================
 
-from sklearn.neighbors._unsupervised import NearestNeighbors as sklearn_NearestNeighbors
+from sklearn.neighbors._unsupervised import NearestNeighbors as _sklearn_NearestNeighbors
 from sklearn.utils.validation import _deprecate_positional_args, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import NearestNeighbors as onedal_NearestNeighbors
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils.validation import check_feature_names
 from .common import KNeighborsDispatchingBase
 
 
-@control_n_jobs(decorated_methods=["fit", "kneighbors"])
-class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
-    __doc__ = sklearn_NearestNeighbors.__doc__
+@control_n_jobs(decorated_methods=["fit", "kneighbors", "radius_neighbors"])
+class NearestNeighbors(KNeighborsDispatchingBase, _sklearn_NearestNeighbors):
+    __doc__ = _sklearn_NearestNeighbors.__doc__
     if sklearn_check_version("1.2"):
-        _parameter_constraints: dict = {**sklearn_NearestNeighbors._parameter_constraints}
+        _parameter_constraints: dict = {
+            **_sklearn_NearestNeighbors._parameter_constraints
+        }
 
     @_deprecate_positional_args
     def __init__(
@@ -60,7 +64,7 @@ class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
             "fit",
             {
                 "onedal": self.__class__._onedal_fit,
-                "sklearn": sklearn_NearestNeighbors.fit,
+                "sklearn": _sklearn_NearestNeighbors.fit,
             },
             X,
             None,
@@ -70,14 +74,14 @@ class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
-        if sklearn_check_version("1.0") and X is not None:
-            self._check_feature_names(X, reset=False)
+        if X is not None:
+            check_feature_names(self, X, reset=False)
         return dispatch(
             self,
             "kneighbors",
             {
                 "onedal": self.__class__._onedal_kneighbors,
-                "sklearn": sklearn_NearestNeighbors.kneighbors,
+                "sklearn": _sklearn_NearestNeighbors.kneighbors,
             },
             X,
             n_neighbors=n_neighbors,
@@ -88,19 +92,41 @@ class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
     def radius_neighbors(
         self, X=None, radius=None, return_distance=True, sort_results=False
     ):
-        _onedal_estimator = getattr(self, "_onedal_estimator", None)
-
         if (
-            _onedal_estimator is not None
+            hasattr(self, "_onedal_estimator")
             or getattr(self, "_tree", 0) is None
             and self._fit_method == "kd_tree"
         ):
-            sklearn_NearestNeighbors.fit(self, self._fit_X, getattr(self, "_y", None))
-        result = sklearn_NearestNeighbors.radius_neighbors(
-            self, X, radius, return_distance, sort_results
+            _sklearn_NearestNeighbors.fit(self, self._fit_X, getattr(self, "_y", None))
+        check_is_fitted(self)
+        return dispatch(
+            self,
+            "radius_neighbors",
+            {
+                "onedal": None,
+                "sklearn": _sklearn_NearestNeighbors.radius_neighbors,
+            },
+            X,
+            radius=radius,
+            return_distance=return_distance,
+            sort_results=sort_results,
         )
 
-        return result
+    def radius_neighbors_graph(
+        self, X=None, radius=None, mode="connectivity", sort_results=False
+    ):
+        return dispatch(
+            self,
+            "radius_neighbors_graph",
+            {
+                "onedal": None,
+                "sklearn": _sklearn_NearestNeighbors.radius_neighbors_graph,
+            },
+            X,
+            radius=radius,
+            mode=mode,
+            sort_results=sort_results,
+        )
 
     def _onedal_fit(self, X, y=None, queue=None):
         onedal_params = {
@@ -110,13 +136,8 @@ class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
             "p": self.effective_metric_params_["p"],
         }
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
-
         self._onedal_estimator = onedal_NearestNeighbors(**onedal_params)
-        self._onedal_estimator.requires_y = requires_y
+        self._onedal_estimator.requires_y = get_requires_y_tag(self)
         self._onedal_estimator.effective_metric_ = self.effective_metric_
         self._onedal_estimator.effective_metric_params_ = self.effective_metric_params_
         self._onedal_estimator.fit(X, y, queue=queue)
@@ -141,6 +162,9 @@ class NearestNeighbors(sklearn_NearestNeighbors, KNeighborsDispatchingBase):
         self._fit_method = self._onedal_estimator._fit_method
         self._tree = self._onedal_estimator._tree
 
-    fit.__doc__ = sklearn_NearestNeighbors.__doc__
-    kneighbors.__doc__ = sklearn_NearestNeighbors.kneighbors.__doc__
-    radius_neighbors.__doc__ = sklearn_NearestNeighbors.radius_neighbors.__doc__
+    fit.__doc__ = _sklearn_NearestNeighbors.__doc__
+    kneighbors.__doc__ = _sklearn_NearestNeighbors.kneighbors.__doc__
+    radius_neighbors.__doc__ = _sklearn_NearestNeighbors.radius_neighbors.__doc__
+    radius_neighbors_graph.__doc__ = (
+        _sklearn_NearestNeighbors.radius_neighbors_graph.__doc__
+    )

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/neighbors/tests/test_neighbors.py

@@ -47,25 +47,27 @@ def test_sklearnex_import_knn_regression(dataframe, queue):
     y = _convert_to_dataframe([0, 0, 1, 1], sycl_queue=queue, target_df=dataframe)
     neigh = KNeighborsRegressor(n_neighbors=2).fit(X, y)
     y_test = _convert_to_dataframe([[1.5]], sycl_queue=queue, target_df=dataframe)
-    pred = _as_numpy(neigh.predict(y_test))
+    pred = _as_numpy(neigh.predict(y_test)).squeeze()
     assert "sklearnex" in neigh.__module__
-    assert_allclose(pred, [0.5])
+    assert_allclose(pred, 0.5)
 
 
+@pytest.mark.parametrize("algorithm", ["auto", "brute"])
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize(
     "estimator",
     [LocalOutlierFactor, NearestNeighbors],
 )
-def test_sklearnex_kneighbors(estimator, dataframe, queue):
+def test_sklearnex_kneighbors(algorithm, estimator, dataframe, queue):
     X = [[0, 0, 2], [1, 0, 0], [0, 0, 1]]
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     test = _convert_to_dataframe([[0, 0, 1.3]], sycl_queue=queue, target_df=dataframe)
-    neigh = estimator(n_neighbors=2).fit(X)
+    neigh = estimator(n_neighbors=2, algorithm=algorithm).fit(X)
     result = neigh.kneighbors(test, 2, return_distance=False)
     result = _as_numpy(result)
     assert "sklearnex" in neigh.__module__
     assert_allclose(result, [[2, 0]])
+    result = neigh.kneighbors()
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())

{scikit_learn_intelex-2024.4.0.data → scikit_learn_intelex-2025.10.0.data}/data/Lib/site-packages/sklearnex/preview/__init__.py

@@ -14,4 +14,4 @@
 # limitations under the License.
 # ==============================================================================
 
-__all__ = ["cluster", "covariance"]
+__all__ = ["covariance", "decomposition"]

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/preview/covariance/covariance.py

@@ -0,0 +1,261 @@
+# ===============================================================================
+# 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 warnings
+from functools import partial
+
+import numpy as np
+import scipy.sparse as sp
+from sklearn.base import clone
+from sklearn.covariance import EmpiricalCovariance as _sklearn_EmpiricalCovariance
+from sklearn.utils.validation import check_array, 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 EmpiricalCovariance as onedal_EmpiricalCovariance
+from onedal.utils._array_api import _is_numpy_namespace
+from onedal.utils.validation import _num_features
+from sklearnex import config_context
+
+from ..._config import get_config
+from ..._device_offload import dispatch, wrap_output_data
+from ..._utils import PatchingConditionsChain, register_hyperparameters
+from ...base import oneDALEstimator
+from ...utils._array_api import _pinvh, enable_array_api, get_namespace, log_likelihood
+from ...utils.validation import assert_all_finite, validate_data
+
+# 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
+@register_hyperparameters({"fit": ("covariance", "compute")})
+@control_n_jobs(decorated_methods=["fit", "mahalanobis"])
+class EmpiricalCovariance(oneDALEstimator, _sklearn_EmpiricalCovariance):
+    __doc__ = _sklearn_EmpiricalCovariance.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **_sklearn_EmpiricalCovariance._parameter_constraints,
+        }
+
+    def _set_covariance(self, covariance):
+        if not get_config()["use_raw_input"]:
+            if sklearn_check_version("1.6"):
+                covariance = check_array(covariance, ensure_all_finite=False)
+            else:
+                covariance = check_array(covariance, force_all_finite=False)
+            assert_all_finite(covariance)
+        # set covariance
+        self.covariance_ = covariance
+        # set precision
+        if self.store_precision:
+            self.precision_ = _pinvh(covariance, check_finite=False)
+        else:
+            self.precision_ = None
+
+    def _save_attributes(self):
+        assert hasattr(self, "_onedal_estimator")
+        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_ += xp.dot(location.T, location)
+            self._onedal_estimator.location_ = xp.zeros_like(
+                self._onedal_estimator.location_
+            )
+        self._set_covariance(self._onedal_estimator.covariance_)
+        self.location_ = self._onedal_estimator.location_
+
+    _onedal_covariance = staticmethod(onedal_EmpiricalCovariance)
+
+    def _onedal_fit(self, X, queue=None):
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32])
+
+        if X.shape[0] == 1:
+            warnings.warn(
+                "Only one sample available. You may want to reshape your data array"
+            )
+
+        self._onedal_estimator = self._onedal_covariance(
+            method="dense", bias=True, assume_centered=self.assume_centered
+        )
+        self._onedal_estimator.fit(X, queue=queue)
+        self._save_attributes()
+
+    def _onedal_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        patching_status = PatchingConditionsChain(
+            f"sklearn.covariance.{class_name}.{method_name}"
+        )
+        if method_name in ["fit", "mahalanobis"]:
+            (X,) = data
+            patching_status.and_conditions(
+                [
+                    (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
+                ]
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
+
+    _onedal_cpu_supported = _onedal_supported
+    _onedal_gpu_supported = _onedal_supported
+
+    def get_precision(self):
+        # use array API-enabled version
+        if self.store_precision:
+            precision = self.precision_
+        else:
+            precision = _pinvh(self.covariance_, check_finite=False)
+        return precision
+
+    def fit(self, X, y=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": _sklearn_EmpiricalCovariance.fit,
+            },
+            X,
+        )
+
+        return self
+
+    @wrap_output_data
+    @support_sycl_format
+    def score(self, X_test, y=None):
+
+        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()
+
+        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):
+            test_cov = xp.asarray(test_cov, device=X.device)
+        res = log_likelihood(test_cov, self.get_precision())
+
+        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(comp_cov, 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":
+            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)
+
+        return (xp.reshape(dist, (-1,))) ** 2
+
+    fit.__doc__ = _sklearn_EmpiricalCovariance.fit.__doc__
+    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__
+    _set_covariance.__doc__ = _sklearn_EmpiricalCovariance._set_covariance.__doc__