fix: try it again

Author: yuejiaointel

onedal/neighbors/neighbors.py

@@ -691,4 +691,4 @@ def fit(self, X, y, queue=None):
 
     @supports_queue
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True, queue=None):
-        return self._kneighbors(X, n_neighbors, return_distance)
+        return self._kneighbors(X, n_neighbors, return_distance)

sklearnex/neighbors/common.py

@@ -31,81 +31,14 @@
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
 from ..utils._array_api import get_namespace
+from ..utils.validation import check_feature_names
 
 
 class KNeighborsDispatchingBase(oneDALEstimator):
-    
-    def _parse_auto_method(self, method, n_samples, n_features):
-        """Parse auto method selection for neighbors algorithm."""
-        result_method = method
-
-        if method in ["auto", "ball_tree"]:
-            condition = (
-                self.n_neighbors is not None and self.n_neighbors >= n_samples // 2
-            )
-            if self.metric == "precomputed" or n_features > 15 or condition:
-                result_method = "brute"
-            else:
-                if self.metric == "euclidean":
-                    result_method = "kd_tree"
-                else:
-                    result_method = "brute"
-
-        return result_method
-
-    def _get_weights(self, dist, weights):
-        """Get weights for neighbors based on distance and weights parameter."""
-        if weights in (None, "uniform"):
-            return None
-        if weights == "distance":
-            # if user attempts to classify a point that was zero distance from one
-            # or more training points, those training points are weighted as 1.0
-            # and the other points as 0.0
-            if dist.dtype is np.dtype(object):
-                for point_dist_i, point_dist in enumerate(dist):
-                    # check if point_dist is iterable
-                    # (ex: RadiusNeighborClassifier.predict may set an element of
-                    # dist to 1e-6 to represent an 'outlier')
-                    if hasattr(point_dist, "__contains__") and 0.0 in point_dist:
-                        dist[point_dist_i] = point_dist == 0.0
-                    else:
-                        dist[point_dist_i] = 1.0 / point_dist
-            else:
-                with np.errstate(divide="ignore"):
-                    dist = 1.0 / dist
-                inf_mask = np.isinf(dist)
-                inf_row = np.any(inf_mask, axis=1)
-                dist[inf_row] = inf_mask[inf_row]
-            return dist
-        elif callable(weights):
-            return weights(dist)
-        else:
-            raise ValueError(
-                "weights not recognized: should be 'uniform', "
-                "'distance', or a callable function"
-            )
-
-    def _validate_targets(self, y, dtype):
-        """Validate and convert target values."""
-        from onedal.utils.validation import _column_or_1d
-        arr = _column_or_1d(y, warn=True)
-
-        try:
-            return arr.astype(dtype, copy=False)
-        except ValueError:
-            return arr
-
-    def _validate_n_classes(self):
-        """Validate that we have at least 2 classes for classification."""
-        length = 0 if self.classes_ is None else len(self.classes_)
-        if length < 2:
-            raise ValueError(
-                f"The number of classes has to be greater than one; got {length}"
-            )
     def _fit_validation(self, X, y=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
-
+        check_feature_names(self, X, reset=True)
         if self.metric_params is not None and "p" in self.metric_params:
             if self.p is not None:
                 warnings.warn(
@@ -134,9 +67,8 @@ def _fit_validation(self, X, y=None):
                 self.effective_metric_ = "chebyshev"
 
         if not isinstance(X, (KDTree, BallTree, _sklearn_NeighborsBase)):
-            xp, _ = get_namespace(X)
             self._fit_X = _check_array(
-                X, dtype=[xp.float64, xp.float32], accept_sparse=True
+                X, dtype=[np.float64, np.float32], accept_sparse=True
             )
             self.n_samples_fit_ = _num_samples(self._fit_X)
             self.n_features_in_ = _num_features(self._fit_X)
@@ -378,4 +310,4 @@ def kneighbors_graph(self, X=None, n_neighbors=None, mode="connectivity"):
 
         return kneighbors_graph
 
-    kneighbors_graph.__doc__ = KNeighborsMixin.kneighbors_graph.__doc__
+    kneighbors_graph.__doc__ = KNeighborsMixin.kneighbors_graph.__doc__