Merge pull request #657 from yzhao062/development

V2.0.7

Author: yzhao062

.github/workflows/testing.yml

@@ -47,10 +47,14 @@ jobs:
         coverage run --source=pyod -m pytest
 
     - name: Coverage report
+      shell: bash
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         COVERALLS_SERVICE_NAME: github-actions
       run: |
-        coveralls --service=github || echo "Coveralls failed to submit - retrying..." && coveralls --service=github
+        coveralls --service=github --no-fail || true
+        echo "Coveralls upload attempted with --no-fail; retrying once in 15s for best effort."
+        sleep 15
+        coveralls --service=github --no-fail || true
 
 

CHANGES.txt

@@ -203,4 +203,8 @@ v<2.0.4>, <04/29/2025> -- Mistakenly we skipped 2.0.4.
 v<2.0.5>, <04/29/2025> -- Add wheel for better installation.
 v<2.0.6>, <09/04/2025> -- Finally, add the auto model selector (#616).
 v<2.0.6>, <12/01/2025> -- Pre-caution for new sklearn break change(#649).
-v<2.0.7>, <01/04/2026> -- Fix compatability issue of new sklearn.
+v<2.0.7>, <01/04/2026> -- Fix compatability issue of new sklearn.
+v<2.0.7>, <02/27/2026> -- Improve NearestNeighbors consistency/performance in KNN, ABOD, SOD, and LUNAR (issue #654).
+v<2.0.7>, <02/27/2026> -- VAE default output activation changed to identity and added identity activation support/tests (issue #651).
+v<2.0.7>, <02/27/2026> -- Fix package_data/MANIFEST configuration to include auto model selector JSON resources in distributions (issue #642).
+v<2.0.7>, <02/27/2026> -- In BaseDeepLearningDetector, explicitly ignore y during unsupervised fit to avoid batch tuple/list device errors in DL detectors (issue #591).

MANIFEST.in

@@ -3,4 +3,5 @@ prune notebooks
 prune pyod/test
 prune README.md
 include README.rst
-include requirements.txt
+include requirements.txt
+recursive-include pyod/utils/model_analysis_jsons *.json

pyod/models/abod.py

@@ -10,7 +10,6 @@
 
 import numpy as np
 from numba import njit
-from sklearn.neighbors import KDTree
 from sklearn.neighbors import NearestNeighbors
 from sklearn.utils import check_array
 from sklearn.utils.validation import check_is_fitted
@@ -117,6 +116,31 @@ class ABOD(BaseDetector):
         - 'default': original ABOD with all training points, which could be
           slow
 
+    algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
+        Algorithm used to compute nearest neighbors when ``method='fast'``.
+
+        - 'ball_tree' will use BallTree
+        - 'kd_tree' will use KDTree
+        - 'brute' will use a brute-force search
+        - 'auto' will attempt to choose the most appropriate algorithm
+
+    leaf_size : int, optional (default=30)
+        Leaf size passed to nearest-neighbor tree backends when applicable.
+        This can affect construction/query speed and memory usage.
+
+    metric : str or callable, optional (default='minkowski')
+        Distance metric used for nearest-neighbor computation in fast mode.
+
+    p : int, optional (default=2)
+        Power parameter for the Minkowski metric when ``metric='minkowski'``.
+
+    metric_params : dict, optional (default=None)
+        Additional keyword arguments for the metric function.
+
+    n_jobs : int, optional (default=1)
+        Number of parallel jobs for nearest-neighbor search.
+        If ``-1``, all available CPU cores are used.
+
     Attributes
     ----------
     decision_scores_ : numpy array of shape (n_samples,)
@@ -137,10 +161,19 @@ class ABOD(BaseDetector):
         ``threshold_`` on ``decision_scores_``.
     """
 
-    def __init__(self, contamination=0.1, n_neighbors=5, method='fast'):
+    def __init__(self, contamination=0.1, n_neighbors=5, method='fast',
+                 algorithm='auto', leaf_size=30, metric='minkowski', p=2,
+                 metric_params=None, n_jobs=1, **kwargs):
         super(ABOD, self).__init__(contamination=contamination)
         self.method = method
         self.n_neighbors = n_neighbors
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.metric = metric
+        self.p = p
+        self.metric_params = metric_params
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
 
     def fit(self, X, y=None):
         """Fit detector. y is ignored in unsupervised methods.
@@ -208,12 +241,19 @@ def _fit_fast(self):
             check_parameter(self.n_neighbors, 1, self.n_train_,
                             include_left=True, include_right=True)
 
-        self.tree_ = KDTree(self.X_train_)
-
-        neigh = NearestNeighbors(n_neighbors=self.n_neighbors)
-        neigh.fit(self.X_train_)
-        ind_arr = neigh.kneighbors(n_neighbors=self.n_neighbors,
-                                   return_distance=False)
+        self.neigh_ = NearestNeighbors(n_neighbors=self.n_neighbors,
+                                       algorithm=self.algorithm,
+                                       leaf_size=self.leaf_size,
+                                       metric=self.metric,
+                                       p=self.p,
+                                       metric_params=self.metric_params,
+                                       n_jobs=self.n_jobs,
+                                       **self.kwargs)
+        self.neigh_.fit(self.X_train_)
+        self.tree_ = self.neigh_
+        ind_arr = self.neigh_.kneighbors(self.X_train_,
+                                         n_neighbors=self.n_neighbors,
+                                         return_distance=False)
 
         for i in range(self.n_train_):
             curr_pt = self.X_train_[i, :]
@@ -293,12 +333,13 @@ def _decision_function_fast(self, X):
 
         """
 
-        check_is_fitted(self, ['tree_'])
+        check_is_fitted(self, ['neigh_'])
         # initialize the output score
         pred_score = np.zeros([X.shape[0], 1])
 
         # get the indexes of the X's k nearest training points
-        _, ind_arr = self.tree_.query(X, k=self.n_neighbors)
+        _, ind_arr = self.neigh_.kneighbors(X, n_neighbors=self.n_neighbors,
+                                            return_distance=True)
 
         for i in range(X.shape[0]):
             curr_pt = X[i, :]

pyod/models/base_dl.py

@@ -186,10 +186,10 @@ def fit(self, X, y=None):
         if self.preprocessing:
             self.X_mean = np.mean(X, axis=0)
             self.X_std = np.std(X, axis=0)
-            train_set = TorchDataset(X=X, y=y,
+            train_set = TorchDataset(X=X, y=None,
                                      mean=self.X_mean, std=self.X_std)
         else:
-            train_set = TorchDataset(X=X, y=y)
+            train_set = TorchDataset(X=X, y=None)
 
         # create data loader
         train_loader = torch.utils.data.DataLoader(

pyod/models/knn.py

@@ -232,26 +232,23 @@ def decision_function(self, X):
         -------
         anomaly_scores : numpy array of shape (n_samples,)
             The anomaly score of the input samples.
+
+        Notes
+        -----
+        This method performs batched neighbor queries through the fitted
+        ``NearestNeighbors`` estimator, so runtime behavior follows the
+        configured neighbor-search parameters (e.g., ``algorithm``,
+        ``metric``, and ``n_jobs``).
         """
-        check_is_fitted(self, ['tree_', 'decision_scores_',
-                               'threshold_', 'labels_'])
+        check_is_fitted(self, ['decision_scores_', 'threshold_', 'labels_'])
 
         X = check_array(X)
 
-        # initialize the output score
-        pred_scores = np.zeros([X.shape[0], 1])
-
-        for i in range(X.shape[0]):
-            x_i = X[i, :]
-            x_i = np.asarray(x_i).reshape(1, x_i.shape[0])
-
-            # get the distance of the current point
-            dist_arr, _ = self.tree_.query(x_i, k=self.n_neighbors)
-            dist = self._get_dist_by_method(dist_arr)
-            pred_score_i = dist[-1]
-
-            # record the current item
-            pred_scores[i, :] = pred_score_i
+        # Use the fitted NearestNeighbors object for batch querying so
+        # query-time behavior is consistent with fit-time configuration.
+        dist_arr, _ = self.neigh_.kneighbors(
+            X, n_neighbors=self.n_neighbors, return_distance=True)
+        pred_scores = self._get_dist_by_method(dist_arr)
 
         return pred_scores.ravel()
 

pyod/models/lunar.py

@@ -124,6 +124,8 @@ class LUNAR(BaseDetector):
 
     n_neighbors: int, optional (default = 5)
         Number of neighbors to use by default for k neighbors queries.
+        In the implementation, the constructor argument name is
+        ``n_neighbours`` for backward compatibility.
 
     negative_sampling: str in ['UNIFORM', 'SUBSPACE', MIXED'], optional (default = 'MIXED)
         Type of negative samples to use between:
@@ -158,6 +160,27 @@ class LUNAR(BaseDetector):
     verbose: int in {0,1}, optional (default = 0):
         To view or hide training progress
 
+    algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
+        Algorithm used to compute nearest neighbors.
+
+    leaf_size : int, optional (default=30)
+        Leaf size passed to nearest-neighbor tree backends when applicable.
+        This can affect construction/query speed and memory usage.
+
+    metric : str or callable, optional (default='minkowski')
+        Distance metric used for nearest-neighbor computation.
+
+    p : int, optional (default=2)
+        Power parameter for the Minkowski metric when
+        ``metric='minkowski'``.
+
+    metric_params : dict, optional (default=None)
+        Additional keyword arguments for the metric function.
+
+    n_jobs : int, optional (default=1)
+        Number of parallel jobs for nearest-neighbor search.
+        If ``-1``, all available CPU cores are used.
+
     Attributes
     ----------
     """
@@ -166,7 +189,9 @@ def __init__(self, model_type="WEIGHT", n_neighbours=5,
                  negative_sampling="MIXED",
                  val_size=0.1, scaler=MinMaxScaler(), epsilon=0.1,
                  proportion=1.0,
-                 n_epochs=200, lr=0.001, wd=0.1, verbose=0, contamination=0.1):
+                 n_epochs=200, lr=0.001, wd=0.1, verbose=0, contamination=0.1,
+                 algorithm='auto', leaf_size=30, metric='minkowski', p=2,
+                 metric_params=None, n_jobs=1, **kwargs):
         super(LUNAR, self).__init__(contamination=contamination)
 
         self.model_type = model_type
@@ -180,6 +205,13 @@ def __init__(self, model_type="WEIGHT", n_neighbours=5,
         self.wd = wd
         self.val_size = val_size
         self.verbose = verbose
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.metric = metric
+        self.p = p
+        self.metric_params = metric_params
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
         self.device = torch.device(
             'cuda' if torch.cuda.is_available() else 'cpu')
 
@@ -239,7 +271,14 @@ def fit(self, X, y=None):
         val_x = np.vstack((val_x, neg_val_x))
         val_y = np.hstack((val_y, neg_val_y))
 
-        self.neigh = NearestNeighbors(n_neighbors=self.n_neighbours + 1)
+        self.neigh = NearestNeighbors(n_neighbors=self.n_neighbours + 1,
+                                      algorithm=self.algorithm,
+                                      leaf_size=self.leaf_size,
+                                      metric=self.metric,
+                                      p=self.p,
+                                      metric_params=self.metric_params,
+                                      n_jobs=self.n_jobs,
+                                      **self.kwargs)
         self.neigh.fit(train_x)
 
         # nearest neighbours of training set

pyod/models/sod.py

@@ -62,6 +62,27 @@ class SOD(BaseDetector):
            specifies the lower limit for selecting subspace.
            0.8 is set as default as suggested in the original paper.
 
+    algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
+        Algorithm used to compute nearest neighbors.
+
+    leaf_size : int, optional (default=30)
+        Leaf size passed to nearest-neighbor tree backends when applicable.
+        This can affect construction/query speed and memory usage.
+
+    metric : str or callable, optional (default='minkowski')
+        Distance metric used for nearest-neighbor computation.
+
+    p : int, optional (default=2)
+        Power parameter for the Minkowski metric when
+        ``metric='minkowski'``.
+
+    metric_params : dict, optional (default=None)
+        Additional keyword arguments for the metric function.
+
+    n_jobs : int, optional (default=1)
+        Number of parallel jobs for nearest-neighbor search.
+        If ``-1``, all available CPU cores are used.
+
     contamination : float in (0., 0.5), optional (default=0.1)
         The amount of contamination of the data set, i.e.
         the proportion of outliers in the data set. Used when fitting to
@@ -88,7 +109,9 @@ class SOD(BaseDetector):
     """
 
     def __init__(self, contamination=0.1, n_neighbors=20, ref_set=10,
-                 alpha=0.8):
+                 alpha=0.8, algorithm='auto', leaf_size=30,
+                 metric='minkowski', p=2, metric_params=None, n_jobs=1,
+                 **kwargs):
         super(SOD, self).__init__(contamination=contamination)
         if isinstance(n_neighbors, int):
             check_parameter(n_neighbors, low=1, param_name='n_neighbors')
@@ -110,6 +133,13 @@ def __init__(self, contamination=0.1, n_neighbors=20, ref_set=10,
         self.n_neighbors = n_neighbors
         self.ref_set = ref_set
         self.alpha = alpha
+        self.algorithm = algorithm
+        self.leaf_size = leaf_size
+        self.metric = metric
+        self.p = p
+        self.metric_params = metric_params
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
 
     def fit(self, X, y=None):
         """Fit detector. y is ignored in unsupervised methods.
@@ -165,7 +195,14 @@ def _snn(self, X):
         snn_indices : numpy array of shape (n_shared_nearest_neighbors,)
             The indices of top k shared nearest neighbors for each observation.
         """
-        knn = NearestNeighbors(n_neighbors=self.n_neighbors)
+        knn = NearestNeighbors(n_neighbors=self.n_neighbors,
+                               algorithm=self.algorithm,
+                               leaf_size=self.leaf_size,
+                               metric=self.metric,
+                               p=self.p,
+                               metric_params=self.metric_params,
+                               n_jobs=self.n_jobs,
+                               **self.kwargs)
         knn.fit(X)
         # Get the knn index
         ind = knn.kneighbors(return_distance=False)

pyod/models/vae.py

@@ -163,8 +163,10 @@ class VAE(BaseDeepLearningDetector):
     hidden_activation_name : str, optional (default='relu')
         The activation function used in hidden layers.
 
-    output_activation_name : str, optional (default='sigmoid')
+    output_activation_name : str, optional (default='identity')
         The activation function used in output layer.
+        ``identity`` is the default to avoid constraining reconstruction
+        outputs to a bounded range when preprocessing is enabled.
 
     batch_norm : boolean, optional (default=False)
         Whether to apply Batch Normalization,
@@ -213,7 +215,7 @@ def __init__(self, contamination=0.1, preprocessing=True,
                  decoder_neuron_list=[32, 64, 128],
                  latent_dim=2,
                  hidden_activation_name='relu',
-                 output_activation_name='sigmoid',
+                 output_activation_name='identity',
                  batch_norm=False, dropout_rate=0.2):
         super(VAE, self).__init__(contamination=contamination,
                                   preprocessing=preprocessing,

pyod/test/test_abod.py

@@ -135,6 +135,20 @@ def test_fit_predict_score(self):
     def test_model_clone(self):
         clone_clf = clone(self.clf)
 
+    def test_fast_mode_tree_and_neighbor_model_consistent(self):
+        assert (hasattr(self.clf, 'neigh_') and self.clf.neigh_ is not None)
+        assert (self.clf.tree_ is self.clf.neigh_)
+
+    def test_fast_mode_neighbor_params_propagation(self):
+        for algorithm in ['auto', 'kd_tree', 'brute']:
+            clf = ABOD(contamination=self.contamination, n_neighbors=5,
+                       method='fast', algorithm=algorithm, n_jobs=-1)
+            clf.fit(self.X_train)
+            assert_equal(clf.neigh_.algorithm, algorithm)
+            assert_equal(clf.neigh_.n_jobs, -1)
+            pred_scores = clf.decision_function(self.X_test)
+            assert_equal(pred_scores.shape[0], self.X_test.shape[0])
+
     def tearDown(self):
         pass