WIP: Enable array api support in neighbor

onedal/neighbors/tests/test_knn_classification.py

@@ -19,31 +19,58 @@
 from numpy.testing import assert_array_equal
 from sklearn import datasets
 
-from onedal.neighbors import KNeighborsClassifier
+# REFACTOR: Import from sklearnex instead of onedal
+# Classification processing now happens in sklearnex layer
+from sklearnex.neighbors import KNeighborsClassifier
 from onedal.tests.utils._device_selection import get_queues
 
 
 @pytest.mark.parametrize("queue", get_queues())
 def test_iris(queue):
+    import sys
+    print(f"\n=== DEBUG test_iris START: queue={queue} ===", file=sys.stderr)
+    # REFACTOR NOTE: queue parameter not used with sklearnex, but kept for test parametrization
     iris = datasets.load_iris()
-    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
-    assert clf.score(iris.data, iris.target, queue=queue) > 0.9
+    print(f"DEBUG test: iris.data type={type(iris.data)}, shape={iris.data.shape}", file=sys.stderr)
+    print(f"DEBUG test: iris.target type={type(iris.target)}, shape={iris.target.shape}", file=sys.stderr)
+    print(f"DEBUG test: Creating KNeighborsClassifier and calling fit", file=sys.stderr)
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target)
+    print(f"DEBUG test: fit completed, clf._fit_X type={type(getattr(clf, '_fit_X', 'NOT_SET'))}", file=sys.stderr)
+    print(f"DEBUG test: Calling score", file=sys.stderr)
+    score = clf.score(iris.data, iris.target)
+    print(f"DEBUG test: score completed, score={score}", file=sys.stderr)
+    assert score > 0.9
     assert_array_equal(clf.classes_, np.sort(clf.classes_))
+    print(f"=== DEBUG test_iris END ===\n", file=sys.stderr)
 
 
 @pytest.mark.parametrize("queue", get_queues())
 def test_pickle(queue):
+    import sys
+    print(f"\n=== DEBUG test_pickle START: queue={queue} ===", file=sys.stderr)
+    # REFACTOR NOTE: queue parameter not used with sklearnex, but kept for test parametrization
     if queue and queue.sycl_device.is_gpu:
         pytest.skip("KNN classifier pickling for the GPU sycl_queue is buggy.")
     iris = datasets.load_iris()
-    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
-    expected = clf.predict(iris.data, queue=queue)
+    print(f"DEBUG test: iris.data type={type(iris.data)}, shape={iris.data.shape}", file=sys.stderr)
+    print(f"DEBUG test: iris.target type={type(iris.target)}, shape={iris.target.shape}", file=sys.stderr)
+    print(f"DEBUG test: Creating KNeighborsClassifier and calling fit", file=sys.stderr)
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target)
+    print(f"DEBUG test: fit completed, clf._fit_X type={type(getattr(clf, '_fit_X', 'NOT_SET'))}", file=sys.stderr)
+    print(f"DEBUG test: Calling predict", file=sys.stderr)
+    expected = clf.predict(iris.data)
+    print(f"DEBUG test: predict completed, expected type={type(expected)}, shape={expected.shape}", file=sys.stderr)
 
     import pickle
 
+    print(f"DEBUG test: Pickling classifier", file=sys.stderr)
     dump = pickle.dumps(clf)
+    print(f"DEBUG test: Unpickling classifier", file=sys.stderr)
     clf2 = pickle.loads(dump)
 
     assert type(clf2) == clf.__class__
-    result = clf2.predict(iris.data, queue=queue)
+    print(f"DEBUG test: Calling predict on unpickled classifier", file=sys.stderr)
+    result = clf2.predict(iris.data)
+    print(f"DEBUG test: predict completed, result type={type(result)}, shape={result.shape}", file=sys.stderr)
     assert_array_equal(expected, result)
+    print(f"=== DEBUG test_pickle END ===\n", file=sys.stderr)

sklearnex/neighbors/_lof.py

@@ -29,7 +29,7 @@
 from sklearnex.neighbors.knn_unsupervised import NearestNeighbors
 
 from ..utils._array_api import get_namespace
-from ..utils.validation import check_feature_names
+from ..utils.validation import check_feature_names, validate_data
 
 
 @control_n_jobs(decorated_methods=["fit", "kneighbors", "_kneighbors"])
@@ -53,9 +53,18 @@ class LocalOutlierFactor(KNeighborsDispatchingBase, _sklearn_LocalOutlierFactor)
     _onedal_kneighbors = NearestNeighbors._onedal_kneighbors
 
     def _onedal_fit(self, X, y, queue=None):
+        import sys
+        print(f"DEBUG LocalOutlierFactor._onedal_fit START: X type={type(X)}, y type={type(y)}", file=sys.stderr)
         if sklearn_check_version("1.2"):
             self._validate_params()
 
+        # REFACTOR: Use validate_data from sklearnex.utils.validation to convert pandas to numpy
+        X = validate_data(
+            self, X, dtype=[np.float64, np.float32], accept_sparse="csr"
+        )
+        print(f"DEBUG: After validate_data, X type={type(X)}", file=sys.stderr)
+
+        print(f"DEBUG LocalOutlierFactor._onedal_fit: Calling _onedal_knn_fit", file=sys.stderr)
         self._onedal_knn_fit(X, y, queue=queue)
 
         if self.contamination != "auto":
