fix: try it again

Author: yuejiaointel

onedal/neighbors/neighbors.py

@@ -269,7 +269,6 @@ def _fit(self, X, y):
         return result
 
     def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
-        use_raw_input = _get_config().get("use_raw_input", False) is True
         n_features = getattr(self, "n_features_in_", None)
         shape = getattr(X, "shape", None)
         if n_features and shape and len(shape) > 1 and shape[1] != n_features:
@@ -296,8 +295,12 @@ def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
 
         if X is not None:
             query_is_train = False
+<<<<<<< HEAD
             if not use_raw_input:
                 X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+=======
+            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+>>>>>>> e003b37f (fix: try it again)
         else:
             query_is_train = True
             X = self._fit_X
@@ -646,6 +649,7 @@ def __init__(
         self,
         n_neighbors=5,
         *,
+        weights="uniform",
         algorithm="auto",
         p=2,
         metric="minkowski",
@@ -660,7 +664,7 @@ def __init__(
             metric_params=metric_params,
             **kwargs,
         )
-        self.requires_y = False
+        self.weights = weights
 
     @bind_default_backend("neighbors.search")
     def train(self, *args, **kwargs): ...
@@ -682,9 +686,9 @@ def _onedal_predict(self, model, X, params):
         return self.infer(params, model, X)
 
     @supports_queue
-    def fit(self, X, y=None, queue=None):
+    def fit(self, X, y, queue=None):
         return self._fit(X, y)
 
     @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/_lof.py

@@ -186,4 +186,4 @@ def score_samples(self, X):
         return -np.mean(lrd_ratios_array, axis=1)
 
     fit.__doc__ = _sklearn_LocalOutlierFactor.fit.__doc__
-    kneighbors.__doc__ = _sklearn_LocalOutlierFactor.kneighbors.__doc__
+    kneighbors.__doc__ = _sklearn_LocalOutlierFactor.kneighbors.__doc__

sklearnex/neighbors/common.py

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

sklearnex/neighbors/knn_classification.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 # ===============================================================================
 
-import numpy as np
 from sklearn.metrics import accuracy_score
 from sklearn.neighbors._classification import (
     KNeighborsClassifier as _sklearn_KNeighborsClassifier,
@@ -25,8 +24,6 @@
 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,23 +138,26 @@ def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         )
 
     def _onedal_fit(self, X, y, queue=None):
+<<<<<<< HEAD
+=======
+        # import sys
+        # print("=" * 50, file=sys.stderr, flush=True)
+        # print("DEBUG: _onedal_fit called!", file=sys.stderr, flush=True)
+        # print("=" * 50, file=sys.stderr, flush=True)
+>>>>>>> e003b37f (fix: try it again)
         onedal_params = {
             "n_neighbors": self.n_neighbors,
             "weights": self.weights,
-            "algorithm": self._fit_method,  # Use parsed method
+            "algorithm": self.algorithm,
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
+            "p": self.effective_metric_params_["p"],
         }
 
         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_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._onedal_estimator.fit(X, y, queue=queue)
 
         self._save_attributes()
 
@@ -193,4 +193,4 @@ def _save_attributes(self):
     predict.__doc__ = _sklearn_KNeighborsClassifier.predict.__doc__
     predict_proba.__doc__ = _sklearn_KNeighborsClassifier.predict_proba.__doc__
     score.__doc__ = _sklearn_KNeighborsClassifier.score.__doc__
-    kneighbors.__doc__ = _sklearn_KNeighborsClassifier.kneighbors.__doc__
+    kneighbors.__doc__ = _sklearn_KNeighborsClassifier.kneighbors.__doc__

sklearnex/neighbors/knn_regression.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
 from sklearn.metrics import r2_score
 from sklearn.neighbors._regression import (
     KNeighborsRegressor as _sklearn_KNeighborsRegressor,
@@ -25,8 +24,6 @@
 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
@@ -128,23 +125,16 @@ def _onedal_fit(self, X, y, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
             "weights": self.weights,
-            "algorithm": self._fit_method,  # Use parsed method
+            "algorithm": self.algorithm,
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
+            "p": self.effective_metric_params_["p"],
         }
 
         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_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._onedal_estimator.fit(X, y, queue=queue)
 
         self._save_attributes()
 
@@ -174,4 +164,4 @@ def _save_attributes(self):
     fit.__doc__ = _sklearn_KNeighborsRegressor.__doc__
     predict.__doc__ = _sklearn_KNeighborsRegressor.predict.__doc__
     kneighbors.__doc__ = _sklearn_KNeighborsRegressor.kneighbors.__doc__
-    score.__doc__ = _sklearn_KNeighborsRegressor.score.__doc__
+    score.__doc__ = _sklearn_KNeighborsRegressor.score.__doc__

sklearnex/neighbors/knn_unsupervised.py

@@ -14,15 +14,13 @@
 # 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
@@ -133,18 +131,15 @@ def radius_neighbors_graph(
     def _onedal_fit(self, X, y=None, queue=None):
         onedal_params = {
             "n_neighbors": self.n_neighbors,
-            "algorithm": self._fit_method,  # Use parsed method
+            "algorithm": self.algorithm,
             "metric": self.effective_metric_,
-            "p": self.effective_metric_params_["p"] if self.effective_metric_params_ else 2,
+            "p": self.effective_metric_params_["p"],
         }
 
         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()
@@ -172,4 +167,4 @@ def _save_attributes(self):
     radius_neighbors.__doc__ = _sklearn_NearestNeighbors.radius_neighbors.__doc__
     radius_neighbors_graph.__doc__ = (
         _sklearn_NearestNeighbors.radius_neighbors_graph.__doc__
-    )
+    )