scikit-learn-intelex 2024.6.0__py312-none-win_amd64.whl → 2025.0.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -0,0 +1,383 @@
+# ==============================================================================
+# Copyright 2021 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 logging
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+
+    import numbers
+    import warnings
+
+    import numpy as np
+    from scipy.sparse import issparse
+    from sklearn.cluster import KMeans as sklearn_KMeans
+    from sklearn.utils._openmp_helpers import _openmp_effective_n_threads
+    from sklearn.utils.validation import (
+        _check_sample_weight,
+        _num_samples,
+        check_is_fitted,
+    )
+
+    from daal4py.sklearn._n_jobs_support import control_n_jobs
+    from daal4py.sklearn._utils import sklearn_check_version
+    from onedal.cluster import KMeans as onedal_KMeans
+    from onedal.utils import _is_csr
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain
+
+    @control_n_jobs(decorated_methods=["fit", "predict", "transform", "fit_transform"])
+    class KMeans(sklearn_KMeans):
+        __doc__ = sklearn_KMeans.__doc__
+
+        if sklearn_check_version("1.2"):
+            _parameter_constraints: dict = {**sklearn_KMeans._parameter_constraints}
+
+        def __init__(
+            self,
+            n_clusters=8,
+            *,
+            init="k-means++",
+            n_init=(
+                "auto"
+                if sklearn_check_version("1.4")
+                else "warn" if sklearn_check_version("1.2") else 10
+            ),
+            max_iter=300,
+            tol=1e-4,
+            verbose=0,
+            random_state=None,
+            copy_x=True,
+            algorithm="lloyd" if sklearn_check_version("1.1") else "auto",
+        ):
+            super().__init__(
+                n_clusters=n_clusters,
+                init=init,
+                max_iter=max_iter,
+                tol=tol,
+                n_init=n_init,
+                verbose=verbose,
+                random_state=random_state,
+                copy_x=copy_x,
+                algorithm=algorithm,
+            )
+
+        def _initialize_onedal_estimator(self):
+            onedal_params = {
+                "n_clusters": self.n_clusters,
+                "init": self.init,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "n_init": self.n_init,
+                "verbose": self.verbose,
+                "random_state": self.random_state,
+            }
+
+            self._onedal_estimator = onedal_KMeans(**onedal_params)
+
+        def _onedal_fit_supported(self, method_name, X, y=None, sample_weight=None):
+            assert method_name == "fit"
+
+            class_name = self.__class__.__name__
+            patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
+
+            sample_count = _num_samples(X)
+            self._algorithm = self.algorithm
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+            correct_count = self.n_clusters < sample_count
+
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+
+            _acceptable_sample_weights = self._validate_sample_weight(sample_weight, X)
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd",
+                    ),
+                    (correct_count, "n_clusters is smaller than number of samples"),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Accepted options are None, constant, or equal weights.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        def fit(self, X, y=None, sample_weight=None):
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_KMeans.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
+
+            return self
+
+        def _onedal_fit(self, X, _, sample_weight, queue=None):
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                dtype=[np.float64, np.float32],
+                order="C",
+                copy=self.copy_x,
+                accept_large_sparse=False,
+            )
+
+            if sklearn_check_version("1.2"):
+                self._check_params_vs_input(X)
+            else:
+                self._check_params(X)
+
+            self._n_features_out = self.n_clusters
+
+            self._initialize_onedal_estimator()
+            self._n_threads = _openmp_effective_n_threads()
+            self._onedal_estimator.fit(X, queue=queue)
+
+            self._save_attributes()
+
+        def _validate_sample_weight(self, sample_weight, X):
+            if sample_weight is None:
+                return True
+            elif isinstance(sample_weight, numbers.Number):
+                return True
+            else:
+                sample_weight = _check_sample_weight(
+                    sample_weight,
+                    X,
+                    dtype=X.dtype if hasattr(X, "dtype") else None,
+                )
+                if np.all(sample_weight == sample_weight[0]):
+                    return True
+                else:
+                    return False
+
+        def _onedal_predict_supported(self, method_name, X, sample_weight=None):
+            class_name = self.__class__.__name__
+            is_data_supported = (
+                _is_csr(X) and daal_check_version((2024, "P", 700))
+            ) or not issparse(X)
+            patching_status = PatchingConditionsChain(
+                f"sklearn.cluster.{class_name}.predict"
+            )
+
+            # algorithm "auto" has been deprecated since 1.1,
+            # algorithm "full" has been replaced by "lloyd"
+            supported_algs = ["auto", "full", "lloyd", "elkan"]
+            if self.algorithm == "elkan":
+                logging.getLogger("sklearnex").info(
+                    "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
+                )
+
+            _acceptable_sample_weights = True
+            if not sklearn_check_version("1.5"):
+                _acceptable_sample_weights = self._validate_sample_weight(
+                    sample_weight, X
+                )
+
+            patching_status.and_conditions(
+                [
+                    (
+                        self.algorithm in supported_algs,
+                        "Only 'lloyd' algorithm is supported, 'elkan' is computed using lloyd.",
+                    ),
+                    (
+                        is_data_supported,
+                        "Supported data formats: Dense, CSR (oneDAL version >= 2024.7.0).",
+                    ),
+                    (
+                        _acceptable_sample_weights,
+                        "oneDAL doesn't support sample_weight. Acceptable options are None, constant, or equal weights.",
+                    ),
+                ]
+            )
+
+            return patching_status
+
+        if sklearn_check_version("1.5"):
+
+            @wrap_output_data
+            def predict(self, X):
+                self._validate_params()
+
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": sklearn_KMeans.predict,
+                    },
+                    X,
+                )
+
+        else:
+
+            @wrap_output_data
+            def predict(
+                self,
+                X,
+                sample_weight="deprecated" if sklearn_check_version("1.3") else None,
+            ):
+                if sklearn_check_version("1.2"):
+                    self._validate_params()
+
+                return dispatch(
+                    self,
+                    "predict",
+                    {
+                        "onedal": self.__class__._onedal_predict,
+                        "sklearn": sklearn_KMeans.predict,
+                    },
+                    X,
+                    sample_weight=sample_weight,
+                )
+
+        def _onedal_predict(self, X, sample_weight=None, queue=None):
+            check_is_fitted(self)
+
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.predict(X, queue=queue)
+
+        def _onedal_supported(self, method_name, *data):
+            if method_name == "fit":
+                return self._onedal_fit_supported(method_name, *data)
+            if method_name in ["predict", "score"]:
+                return self._onedal_predict_supported(method_name, *data)
+            raise RuntimeError(
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
+
+        _onedal_gpu_supported = _onedal_supported
+        _onedal_cpu_supported = _onedal_supported
+
+        @wrap_output_data
+        def fit_transform(self, X, y=None, sample_weight=None):
+            return self.fit(X, sample_weight=sample_weight)._transform(X)
+
+        @wrap_output_data
+        def transform(self, X):
+            check_is_fitted(self)
+
+            X = self._check_test_data(X)
+            return self._transform(X)
+
+        @wrap_output_data
+        def score(self, X, y=None, sample_weight=None):
+            return dispatch(
+                self,
+                "score",
+                {
+                    "onedal": self.__class__._onedal_score,
+                    "sklearn": sklearn_KMeans.score,
+                },
+                X,
+                y,
+                sample_weight=sample_weight,
+            )
+
+        def _onedal_score(self, X, y, sample_weight=None, queue=None):
+            check_is_fitted(self)
+
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[np.float64, np.float32],
+            )
+
+            if not sklearn_check_version("1.5") and sklearn_check_version("1.3"):
+                if isinstance(sample_weight, str) and sample_weight == "deprecated":
+                    sample_weight = None
+
+                if sample_weight is not None:
+                    warnings.warn(
+                        "'sample_weight' was deprecated in version 1.3 and "
+                        "will be removed in 1.5.",
+                        FutureWarning,
+                    )
+
+            if not hasattr(self, "_onedal_estimator"):
+                self._initialize_onedal_estimator()
+                self._onedal_estimator.cluster_centers_ = self.cluster_centers_
+
+            return self._onedal_estimator.score(X, queue=queue)
+
+        def _save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.cluster_centers_ = self._onedal_estimator.cluster_centers_
+            self.labels_ = self._onedal_estimator.labels_
+            self.inertia_ = self._onedal_estimator.inertia_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+
+            self._n_init = self._onedal_estimator._n_init
+
+        fit.__doc__ = sklearn_KMeans.fit.__doc__
+        predict.__doc__ = sklearn_KMeans.predict.__doc__
+        transform.__doc__ = sklearn_KMeans.transform.__doc__
+        fit_transform.__doc__ = sklearn_KMeans.fit_transform.__doc__
+        score.__doc__ = sklearn_KMeans.score.__doc__
+
+else:
+    from daal4py.sklearn.cluster import KMeans
+
+    logging.warning(
+        "Sklearnex KMeans requires oneDAL version >= 2023.2, falling back to daal4py."
+    )

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -0,0 +1,153 @@
+# ===============================================================================
+# Copyright 2021 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 scipy.sparse import csr_matrix
+from sklearn.datasets import make_blobs
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+    get_queues,
+)
+from sklearnex import config_context
+
+
+def generate_dense_dataset(n_samples, n_features, density, n_clusters):
+    np.random.seed(2024 + n_samples + n_features + n_clusters)
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        n_features=n_features,
+        centers=n_clusters,
+        cluster_std=1.0,
+        random_state=42,
+    )
+    mask = np.random.binomial(1, density, (n_samples, n_features))
+    X = X * mask
+    return X
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_dense_data(dataframe, queue, algorithm, init):
+    if not sklearn_check_version("1.1") and algorithm == "lloyd":
+        pytest.skip("lloyd requires sklearn>=1.1.")
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_dense_df = _convert_to_dataframe(X_dense, sycl_queue=queue, target_df=dataframe)
+
+    kmeans_dense = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_dense_df)
+
+    if daal_check_version((2023, "P", 200)):
+        assert "sklearnex" in kmeans_dense.__module__
+    else:
+        assert "daal4py" in kmeans_dense.__module__
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize("init", ["k-means++", "random"])
+def test_sklearnex_import_for_sparse_data(queue, algorithm, init):
+    from sklearnex.cluster import KMeans
+
+    X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
+    X_sparse = csr_matrix(X_dense)
+
+    kmeans_sparse = KMeans(
+        n_clusters=3, random_state=0, algorithm=algorithm, init=init
+    ).fit(X_sparse)
+
+    assert "sklearnex" in kmeans_sparse.__module__
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+def test_results_on_dense_gold_data(dataframe, queue, algorithm):
+    if not sklearn_check_version("1.1") and algorithm == "lloyd":
+        pytest.skip("lloyd requires sklearn>=1.1.")
+
+    from sklearnex.cluster import KMeans
+
+    X_train = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
+    X_test = np.array([[0, 0], [12, 3]])
+    X_train_df = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    X_test_df = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+
+    kmeans = KMeans(n_clusters=2, random_state=0, algorithm=algorithm).fit(X_train_df)
+
+    if queue and queue.sycl_device.is_gpu:
+        # KMeans Init Dense GPU implementation is different from CPU
+        expected_cluster_labels = np.array([0, 1], dtype=np.int32)
+        expected_cluster_centers = np.array([[1.0, 2.0], [10.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+    else:
+        expected_cluster_labels = np.array([1, 0], dtype=np.int32)
+        expected_cluster_centers = np.array([[10.0, 2.0], [1.0, 2.0]], dtype=np.float32)
+        expected_inertia = 16.0
+
+    assert_allclose(expected_cluster_labels, _as_numpy(kmeans.predict(X_test_df)))
+    assert_allclose(expected_cluster_centers, _as_numpy(kmeans.cluster_centers_))
+    assert expected_inertia == kmeans.inertia_
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2024, "P", 700)),
+    reason="Sparse data requires oneDAL>=2024.7.0",
+)
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("init", ["k-means++", "random", "arraylike"])
+@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize(
+    "dims", [(1000, 10, 0.95, 3), (50000, 100, 0.75, 10), (10000, 10, 0.8, 5)]
+)
+def test_dense_vs_sparse(queue, init, algorithm, dims):
+    from sklearnex.cluster import KMeans
+
+    if init == "random":
+        pytest.skip("Random initialization in sparse K-means is buggy.")
+
+    # For higher level of sparsity (smaller density) the test may fail
+    n_samples, n_features, density, n_clusters = dims
+    X_dense = generate_dense_dataset(n_samples, n_features, density, n_clusters)
+    X_sparse = csr_matrix(X_dense)
+
+    if init == "arraylike":
+        np.random.seed(2024 + n_samples + n_features + n_clusters)
+        init = X_dense[np.random.choice(n_samples, size=n_clusters, replace=False)]
+
+    kmeans_dense = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_dense)
+    kmeans_sparse = KMeans(
+        n_clusters=n_clusters, random_state=0, init=init, algorithm=algorithm
+    ).fit(X_sparse)
+
+    assert_allclose(
+        kmeans_dense.cluster_centers_,
+        kmeans_sparse.cluster_centers_,
+    )

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -19,13 +19,14 @@ import warnings
 
 import numpy as np
 from scipy import linalg