@@ -75,6 +84,7 @@ def _onedal_fit(self, X, y, queue=None):
             )
         self.n_neighbors_ = max(1, min(self.n_neighbors, n_samples - 1))
 
+        print(f"DEBUG LocalOutlierFactor._onedal_fit: Calling _onedal_kneighbors", file=sys.stderr)
         (
             self._distances_fit_X_,
             _neighbors_indices_fit_X_,
@@ -109,9 +119,12 @@ def _onedal_fit(self, X, y, queue=None):
                     "Increase the number of neighbors for more accurate results."
                 )
 
+        print(f"DEBUG LocalOutlierFactor._onedal_fit END: _fit_X type={type(getattr(self, '_fit_X', 'NOT_SET'))}", file=sys.stderr)
         return self
 
     def fit(self, X, y=None):
+        import sys
+        print(f"DEBUG LocalOutlierFactor.fit START: X type={type(X)}, X shape={getattr(X, 'shape', 'NO_SHAPE')}", file=sys.stderr)
         result = dispatch(
             self,
             "fit",
@@ -122,9 +135,12 @@ def fit(self, X, y=None):
             X,
             None,
         )
+        print(f"DEBUG LocalOutlierFactor.fit END: result type={type(result)}", file=sys.stderr)
         return result
 
     def _predict(self, X=None):
+        import sys
+        print(f"DEBUG LocalOutlierFactor._predict START: X type={type(X)}", file=sys.stderr)
         check_is_fitted(self)
 
         if X is not None:
@@ -136,6 +152,7 @@ def _predict(self, X=None):
             is_inlier = np.ones(self.n_samples_fit_, dtype=int)
             is_inlier[self.negative_outlier_factor_ < self.offset_] = -1
 
+        print(f"DEBUG LocalOutlierFactor._predict END: is_inlier type={type(is_inlier)}", file=sys.stderr)
         return is_inlier
 
     # This had to be done because predict loses the queue when no
@@ -146,13 +163,28 @@ def _predict(self, X=None):
     @wraps(_sklearn_LocalOutlierFactor.fit_predict, assigned=["__doc__"])
     @wrap_output_data
     def fit_predict(self, X, y=None):
-        return self.fit(X)._predict()
+        import sys
+        print(f"DEBUG LocalOutlierFactor.fit_predict START: X type={type(X)}", file=sys.stderr)
+        result = self.fit(X)._predict()
+        print(f"DEBUG LocalOutlierFactor.fit_predict END: result type={type(result)}", file=sys.stderr)
+        return result
 
     def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
+        import sys
+        print(f"DEBUG LocalOutlierFactor._kneighbors START: X type={type(X)}, n_neighbors={n_neighbors}, return_distance={return_distance}", file=sys.stderr)
+
+        # Validate n_neighbors parameter first (before check_is_fitted)
+        if n_neighbors is not None:
+            self._validate_n_neighbors(n_neighbors)
+
         check_is_fitted(self)
         if X is not None:
             check_feature_names(self, X, reset=False)
-        return dispatch(
+
+        # Validate kneighbors parameters (inherited from KNeighborsDispatchingBase)
+        self._kneighbors_validation(X, n_neighbors)
+
+        result = dispatch(
             self,
             "kneighbors",
             {
@@ -163,14 +195,25 @@ def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
             n_neighbors=n_neighbors,
             return_distance=return_distance,
         )
+        print(f"DEBUG LocalOutlierFactor._kneighbors END: result type={type(result)}", file=sys.stderr)
+        return result
 
     kneighbors = wrap_output_data(_kneighbors)
 
     @available_if(_sklearn_LocalOutlierFactor._check_novelty_score_samples)
     @wraps(_sklearn_LocalOutlierFactor.score_samples, assigned=["__doc__"])
     @wrap_output_data
     def score_samples(self, X):
+        import sys
+        print(f"DEBUG LocalOutlierFactor.score_samples START: X type={type(X)}", file=sys.stderr)
         check_is_fitted(self)
+
+        # Validate and convert X (pandas to numpy if needed)
+        X = validate_data(
+            self, X, dtype=[np.float64, np.float32], accept_sparse="csr", reset=False
+        )
+
+        check_feature_names(self, X, reset=False)
 
         distances_X, neighbors_indices_X = self._kneighbors(
             X, n_neighbors=self.n_neighbors_
@@ -183,7 +226,9 @@ def score_samples(self, X):
 
         lrd_ratios_array = self._lrd[neighbors_indices_X] / X_lrd[:, np.newaxis]
 
-        return -np.mean(lrd_ratios_array, axis=1)
+        result = -np.mean(lrd_ratios_array, axis=1)
+        print(f"DEBUG LocalOutlierFactor.score_samples END: result type={type(result)}", file=sys.stderr)
+        return result
 
     fit.__doc__ = _sklearn_LocalOutlierFactor.fit.__doc__
-    kneighbors.__doc__ = _sklearn_LocalOutlierFactor.kneighbors.__doc__
+    kneighbors.__doc__ = _sklearn_LocalOutlierFactor.kneighbors.__doc__