refactor: move/delete some methods in neighbors.py

Author: yuejiaointel

sklearnex/neighbors/common.py

@@ -35,6 +35,74 @@
 
 
 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()

sklearnex/neighbors/knn_classification.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ===============================================================================
 
+import numpy as np
 from sklearn.metrics import accuracy_score
 from sklearn.neighbors._classification import (
     KNeighborsClassifier as _sklearn_KNeighborsClassifier,
@@ -24,6 +25,8 @@
 from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.neighbors import KNeighborsClassifier as onedal_KNeighborsClassifier
+from onedal.utils.validation import _check_X_y, _check_classification_targets, _check_n_features
+from onedal.common._estimator_checks import _is_classifier
 
 from .._device_offload import dispatch, wrap_output_data
 from ..utils.validation import check_feature_names
@@ -141,16 +144,20 @@ def _onedal_fit(self, X, y, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
             "weights": self.weights,
-            "algorithm": self.algorithm,
+            "algorithm": self._fit_method,  # Use parsed method
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"],
+            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
         }
 
         self._onedal_estimator = onedal_KNeighborsClassifier(**onedal_params)
-        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)
+        self._onedal_estimator._fit_method = self._fit_method
+        self._onedal_estimator.classes_ = self.classes_
+        
+        # Prepare y for onedal
+        fit_y = self._validate_targets(processed_y, X.dtype).reshape((-1, 1))
+        self._onedal_estimator.fit(X, fit_y, queue=queue)
 
         self._save_attributes()
 

sklearnex/neighbors/knn_regression.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
+import numpy as np
 from sklearn.metrics import r2_score
 from sklearn.neighbors._regression import (
     KNeighborsRegressor as _sklearn_KNeighborsRegressor,
@@ -24,6 +25,8 @@
 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 onedal.utils.validation import _check_X_y, _check_n_features
+from onedal.common._estimator_checks import _is_regressor
 
 from .._device_offload import dispatch, wrap_output_data
 from ..utils.validation import check_feature_names
@@ -125,16 +128,23 @@ def _onedal_fit(self, X, y, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
             "weights": self.weights,
-            "algorithm": self.algorithm,
+            "algorithm": self._fit_method,  # Use parsed method
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"],
+            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
         }
 
         self._onedal_estimator = onedal_KNeighborsRegressor(**onedal_params)
-        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)
+        self._onedal_estimator._fit_method = self._fit_method
+        
+        # For regression, prepare y data
+        fit_y = self._validate_targets(y, X.dtype).reshape((-1, 1))
+        self._onedal_estimator.fit(X, fit_y, queue=queue)
+        
+        # Reshape y back if needed
+        if self._shape is not None:
+            self._y = np.reshape(y, self._shape)
 
         self._save_attributes()
 

sklearnex/neighbors/knn_unsupervised.py

@@ -14,13 +14,15 @@
 # limitations under the License.
 # ===============================================================================
 
+import numpy as np
 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 onedal.utils.validation import _check_array, _check_n_features
 
 from .._device_offload import dispatch, wrap_output_data
 from ..utils.validation import check_feature_names
@@ -131,15 +133,18 @@ def radius_neighbors_graph(
     def _onedal_fit(self, X, y=None, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
-            "algorithm": self.algorithm,
+            "algorithm": self._fit_method,  # Use parsed method
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"],
+            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
         }
 
         self._onedal_estimator = onedal_NearestNeighbors(**onedal_params)
-        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_method = self._fit_method
+        self._onedal_estimator.fit(X, y, queue=queue)
+
+        self._save_attributes()
         self._onedal_estimator.fit(X, y, queue=queue)
 
         self._save_attributes()