Venue: NeurIPS 2021 Conference

Reviews:

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper introduce a way to test the generalization performance of DNNs using labeled together with unlabeld datasets via less labeling efforts. Authors proposed  TestRank -- an integrated approach that 
(1) adopts an semi-supervised learning algorithm to "label" every unlabeled sample using a vector of discriminative features using GNN and label data.
(2) retrieves features of every unlabeled sample from the DNN model under testing, and
(3) trains an MLP using both GNN-predicted features and DNN-extracted features as inputs to predict failures of the DNN model as targets.
Some evaluation has been done using three image classification datasets. 
main_review: Testing generalization performance of DNNs with unlabeled datasets is an important problem of deep learning. I am wondering whether the proposed problem formulation "test prioritization" really makes sense in ML societies (I noted the most of cited papers were from the software engineering domain). 

Actually, there are a series of challenges and works on predicting the generalization gap using unlabeled datasets or validation-free information, such as NIPS 2020 Challenge "Predicting Generalization Gap" . Furthermore, there are also some papers in this domain such as "In Search of Robust Measures of Generalization" at NIPS 2020, and "Predicting the Generalization Gap in Deep Networks with Margin Distributions" at ICLR 2019. 

Two simple yet effective baseline to compare with TestRank are as follows.
(1) Using random data augmentation to generate pseudo testing samples using the training dataset with labels preserved, and predicting the generalization gap using the pseudo testing samples and the training samples. The gap of classification error between original samples and augmented samples could simply predict the generalization performance.
 
(2) Using random data augmentation to generate an additional set of unlabeled dataset using the original unlabeled datasets, and verifying whether the outputs of the DNN model based on every pair of images (the original image and the augmented image) are consistent. Such inconsistency should also characterize the generalization gap. 

limitations_and_societal_impact: This paper introduces a way to test the generalization performance of DNNs incorporating unlabeled datasets (validation-free information).
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper proposes a new test sample prioritization strategy to test deep learning systems. The objective is to maximize the number of failure-inducing samples selected from unlabeled samples. The authors propose to leverage both the samples' intrinsic properties (from the model's prediction behavior on them) and contextual properties (from other labeled samples close to them) as the criteria to select samples. By learning another binary classifier that takes the two properties as input, TestRank produces probabilities to rank the test samples. Empirical results demonstrate that TestRank outperforms existing test prioritization techniques.
main_review: ####Stregths:
- Clear description of the technique.
- Using contextual features generated by KNN+GNN seems novel.

####Weakness:
- Lack of justification on why samples close to incorrectly-labeled samples should be prioritized.
- Unclear why GNN is needed to extract contextual property -- how it compares to simple alternatives.

####Comments:

Overall, the paper is well-written. The motivation and the methodology are clearly described and very easy to understand. Having said that, my main concern is that I am not convinced by the criterion that the authors choose to prioritize test samples. I understand the authors' motivation is that test samples close to known error-inducing samples should be prioritized, as these samples are more likely "failure-revealing ." However, this assumption raises two questions:

First, if failure-revealing is the only criterion, numerous adversarial testing papers have been shown very effective in constructing error-inducing samples. The generated samples can also be far away from the decision boundary. Besides, the generated samples can be regularized to match real-world image distribution (using GANs or hard constraints). Given that adversarial testing can generate an unbounded number of real-world failure-revealing test samples, I do not see the clear use-case or unique advantage of test prioritization using only existing (limited number of) samples.

Second, I think the ultimate goal of testing is to reveal model violations of some abstract properties. For example, for computer vision models, we want to test whether the model is robust to a certain class of transformation (lighting conditions), labels, background, object poses, etc. Therefore, the testing should uncover diverse samples that can reveal different property violations instead of keeping generating samples violating the same properties. The idea is similar to traditional software testing, where we are interested in constructing tests that trigger different code paths. So why prioritize those samples that we already know the model is highly likely to fail?

As of methodology, I do not find the justification for using GNN (in Section 3.3) convincing. I understand that measuring the proximity of images is challenging, but why not directly leverage the target model, e.g., using its last convolution layer (often used to produce image representations), to generate the representation and compute the distance? Since the contextual property identifies the close samples from the target model's perspective, it seems natural to use its internal representation of the inputs to compute distances. This also saves the scalability issue of GNNs when working on a large number of nodes.

