Several fixes for kNN classification and unsupervised (#962)

Author: KalyanovD

deselected_tests.yaml

@@ -209,17 +209,8 @@ deselected_tests:
   # Some sklearnex docstrings differ from scikit-learn.
   - tests/test_docstrings.py >=1.0.2
 
-  # Results with scikit-learn are different for KNN in new ifaces. Need to fix.
-  - neighbors/tests/test_neighbors.py::test_KNeighborsClassifier_multioutput
-
   # Temporary deselected up to 2021.6 release. Need to fix
   - ensemble/tests/test_bagging.py::test_classification
-  - neighbors/tests/test_neighbors.py::test_KNeighborsClassifier_multioutput
-  - tests/test_common.py::test_estimators[KNeighborsClassifier()-check_classifier_data_not_an_array]
-  - tests/test_common.py::test_estimators[KNeighborsClassifier()-check_dont_overwrite_parameters]
-  - tests/test_common.py::test_estimators[NearestNeighbors()-check_dont_overwrite_parameters]
-  - tests/test_common.py::test_pandas_column_name_consistency[KNeighborsClassifier()]
-  - tests/test_common.py::test_pandas_column_name_consistency[NearestNeighbors()]
 
   # --------------------------------------------------------
   # Not need of testing for daal4py patching

onedal/neighbors/neighbors.py

@@ -157,15 +157,15 @@ def _validate_n_classes(self):
     def _fit(self, X, y, queue):
         self._onedal_model = None
         self._tree = None
-        self.shape = None
+        self._shape = None
         self.classes_ = None
         self.effective_metric_ = getattr(self, 'effective_metric_', self.metric)
         self.effective_metric_params_ = getattr(
             self, 'effective_metric_params_', self.metric_params)
 
         if y is not None or self.requires_y:
             X, y = super()._validate_data(X, y, dtype=[np.float64, np.float32])
-            self.shape = y.shape
+            self._shape = y.shape
 
             if _is_classifier(self) or _is_regressor(self):
                 if y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1:
@@ -186,7 +186,8 @@ def _fit(self, X, y, queue):
                 if not self.outputs_2d_:
                     self.classes_ = self.classes_[0]
                     self._y = self._y.ravel()
-                self._validate_n_classes()
+                if _is_classifier(self):
+                    self._validate_n_classes()
             else:
                 self._y = y
         else:
@@ -212,12 +213,12 @@ def _fit(self, X, y, queue):
             self.algorithm,
             self.n_samples_fit_, self.n_features_in_)
 
-        if _is_classifier(self) and y.dtype != X.dtype:
+        if (_is_classifier(self) or _is_regressor(self)) and y.dtype != X.dtype:
             y = self._validate_targets(self._y, X.dtype).reshape((-1, 1))
         result = self._onedal_fit(X, y, queue)
 
         if y is not None and _is_regressor(self):
-            self._y = y if self.shape is None else y.reshape(self.shape)
+            self._y = y if self._shape is None else y.reshape(self._shape)
 
         self._onedal_model = result.model
         result = self

sklearnex/neighbors/knn_classification.py

@@ -110,6 +110,8 @@ def __init__(self, n_neighbors=5, *,
             n_jobs=n_jobs, **kwargs)
 
     def fit(self, X, y):