-from sklearn.base import BaseEstimator
+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.validation import _num_features
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
-from onedal._device_offload import support_usm_ndarray
 from onedal.covariance import (
     IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
 )
@@ -34,6 +35,7 @@ from sklearnex import config_context
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, register_hyperparameters
 from ..metrics import pairwise_distances
+from ..utils._array_api import get_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
@@ -98,7 +100,6 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
 
     get_precision = sklearn_EmpiricalCovariance.get_precision
     error_norm = wrap_output_data(sklearn_EmpiricalCovariance.error_norm)
-    score = wrap_output_data(sklearn_EmpiricalCovariance.score)
 
     def __init__(
         self, *, store_precision=False, assume_centered=False, batch_size=None, copy=True
@@ -114,9 +115,9 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
         )
         return patching_status
 
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
+        self._onedal_estimator.finalize_fit(queue=queue)
         self._need_to_finalize = False
 
         if not daal_check_version((2024, "P", 400)) and self.assume_centered:
@@ -191,12 +192,49 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             else:
                 self.n_samples_seen_ += X.shape[0]
 
-            self._onedal_estimator.partial_fit(X, queue)
+            self._onedal_estimator.partial_fit(X, queue=queue)
         finally:
             self._need_to_finalize = True
 
         return self
 
+    @wrap_output_data
+    def score(self, X_test, y=None):
+        xp, _ = get_namespace(X_test)
+
+        location = self.location_
+        if sklearn_check_version("1.0"):
+            X = self._validate_data(
+                X_test,
+                dtype=[np.float64, np.float32],
+                reset=False,
+            )
+        else:
+            X = check_array(
+                X_test,
+                dtype=[np.float64, np.float32],
+            )
+
+        if "numpy" not in xp.__name__:
+            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 partial_fit(self, X, y=None, check_input=True):
         """
         Incremental fit with X. All of X is processed as a single batch.
@@ -288,26 +326,39 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue, check_input=False)
 
-        self._onedal_finalize_fit()
+        self._onedal_finalize_fit(queue=queue)
 
         return self
 
     # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
-    @wrap_output_data
     def mahalanobis(self, X):
         if sklearn_check_version("1.0"):
-            self._validate_data(X, reset=False, copy=self.copy)
-        else:
-            check_array(X, copy=self.copy)
+            self._check_feature_names(X, reset=False)
 
+        xp, _ = get_namespace(X)
         precision = self.get_precision()
-        with config_context(assume_finite=True):
-            # compute mahalanobis distances
-            dist = pairwise_distances(
-                X, self.location_[np.newaxis, :], metric="mahalanobis", VI=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, :]
+        if "numpy" not in xp.__name__:
+            # Guarantee that inputs to pairwise_distances match in type and location
+            location = xp.asarray(location, device=X.device)
+
+        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 np.reshape(dist, (len(X),)) ** 2
+        return (xp.reshape(dist, (-1,))) ** 2
 
     _onedal_cpu_supported = _onedal_supported
     _onedal_gpu_supported = _onedal_supported