###Minor:

Sometimes "TestRank" is named as "TextRank". Are they indicating the same thing?

Does training the binary classifier (for failure-revealing) also update the weight parameters of the GNN? It is interesting to study which strategy works better - updating GNNs or keeping them frozen.

Approximate nearest neighbor (ANN) might be a very good alternative to KNN as the authors are approximating the computation anyway (ignoring unlabeled samples). ANN is much more efficient than KNN.

"et. al."->"et al." 
limitations_and_societal_impact: Yes
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: - Given a dataset of labeled and unlabeled examples, authors build a
  data point prioritization technique, which helps choose data points
  to be labeled next, with a goal of revealing failures as soon as
  possible. The technique should help prioritize labelling instances
  which currently trained model would misclassify.
- They use intrinsic and contextual attributes to build a model
  performing data point prioritization. Intrinsic attributes are those
  that are obtained by observing outputs of the deep learning model
  for a given input. Contextual capture information about similarity
  to the other instances -- if a given instance is similar to
  misclassified instances, that would be a strong signal that the
  instance is problematic.
- For intrinsic attributes, they use the output layer logits (before
  the softmax activation) of the DL model to construct a vector to be
  used for a final model. Second, they use a graph neural network to
  create contextual representation vector out of both labeled and
  unlabeled data. The aforementioned vectors are input to an
  multi-layer perceptron (MLP) model. The output of the MLP is a
  probability that a given input would be misclassified by the DL
  model.
- They evaluate their model against other data point prioritization
  techniques measuring number of failure revealing instances for a
  given labelling budget.
main_review: - I find the problem being solved an important one as manual labelling
  costs can become prohibitive. The problem being solved should help
  maximize the gains from manual labelling efforts providing a better
  quality model with less data overall.
  
- Considering that the overall goal is to maximize the quality of the
  data we label and generality of the model we train using that data,
  I wonder if data point prioritization techniques should be run on a
  single model or multiple models trained. We only know that the
  instances prioritized are troublesome for the current model, but are
  they really special? What if we trained another model with the same
  data we have, would we end up prioritizing different inputs?

- I would like to see evaluation on more models. More precisely, I
  would like to see for a single dataset having couple of model
  architectures, and for each architecture K models trained. Then,
  evaluate data point prioritization techniques on K models for each
  architecture. This is to gain more confidence that the performance
  gains generalize across models and architectures.

- I find it slightly difficult to read the paper. For example, on line
  256 it is written: "8K/10K/1.5K", but it is not written what the
  splits are for. Then, the following sentence sounds incomplete:
  "when ..., the maximum number of failures can be identified by a
  test prioritization technique equals to the budget". Also, following
  one: "which exploits the relational inductive-bias that exhibits in
  the graph structure". Also, following sentence: "we assume that
  there are 10,000 unlabeled data, and 2,000 of them can detect model
  failures", should probably start with: "let's assume".

- I see many mentions of "test prioritization" in the
  paper. Personally, I would find "data point prioritization", or
  "instance prioritization" a more natural name than the "test
  prioritization". The reason is that in software engineering, in the
  case of test case prioritization, there is already an oracle
  predefined for the tests being prioritized, while in this case we
  are about to create the oracle (label a prioritized instance). There
  are also mentions of "test instance prioritization" and "test input
  prioritization" which sound more natural. What might help paper read
  better is to use the naming consistently.

- Figure 3. It's hard to distinguish colors of different approaches in
  the legend.
limitations_and_societal_impact: Regarding the limitations, authors recognize that not each data
instance prioritized is of the same importance, which they did not
take into consideration. I think another important point to mention is
that while the technique learns to prioritize instances for a single
model, it is unclear if these instances are in any way special, or
they are just specific to the model trained. This is important if our
goal is to produce the best quality dataset. Alternatively, if the
idea is to keep retraining the model with the additional data it would
be good to evaluate how model benefits when augmented with newly
labeled data points.
review_title: null

Meta-review: The reviewers appreciated both the interesting problem of prioritizing unlabelled data points as well as the graph-based similarity technique to predict failure-revealing capabilities of data points. There were some concerns regarding baselines, additional evaluation tasks, and motivation of design choices, but the responses clarified many of these concerns. It would be great if authors can incorporate the additional clarifications and experimental results in the final version.
Decision: Accept (Poster)