+        if Version(sklearn_version) >= Version("1.0"):
+            self._check_feature_names(X, reset=True)
         if self.metric_params is not None and 'p' in self.metric_params:
             if self.p is not None:
                 warnings.warn("Parameter p is found in metric_params. "
@@ -224,6 +226,8 @@ def fit(self, X, y):
     @wrap_output_data
     def predict(self, X):
         check_is_fitted(self)
+        if Version(sklearn_version) >= Version("1.0"):
+            self._check_feature_names(X, reset=False)
         return dispatch(self, 'neighbors.KNeighborsClassifier.predict', {
             'onedal': self.__class__._onedal_predict,
             'sklearn': sklearn_KNeighborsClassifier.predict,
@@ -232,6 +236,8 @@ def predict(self, X):
     @wrap_output_data
     def predict_proba(self, X):
         check_is_fitted(self)
+        if Version(sklearn_version) >= Version("1.0"):
+            self._check_feature_names(X, reset=False)
         return dispatch(self, 'neighbors.KNeighborsClassifier.predict_proba', {
             'onedal': self.__class__._onedal_predict_proba,
             'sklearn': sklearn_KNeighborsClassifier.predict_proba,
@@ -240,6 +246,8 @@ def predict_proba(self, X):
     @wrap_output_data
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         check_is_fitted(self)
+        if Version(sklearn_version) >= Version("1.0"):
+            self._check_feature_names(X, reset=False)
         return dispatch(self, 'neighbors.KNeighborsClassifier.kneighbors', {
             'onedal': self.__class__._onedal_kneighbors,
             'sklearn': sklearn_KNeighborsClassifier.kneighbors,
@@ -267,85 +275,98 @@ def radius_neighbors(self, X=None, radius=None, return_distance=True,
 
     def _onedal_gpu_supported(self, method_name, *data):
         X_incorrect_type = isinstance(data[0], (KDTree, BallTree, sklearn_NeighborsBase))
-        if not X_incorrect_type:
-            if self._fit_method in ['auto', 'ball_tree']:
-                condition = self.n_neighbors is not None and \
-                    self.n_neighbors >= self.n_samples_fit_ // 2
-                if self.n_features_in_ > 11 or condition:
-                    result_method = 'brute'
-                else:
-                    if self.metric in ['euclidean']:
-                        result_method = 'kd_tree'
-                    else:
-                        result_method = 'brute'
+
+        if X_incorrect_type:
+            return False
+
+        if self._fit_method in ['auto', 'ball_tree']:
+            condition = self.n_neighbors is not None and \
+                self.n_neighbors >= self.n_samples_fit_ // 2
+            if self.n_features_in_ > 11 or condition:
+                result_method = 'brute'
             else:
-                result_method = self._fit_method
-        if method_name == 'neighbors.KNeighborsClassifier.fit':
-            if X_incorrect_type:
-                return False
-            is_sparse = sp.isspmatrix(data[0])
-            class_count = None
+                if self.effective_metric_ in ['euclidean']:
+                    result_method = 'kd_tree'
+                else:
+                    result_method = 'brute'
+        else:
+            result_method = self._fit_method
+
+        is_sparse = sp.isspmatrix(data[0])
+        is_single_output = False
+        class_count = 1
+        if len(data) > 1 or hasattr(self, '_onedal_estimator'):
+            # To check multioutput, might be overhead
             if len(data) > 1:
-                class_count = len(np.unique(data[1]))
-                # To check multioutput, might be overhead
                 y = np.asarray(data[1])
-                is_single_output = y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1
-            return result_method in ['brute'] and \
-                self.effective_metric_ in ['manhattan',
-                                           'minkowski',
-                                           'euclidean',
-                                           'chebyshev',
-                                           'cosine'] and \
-                class_count >= 2 and \
-                not is_sparse and \
-                is_single_output
+                class_count = len(np.unique(y))
+            if hasattr(self, '_onedal_estimator'):
+                y = self._onedal_estimator._y
+            is_single_output = y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1
+        is_valid_for_brute = result_method in ['brute'] and \
+            self.effective_metric_ in ['manhattan',
+                                       'minkowski',
+                                       'euclidean']
+        is_valid_weights = self.weights in ['uniform', "distance"]
+        main_condition = is_valid_for_brute and not is_sparse and \
+            is_single_output and is_valid_weights
+
+        if method_name == 'neighbors.KNeighborsClassifier.fit':
+            return main_condition and class_count >= 2
         if method_name in ['neighbors.KNeighborsClassifier.predict',
                            'neighbors.KNeighborsClassifier.predict_proba',
                            'neighbors.KNeighborsClassifier.kneighbors']:
-            return hasattr(self, '_onedal_estimator') and not sp.isspmatrix(data[0])
+            return main_condition and hasattr(self, '_onedal_estimator')
         raise RuntimeError(f'Unknown method {method_name} in {self.__class__.__name__}')
 
     def _onedal_cpu_supported(self, method_name, *data):
         X_incorrect_type = isinstance(data[0], (KDTree, BallTree, sklearn_NeighborsBase))
-        if not X_incorrect_type:
-            if self._fit_method in ['auto', 'ball_tree']:
-                condition = self.n_neighbors is not None and \
-                    self.n_neighbors >= self.n_samples_fit_ // 2
-                if self.n_features_in_ > 11 or condition:
-                    result_method = 'brute'
-                else:
-                    if self.metric in ['euclidean']:
-                        result_method = 'kd_tree'
-                    else:
-                        result_method = 'brute'
+
+        if X_incorrect_type:
+            return False
+
+        if self._fit_method in ['auto', 'ball_tree']:
+            condition = self.n_neighbors is not None and \
+                self.n_neighbors >= self.n_samples_fit_ // 2
+            if self.n_features_in_ > 11 or condition:
+                result_method = 'brute'
             else:
-                result_method = self._fit_method
-        if method_name == 'neighbors.KNeighborsClassifier.fit':
-            if X_incorrect_type:
-                return False
-            is_sparse = sp.isspmatrix(data[0])
-            class_count = None
+                if self.effective_metric_ in ['euclidean']:
+                    result_method = 'kd_tree'
+                else:
+                    result_method = 'brute'
+        else:
+            result_method = self._fit_method
+
+        is_sparse = sp.isspmatrix(data[0])
+        is_single_output = False
+        class_count = 1
+        if len(data) > 1 or hasattr(self, '_onedal_estimator'):
+            # To check multioutput, might be overhead
             if len(data) > 1:
-                class_count = len(np.unique(data[1]))
-                # To check multioutput, might be overhead
                 y = np.asarray(data[1])
-                is_single_output = y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1
-            is_valid_for_kd_tree = \
-                result_method in ['kd_tree'] and self.effective_metric_ in ['euclidean']
-            is_valid_for_brute = result_method in ['brute'] and \
-                self.effective_metric_ in ['manhattan',
-                                           'minkowski',
-                                           'euclidean',
-                                           'chebyshev',
-                                           'cosine']
-            return (is_valid_for_kd_tree or is_valid_for_brute) and \
-                class_count >= 2 and \
-                not is_sparse and \
-                is_single_output
+                class_count = len(np.unique(y))
+            if hasattr(self, '_onedal_estimator'):
+                y = self._onedal_estimator._y
+            is_single_output = y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1
+        is_valid_for_kd_tree = \
+            result_method in ['kd_tree'] and self.effective_metric_ in ['euclidean']
+        is_valid_for_brute = result_method in ['brute'] and \
+            self.effective_metric_ in ['manhattan',
+                                       'minkowski',
+                                       'euclidean',
+                                       'chebyshev',
+                                       'cosine']
+        is_valid_weights = self.weights in ['uniform', "distance"]
+        main_condition = (is_valid_for_kd_tree or is_valid_for_brute) and \
+            not is_sparse and is_single_output and is_valid_weights
+
+        if method_name == 'neighbors.KNeighborsClassifier.fit':
+            return main_condition and class_count >= 2
         if method_name in ['neighbors.KNeighborsClassifier.predict',
                            'neighbors.KNeighborsClassifier.predict_proba',
                            'neighbors.KNeighborsClassifier.kneighbors']:
-            return hasattr(self, '_onedal_estimator') and not sp.isspmatrix(data[0])
+            return main_condition and hasattr(self, '_onedal_estimator')
         raise RuntimeError(f'Unknown method {method_name} in {self.__class__.__name__}')
 
     def _onedal_fit(self, X, y, queue=None):
@@ -387,7 +408,6 @@ def _save_attributes(self):
         self.n_samples_fit_ = self._onedal_estimator.n_samples_fit_
         self._fit_X = self._onedal_estimator._fit_X
         self._y = self._onedal_estimator._y
-        self.shape = self._onedal_estimator.shape
         self._fit_method = self._onedal_estimator._fit_method
         self.outputs_2d_ = self._onedal_estimator.outputs_2d_
         self._tree = self._onedal_estimator._tree