ArXiv: 2010.15980

🎯 Pitch

Masked language models can perform sentiment analysis and extract factual knowledge without any fine-tuning, achieving accuracy on par with supervised models when prompted correctly. AutoPrompt discovers these prompts automatically through a gradient-guided search over discrete trigger words, eliminating the guesswork of manual prompt design and revealing that models harbor far more task-specific competence than previously measured.

1. Executive Summary

This paper introduces AUTOPROMPT, an automated method for constructing prompts that elicit knowledge from pretrained language models by reformulating tasks as fill-in-the-blank problems. Using a gradient-guided search over discrete trigger tokens shared across all inputs—and an automated label token selection procedure that maps vocabulary words to class labels by marginalizing over the model's masked token predictions—AUTOPROMPT probes masked language models (BERT_BASE_ and RoBERTa_LARGE_) on sentiment analysis, natural language inference, fact retrieval, and relation extraction without any fine-tuning or additional parameters. The method achieves 91.4% accuracy on SST-2 sentiment analysis (matching fine-tuned BERT and ELMo models) and improves precision-at-1 on the LAMA fact retrieval benchmark by up to 12 points over manually crafted prompts (43.3% vs. 31.1%), establishing that pretrained MLMs contain substantially more task-specific knowledge than previously estimated, though this knowledge remains bounded—on relation extraction, performance drops sharply when context sentences are artificially falsified, revealing that MLMs rely heavily on memorized background facts rather than genuine extraction capabilities.

2. Context and Motivation

The Core Problem: We Don't Know What Pretrained Language Models Actually Know

Pretrained language models like BERT and RoBERTa achieve remarkable performance when fine-tuned on downstream tasks. But this creates a fundamental ambiguity: did the model learn the relevant knowledge during pretraining, or did it acquire that knowledge only during the supervised fine-tuning step? The distinction matters enormously for both scientific understanding of these models and for practical deployment decisions.

This paper tackles a deceptively simple question: if we take a pretrained language model off the shelf—without any additional training, without any additional parameters—and simply ask it the right way, how much task-specific knowledge can we extract? The answer has been elusive because the method used to ask the question profoundly influences the apparent answer. The same model can appear knowledgeable or ignorant depending on how the question is phrased, and prior to this work, constructing effective phrasings required labor-intensive manual effort and guesswork.

Why This Gap Matters

The paper identifies several reasons why measuring what pretrained LMs genuinely know is important, spanning scientific, practical, and methodological concerns.

Scientific understanding: disentangling pretraining from fine-tuning. When a fine-tuned BERT model achieves high accuracy on sentiment analysis, we cannot easily attribute that capability to the pretraining process. The fine-tuning stage may be teaching the model sentiment analysis from scratch using the labeled data, or it may simply be teaching the model how to express sentiment analysis knowledge it already acquired from reading billions of words during pretraining. These two scenarios imply very different things about the nature of pretraining, about what linguistic and world knowledge is learnable from language modeling objectives alone, and about how we should design future pretraining procedures. Without a method to probe pretrained LMs without additional training, we cannot distinguish between these hypotheses.

Evaluating models as knowledge bases. Petroni et al. (2019) introduced the provocative idea that language models could serve as knowledge bases—repositories of factual information that can be queried in natural language. If true, this would have significant implications: rather than maintaining structured knowledge bases that require manual curation, we could simply query a pretrained LM. However, the validity of this idea depends entirely on whether our querying methods actually surface the knowledge that exists in the model. If our prompts are suboptimal, we might conclude that a model lacks knowledge that it actually possesses—a false negative that underestimates the model's capabilities and the viability of the LM-as-knowledge-base paradigm.

Practical advantages over fine-tuning. Beyond scientific understanding, prompting offers practical benefits the paper highlights in Section 7. Fine-tuning requires storing large model checkpoints for each individual task—a BERT_BASE_ checkpoint is roughly 440 MB. Deploying a system that handles dozens of tasks would require gigabytes of storage and the operational complexity of serving many separate models. Prompting, by contrast, uses a single pretrained model across all tasks, with only the prompt text varying per task. This drastically reduces deployment complexity. Moreover, as the paper demonstrates in Figure 2, prompting can outperform fine-tuning in low-data regimes where labeled examples are scarce—a common real-world scenario.

Where Prior Approaches Fall Short

The paper identifies three major approaches for analyzing pretrained LMs' knowledge, each with significant limitations that AUTOPROMPT is designed to address.

Probing classifiers introduce false positives. The dominant approach in the interpretability literature has been to train probing classifiers—typically shallow models like logistic regression or small feedforward networks—that take frozen LM representations as input features and predict some linguistic property (part of speech, dependency relations, semantic roles, etc.). If the probing classifier achieves high accuracy, the argument goes, the LM must encode that property in its representations (Conneau et al., 2018; Liu et al., 2019).

The paper identifies a critical flaw with this reasoning, citing Hewitt and Liang (2019) and Voita and Titov (2020): high probing accuracy is not sufficient evidence that the LM actually contains the target knowledge. The probing classifier itself has learned parameters, and it may be extracting the knowledge from the representations in ways that the model itself cannot use. In other words, the classifier might be solving the task using information that is only latently present in the representations, not information that the model can access or deploy for its own predictions. This creates a false-positive problem: we might conclude the LM "knows" something when in reality a separate learned component is doing the work. As the paper states in Section 1:

"probing classifiers require additional learned parameters and are thus susceptible to false positives; high probing accuracy is not a sufficient condition to conclude that an LM contains a certain piece of knowledge"

Additionally, probing classifiers typically operate on the model's internal representations—the hidden state vectors at various layers. This requires technical access to the model internals and imposes constraints on what can be probed: the knowledge must be representable as a simple token- or sequence-level classification task that a shallow classifier can learn from fixed-dimensional vector inputs. More complex or structured knowledge (e.g., multi-step reasoning, relational knowledge involving multiple entities) is difficult to probe with this paradigm.

Attention visualization suffers from correlation-not-causation problems. Another common analysis technique is to visualize attention weights—the soft alignment scores between tokens in different positions—and interpret them as explanations of what the model is "looking at" when making predictions. The paper notes that this approach has been subjected to substantial criticism (Jain and Wallace, 2019; Wiegreffe and Pinter, 2019) because attention weights may be correlated with, but not causally responsible for, the model's predictions. A token may receive high attention not because the model is using it to make a decision, but because of some other structural property of the input. Like probing classifiers, attention visualization struggles with the distinction between correlation and causation, and it cannot evaluate knowledge that does not manifest as interpretable attention patterns.

Manual prompting is fragile, labor-intensive, and underestimates model knowledge. The third approach—and the one AUTOPROMPT builds upon—is prompting: reformulating a task as a fill-in-the-blank problem that the LM can solve using its language modeling capabilities. For example, to probe whether BERT knows Barack Obama's birthplace, Petroni et al. (2019) feed the model "Barack Obama was born in [MASK]" and check whether it predicts "Hawaii." This is the LAMA benchmark approach.

Prompting has a crucial advantage over probing classifiers: it does not introduce any additional learned parameters. The same pretrained LM is used as-is, without modification. The prompt is the only thing that changes. This means that if a prompted LM solves a task correctly, we can be confident that the knowledge genuinely exists in the model—the prompt is simply providing a format that makes that knowledge accessible. There is no separate classifier to do the work. As the paper puts it:

"Compared to existing model analysis methods, prompting is non-invasive: it does not introduce large amounts of additional parameters or require direct inspection of a model's representations. Thus prompting provides a lower bound on what the model 'knows,' and is therefore a more useful analysis tool."

The "lower bound" framing is important: prompting can only underestimate what the model knows. If prompting fails, it could be because the model genuinely lacks the knowledge, or it could be because the prompt was poorly constructed. If prompting succeeds, the model definitely has the knowledge. This makes prompting a conservative but trustworthy analysis tool.

However, the paper identifies three specific failure modes of existing prompting approaches that motivated the development of AUTOPROMPT:

1. Manual prompt construction is labor-intensive and non-intuitive. For some tasks, writing a natural prompt is straightforward: to probe birthplace knowledge, "was born in" is an obvious phrasing. But for many tasks, the right prompt is far from obvious. How should one phrase a prompt for sentiment analysis as a fill-in-the-blank problem? For natural language inference? The paper notes that manual prompt writing requires "time consuming and non-intuitive" effort, and for some tasks there is no clear natural language template at all.

2. Models are highly sensitive to prompt phrasing, and suboptimal prompts cause artificially low performance. Jiang et al. (2020) demonstrated that different manually written prompts for the same fact retrieval task can yield dramatically different accuracy. The paper cites this directly:

"models are highly sensitive to this context: improperly-constructed contexts cause artificially low performance (Jiang et al., 2020)"

This sensitivity means that a researcher who writes a suboptimal prompt might incorrectly conclude that the model lacks certain knowledge, when in reality the model has the knowledge but the prompt fails to elicit it. For prompting to serve as a reliable lower-bound estimator of model knowledge, we need prompts that are as effective as possible—otherwise the lower bound is artificially loose and uninformative.

3. Different models may require different prompts. A prompt that works well for BERT may not work well for RoBERTa, since the two models have different tokenization, different training data, and potentially different inductive biases about how language is structured. Writing separate manual prompts for every model variant is impractical, especially as the number of pretrained models proliferates.

Prior Attempts to Improve Prompting (and Their Limitations)

The paper positions AUTOPROMPT relative to two specific prior works that attempted to move beyond purely manual prompt construction.

LPAQA (Jiang et al., 2020) addressed the prompt sensitivity problem for fact retrieval specifically. LPAQA systematically generates prompts by (1) mining Wikipedia text for sentences that express the target relation, extracting the context around the subject and object as candidate prompts, (2) using back-translation to paraphrase existing prompts, and (3) crowdsourcing new prompts from human annotators. They also ensemble predictions across multiple prompts. This approach improved substantially over LAMA's single manual prompts, demonstrating that better prompts surface more knowledge.

However, LPAQA has significant limitations that AUTOPROMPT addresses. First, it is specific to fact retrieval—the Wikipedia mining approach relies on having structured knowledge base triples with known subject-relation-object patterns that can be matched against text. It does not generalize to sentiment analysis, NLI, or other classification tasks where there is no knowledge base to mine. Second, while LPAQA's approach is more systematic than pure manual writing, it still requires substantial task-specific engineering: designing the mining heuristics, setting up paraphrasing pipelines, and running crowdsourcing for each new relation. Third, LPAQA does not customize prompts for the specific model being probed—it produces generic prompts that may be suboptimal for a given model's idiosyncrasies.

The authors position AUTOPROMPT as a more general and model-aware alternative:

"we automatically generate prompts for any task, which leads to higher accuracy and opens up new phenomena to analyze."

Universal Adversarial Triggers (Wallace et al., 2019) introduced the gradient-guided search over discrete tokens that AUTOPROMPT adapts. Wallace et al. showed that appending a sequence of "trigger" tokens—shared across all inputs and optimized via gradient-based search—could cause NLP models to produce specific (often adversarial) outputs regardless of the input. For example, appending a particular phrase to movie reviews might cause a sentiment classifier to always predict "positive."

AUTOPROMPT repurposes this search procedure for a constructive rather than adversarial purpose: instead of searching for triggers that force a particular (potentially wrong) output, AUTOPROMPT searches for triggers that maximize the likelihood of the correct output on training data. The key insight is that the same gradient-guided discrete optimization that can break models can also be used to build better prompts for eliciting knowledge. The paper makes this connection explicit in Section 2.2, and the core technical approach—computing a first-order approximation of the log-likelihood change from swapping a trigger token, then evaluating top candidates—is directly adapted from Wallace et al. (2019).

How AUTOPROMPT Positions Itself

The paper positions AUTOPROMPT not as a replacement for all other probing methods, but as a complementary tool that fills a specific gap in the interpretability toolkit. The closing of Section 7 states this explicitly:

"AUTOPROMPT makes prompt-based probes more generally applicable, but, it still remains just one tool in the toolbox of the interpretability researcher."

This is important framing. Different probing methods have different strengths: linear probes can analyze specific representational dimensions, attention visualization can provide qualitative insights into information flow, and prompting provides conservative lower-bound estimates of task knowledge. AUTOPROMPT expands the scope of what prompting can probe by removing the manual prompt construction bottleneck, but it does not claim to make other methods obsolete.

The paper also positions AUTOPROMPT as a method for automated prompt generation, not just prompt-based analysis. This distinction matters for the practical applications the paper explores (Section 7): the prompts AUTOPROMPT generates aren't just for analyzing models—they can be used to actually deploy the models for downstream tasks without fine-tuning. The paper explicitly connects to the GPT-3 paradigm (Brown et al., 2020), where prompts serve as the primary interface to a general-purpose model, and suggests AUTOPROMPT could automate prompt construction in that setting.

Finally, the paper positions itself relative to the broader goal of understanding what language models learn during pretraining. The experiments on fact retrieval (Section 5) and relation extraction (Section 6) are specifically designed to test claims from Petroni et al. (2019) that LMs can serve as knowledge bases, using more effective prompts to establish tighter lower bounds. The experiments on sentiment analysis (Section 3) and NLI (Section 4) extend this probing paradigm to tasks that were previously considered outside the scope of prompting-based analysis, demonstrating that MLMs have more task-specific capabilities than previously demonstrated—capabilities that were simply inaccessible without properly constructed prompts.

3. Technical Approach

3.1 Reader Orientation

This paper is a method paper that introduces an algorithm for automatically constructing prompts that turn classification and knowledge retrieval tasks into fill-in-the-blank problems for masked language models. AUTOPROMPT solves the problem of manual prompt engineering by searching over a discrete space of shared "trigger tokens" using gradient-based optimization, then mapping the language model's token predictions to class labels through an automated label selection procedure—all without modifying the pretrained model or adding parameters.

3.2 Big-Picture Architecture

The AUTOPROMPT system has four major components that work together in a pipeline:

  1. A template $\lambda$ — a structural skeleton that defines where the original task input(s), the trigger tokens, and the prediction [MASK] token will be placed in the final prompt. The template is hand-specified once per task type, not learned.

  2. Trigger token search — a gradient-guided discrete optimization procedure that learns a set of shared trigger tokens $x_{\text{trig}}$ (denoted [T] in templates) by iteratively swapping tokens to maximize the likelihood of correct labels on training data. These triggers are the same for all examples and are the core learned component.

  3. Label token sets $\mathcal{V}_y$ — for each class label $y$, a set of vocabulary words that "mean" that label. For classification tasks (sentiment analysis, NLI), these are automatically discovered using a logistic regression heuristic. For fact retrieval, the label token is simply the entity name itself (the object of the knowledge base triple).

  4. Inference via marginalization — given a constructed prompt $x_{\text{prompt}}$, the MLM produces a distribution $p([\text{MASK}] \mid x_{\text{prompt}})$ over all vocabulary tokens. The probability for class $y$ is the sum $\sum_{w \in \mathcal{V}_y} p([\text{MASK}] = w \mid x_{\text{prompt}})$ of the model's predictions for all tokens in the label set $\mathcal{V}_y$. The model is then evaluated the same as any classifier.

Information flow: Task inputs (e.g., a movie review) enter the system → the template structuralizes the input alongside placeholder trigger tokens → the learned trigger tokens fill the placeholder positions → the combined prompt is fed to the frozen MLM → the MLM predicts a distribution over the [MASK] position → predictions are marginalized over the label token sets → a class label is produced.

3.3 Roadmap for the Deep Dive

  • First, the formal notation and task reformulation framework, establishing the clean separation between original inputs $x_{\text{inp}}$, prompts $x_{\text{prompt}}$, and the template $\lambda$ that maps between them. This is the scaffolding everything else builds on.

  • Second, the gradient-based trigger token search, which is the core technical contribution. Understanding how AUTOPROMPT approximates the effect of discrete token swaps using input embedding gradients—and why this enables efficient search over a vocabulary of tens of thousands of tokens—is essential for understanding why the method works.

  • Third, the automated label token selection procedure, which converts the MLM's token-level predictions into class-level probabilities without requiring manual specification of which words correspond to which labels.

  • Fourth, the overall optimization loop and evaluation protocol, tying together the trigger search with validation-based model selection and explaining how labeled training data is used without overfitting the probe to the test set.

3.4 Detailed, Sentence-Based Technical Breakdown

This is a method paper whose core idea is that prompts can be automatically constructed by learning a small set of shared trigger tokens via gradient-based discrete optimization, then interpreting the MLM's output distribution by marginalizing over automatically discovered sets of label tokens.

Task Reformulation: Converting Classification Into Masked Language Modeling

The fundamental operation AUTOPROMPT performs is converting an arbitrary classification (or knowledge retrieval) task into a format that a masked language model can process natively. Every MLM is trained to fill in [MASK] tokens by predicting which vocabulary word is most likely at that position. AUTOPROMPT exploits this capability by designing prompts where the [MASK] position corresponds to the answer the task requires.

Notation and the template abstraction. The paper carefully separates three concepts that are easy to conflate:

  • $x_{\text{inp}}$ is the original task input — the raw data for the task. For sentiment analysis, this is the movie review text ("a real joy."). For NLI, this is the premise and hypothesis pair. For fact retrieval, this is the subject entity of a knowledge base triple.

  • $x_{\text{prompt}}$ is the prompt actually fed to the MLM — the sequence of tokens that includes the original input surrounded by additional context, trigger tokens, and a [MASK] token at the position where the model should make its prediction.

  • $\lambda$ is the template — a function or structural specification that maps $x_{\text{inp}}$ to $x_{\text{prompt}}$, defining exactly where each input component goes and where the trigger tokens and prediction token [P] are placed. The paper uses [P] in templates to distinguish the task's prediction mask from other [MASK] tokens that might naturally appear in the input text.

The template is hand-designed once per task type, not learned. Examples from Table 3 in the paper:

  • Sentiment analysis: "{sentence} [T] ... [T] [P]." — the review is placed first, followed by several trigger tokens, followed by the prediction mask.

  • NLI: "{prem} [P] [T] ... [T] {hyp}" — the premise appears first with the prediction mask immediately after, then trigger tokens, then the hypothesis.

  • Fact retrieval: "{sub} [T] ... [T] [P]." — the subject entity is placed first, followed by trigger tokens, followed by the prediction mask whose ground-truth fill is the object entity.

The [T] placeholder represents a position that will be filled by a trigger token — a vocabulary token that is shared across all prompts for that task and is learned by the gradient-based search procedure described in Section 3.4 of this document. The [P] placeholder represents the prediction position where the MLM's output distribution is interpreted.

Why a template rather than full generation. The paper intentionally constrains the prompt structure to a template with fixed placement of input and prediction tokens plus a variable-length sequence of shared triggers. This is a deliberate design choice driven by two considerations. First, it keeps the search space manageable — rather than searching over all possible prompt structures (which would be combinatorially explosive), AUTOPROMPT only searches over which tokens fill the trigger positions, reducing the problem to a sequence of discrete token substitutions. Second, it ensures that the relationship between the input and the prediction position is consistent across examples, which is necessary for the trigger tokens (which are shared across all inputs) to serve as useful context that biases the MLM toward the correct class-conditional output distribution.

Inference by marginalization over label tokens. For a given constructed prompt $x_{\text{prompt}}$, feeding it through the MLM produces a probability distribution over the entire vocabulary at the [MASK] position:

p([MASK]∣xprompt)p([\text{MASK}] \mid x_{\text{prompt}})

where the output is a vector of dimension $|\mathcal{V}|$ (the vocabulary size, typically 30,000–50,000 tokens), with each entry representing the model's estimated probability that the corresponding token fills the blank.

For classification tasks, this distribution must be converted into a distribution over class labels. AUTOPROMPT does this by defining, for each class label $y$, a set of label tokens $\mathcal{V}_y \subset \mathcal{V}$ that correspond to that label. The class probability is then:

p(y∣xprompt)=∑w∈Vyp([MASK]=w∣xprompt)p(y \mid x_{\text{prompt}}) = \sum_{w \in \mathcal{V}_y} p([\text{MASK}] = w \mid x_{\text{prompt}})

where $\mathcal{V}_y$ is the set of vocabulary tokens associated with label $y$, and the sum is over all tokens in that set.

What it computes: for each class label, the model sums the probability it assigns to every vocabulary token in that label's set. If the positive sentiment label set is {"fantastic", "great", "wonderful"} and the model assigns probabilities 0.3, 0.2, and 0.1 to these tokens respectively, then $p(\text{positive}) = 0.6$.

Why marginalization rather than single-token mapping: mapping each class to exactly one vocabulary token (e.g., "positive" → "good") is brittle for two reasons. First, the model may distribute probability mass across multiple semantically similar words (fantastic, excellent, wonderful), and summing captures this distributed representation. Second, for abstract class labels like "entailment" or "neutral" in NLI, there may be no single vocabulary token that cleanly corresponds to the class concept — but there may be multiple tokens that collectively indicate the concept. The paper finds in Figure 3 (Appendix A) that increasing the label set size from 1 to 3 tokens improves accuracy substantially (approximately +5% for BERT, +10% for RoBERTa on SST-2), empirically validating this design choice.

For fact retrieval and relation extraction, the label set is trivial: $\mathcal{V}_y$ contains exactly the entity name(s) that are the correct answer — the object of the knowledge base triple. No marginalization is needed because the class labels are themselves vocabulary tokens. The paper evaluates by ranking all tokens by probability and measuring whether the correct entity appears at rank 1 ($P@1$) or in the top $k$ ($P@k$).

This is the core technical mechanism that distinguishes AUTOPROMPT from prior prompting work. The goal is to find a sequence of trigger tokens $x_{\text{trig}} = [t_1, t_2, ..., t_m]$ (where $m$ is typically 3–7 tokens) that, when inserted into the template alongside each input, maximize the probability the MLM assigns to the correct class label.

The discrete optimization problem. The trigger tokens are drawn from the model's vocabulary $\mathcal{V}$, which contains 30,000+ tokens. Searching over all possible sequences of length $m$ is $|\mathcal{V}|^m$ possibilities — completely intractable even for $m=3$. The problem is compounded by the fact that evaluating any candidate sequence requires running the MLM on (a batch of) training examples, so each evaluation is computationally expensive.

AUTOPROMPT addresses this with a gradient-guided greedy search adapted directly from the Universal Adversarial Triggers work (Wallace et al., 2019). The key insight is that although the token space is discrete, the model is differentiable with respect to its input embeddings. By computing the gradient of the log-likelihood with respect to the input embedding at a trigger token position, AUTOPROMPT can identify which vocabulary tokens would most increase the objective if swapped into that position — without having to evaluate all possible replacements.

Step-by-step search procedure. The search is performed iteratively, token-by-token. At each step, the algorithm focuses on one specific trigger token position $j$ (cycling through positions or randomly selecting) and applies the following procedure:

Step 1: Compute the gradient signal. For a batch of training examples, AUTOPROMPT constructs the current prompt (with the current trigger tokens), feeds it through the MLM, and computes the log-likelihood of the correct labels: $\log p(y \mid x_{\text{prompt}})$. It then backpropagates this scalar through the entire model to obtain the gradient with respect to the input embedding at position $j$ — the vector $\nabla_{e^{(j)}_{\text{trig}}} \log p(y \mid x_{\text{prompt}})$, where $e^{(j)}_{\text{trig}}$ is the embedding vector for the token currently occupying trigger position $j$.

This gradient tells us: if we could make an infinitesimal change to the embedding vector at this position, in which direction should we move to increase the log-likelihood? Since the embedding space is continuous but the vocabulary is discrete, we cannot follow this gradient directly. Instead, we use it to score vocabulary tokens.

Step 2: Score all vocabulary tokens via dot-product. For each token $w$ in the vocabulary, AUTOPROMPT computes a first-order approximation of the change in log-likelihood that would result from replacing the current trigger token with $w$. This approximation is:

score(w)=win⊤∇log⁡p(y∣xprompt)\text{score}(w) = w_{\text{in}}^\top \nabla \log p(y \mid x_{\text{prompt}})

where $w_{\text{in}} \in \mathbb{R}^d$ is the input embedding of token $w$ (the embedding vector from the model's embedding matrix, before any positional encoding), and the gradient is taken with respect to the input embedding of the current trigger token at position $j$.

What it computes: the dot product between a candidate token's embedding and the gradient direction. Intuitively, this measures how "aligned" each candidate token is with the direction that maximally increases the log-likelihood. Tokens whose embeddings point in the same direction as the gradient receive high scores; tokens with orthogonal or opposite embeddings receive low scores.

Why the dot-product approximates the token swap effect: The log-likelihood $\log p(y \mid x_{\text{prompt}})$ depends on the trigger token at position $j$ through that token's embedding. Swapping the token from $t$ to $w$ changes the embedding at that position from $e_t$ to $e_w$. A first-order Taylor expansion of the log-likelihood around $e_t$ gives:

log⁡p(y∣ew)≈log⁡p(y∣et)+(ew−et)⊤∇log⁡p(y∣et)\log p(y \mid e_w) \approx \log p(y \mid e_t) + (e_w - e_t)^\top \nabla \log p(y \mid e_t)

Since $e_t^\top \nabla \log p(y \mid e_t)$ is constant with respect to $w$, comparing candidates reduces to comparing $e_w^\top \nabla \log p(y \mid e_t) = w_{\text{in}}^\top \nabla$. The token with the highest dot-product is predicted to produce the largest increase.

Computational efficiency. This dot-product scoring over the entire vocabulary requires $|\mathcal{V}| \times d$ multiplications — the exact same number of multiplications as the final output projection layer of the transformer LM. In practice, this means the full-vocabulary scoring is roughly as expensive as a single forward pass of the model. This is what makes the search tractable: we can approximate the effect of 30,000+ token swaps with one backward pass plus effectively one matrix multiplication, rather than 30,000 forward passes.

Step 3: Candidate set evaluation. The algorithm selects the top-$k$ tokens by the approximation score to form a candidate set:

Vcand=top-kw∈V[win⊤∇log⁡p(y∣xprompt)]\mathcal{V}_{\text{cand}} = \text{top-}k_{w \in \mathcal{V}} \left[ w_{\text{in}}^\top \nabla \log p(y \mid x_{\text{prompt}}) \right]

where $k$ is a hyperparameter — the paper sweeps $k \in \{10, 100\}$ for sentiment analysis and $k \in \{10, 50\}$ for NLI, using a separate development batch to choose the best value.

For each candidate in $\mathcal{V}_{\text{cand}}$, AUTOPROMPT performs an exact re-evaluation: it constructs the prompt with the candidate token substituted at position $j$, runs the MLM forward on a batch of data, and computes the actual log-likelihood (not the approximation). The candidate that achieves the highest actual log-likelihood is selected as the new trigger token at position $j$.

Why the two-stage approach (approximate scoring then exact evaluation) rather than evaluating all tokens exactly: evaluating all $|\mathcal{V}| \approx 30,500$ tokens exactly would require 30,500 forward passes of the model per trigger position update, which is computationally prohibitive. The gradient-based scoring narrows the search to $k$ promising candidates (typically 10 or 100), requiring only $k$ forward passes for exact evaluation. The paper reports the grid search over hyperparameters required "2 days to run with 8 NVIDIA 2080Ti GPUs" for sentiment analysis (Section 3, footnote 3), indicating that even with this efficiency optimization, the search is computationally intensive.

Token initialization. All trigger tokens are initialized to [MASK] tokens. This is a natural choice because the MLM's own [MASK] embedding is already a "neutral" embedding that the model is trained to fill with predictions — starting from [MASK] biases the search toward tokens that the model associates with informative content rather than arbitrary tokens. The paper does not explore alternative initializations.

Training data usage. The gradient computation uses one batch of training data (the paper does not specify the exact batch size used during search), while the exact evaluation step uses a separate batch of data. This separation is important: evaluating on the same batch used to compute the gradient would favor tokens that overfit to that specific batch rather than tokens that generalize. By using different batches for gradient computation and evaluation, AUTOPROMPT selects tokens that improve likelihood on held-out data within the training set.

Constraint: preventing knowledge base leakage. For fact retrieval and relation extraction tasks, AUTOPROMPT explicitly prevents trigger tokens from being proper nouns or tokens that appear as gold (correct) objects in the training data. Without this constraint, the search would "cheat" by embedding common answers directly into the trigger sequence — for example, if many training facts have "United States" as the answer, the search might place "United" and "States" as trigger tokens, artificially inflating accuracy on the test set without actually eliciting knowledge from the model. This constraint is implemented procedurally during the candidate evaluation step: any candidate token that appears in a blacklist (proper nouns + gold training objects) is excluded from $\mathcal{V}_{\text{cand}}$ before exact evaluation.

Hyperparameter sensitivity. The paper analyzes the effect of varying the number of trigger tokens $|x_{\text{trig}}|$ and the candidate set size $|\mathcal{V}_{\text{cand}}|$ in Appendix A (Figure 3). The finding is that varying the number of trigger tokens has little effect on final accuracy — prompts with 3, 4, 5, or 6 trigger tokens achieve similar performance. This stability is important because it means practitioners do not need extensive tuning of this hyperparameter. The candidate set size also does not substantially impact results ($k=10$ and $k=100$ produce similar trends), though the paper fixes $|\mathcal{V}_{\text{cand}}| = 100$ for the analysis in Figure 3.

Automated Label Token Selection

For classification tasks where the class labels are abstract concepts (sentiment polarity, entailment, contradiction) rather than specific entity names, AUTOPROMPT must discover which vocabulary tokens correspond to which labels. The paper develops a two-step procedure that uses a simple logistic regression probe as an intermediary to bridge between the MLM's representational space and the vocabulary space.

Why label token selection matters. The choice of label tokens directly determines the model's apparent accuracy. If the positive sentiment label set contains only "good" but the model predicts "fantastic" with high probability, the system misses a correct prediction. If the contradiction label set accidentally includes a token that the model also predicts for entailment examples, accuracy suffers. Manual label token selection suffers from the same problem as manual prompt construction: it requires guesswork and is prone to underestimating model knowledge due to suboptimal token choices.

Step 1: Train a logistic regression probe. AUTOPROMPT first uses a prompt with the template structure but with [MASK] tokens in the trigger positions (before any trigger search is performed). For each training example, it feeds this initial prompt through the MLM and extracts the contextualized embedding of the [MASK] token — the hidden state vector $h \in \mathbb{R}^d$ at the [MASK] position from the final transformer layer:

h=Transformerenc(x~)h = \text{Transformer}_{\text{enc}}(\tilde{x})

where $\tilde{x}$ is the prompt with unoptimized [MASK] trigger tokens, and the subscript "enc" denotes the encoder-only architecture of BERT/RoBERTa.

A logistic regression classifier is then trained to predict the class label $y$ from this contextualized embedding $h$:

p(y∣h)∝exp⁡(h⋅y+βy)p(y \mid h) \propto \exp(h \cdot \mathbf{y} + \beta_y)

where $\mathbf{y} \in \mathbb{R}^d$ is the learned weight vector for class label $y$, $\beta_y \in \mathbb{R}$ is the learned bias term for that class, and the dot product $h \cdot \mathbf{y}$ produces an unnormalized score. After softmax normalization across classes, this provides a probability distribution.

What this learns: the weight vector $\mathbf{y}$ captures the direction in the MLM's representational space that is most indicative of class $y$. If the model's [MASK] hidden state points strongly in the direction of $\mathbf{y}_{\text{positive}}$, the example is likely positive sentiment.

Step 2: Project label directions onto the vocabulary. The key insight is that the learned weight vector $\mathbf{y}$ can be reinterpreted as a "class direction" in the same space as the model's output word embeddings. The MLM's prediction at the [MASK] position is computed by taking the dot product between the contextualized embedding $h$ and each output word embedding $w_{\text{out}}$ (the embedding used in the final projection layer), then applying softmax. If $h \cdot \mathbf{y}$ is large for positive examples, and $h \cdot w_{\text{out}}$ is large when token $w$ is likely, then $w_{\text{out}} \cdot \mathbf{y}$ should be large for tokens $w$ that are semantically associated with class $y$.

AUTOPROMPT exploits this by computing a score for every vocabulary token $w$ with respect to each class label:

s(y,w)∝exp⁡(wout⋅y+βy)s(y, w) \propto \exp(w_{\text{out}} \cdot \mathbf{y} + \beta_y)

where $w_{\text{out}} \in \mathbb{R}^d$ is the output embedding of token $w$ (from the LM head's weight matrix), and $\mathbf{y}$ and $\beta_y$ are the weight vector and bias learned by the logistic regression probe in Step 1.

What it computes: for each class label and each token in the vocabulary, a score representing how strongly that token's output embedding aligns with the learned class direction. Tokens whose output embeddings point in the same direction as $\mathbf{y}_{\text{positive}}$ receive high scores for the positive class.

Label set construction. The final label token sets are constructed by taking the top-$k$ highest-scoring tokens for each class:

Vy=top-kw∈V[s(y,w)]\mathcal{V}_y = \text{top-}k_{w \in \mathcal{V}} [s(y, w)]

The hyperparameter $|\mathcal{V}_y|$ (the $k$ in this top-$k$ selection) is swept as part of the prompt search. The paper evaluates $|\mathcal{V}_y| \in \{1, 3, 5\}$ for sentiment analysis and $|\mathcal{V}_y| \in \{1, 3, 5, 10\}$ for NLI.

Why logistic regression rather than directly using attention or gradient signals: the logistic regression probe serves as an intermediary because it learns a direct mapping from the [MASK] representation to class labels. This provides a clear, interpretable weight vector $\mathbf{y}$ for each class. Alternatives like using the gradient of the label likelihood with respect to $h$ (which would be similar to the trigger search gradient) are noisier because they are computed on single examples rather than trained across the dataset. The logistic probe aggregates signal across many examples, producing more stable class directions.

Empirical behavior. The paper's analysis in Appendix A (Figure 3) shows that label set size matters substantially: moving from 1 to 3 tokens per label increased accuracy by approximately 5 percentage points for BERT and 10 percentage points for RoBERTa on SST-2. Increasing from 3 to 5 tokens provided diminishing returns. This suggests that the model does distribute its predictions across multiple semantically related vocabulary tokens, and summing over these tokens captures more of the model's knowledge.

Qualitative examples. The paper provides example label tokens in Table 3. For RoBERTa on sentiment analysis: positive = {"partnership", "extraordinary", "##bla"} (where ##bla is a subword token that completes a word like "incomparable" or "fabulous"); negative = {"worse", "persisted", "unconstitutional"}. For NLI contradiction: {"Nobody", "nobody", "nor"}. These examples demonstrate that the discovered label tokens are often interpretable — "extraordinary" is clearly positive, "Nobody"/"nobody"/"nor" are negation terms associated with contradiction — though some tokens ("##bla", "persisted") appear less intuitive and may capture more subtle statistical associations in the model's training distribution.

Overall Optimization Loop and Model Selection

The trigger token search and label token selection are run together within a validation-based outer loop that selects the best-performing prompt configuration.

Outer validation loop. AUTOPROMPT performs the trigger search for multiple iterations (the paper does not specify a fixed number of iterations; the search continues until convergence or a budget is exhausted). At the end of every iteration, the current prompt (current trigger tokens + chosen label set) is evaluated on a withheld development set — a separate split of the training data not used for the gradient computation or candidate evaluation. The development set accuracy (or label likelihood) is recorded, and the best prompt found during the entire search — not necessarily the final iteration — is returned as the output.

Why track the best prompt across all iterations rather than using the final prompt: the greedy search is not guaranteed to improve monotonically. A trigger token swap that increases likelihood on the batch used for gradient computation and candidate evaluation may decrease likelihood on the development set. By checkpointing the best development-set performance, AUTOPROMPT avoids overfitting to the particular batches used during search.

Hyperparameter grid search. The trigger search is embedded within an outer grid search over the method's hyperparameters:

  • Number of trigger tokens $|x_{\text{trig}}|$: the paper sweeps $[3, 6]$ for sentiment analysis, $[1, 5]$ for NLI
  • Candidate set size $|\mathcal{V}_{\text{cand}}|$: $\{10, 100\}$ for sentiment analysis, $\{10, 50\}$ for NLI
  • Label set size $|\mathcal{V}_y|$: $\{1, 3, 5\}$ for sentiment analysis, $\{1, 3, 5, 10\}$ for NLI

For each hyperparameter combination, AUTOPROMPT runs the full trigger search and label token selection, evaluates on the development set, and the configuration with the highest development set accuracy is selected. The final evaluation is on a completely separate test set that was never used during any part of the search or selection process.

Data splits. The paper uses standard dataset splits where available (e.g., the SST-2 train/dev/test split, the LAMA test set from Petroni et al. 2019). For fact retrieval, since the T-REx training data comes from a different distribution than the LAMA test set, the paper also constructs a separate 60-20-20 train/dev/test split within T-REx itself to measure performance when train and test distributions match.

Preventing test set leakage. The prompt search uses only training and development data. The test set is held out completely. For the low-data experiments (Figure 2), the paper repeatedly samples random training subsets and evaluates on the full development set, running 10 independent trials with different random seeds to measure variance. This protocol ensures that the reported accuracies are not inflated by the search process overfitting to the test distribution.

Manual prompt baseline. The paper constructs manual prompts for sentiment analysis as a comparison point, intentionally doing so before automated prompts are generated "to avoid bias" (Section 3). The manual prompt uses the template "{sentence} this movie was [P]." with label tokens "terrible" and "fantastic". This prompt exploits domain knowledge that SST-2 consists of movie reviews — knowledge that AUTOPROMPT does not use — yet AUTOPROMPT's discovered prompt still substantially outperforms it (91.4% vs. 85.2% for RoBERTa on the test set), demonstrating that automated search can find more effective phrasings than human intuition even when the human leverages task-specific domain knowledge.

4. Key Insights and Innovations

Innovation 1: Prompting as a Lower-Bound Estimator of Model Knowledge — and Making It Practical

The paper's most fundamental conceptual contribution is not the search algorithm itself, but the reframing of prompting as the gold-standard method for conservatively estimating what pretrained LMs know, combined with demonstrating that this method can be made practical across diverse tasks through automation.

Prior to AUTOPROMPT, the field's dominant approaches for analyzing LM knowledge were probing classifiers and attention visualization — methods that the paper argues are fundamentally limited by the false-positive problem: high accuracy on a probing task does not imply the model actually uses the probed knowledge for its own predictions (Hewitt and Liang, 2019; Voita and Titov, 2020). Probing classifiers introduce additional learned parameters, which means the classifier itself might be doing the intellectual work of solving the task, extracting signal from representations that the pretrained model cannot access or deploy. The probing paradigm conflates "information is encoded in the representations" with "information is accessible to the model," and this conflation has led to persistent overestimation of what pretrained LMs genuinely know.

Prompting solves this by construction: there are no additional parameters. The same frozen LM that was pretrained on language modeling is used as-is, and the only thing that changes is the text it receives as input. If the model can produce the correct answer given a well-constructed prompt, we can be absolutely certain that the knowledge existed in the model before we asked — because there is no other component that could have acquired or produced that knowledge. This makes prompting a conservative lower bound on model knowledge: success guarantees knowledge exists, while failure might mean the model lacks knowledge or the prompt was poorly constructed. This is the epistemological opposite of probing classifiers, which provide upper bounds that are potentially inflated by the probe's own learning capacity.

The field recognized this advantage of prompting in principle — Petroni et al. (2019) used it for the LAMA benchmark, and Jiang et al. (2020) improved prompts for fact retrieval with LPAQA — but prompting remained limited in practice because constructing effective prompts required manual effort and guesswork. For fact retrieval, writing "was born in [MASK]" is natural; for sentiment analysis or NLI, there is no obvious fill-in-the-blank phrasing. Prior work had no systematic method to discover prompts for arbitrary tasks, and as a result, the prompting-as-lower-bound paradigm was restricted to a narrow class of problems with obvious template structures.

AUTOPROMPT's insight is that the prompt discovery problem — finding the right words to surround the input — can be treated as a discrete optimization over the model's vocabulary, solved via gradient-guided search. This removes the manual effort bottleneck that restricted prompting to fact retrieval and opens the paradigm to arbitrary classification tasks. The significance is not the search algorithm per se (adapted from Wallace et al., 2019), but the demonstration that this search can surface knowledge that manual prompting missed entirely: on sentiment analysis, AUTOPROMPT achieves 91.4% accuracy versus 85.2% for a manual prompt that exploited domain knowledge (Table 1); on fact retrieval, it improves P@1 by up to 12 points over manual prompts (Table 4); on the P106 relation ("is a Y by profession"), manual prompting achieves 0.63% P@1 while AUTOPROMPT reaches 14.72% (Table 6). These are not incremental improvements — they are qualitative changes in the apparent capability of the model, revealing that prior manual prompts were so suboptimal that they made the model appear essentially incapable on certain relations.

This reframing has implications beyond the paper's empirical results. It establishes that any conclusion about what a pretrained LM "cannot do" based on manual prompting is premature unless automated search methods have been exhausted. The field's understanding of pretrained model capabilities is systematically biased downward by the poverty of manual prompt engineering, and AUTOPROMPT provides a principled way to tighten these lower bounds. This is a conceptual advance in how we should evaluate models, not just a better method for doing so.

Innovation 2: The Shared Trigger Token as a Task-Specification Mechanism — Not Adversarial, but Constructive

AUTOPROMPT adapts the gradient-guided trigger search from Wallace et al. (2019)'s universal adversarial triggers, but it fundamentally repurposes the mechanism from an attack tool into a task-specification tool. This repurposing is conceptually subtle and represents a genuine intellectual shift rather than a straightforward application.

In the adversarial setting, trigger tokens are optimized to override the model's normal behavior — to force a specific output regardless of the input, typically by exploiting brittle features or biases. The prompts discovered by Wallace et al. (2019) are nonsensical, model-specific, and deliberately designed to cause failure. The underlying assumption is that trigger tokens work by finding "shortcuts" that the model is overly sensitive to.

AUTOPROMPT's key insight is that the same search procedure can be used to construct legitimate task prompts — tokens that help the model express knowledge it already has rather than forcing it to produce a particular output. The triggers discovered by AUTOPROMPT are not adversarial shortcuts; they serve as shared context that biases the model toward the correct task-conditional output distribution. For sentiment analysis, the trigger tokens ("atmosphere alot dialogue Clone totally") create a context that shifts the model from generic review-completion mode to sentiment-classification mode, causing it to fill the [MASK] with sentiment-bearing words rather than content words. For fact retrieval, triggers specific to each relation (e.g., "ediatric striker ice baseman defensive" for the POSITION PLAYED ON TEAM relation) provide lexical cues that narrow the model's output distribution to the relevant entity type, even though the resulting phrase is ungrammatical.

The evidence that these are genuine task specifications rather than adversarial shortcuts comes from multiple angles. First, the triggers do not embed the correct answers — the paper explicitly prevents trigger tokens from being proper nouns or gold training objects (Section 5), and the discovered triggers for fact retrieval contain relation-relevant content words ("striker," "baseman," "defensive" for sports positions) rather than answer entities. Second, the prompts generalize — the same triggers are used across all test examples for that relation or task, and they improve performance on held-out test data. Third, when the task cannot be solved by the model (as on the hardest relations or on perturbed relation extraction sentences where the correct answer was replaced with a false one), the triggers do not recover performance — they cannot make the model know something it does not know (Table 5: BERT drops from 90.73% to 56.43% P@1 on perturbed RE data).

This reframing from adversarial to constructive is significant because it opens a new perspective on what prompts are doing. A prompt is not just natural language instructions — it is a set of tokens that shifts the model's internal representations and output distribution in task-relevant ways. Some of those tokens may be natural language instruction words, but they could also be n-grams, content words, or even ungrammatical sequences that happen to activate the right latent knowledge. AUTOPROMPT demonstrates that effective prompts need not be interpretable or grammatical to elicit knowledge — a discovery that challenges the assumption (implicit in manual prompt writing) that prompts should read as natural instructions. This has implications for how we think about prompt engineering more broadly: the goal is not to write good English, but to find the token sequences that maximally surface the model's relevant capabilities.

Innovation 3: Difficulty-Dependent Label Token Selection — Bridging Representational and Vocabulary Spaces

The automated label token selection procedure (Section 2.3) is easy to overlook as a minor implementation detail, but it represents a genuinely novel solution to a problem that prior prompting work either ignored or solved manually: how do you map abstract class labels (entailment, positive sentiment, contradiction) to specific vocabulary tokens that an MLM can predict?

Prior to AUTOPROMPT, the dominant approach for classification via prompting was to manually specify which words correspond to which labels. Jiang et al. (2020) used manually chosen label words. Schick and Schütze (2020) manually designed verbalizers that map labels to vocabulary tokens. This manual specification suffers from the same problems as manual prompt construction: it requires guesswork, is fragile to poor choices, and may underestimate model knowledge if the chosen label tokens do not match the model's preferred lexical expression of a concept.

AUTOPROMPT's innovation is to use a trained linear probe as an intermediary between the representational space and the vocabulary space. The two-step procedure — train a logistic regression classifier to predict labels from the [MASK] hidden state, then use the learned weight vectors to score vocabulary tokens — is conceptually elegant because it exploits a property of transformer LMs that was not obvious a priori: the directions in hidden state space that discriminate between classes should align with the output embedding directions of vocabulary tokens associated with those classes.

This works because of how masked language model prediction operates. The probability of token ww at the masked position is proportional to exp⁡(h⋅wout)\exp(h \cdot w_{\text{out}}), where hh is the contextualized hidden state and woutw_{\text{out}} is the output embedding. If the logistic probe learns a weight vector ypositive\mathbf{y}_{\text{positive}} such that h⋅ypositiveh \cdot \mathbf{y}_{\text{positive}} is large for positive-sentiment examples, and if the model tends to predict sentiment-bearing words for those examples (so h⋅"fantastic"outh \cdot \text{"fantastic"}_{\text{out}} is also large), then ypositive\mathbf{y}_{\text{positive}} and "fantastic"out\text{"fantastic"}_{\text{out}} should point in similar directions. The dot product ypositive⋅wout\mathbf{y}_{\text{positive}} \cdot w_{\text{out}} captures this alignment, and the top-scoring tokens are those whose output embeddings are most aligned with the learned class direction.

This is not obvious — there is no architectural guarantee that the directions learned by a logistic probe on the hidden state align with the output embedding directions of semantically related words. The fact that it works empirically (Figure 3 shows that increasing label set size from 1 to 3 tokens improves accuracy by ~5-10%) is itself a finding about how transformer LMs structure their representational space: the dimensions that discriminate between output classes are shared with the dimensions that discriminate between vocabulary items. This suggests that the model's internal representations for classification tasks are organized in a way that is lexically grounded — the model distinguishes positive from negative sentiment along axes that correspond to the embeddings of sentiment-bearing words.

The alternative approaches that this innovation avoids are instructive. One could manually specify label tokens (fragile, requires domain expertise). One could use the model's own predictions on training data to discover which tokens it associates with each class (but this requires already having a good prompt to get reliable predictions, creating a circular dependency). One could train the logistic probe and then directly use its predictions as the classifier output (but this introduces learned parameters and defeats the purpose of parameter-free probing). AUTOPROMPT's approach is distinctive because it uses the probe to discover label tokens, then discards the probe — the final classification uses only the original MLM's predictions marginalized over the discovered token sets. The probe serves as a disposable bridge between task labels and vocabulary items, enabling parameter-free evaluation while avoiding manual specification.

Innovation 4: Prompting Outperforms Fine-Tuning in Low-Data Regimes — A Diagnostic Finding About Model Adaptation

The finding that AUTOPROMPT prompts can outperform fine-tuning when training data is scarce (Figure 2, Section 3, Section 7) is not just a practical observation — it is a diagnostic finding about a fundamental difference between how models access knowledge through prompting versus fine-tuning.

The result: with only 10 training examples for NLI, AUTOPROMPT with BERT achieves higher average accuracy than fine-tuned BERT, and AUTOPROMPT with RoBERTa significantly outperforms fine-tuned RoBERTa. Moreover, fine-tuning exhibits high variance across random seeds, with some runs "failing" entirely (producing near-chance accuracy), while AUTOPROMPT's performance is more stable (Figure 2, consistent with Dodge et al., 2020's findings about fine-tuning instability).

What makes this intellectually distinctive is that it reveals a barrier that models must surmount when converted to fine-tuned classifiers that does not exist when tasks are presented as masked language modeling. A fine-tuned BERT must learn: (1) that a new output head exists with arbitrary class indices, (2) how to map its pretrained representations to these indices through a randomly initialized projection layer, and (3) how to adjust its internal representations to optimize this mapping — all from a handful of examples. This is a difficult credit assignment problem with high variance depending on initialization and data order.

A prompted BERT, by contrast, needs only to learn which trigger tokens shift its existing language modeling distribution toward class-appropriate vocabulary. The task structure is native to the model's pretraining objective — filling in [MASK] tokens is exactly what it was trained to do — and the trigger tokens need only serve as context that biases this familiar operation. The credit assignment problem is dramatically simpler because the model's output space (the vocabulary) and objective (likelihood of the correct token) remain unchanged. AUTOPROMPT essentially asks: "given what the model already knows how to do, which words should we say to make it produce the answer we want?" — whereas fine-tuning asks: "learn an entirely new output mapping from scratch."

This framing explains why the advantage is most pronounced at extremely low data sizes (10 examples) and diminishes or reverses as data increases (1,000 examples). With more data, fine-tuning can reliably learn the new output mapping and may even surpass prompting because it can adjust the model's internal representations rather than relying on the fixed pretrained representations. But the fact that prompting wins in the low-data limit reveals that the model's pretrained knowledge is more readily accessible through its native language modeling interface than through a learned classification head — a finding with implications for few-shot learning, model adaptation, and our understanding of what fine-tuning actually does to pretrained representations.

This finding also provides evidence against a common intuition: that fine-tuning is always the best way to adapt a pretrained model to a task, and that prompting is merely a weaker but more convenient alternative. The data suggests instead that prompting and fine-tuning occupy different regions of the data-efficiency Pareto frontier, with prompting dominating at the extreme low-data end and fine-tuning dominating with sufficient data. This is not a claim that prompting is universally better, but that the choice between prompting and fine-tuning should depend on available data quantity — a nuanced position that the paper supports with controlled experiments rather than assertion.

5. Experimental Analysis

Evaluation Methodology

  • Datasets. The paper evaluates on four tasks using standard benchmarks. Sentiment analysis uses the binary Stanford Sentiment Treebank (SST-2; Socher et al., 2013) with the standard train/test splits. Natural language inference uses the SICK-E entailment dataset (Marelli et al., 2014; ~10,000 human-annotated sentence pairs labeled entailment, contradiction, or neutral). Fact retrieval uses the LAMA benchmark (Petroni et al., 2019) consisting of (subject, relation, object) triples drawn from Wikidata, with the original LAMA test set and a separate T-REx split for same-distribution evaluation. Relation extraction uses T-REx (ElSahar et al., 2018), where each fact comes with context sentences mentioning the subject and object surface forms.

  • Base Models. All experiments use BERT_BASE_ (110M parameters) and RoBERTa_LARGE_ (355M parameters), accessed via the HuggingFace transformers library (Wolf et al., 2019) with pretrained weights frozen throughout. The paper argues BERT is chosen because it is "representative of the capabilities of many contemporary MLMs" (Section 4), and RoBERTa provides a larger-scale comparison point with different pretraining (dynamic masking, more data, no next-sentence prediction objective). The models are never fine-tuned during AUTOPROMPT experiments — all knowledge is elicited from the frozen pretrained weights.

  • Metrics. For sentiment analysis and NLI, the primary metric is accuracy — the fraction of test examples where the predicted class matches the ground-truth label, with predictions obtained by marginalizing MLM output probabilities over label token sets using Equation (1). For fact retrieval and relation extraction, the paper uses precision-at-k (P@k), specifically P@1 and P@10, and mean reciprocal rank (MRR). P@1 measures the fraction of test facts where the correct object entity is the MLM's highest-probability token prediction at the [MASK] position. MRR is the mean of 1/rank across test facts, where rank is the position of the correct entity in the probability-sorted list of all vocabulary tokens.

  • Baselines. The paper compares against several existing approaches. For fact retrieval: LAMA (Petroni et al., 2019) provides manually crafted prompts (e.g., "was born in" for PLACE OF BIRTH) and serves as the baseline for human-designed prompting. LPAQA (Jiang et al., 2020) generates prompts via Wikipedia mining, back-translation, and crowdsourcing; the paper compares against both LPAQA's single best prompt (Top1) and ensemble methods. For relation extraction: a supervised LSTM-based RE model from Sorokin and Gurevych (2017), identical to the baseline used by Petroni et al. (2019). For sentiment analysis and NLI: linear probing classifiers trained on top of frozen MLM representations with average pooling, and fine-tuned BERT/RoBERTa models using Mosbach et al. (2020)'s recommended hyperparameters for small datasets. Manual prompts are also constructed for sentiment analysis using the template "{sentence} this movie was [P]." with label tokens "terrible"/"fantastic."

  • Generation Budget / Compute Accounting. The paper does not measure compute in terms of FLOPs or generations as done in modern scaling work. Instead, the prompt search is parameterized by the number of trigger tokens $|x_{\text{trig}}|$, the candidate set size $|\mathcal{V}_{\text{cand}}|$, and the number of search iterations — but none of these are used to report efficiency ratios or cost comparisons. The paper reports wall-clock time only for the hyperparameter sweep on sentiment analysis (~2 days on 8× NVIDIA 2080Ti GPUs; Section 3, footnote 3). The low-data experiments in Figure 2 control for the number of labeled training examples (10, 100, 1000) rather than computational budget, making it a data-efficiency comparison rather than a FLOPs-matched comparison.

  • Cross-Validation / Statistical Protocol. For the low-data experiments (Figure 2), AUTOPROMPT is run 10 times on random subsets of the training data with different random seeds, and the paper reports maximum, minimum, and average accuracy to characterize variance. For the main prompt search, a single train/dev/test split is used: the trigger search uses training data for gradient computation and candidate evaluation, a separate development set for model selection (tracking the best prompt across all search iterations), and a completely held-out test set for final evaluation. For the T-REx fact retrieval experiments, the paper constructs a 60-20-20 train/dev/test split to measure performance when train and test distributions match, in addition to the original LAMA test set where training data comes from a different distribution. The paper does not use k-fold cross-validation for prompt selection and does not report confidence intervals on test set accuracy.

Main Quantitative Results

Sentiment Analysis (Section 3)

Headline result. AUTOPROMPT-generated prompts achieve 91.4% test accuracy with RoBERTa_LARGE_ on SST-2, outperforming the manual prompt (85.2%) by 6.2 percentage points and matching the performance of fine-tuned BERT (93.5% per GLUE leaderboard) and a BiLSTM+ELMo model (89.3%) — all without any parameter updates (Table 1).

Model comparison. BERT_BASE_ with AUTOPROMPT reaches 82.3% test accuracy, compared to 63.2% for the manual prompt — a 19.1 percentage point improvement. RoBERTa_LARGE_ with AUTOPROMPT reaches 91.4% versus 85.2% manual, demonstrating that the larger model benefits from automated prompting as well, though the relative gap is smaller (6.2 vs. 19.1 points). Linear probing achieves 83.4% (BERT) and 88.8% (RoBERTa), meaning AUTOPROMPT is roughly competitive with probing for BERT and slightly better for RoBERTa — despite using no additional parameters where probing classifiers introduce learned weights.

Manual prompts for sentiment analysis substantially underperform: the manually constructed prompt "{sentence} this movie was [P]." with label tokens "terrible" and "fantastic" yields only 63.2% (BERT) and 85.2% (RoBERTa). The paper notes this prompt was deliberately constructed with domain knowledge (SST-2 contains movie reviews), yet AUTOPROMPT discovers a more effective formulation without this domain knowledge.

Discovered prompt. For RoBERTa, the best prompt found is: "{sentence} atmosphere alot dialogue Clone totally [P]." with positive label tokens {"partnership", "extraordinary", "##bla"} and negative tokens {"worse", "persisted", "unconstitutional"} (Table 3). The trigger tokens are ungrammatical but the label tokens are largely interpretable — "extraordinary" indicating positive, "worse" indicating negative.

Natural Language Inference (Section 4)

Headline result. AUTOPROMPT achieves 69.3% accuracy with RoBERTa_LARGE_ on the balanced 3-way SICK-E dataset, compared to 55.4% for BERT_BASE_ (Table 2). On the unbiased 2-way entailment vs. contradiction task, AUTOPROMPT achieves 87.3% (RoBERTa) — comparable to a fine-tuned BERT model.

Model comparison on variants. Table 2 reports results on three SICK-E variants. On the standard (imbalanced) dataset, AUTOPROMPT achieves 62.3% (BERT) and 65.0% (RoBERTa) versus 68.0% and 72.6% for linear probing. On the 3-way balanced variant (where the majority baseline is 33.3%), AUTOPROMPT with BERT achieves 55.4% — notably higher than linear probing's 49.5%, indicating that for this task setup, probing classifiers actually underestimate model knowledge relative to prompting, the opposite of what the false-positive concern would predict. On the 2-way variant, RoBERTa with AUTOPROMPT reaches 87.3%, approaching the 95.6% achieved by fine-tuned BERT.

Class-wise performance analysis. The paper reports precision broken down by class label for the 3-way balanced dataset. BERT achieves 74.9% precision on contradiction, 54.4% on entailment, and 36.8% on neutral. RoBERTa achieves 84.9%, 65.1%, and 57.3% respectively (Table 2 discussion). The neutral class is the hardest for both models — and the paper observes that the automatically discovered label tokens are "more interpretable for contradiction compared to entailment or neutral" (Section 4), with contradiction tokens including {"Nobody", "nobody", "nor"} (Table 3). This correlation between label token interpretability and per-class precision suggests that tasks with clearly lexicalized concepts (like contradiction, where negation words provide strong signal) are more amenable to prompt-based probing than tasks with diffuse lexical representations (like neutral).

Discovered prompt. For NLI, the best prompt template is: "{prem} [P] [T] ... [T] {hyp}" (Table 3). An example constructed prompt: "Two dogs are wrestling and hugging [MASK] concretepathic workplace There is no dog wrestling and hugging." The trigger tokens include "concretepathic" (likely a subword artifact) and "workplace," and the prediction [MASK] sits between the premise and hypothesis with trigger tokens following — a structural choice that places the classification decision adjacent to the premise, with the hypothesis providing additional context after the triggers.

Fact Retrieval (Section 5)

Headline result. AUTOPROMPT with 7 trigger tokens achieves 43.34% P@1 on the original LAMA test set with BERT, compared to 31.10% for LAMA's manual prompts — a 12.24 percentage point improvement. Compared to LPAQA's single best prompt (34.10%), AUTOPROMPT improves P@1 by 9.24 points, and it outperforms LPAQA's ensemble method (which averages up to 30 prompts) by approximately 4 points despite using only a single prompt per relation (Table 4, left).

Metric breakdown. On Original LAMA: AUTOPROMPT 7 tokens achieves MRR 53.89, P@10 73.93, P@1 43.34; LAMA manual achieves MRR 40.27, P@10 59.49, P@1 31.10. The improvement is consistent across all three metrics.

On T-REx (same-distribution evaluation): AUTOPROMPT 7 tokens achieves MRR 54.89, P@10 72.02, P@1 45.57; LAMA manual achieves MRR 35.79, P@10 54.29, P@1 26.38. The P@1 improvement is 19.19 percentage points — even larger than on Original LAMA, likely because the T-REx training data is from the same distribution as the test data, giving AUTOPROMPT more signal for trigger token optimization.

Trigger length comparison. Using 7 trigger tokens (53.89 MRR, 43.34 P@1) only marginally improves over 5 trigger tokens (53.06 MRR, 42.94 P@1), indicating stability to this hyperparameter choice (Table 4, left).

BERT vs. RoBERTa. When evaluated on the subset of LAMA examples where the object is a single token for both models (Original-RoBERTa subset, since BERT and RoBERTa have different tokenization), BERT with AUTOPROMPT (5 tokens) achieves MRR 55.22, P@10 74.01, P@1 45.23, while RoBERTa achieves MRR 49.90, P@10 68.34, P@1 40.01 (Table 4, right). BERT consistently outperforms RoBERTa on fact retrieval despite being a smaller model — a counterintuitive finding that the paper notes is "surprising" and "worthy of investigating further." The paper observes qualitatively that prompts generated for RoBERTa "tend to contain more irrelevant words" (Section 5), e.g., symbols like "), (" and proper nouns like "Trump" appearing in the prompt for the POSITION PLAYED ON TEAM relation (Table 7, Appendix C), suggesting that the trigger search for RoBERTa converges to noisier solutions — possibly because RoBERTa's different pretraining distribution makes the gradient signal less informative for token selection.

Relation-level breakdown (Table 6, Appendix C). AUTOPROMPT is not uniformly better than manual prompts across all 41 LAMA relations. On relations where manual prompts are straightforward and specific (e.g., "is developed by" for P178: 62.84% manual vs. 66.72% AUTOPROMPT; "is produced by" for P176: 85.64% manual vs. 87.78% AUTOPROMPT), the gap is modest. On relations where manual prompts are vague or difficult to specify naturally, AUTOPROMPT provides massive improvements: P106 ("is a [Y] by profession") improves from 0.63% to 14.72%; P136 ("plays [Y] music") improves from 0.75% to 55.42%; P413 ("plays in [Y] position") improves from 0.53% to 41.71%. AUTOPROMPT degrades performance on only 2 of 41 relations: P1376 ("is the capital of [Y]", 73.93% → 40.17% with 5 triggers) and P361 ("is part of [Y]", 23.61% → 17.70%). This confirms that manual prompts are competitive when the relation lends itself to natural phrasing but severely underestimate model knowledge when the relation is difficult to express in a short natural language template.

Qualitative examples (Table 7, Appendix C). For P136 (music genre): manual prompt is "[X] plays [Y] music" (0.70% P@1); AUTOPROMPT BERT discovers "[X] freaking genre orchestra fiction acid [Y]" (59.95% P@1). The trigger tokens "genre," "orchestra," "acid" are directly related to music genres. For P27 (country of citizenship): manual prompt "[X] is [Y] citizen" achieves 0.0% P@1; AUTOPROMPT BERT produces "[X] m³ badminton pieces internationally representing [Y]" (46.13% P@1), where "internationally representing" provides lexical cues for nationality despite the overall prompt being ungrammatical.

Relation Extraction (Section 6)

Headline result. BERT with AUTOPROMPT achieves 90.73% P@1 on T-REx relation extraction, compared to 57.95% for the supervised LSTM RE model (Sorokin and Gurevych, 2017) — a 32.78 percentage point improvement (Table 5, "Original" column). AUTOPROMPT also substantially outperforms LAMA manual prompts (69.06%) and LPAQA (76.55%), both of which were designed for fact retrieval but applied here with context sentences.

The perturbed sentence analysis reveals a critical boundary. When sentences are artificially falsified by replacing the gold object with a random incorrect object (e.g., "born in Yokohama" → "born in Yorkshire"), MLM performance drops sharply: BERT with AUTOPROMPT falls from 90.73% to 56.43%, and RoBERTa falls from 60.33% to 28.95%. The supervised RE model, by contrast, is essentially unaffected (57.95% → 58.81%). This dissociation reveals that a substantial portion of the MLMs' relation extraction accuracy comes from memorized background knowledge rather than genuine extraction from the provided context. The MLMs already know the facts being tested and largely ignore the context sentences when those context sentences conflict with their memorized knowledge.

The paper interprets this as evidence that MLMs rely on "background information rather than relation extraction" (Section 6). Crucially, this is not a failure of AUTOPROMPT specifically — the same pattern holds for LAMA and LPAQA prompts (Table 5, "Perturbed" column: LAMA drops from 69.06% to 28.02%; LPAQA drops from 76.55% to 30.79%). AUTOPROMPT elicits better performance overall but does not fundamentally change the model's reliance on memorization.

RoBERTa underperforms on RE. RoBERTa with AUTOPROMPT achieves only 60.33% P@1 — worse than BERT with LAMA manual prompts (69.06%) and much worse than BERT with AUTOPROMPT (90.73%). This is consistent with the fact retrieval finding that RoBERTa's prompts contain more irrelevant tokens (Section 5 discussion), and reinforces that BERT's tokenization or pretraining may be better suited to entity-level knowledge tasks.

Qualitative examples (Table 8, Appendix D). For P103 (native language): BERT produces "Alexandra Lamy speaks airfield dripping % of [MASK]" and correctly predicts "French." For P176 (manufacturer), with a falsified sentence saying "manufactured by Toyota" (original: Honda), RoBERTa produces "Honda Civic del Sol defy trademarks of namesake manufacturer [MASK]" and (incorrectly) predicts "Toyota," demonstrating failure to extract the actual relation from the sentence — the model answers based on its own knowledge that Honda Civic del Sol is manufactured by Honda, not the sentence's claim.

Low-Data Regime: Prompting vs. Fine-Tuning (Figure 2)

Headline result. When training data is extremely scarce (10 examples), AUTOPROMPT achieves higher average accuracy than fine-tuning on NLI for both BERT and RoBERTa, and more stable performance across random seeds, though fine-tuning surpasses AUTOPROMPT on sentiment analysis at the same data sizes (Figure 2).

Sentiment analysis (Figures 2a, 2b). For both BERT and RoBERTa, fine-tuning achieves higher average accuracy than AUTOPROMPT at all data sizes (10, 100, 1000). However, at 10 examples, RoBERTa fine-tuning exhibits very high variance (Figure 2b: error bars span from roughly 0.5 to 0.9 accuracy), with some runs "failing" entirely — achieving near-chance performance — while AUTOPROMPT's performance is tightly clustered around 0.75-0.80. At 1000 examples, both methods converge to similar accuracy (~0.88 for BERT, ~0.92 for RoBERTa), with fine-tuning slightly ahead.

NLI (Figures 2c, 2d). On the balanced 3-way SICK-E task (where chance is 33.3%), AUTOPROMPT with BERT achieves higher average accuracy than fine-tuning at 10 examples (~0.45 vs. ~0.35), with fine-tuning exhibiting dramatic variance (min ~0.25, max ~0.55). At 100 and 1000 examples, fine-tuning overtakes AUTOPROMPT. For RoBERTa (Figure 2d), AUTOPROMPT substantially outperforms fine-tuning at both 10 examples (~0.55 vs. ~0.35) and 100 examples (~0.62 vs. ~0.53), with fine-tuning only catching up at 1000 examples. Moreover, RoBERTa fine-tuning at 10 examples has a minimum accuracy close to chance (~0.33), while AUTOPROMPT's minimum is above 0.50.

Instability of fine-tuning. The paper reports this finding is "consistent with Dodge et al. (2020)" on fine-tuning instability. The error bars in Figure 2 show that fine-tuning can result in "failed runs" where accuracy plummets, particularly for RoBERTa at small data sizes. AUTOPROMPT, by contrast, is more stable — the gap between max and min accuracy is smaller across all configurations tested.

Ablation Studies and Robustness Checks

Trigger set size ($|x_{\text{trig}}|$): Varying the number of trigger tokens from 3 to 6 has little effect on sentiment analysis accuracy for either BERT or RoBERTa (Appendix A, Figure 3). Both models show roughly flat accuracy curves across trigger lengths for any given label set size. This stability is important for practical use — practitioners need not extensively tune this hyperparameter.

Label set size ($|\mathcal{V}_y|$): Increasing label tokens per class from 1 to 3 substantially improves accuracy — approximately +5 points for BERT and +10 points for RoBERTa on SST-2 (Appendix A, Figure 3). Increasing further from 3 to 5 provides diminishing returns (accuracy curves flatten). This validates the marginalization approach: the model distributes probability mass across multiple semantically related vocabulary tokens, and summing over more tokens captures more of the model's knowledge. Qualitatively, the paper finds that the discovered label tokens are "generally intuitive" — "marvelous" and "philanthrop" for positive, "worse" and "incompetence" for negative with RoBERTa — but some tokens are less interpretable ("##bla" as positive, "persisted" as negative), suggesting the model's associations are partially coherent and partially statistical artifacts.

Candidate set size ($|\mathcal{V}_{\text{cand}}|$): Comparing $|\mathcal{V}_{\text{cand}}| = 10$ vs. $|\mathcal{V}_{\text{cand}}| = 100$ on sentiment analysis, the paper notes "similar trends" (Appendix A) — the hyperparameter does not substantially impact final accuracy, indicating the gradient-based scoring is reliable enough that even a small candidate set (10 tokens) usually contains good replacements. Exact numbers are not reported for this comparison.

Trigger length for fact retrieval: Using 7 trigger tokens (MRR 53.89, P@1 43.34) vs. 5 trigger tokens (MRR 53.06, P@1 42.94) on the Original LAMA dataset: the difference is small — 0.83 MRR points and 0.40 P@1 points (Table 4, left). On T-REx, the gap is similarly modest (MRR 54.89 vs. 54.42; P@1 45.57 vs. 45.40). This supports the finding from sentiment analysis that trigger length is not a sensitive hyperparameter.

Training data distribution for fact retrieval: Comparing Original LAMA evaluation (where training data from T-REx is distributionally different from the LAMA test set) to T-REx evaluation (where train and test come from the same distribution), AUTOPROMPT achieves higher absolute numbers on T-REx (P@1 45.57 vs. 43.34 with 7 tokens; Table 4), but the relative improvement over baselines is actually larger on Original LAMA (+12.24 P@1 over LAMA manual on Original vs. +19.19 on T-REx) — the difference in absolute improvement is because the baselines perform worse on T-REx (LAMA manual P@1 26.38 on T-REx vs. 31.10 on Original), potentially due to the T-REx test set being harder or the manual prompts being optimized for the LAMA distribution.

Label token interpretability and class-wise performance: The paper observes that label tokens for contradiction ("Nobody, nobody, nor" in Table 3) are more interpretable than those for entailment ("##found, ##ways, Agency") and neutral ("##ponents, ##lary, ##uated"). The precision breakdown for the 3-way balanced SICK-E dataset aligns with this: contradiction achieves the highest per-class precision for both BERT (74.9%) and RoBERTa (84.9%), while neutral is lowest (36.8% and 57.3%). This correlation suggests that AUTOPROMPT is more effective when the class concept is lexically crystallized — contradiction is strongly associated with specific negation words that exist in the vocabulary, while neutral sentiment lacks a clear lexical anchor.

Proper noun and gold object constraints on fact retrieval: The paper explicitly prevents trigger tokens from being proper nouns or gold training objects (Section 5). The resulting prompts for fact retrieval (Table 7, Appendix C) contain content words related to the relation (e.g., "ediatric striker ice baseman defensive" for sports positions; "freaking genre orchestra fiction acid" for music genre) rather than entity names, confirming that the constraint successfully prevents answer-leakage shortcuts and instead forces the search to find relation-relevant lexical cues.

Ablation by oracle: what happens without AUTOPROMPT? The manual prompts (Table 1 for sentiment analysis; Table 4 for fact retrieval; Table 2 for NLI via the majority baseline) serve as an implicit ablation of the automated search: without AUTOPROMPT, the same frozen models appear substantially less capable. On fact retrieval, manual prompts miss 12+ P@1 points of model knowledge on average, and on specific relations (P106, P136, P413), they miss nearly all of it — yielding accuracies near zero where AUTOPROMPT reveals non-trivial capability.

Perturbed sentences as an ablation of model mechanism in RE: By comparing MLM performance on original vs. falsified context sentences (Table 5), the paper ablates whether MLMs are genuinely performing extraction or relying on memorization. The massive drop (90.73% → 56.43% for BERT) reveals that extraction is not the primary mechanism — the models are largely recalling facts. The fact that the supervised RE model does not drop (57.95% → 58.81%) confirms the experimental manipulation works: the perturbation is detectable by models that actually perform extraction, but MLMs override the sentence evidence with their own knowledge.

Critical Assessment

Claim 1: AUTOPROMPT "achieves higher average- and worst-case accuracy than fine-tuning in low-data regimes" (Abstract, Section 7)

This claim is supported with qualifications that the paper itself makes visible. Figure 2 shows that on NLI, AUTOPROMPT achieves higher average accuracy than fine-tuning at 10 examples (both BERT and RoBERTa) and at 100 examples (RoBERTa only). On sentiment analysis, fine-tuning outperforms AUTOPROMPT at all data sizes. So the claim holds for NLI but not for sentiment analysis — a task-dependent result that the paper states in the abstract without qualification ("sometimes achieving performance on par with recent state-of-the-art supervised models" in the abstract refers to the 91.4% SST-2 result, not the low-data claim, but the low-data claim in Section 7 is stated generally).

Additionally, the observed advantage is specific to average performance. The paper's emphasis on worst-case accuracy (the lower bound of the error bars) is significant: fine-tuning with RoBERTa at 10 examples on NLI has a minimum accuracy near chance while AUTOPROMPT's minimum is substantially above chance. This stability advantage is arguably more important than the average advantage — a method that works reliably with small data is more useful than one that may work well or may fail catastrophically.

However, the experimental design has a limitation: the fine-tuning baseline uses Mosbach et al. (2020)'s recommended hyperparameters for small datasets, but the paper does not assess whether alternative fine-tuning strategies (different learning rates, prompt-based fine-tuning as in Schick and Schütze (2020), or PET-style approaches) would close the gap. The fine-tuning runs exhibit high variance, which is consistent with known instability issues, but a more thorough comparison would include methods specifically designed for low-data fine-tuning stability.

Claim 2: AUTOPROMPT "elicits more accurate factual knowledge from MLMs than manually created prompts on the LAMA benchmark" (Abstract)

Strongly supported. The evidence is comprehensive and multi-metric. On Original LAMA: P@1 improves from 31.10% (LAMA manual) to 43.34% (AUTOPROMPT 7 tokens) — a 12.24 point absolute improvement. On T-REx: P@1 improves from 26.38% to 45.57% — a 19.19 point improvement. AUTOPROMPT also outperforms LPAQA's single best prompt (34.10% → 43.34% P@1) and their ensemble method (~4 points ahead, as stated in Section 5). The relation-level breakdown (Table 6) shows the improvement is widespread (38 of 41 relations improve or stay roughly flat) and massive on specific hard-to-phrase relations (P106: 0.63% → 14.72%; P136: 0.75% → 55.42%).

The one qualitative weakness is the degradation on P1376 (73.93% → 40.17%), which is not discussed in detail. This suggests that for some relations, the manual prompt captures a natural phrasing that AUTOPROMPT's ungrammatical trigger search cannot recover — possibly because the manual prompt "is the capital of" is nearly optimal and the trigger search overfits to training-set lexical patterns that don't transfer.

Claim 3: MLMs have "inherent capability to perform sentiment analysis and natural language inference without additional parameters or fine-tuning" (Abstract)

Supported, with evidence that the capability is genuine but falls short of supervised state-of-the-art. AUTOPROMPT achieves 91.4% on SST-2 (RoBERTa) — better than fine-tuned BERT (93.5%) and a BiLSTM+ELMo (89.3%), but below fine-tuned RoBERTa (96.7% per GLUE leaderboard). The NLI results (69.3% on 3-way balanced SICK-E with RoBERTa) are well above chance (33.3%) but substantially below fine-tuned performance (84.0% for BERT, 95.6% for 2-way). The prompting results establish a meaningful lower bound on model knowledge, and the fact that these lower bounds are non-trivial (91% on sentiment, 69% on NLI) demonstrates that pretraining alone imparts substantial task capability.

A missing experiment is whether AUTOPROMPT prompts for one model transfer to another model family (GPT, T5) or whether the prompts are model-specific. The paper's prompts are optimized for specific BERT/RoBERTa checkpoints, and given the finding that RoBERTa's prompts differ qualitatively from BERT's (more irrelevant tokens, worse fact retrieval performance), prompt transferability is not guaranteed. This is an important boundary condition that limits the practical claim: you need to run AUTOPROMPT for each model you want to deploy.

Claim 4: MLMs can serve as "relation extractors more effectively than supervised relation extraction models" (Abstract)

Supported for the original (unperturbed) setting, but substantially undermined by the perturbed sentence analysis. The 90.73% P@1 for BERT with AUTOPROMPT vs. 57.95% for the supervised RE model is a striking result — until you examine the perturbed condition. The fact that BERT performance drops to 56.43% on falsified sentences reveals that the high original accuracy is largely attributable to the model recalling memorized facts rather than extracting them from text. This means the claim that MLMs can serve as "relation extractors" requires a crucial qualification: they excel at relation extraction only when the text contains facts they already know — which is a very different capability from extracting novel relational information from arbitrary text.

The paper is transparent about this finding and does not hide the perturbed results, but the abstract's claim is stated without this qualification. The claim as written ("MLMs can be used as relation extractors more effectively than supervised relation extraction models") is true for the standard evaluation but misleading without the context that this effectiveness stems from memorization, not genuine extraction.

An experiment that would have strengthened this analysis: test the supervised RE model on facts that are likely in BERT's training data vs. facts that are unlikely to be (e.g., synthetic relations, very recent facts) to see if the gap closes when memorization is impossible. This would directly isolate the contribution of memorization vs. extraction.

General Strengths of the Experimental Design

Multiple tasks spanning different knowledge types. The paper tests classification (sentiment), inference (NLI), knowledge recall (fact retrieval), and information extraction (relation extraction) — covering a broad range of what one might want to probe in an LM.

Multiple baselines per task. For fact retrieval, AUTOPROMPT is compared against both LAMA (manual) and LPAQA (mined/paraphrased/crowdsourced), as well as the LPAQA ensemble. For sentiment and NLI, comparisons include linear probing, fine-tuning, and manual prompts.

Validation-based model selection. Using a held-out development set to select the best prompt across search iterations, rather than the final iteration, prevents overfitting to the particular batches used during gradient computation. This is a clean protocol.

Controlled low-data experiments. The 10-trial repeated sampling with error bars in Figure 2 provides a more complete picture of performance variance than single-run results.

The perturbed sentence analysis in RE. This is a genuinely clever experiment that reveals a mechanism limitation — the use of falsified context sentences to distinguish extraction from memorization is a clean intervention that yields an unambiguous result.

Genuine Weaknesses

Single model family (BERT, RoBERTa). All experiments use encoder-only masked language models from the BERT family. The paper claims in Section 8 that AUTOPROMPT "can be trivially extended to standard language models," but no experiments with autoregressive models (GPT-2, GPT-3) or encoder-decoder models (T5, BART) are presented. Given that GPT-3-style prompting has become the dominant paradigm, this is a significant omission — the paper would be substantially stronger with even one autoregressive LM experiment to validate the claimed extensibility.

Small test sets. The LAMA Original test set is not sized explicitly in the paper, but the relation-level breakdown in Table 6 spans 41 relations with widely varying numbers of test facts (some relations have 1000 training facts but unclear test counts). The SICK-E test set is part of a ~10,000 example dataset, but the exact test split size is not specified. For the low-data experiments, training set sizes of 10, 100, and 1000 are tested, but the development and test sets are fixed — meaning at 10 training examples, AUTOPROMPT is selecting prompts based on gradient signal from as few as 5-8 examples (since the gradient batch and evaluation batch are separate).

No statistical significance testing. The paper does not report confidence intervals on main results (except indirectly through the error bars in Figure 2), does not perform statistical tests comparing AUTOPROMPT to baselines, and does not assess whether the observed differences (e.g., AUTOPROMPT vs. LPAQA on fact retrieval, or AUTOPROMPT vs. linear probing on NLI) are statistically significant given the test set sizes.

The discovered prompts are not evaluated for stability across search runs. The gradient-based search is greedy and deterministic given a fixed data order and random seed, but the paper does not report whether running AUTOPROMPT with different random seeds produces different prompts and different accuracies. Given the reported instability of fine-tuning, an analogous stability analysis for AUTOPROMPT's own optimization would be valuable — do different initializations (all [MASK] vs. random tokens) or different data orders lead to substantially different discovered prompts?

The linear probing baseline is weak for NLI. Linear probing achieves 49.5% (BERT) and 49.4% (RoBERTa) on the 3-way balanced SICK-E — barely above the 33.3% majority baseline in one case. This is unusually low compared to typical probing results on NLI tasks, and the paper does not discuss why probing fails here while prompting succeeds. A stronger probing baseline (e.g., probing from multiple layers, using concatenation rather than averaging) might close the gap with AUTOPROMPT.

No analysis of whether discovered prompts transfer across random seeds or training subsets. Given the low-data experiments (10 examples), the prompts found by AUTOPROMPT likely depend on which 10 examples are selected. The paper does not report how much the discovered prompt varies depending on the random training subset, which matters for practical reliability.

AUTOPROMPT's own computational cost is not included in any efficiency comparison. The prompt search requires running the trigger optimization (gradient computation + candidate evaluation over many iterations) plus the outer grid search over hyperparameters. The paper reports 2 days on 8 GPUs for sentiment analysis, but this cost is never compared to the cost of fine-tuning (which completes in minutes on a single GPU for these dataset sizes) or to the cost of manual prompt writing. This is acceptable for a probing paper — the goal is analysis, not deployment efficiency — but it limits the practical claim that AUTOPROMPT is a "viable parameter-free alternative" to fine-tuning.

Experiments That Would Have Strengthened the Paper

  • Autoregressive LM experiments. Applying AUTOPROMPT to GPT-2 or GPT-3 would validate the claim of trivial extensibility and connect the method to the prompting paradigm that became dominant in 2020-2021.

  • Cross-model transfer of prompts. Testing whether a prompt discovered for BERT also works for RoBERTa (and vice versa) would measure how model-specific the discovered prompts are.

  • Ablation of the template structure. The paper fixes prompt templates (e.g., "{sentence} [T] ... [T] [P]") and only searches over trigger tokens. Varying the template — e.g., placing trigger tokens before the input, varying the position of [P] — would reveal whether the template choice is consequential.

  • Comparison to continuous prompt tuning methods. While AUTOPROMPT predates the prefix-tuning / prompt-tuning literature (Li and Liang, 2021; Lester et al., 2021), a synthetic comparison to a "soft prompt" baseline where continuous vectors are optimized in embedding space (rather than discrete tokens) would help distinguish whether the discrete nature of AUTOPROMPT's search is necessary or whether continuous optimization could achieve similar results more efficiently.

  • Difficulty analysis for fact retrieval. The paper breaks down fact retrieval by relation (Table 6) but does not analyze which types of facts AUTOPROMPT helps most for — e.g., common vs. rare entities, single- vs. multi-token objects, relations with many vs. few training examples. This would provide insight into the conditions under which automated prompting is most valuable.

6. Limitations and Trade-offs

Prompt Discovery Requires Labeled Training Data

The assumption or constraint. The gradient-based trigger search and the logistic regression label token selection both require access to labeled training examples for the target task. The paper states this explicitly in Section 7:

"One downside of AUTOPROMPT is that it requires labeled training data. Although this is also required for other probing techniques (e.g., linear probing classifiers), manual prompts rely on domain/language insights instead of labeled data."

This distinguishes AUTOPROMPT from manual prompting approaches (Petroni et al., 2019) and from few-shot in-context learning paradigms (Brown et al., 2020), where no labeled data is needed at all—only a task description and optionally a few input-output demonstrations.

The consequence. AUTOPROMPT cannot be applied in true zero-shot settings where no task-specific labeled data exists. This limits its use as a pure analysis tool for languages, domains, or tasks where annotation is unavailable or expensive. For fact retrieval, the paper circumvents this by using T-REx knowledge base triples as training data (Section 5), but this relies on the existence of a structured knowledge base aligned with the target relations—a resource that does not exist for sentiment analysis, NLI, or arbitrary classification tasks. The low-data experiments (Figure 2) show AUTOPROMPT can work with as few as 10 examples, but even 10 labeled examples may be unavailable in truly novel domains or tasks.

Additionally, the labeled data requirement creates a subtle tension with AUTOPROMPT's primary use case as a probing tool. If the goal is to estimate what a pretrained LM knows without fine-tuning, the method itself requires some amount of task-specific supervision to construct the probe. This supervision is used only for prompt construction, not for updating model parameters, so the probe remains parameter-free—but the prompt discovery process is not supervision-free. The distinction between "no additional parameters" (true) and "no supervision" (false) is important for interpreting AUTOPROMPT's results: the prompts are optimized to surface knowledge using labeled examples, which means the lower bound on model knowledge is conditioned on having found a good prompt via supervised search. Without labeled data, one cannot run AUTOPROMPT, and a manual prompt (which requires no data but likely underestimates knowledge) is the only alternative.

What evidence exists in the paper. The low-data experiments in Figure 2 demonstrate the data requirement empirically: accuracy degrades as training examples decrease from 1000 to 100 to 10, though the degradation is less severe for AUTOPROMPT than for fine-tuning on NLI. The paper does not test the zero-shot case (0 labeled examples), which would require a different prompt construction strategy entirely.

Mitigation status. The paper acknowledges the limitation but does not resolve it. Section 7 states that manual prompts "rely on domain/language insights instead of labeled data," positioning this as a tradeoff rather than a failure. The paper does not propose a label-free variant of AUTOPROMPT, nor does it explore whether prompts discovered for one task or model transfer to related tasks or models without additional labeled data. This is left as an open challenge.

Discovered Prompts Are Non-Interpretable and Model-Specific

The assumption or constraint. AUTOPROMPT's search over discrete trigger tokens produces prompts optimized solely for maximizing label likelihood, with no constraint that the resulting token sequences be grammatical, semantically coherent, or interpretable to humans. The paper acknowledges this in Section 7:

"Compared to human-designed prompts, AUTOPROMPT generated prompts lack interpretability, which is similar to other probing techniques, such as linear probing classifiers."

Furthermore, the prompts are optimized against a specific pretrained model checkpoint and tokenizer—there is no mechanism to ensure transferability to other models.

The consequence. The discovered prompts provide little insight into why the model knows what it knows. A manual prompt like "was born in [MASK]" clearly expresses the relation being probed and tells the researcher something about how the model organizes knowledge. An AUTOPROMPT prompt like "{sub} ediatric striker ice baseman defensive [MASK]" for the POSITION PLAYED ON TEAM relation (Table 7, Appendix C) achieves 41.71% P@1 (vs. 0.53% for the manual prompt), but the mechanism by which it works is opaque: the trigger tokens include sports-related words ("striker," "baseman," "defensive") but also non-words ("ediatric") and the overall sequence is ungrammatical. This opacity means AUTOPROMPT improves measurement of model knowledge at the cost of understanding of how that knowledge is organized—a tradeoff the paper acknowledges by calling AUTOPROMPT "just one tool in the toolbox of the interpretability researcher" (Section 7).

The model-specificity problem is also significant. The paper shows that BERT's discovered prompts differ qualitatively from RoBERTa's (Section 5, Table 7): RoBERTa's prompts "tend to contain more irrelevant words" and include symbols like "), (" for the POSITION PLAYED ON TEAM relation, and BERT consistently outperforms RoBERTa on fact retrieval despite being a smaller model (Table 4, right: BERT P@1 45.23 vs. RoBERTa 40.01). This means running AUTOPROMPT for BERT tells you about BERT's knowledge specifically, not about pretrained MLMs in general. To compare models, you must run the full prompt search separately for each model—a computationally expensive proposition (2 days on 8 GPUs per sentiment analysis hyperparameter sweep, Section 3 footnote).

What evidence exists in the paper. Table 7 (Appendix C) provides extensive examples of discovered prompts alongside manual prompts, making the interpretability gap visually obvious. The BERT vs. RoBERTa comparison in Table 4 (right) demonstrates that prompts do not transfer—RoBERTa underperforms BERT even with its own optimized prompts. RoBERTa's prompts containing "Trump," commas, and parentheses (Table 7) illustrate the kind of noise that emerges from optimizing against a specific model's embedding space.

Mitigation status. None beyond acknowledgment. The paper positions AUTOPROMPT as a measurement tool rather than an explanation tool, which is a defensible choice given the stated goal of establishing tighter lower bounds on model knowledge, but it means AUTOPROMPT cannot replace manual prompts or other interpretability methods for understanding how models represent knowledge. The model-specificity is not addressed at all—no cross-model prompt transfer experiments are conducted, and no method for generating model-agnostic prompts is proposed.

Prompt Search Is Computationally Expensive and Not Cost-Accounted

The assumption or constraint. The gradient-based trigger search involves iteratively computing gradients through the entire transformer model, evaluating candidate tokens via exact forward passes, and wrapping this in an outer grid search over hyperparameters. The paper reports the computational cost only once: sentiment analysis "required 2 days to run with 8 NVIDIA 2080Ti GPUs" (Section 3, footnote 3), which is approximately 384 GPU-hours per hyperparameter configuration. This cost covers the search for a single task on a single model—repeat for each combination of dataset, model, and hyperparameter setting.

The consequence. AUTOPROMPT's computational overhead is several orders of magnitude larger than the cost of writing a manual prompt, and is comparable to or exceeds the cost of fine-tuning the model itself for many tasks. Fine-tuning BERT_BASE_ on SST-2 takes minutes on a single GPU; AUTOPROMPT's search takes days on 8 GPUs. This cost is never factored into any efficiency comparison in the paper: the low-data experiments (Figure 2) compare AUTOPROMPT and fine-tuning purely in terms of labeled example count, not total computational cost. A practitioner deciding between AUTOPROMPT and fine-tuning at 10 examples would need to weigh the accuracy advantage (present for NLI but not sentiment analysis) against a ~100-1000× difference in compute expenditure.

This cost also limits the practical applicability claimed in Section 7. The paper argues prompting has advantages over fine-tuning because "only prompts are stored for each individual task, while the same pretrained model is used across all of the tasks"—reducing disk storage and deployment complexity. While true for inference, this ignores the cost of discovering those prompts. If a practitioner needs to deploy 50 tasks with AUTOPROMPT, they face 50 separate multi-day searches, each consuming hundreds of GPU-hours. The total compute cost of prompt discovery may rival or exceed the cost of fine-tuning all 50 models, even though fine-tuning requires storing separate checkpoints.

A subtler consequence: the high computational cost likely prevented the authors from running AUTOPROMPT on additional benchmarks (QQP, RTE), which the paper acknowledges in Section 7 performed "not considerably better than chance." It is unclear whether this reflects a genuine limitation of the method or insufficient search budget to find effective prompts for these tasks.

What evidence exists in the paper. The 2-days-on-8-GPUs figure (Section 3, footnote 3) is the only explicit cost report. The paper does not report search times for NLI, fact retrieval, or relation extraction, does not compare AUTOPROMPT's total FLOPs to fine-tuning's total FLOPs for any experiment, and does not account for search cost in the low-data comparisons of Figure 2. The fact that the paper tested only sentiment analysis, NLI, and fact/relation retrieval—and abandoned QQP and RTE—may partially reflect the computational burden of running the full search on additional datasets.

Mitigation status. Not addressed. The paper does not propose any efficiency improvements to the search procedure (e.g., pruning the vocabulary before scoring, using smaller models for prompt search and transferring to larger models, reducing the number of gradient steps). The acknowledgment in Section 7 that AUTOPROMPT is "sometimes brittle" and that "we leave more effective crafting techniques for future directions" hints at awareness of the issue but does not constitute a solution. The search cost is a fundamental limitation that any practitioner would need to account for when deciding whether to use AUTOPROMPT, and the paper's silence on cost-effectiveness comparisons weakens the practical deployment argument made in Section 7.

Single Model Family and Single Evaluation Paradigm

The assumption or constraint. All experiments use BERT_BASE_ and RoBERTa_LARGE_—both encoder-only masked language models from the same architectural family, pretrained with similar objectives (masked language modeling with some variation). The paper claims in Section 8 that AUTOPROMPT "can be trivially extended to standard language models," but provides no experimental evidence with autoregressive LMs (GPT, OPT, LLaMA) or encoder-decoder models (T5, BART). The evaluation is confined to English-language benchmarks (SST-2, SICK-E, LAMA, T-REx) with standard dataset splits.

The consequence. We cannot determine whether AUTOPROMPT's effectiveness is specific to the BERT-family masked LM pretraining objective, or whether it generalizes to the autoregressive left-to-right language modeling objective that dominates current large-scale models (GPT-3, GPT-4, LLaMA, Claude). This is a significant gap because the paper was published in late 2020, contemporaneous with the rise of GPT-3 and autoregressive few-shot prompting as the dominant paradigm. The claimed "trivial" extensibility is untested, and there are reasons to doubt it: autoregressive LMs cannot naturally fill in blanks in the middle of a sequence—they generate left-to-right. Adapting the template structure "{sentence} [T] ... [T] [P]" to an autoregressive LM would require placing the [P] token at the end of the prompt, which changes the information flow compared to the masked LM setting where the model attends bidirectionally to all context around the mask. Whether the gradient-based trigger search remains effective under this structural change is an open question.

Additionally, the BERT vs. RoBERTa comparison (Table 4, right) already shows significant performance differences between two models within the same family, with BERT outperforming the larger RoBERTa on fact retrieval. This suggests that AUTOPROMPT's results are sensitive to model-specific factors (tokenization, pretraining data, training duration), and extrapolating from BERT/RoBERTa results to other model families is unwarranted without direct evidence.

What evidence exists in the paper. None—the paper contains zero experiments with autoregressive or encoder-decoder models. The claim of trivial extensibility in Section 8 is a brief forward-looking statement with no supporting evidence.

Mitigation status. The paper acknowledges the scope limitation implicitly by stating the focus is on masked language models in Section 2.1 ("Although we focus only on MLMs in this work") and Section 8 ("Although we focus only on masked language models in this paper"). The "trivially extendable" claim gestures at future work but does not constitute mitigation. Given the dominance of autoregressive LMs in the prompt engineering literature that followed this paper (2021-2023), the absence of even a single autoregressive experiment is the most significant empirical gap.

Performance Degrades on Imbalanced Data and Abstract Concepts

The assumption or constraint. AUTOPROMPT discovers trigger tokens and label tokens by maximizing average log-likelihood on training data. This objective is sensitive to class imbalance: if one class dominates the training set, the search will prioritize prompts that increase likelihood for the majority class, potentially at the expense of minority classes. The paper acknowledges this in Section 7:

"Another limitation of AUTOPROMPT is that it can sometimes struggle when the training data is highly imbalanced. For example, in Sections 4 and 5 we show that the prompts often just increase the likelihood of the majority label."

Additionally, the method assumes that class labels can be associated with sets of vocabulary tokens via the logistic regression heuristic (Section 2.3). This assumption works well when class concepts are lexically crystallized—strongly associated with specific words (e.g., contradiction → negation words)—but may fail for abstract or diffuse concepts that lack clear lexical anchors.

The consequence. AUTOPROMPT performs unevenly across class labels within a task, and across tasks that differ in conceptual abstractness. On the 3-way balanced SICK-E NLI dataset (Table 2 discussion in Section 4), class-wise precision varies dramatically: BERT achieves 74.9% on contradiction, 54.4% on entailment, and 36.8% on neutral; RoBERTa achieves 84.9%, 65.1%, and 57.3%. Neutral—the most abstract and lexically diffuse of the three NLI classes—is the hardest for both models, and the paper observes that the discovered label tokens for neutral are the least interpretable ("##ponents, ##lary, ##uated" in Table 3). This correlation between label token interpretability and per-class accuracy suggests that AUTOPROMPT is fundamentally limited for concepts that do not map cleanly onto vocabulary items.

The paper also reports in Section 7 that preliminary evaluation on QQP (paraphrase detection) and RTE (recognizing textual entailment) "did not perform considerably better than chance." While the paper does not specify the cause, a plausible explanation is that these tasks involve abstract relational judgments (paraphrase, entailment) that are difficult to reduce to fill-in-the-blank with a small set of label tokens—the label token selection procedure may fail to find vocabulary tokens that reliably discriminate between the classes.

More broadly, this limitation implies a fundamental boundary condition for prompt-based probing: tasks that are naturally expressed as token prediction (filling in an entity name, a sentiment word, a contradiction marker) are amenable to AUTOPROMPT; tasks that require relational or compositional reasoning over multiple tokens may not be. This is not a failure of AUTOPROMPT specifically, but of the fill-in-the-blank probing paradigm itself—a limitation the paper acknowledges in Section 7: "we cannot conclude that BERT does not know paraphrasing or entailment from these results."

What evidence exists in the paper. The NLI class-wise precision breakdown (Section 4) directly demonstrates the uneven performance. The QQP and RTE results are mentioned but not shown—the paper states they "did not perform considerably better than chance" without providing exact numbers, making it difficult to assess how severe the failure is. The label token examples in Table 3 (contradiction: {"Nobody, nobody, nor"} vs. neutral: {"##ponents, ##lary, ##uated"}) illustrate the interpretability gradient qualitatively. The paper's recommendation in Section 7 to "rebalance the training data" acknowledges the imbalance sensitivity without demonstrating its effectiveness.

Mitigation status. Partially addressed. The paper suggests rebalancing training data as a mitigation for class imbalance and notes that they did this for NLI (the 3-way balanced and 2-way variants in Table 2 were explicitly constructed "to avoid the effects of label imbalance"). However, rebalancing does not solve the deeper problem of conceptual abstractness—even with balanced NLI data, neutral remains substantially harder than contradiction. For the QQP/RTE failures, no solution is proposed. The paper's framing of AUTOPROMPT as "just one tool in the toolbox" (Section 7) is an implicit acknowledgment that the method does not work for all tasks, but the boundary between tasks that work and tasks that don't is characterized only empirically, not theoretically.

The Hardest Instances Show No Improvement—Prompting Cannot Create Missing Knowledge

The assumption or constraint. AUTOPROMPT, like all prompting methods, can only surface knowledge that already exists in the pretrained model's weights. If the model lacks certain knowledge entirely—because it was not present in the pretraining data, or because the concept requires reasoning capabilities the model does not possess—no prompt engineering can recover it. The paper does not state this as an explicit assumption, but it is a logical consequence of the probing paradigm: prompting provides a lower bound on model knowledge, meaning it can only underestimate, not overestimate, what the model knows. But equally, if the lower bound is near zero, the model genuinely lacks that knowledge.

The consequence. AUTOPROMPT cannot help on the hardest instances within a task—examples where the base model's probability of producing the correct answer is near zero regardless of how the question is phrased. The paper provides indirect evidence for this across multiple tasks:

  • Fact retrieval: While AUTOPROMPT dramatically improves P@1 on many relations, the worst-performing relations remain near zero. For P190 ("X and Y are twin cities"), AUTOPROMPT achieves only 2.31% P@1 (Table 6)—barely better than LAMA (2.41%) and LPAQA (1.91%). The trigger tokens cannot compensate for the model's lack of knowledge about twin city relationships.

  • Relation extraction with perturbed sentences: When context sentences are falsified (Table 5), BERT with AUTOPROMPT drops from 90.73% to 56.43% P@1, and RoBERTa drops to 28.95%. The model's memorized knowledge overrides the contradictory sentence evidence, and AUTOPROMPT's prompts cannot force the model to extract information it does not believe to be true.

  • Low-data fine-tuning comparison: On sentiment analysis, fine-tuning outperforms AUTOPROMPT at all data sizes (Figure 2a, 2b), suggesting that for this task, the model benefits from learning task-specific representations through parameter updates beyond what prompting can elicit—even with optimized prompts.

This limitation is not specific to AUTOPROMPT—it is inherent to the prompting paradigm—but it is important for practitioners to understand. AUTOPROMPT improves the measurement of model knowledge but cannot change the quantity of knowledge. For tasks where the model's pretrained knowledge is genuinely insufficient (as appears to be the case for the hardest fact retrieval relations, for QQP/RTE, and for elements of sentiment analysis where fine-tuning provides gains beyond prompting), no amount of prompt optimization will close the gap.

What evidence exists in the paper. The relation-level breakdown in Table 6 shows persistent near-zero performance on specific relations (P190: 2.31%, P530: 3.11%) despite AUTOPROMPT's large gains on other relations. The perturbed RE experiment (Table 5) demonstrates that AUTOPROMPT's prompts cannot make the model perform genuine extraction when its memorized knowledge contradicts the provided text. The fine-tuning vs. AUTOPROMPT comparison on sentiment analysis (Figure 2a, 2b) shows fine-tuning's advantage across all data sizes. The QQP/RTE admission in Section 7 implies that for some tasks, the model's underlying capability is insufficient for prompting to work at all.

Mitigation status. None—this is a fundamental constraint of the probing paradigm, not a fixable limitation. The paper handles it appropriately by framing prompting as a lower bound and by acknowledging that different probing methods have complementary strengths (Section 7: "different probing methods have different tasks and phenomena they are suitable for"). The critical practical implication is that AUTOPROMPT cannot determine why a model fails on a particular instance—whether due to missing knowledge, inaccessible knowledge, or prompt failure—which limits its utility as a diagnostic tool for understanding model failures. The paper does not address this diagnostic ambiguity.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper resolves a fundamental tension in the interpretability literature by establishing that prompting—not probing classifiers or attention visualization—provides the epistemologically sound lower bound on what pretrained models genuinely know, and then demonstrates that this lower bound can be systematically tightened through automated search. Prior to AUTOPROMPT, the field was divided between methods that risked false positives (probing classifiers introduce learned parameters that may do the intellectual work) and methods that risked false negatives (manual prompts may be so suboptimal that they make capable models appear ignorant). The paper's core methodological contribution is resolving this false negative problem: by replacing manual prompt engineering with gradient-guided discrete optimization over the model's own vocabulary, AUTOPROMPT demonstrates that many prior conclusions about model ignorance were artifacts of poor prompt construction, not genuine capability gaps.

The magnitude of the re-estimation is substantial. On the LAMA fact retrieval benchmark, AUTOPROMPT improves P@1 from 31.1% to 43.3%—a ~12-point absolute gain that means roughly 40% more facts are now known to be retrievable. On specific relations like P136 (music genre), the reassessment is even starker: manual prompts suggested the model knew essentially nothing (0.7% P@1), while AUTOPROMPT reveals 55.4% P@1—a ~79× multiplicative improvement in apparent capability. These are not incremental refinements; they are qualitative changes in what we conclude the model knows, and they call into question every prior negative result based on manual prompting that did not exhaust automated search.

This reframing elevates prompting from one among several probing tools to the conservative gold standard for establishing lower bounds on model knowledge. The logic is clean: if a frozen model with no additional parameters can produce the correct answer given some input text, the knowledge must have existed in the model beforehand. Probing classifiers cannot make this guarantee because the classifier itself could be extracting latent information the model cannot deploy. Attention visualization cannot make this guarantee because correlation is not causation. Prompting alone provides the epistemological guarantee of no false positives. AUTOPROMPT makes this guarantee practical by removing the manual effort bottleneck that restricted prompting to fact retrieval and a handful of other tasks with obvious fill-in-the-blank phrasings.

The paper also reconciles a specific contradiction in the probing literature. Hewitt and Liang (2019) and Voita and Titov (2020) had established that high probing classifier accuracy does not imply the model uses the probed knowledge—a devastating critique of the dominant interpretability paradigm. But this left open the question: how should we measure model knowledge instead? The paper provides a concrete, validated answer. Moreover, it demonstrates cases where probing classifiers actually underestimate model knowledge relative to prompting: on the balanced 3-way SICK-E NLI task, linear probing achieves 49.5% (barely above the 33.3% majority baseline) while AUTOPROMPT achieves 55.4% for BERT and 69.3% for RoBERTa (Table 2). This shows that probing classifiers are vulnerable to false negatives as well as false positives—a finding that further strengthens the case for prompting as the preferred lower-bound estimator.

The paper's most intriguing conceptual shift is demonstrating that effective prompts need not be interpretable or grammatical. The trigger tokens discovered by AUTOPROMPT—"ediatric striker ice baseman defensive" for sports positions, "freaking genre orchestra fiction acid" for music genres—are essentially nonsense to a human reader, yet they surface model knowledge far more effectively than natural language prompts like "plays in position" or "plays music." This challenges the implicit assumption throughout the prompting literature (from Petroni et al., 2019, through GPT-3 in-context learning, to modern instruction-tuned models) that prompts should read as natural instructions. AUTOPROMPT's results suggest that the goal of prompt engineering is not to write good English, but to find the token sequences that maximally shift the model's internal representations toward the desired output distribution—and that these sequences may be ungrammatical, opaque, and model-specific without losing effectiveness.

This finding makes several research directions newly attractive. First, it suggests that the space of effective prompts is vastly larger than the space of natural language instructions, and that automated search can explore regions of this space that human intuition would never consider. Second, it raises the question of whether the interpretability of discovered prompts matters at all for practical deployment, or whether we should simply accept opaque but effective prompts as tools. Third, it connects prompting to the broader literature on adversarial examples and universal triggers (Wallace et al., 2019), suggesting that the same mechanisms that can break models can also productively steer them.

Conversely, the paper makes certain research directions less attractive. The perturbed sentence analysis for relation extraction (Table 5) is particularly sobering: BERT with AUTOPROMPT achieves 90.7% P@1 on original sentences but plummets to 56.4% on sentences where the correct answer was replaced with a false one. This reveals that what looked like extraction was actually memorized recall—the model already knew the facts and largely ignored the provided context. This finding casts doubt on the entire enterprise of using prompted MLMs as genuine information extraction systems (as opposed to knowledge retrieval systems), and it suggests that future work on LM-as-knowledge-base should carefully distinguish between recall-from-memory and extraction-from-text, using falsified-context controls like the paper introduces. More broadly, it demonstrates that impressive prompting results can be mechanistically misleading, and that controlled experiments that isolate the information source are essential for valid interpretation.

Follow-Up Research This Work Enables

Transfer learning for prompts: do triggers discovered on one model help on another, or are they inherently model-specific? The paper shows that BERT and RoBERTa produce qualitatively different prompts (RoBERTa's contain more irrelevant tokens and symbols; Table 7, Appendix C), and that BERT outperforms RoBERTa on fact retrieval despite being smaller (P@1 45.23 vs. 40.01; Table 4, right). A systematic cross-model transfer experiment would directly evaluate whether AUTOPROMPT triggers from BERT improve RoBERTa's performance and vice versa, and whether the gap between transferred and model-specific prompts is larger for models with different tokenizers (BERT vs. GPT-2) than for models sharing a tokenizer (BERT vs. DistilBERT). This would establish whether the trigger search finds universal task-relevant lexical cues or model-specific embedding space artifacts—a distinction with major practical implications for whether AUTOPROMPT must be rerun for every deployed model.

Extending AUTOPROMPT to autoregressive language models with a causal prompt structure. The paper claims the method is "trivially extendable" (Section 8) but provides no experimental evidence. A strong follow-up would apply AUTOPROMPT to GPT-2 or LLaMA on the same tasks (sentiment analysis, fact retrieval), placing the trigger tokens and prediction position at the end of the prompt to accommodate left-to-right generation. The comparison would answer: does the gradient-based trigger search remain effective when the model attends only leftward to the context, rather than bidirectionally around a masked position? Concretely, does AUTOPROMPT with GPT-2-medium match or exceed the fact retrieval P@1 that BERT_BASE_ achieves (43.3%)? A negative result (substantially worse performance with autoregressive LMs) would reveal a fundamental constraint on prompting-based probing that the paper's "trivially extendable" claim overlooks.

Combining AUTOPROMPT triggers with continuous soft prompt optimization. AUTOPROMPT searches over discrete tokens using gradient approximations; the subsequent prefix-tuning and prompt-tuning literature (Li and Liang, 2021; Lester et al., 2021) optimizes continuous embedding vectors directly via gradient descent. A direct comparison on the same tasks would establish whether discrete token search provides advantages (interpretability of the discovered tokens, compatibility with any LM without modifying its embedding space) or whether continuous optimization achieves higher accuracy at lower computational cost. A particularly informative experiment would use AUTOPROMPT's discovered discrete tokens to initialize a continuous soft prompt and then fine-tune—testing whether the discrete search provides a better starting point than random initialization, effectively combining the strengths of both approaches.

Falsified-context controls as a standard evaluation protocol for LM-as-knowledge-base claims. The perturbed sentence experiment in Section 6 is methodologically significant beyond its specific result. It provides a template for mechanism ablation: systematically replacing correct facts with false ones to measure whether the model is extracting from text or recalling from memory, then attributing performance changes to specific information sources. A systematic study applying this methodology across all LAMA relations, across different types of knowledge (factual, commonsense, linguistic), and across model scales (from BERT_BASE_ to very large LMs) would map out which capabilities are genuinely extractive versus merely recall-based—a crucial distinction for the viability of prompted LMs as information extraction systems. The paper's result that the supervised RE model is unaffected by perturbation (57.95% → 58.81%) while MLMs drop dramatically (90.73% → 56.43%) provides a clean baseline for this protocol.

Difficulty-predicting meta-models for whether AUTOPROMPT will help on a given task or instance. The paper shows that AUTOPROMPT dramatically improves performance on some relations (P136: 0.7% → 55.4%) while barely helping on others (P190: 2.41% → 2.31%), and that it fails entirely on QQP and RTE. What predicts this variation? Training a classifier on task-level features (class abstractness, presence of clear lexical anchors, label token interpretability scores from the logistic regression heuristic) to predict AUTOPROMPT's effectiveness would produce a practical tool for deciding whether to invest the computational cost of trigger search on a new task. Instance-level difficulty prediction—using the model's own [MASK] hidden state uncertainty or the variance of trigger token candidates during search—would enable adaptive allocation of search budget, concentrating iterations on examples where prompt optimization is most likely to help.

Ablation of the logistic regression label token selection: is the two-step procedure necessary, or can simpler heuristics suffice? The paper's label token selection (Section 2.3) trains a logistic probe on [MASK] hidden states, then uses the learned weight vectors to score vocabulary tokens. An ablation comparing this to: (a) directly using the top-k tokens by average prediction probability from the initial [MASK] prompt, (b) using the gradient of the label log-likelihood with respect to the output vocabulary (analogous to the trigger search gradient), or (c) manually specifying label tokens based on task knowledge—would isolate how much the logistic regression step contributes. If simpler heuristics match the logistic probe's performance, the method becomes substantially simpler and faster. If the logistic probe is essential, it reveals that the learned class direction in representational space captures information beyond simple token-label co-occurrence.

Practical Applications and Downstream Use Cases

Deploying a single pretrained model for dozens of tasks without storing fine-tuned checkpoints. The most direct practical use case follows from the paper's argument in Section 7: a cloud API or on-device system serving many NLP tasks can use a single frozen BERT/RoBERTa checkpoint plus per-task AUTOPROMPT prompts, eliminating the need to store and serve dozens of fine-tuned model copies. The storage savings are concrete: a single BERT_BASE_ checkpoint is ~440 MB; adding 50 fine-tuned copies requires ~22 GB. AUTOPROMPT reduces this to ~440 MB plus a few kilobytes of trigger tokens per task. For sentiment analysis, AUTOPROMPT achieves 91.4% accuracy with RoBERTa (Table 1)—below fine-tuned RoBERTa at 96.7% but above fine-tuned BERT at 93.5%—making the storage-accuracy tradeoff quantifiable. The primary deployment cost is the upfront compute for prompt discovery (~2 days on 8 GPUs per task per model; Section 3, footnote 3), which must be amortized over inference queries.

Low-resource and low-data task adaptation where fine-tuning is unstable. The paper's finding that AUTOPROMPT achieves higher average and worst-case accuracy than fine-tuning with 10 labeled examples on NLI (Figure 2c, 2d), and that fine-tuning exhibits catastrophic variance (RoBERTa on NLI: min near chance, max ~0.55), makes AUTOPROMPT immediately useful for practitioners facing truly tiny labeled datasets. For a humanitarian or niche-domain application with only a handful of annotated examples—say, classifying medical reports in a low-resource language where bilingual annotators are scarce—AUTOPROMPT provides a more reliable alternative to the "fine-tune and hope it doesn't crash" approach. The stability advantage (narrower error bars in Figure 2) is arguably more important than the average accuracy advantage in production settings where a single failed run can derail deployment.

Automated prompt engineering for the GPT-3/LLaMA in-context learning paradigm. Although the paper focuses on MLMs, the gradient-guided trigger search can be adapted to generate prefixes for autoregressive LMs, automating the prompt engineering that currently consumes substantial human effort in few-shot and zero-shot settings. Concretely, for a task where practitioners currently hand-write instructions and demonstrations, AUTOPROMPT could search for optimal trigger tokens (functioning as a learned "task prefix") appended before the few-shot examples, optimizing directly for task accuracy rather than relying on the practitioner's intuition about effective phrasing. The 4× to 79× multiplicative improvements AUTOPROMPT achieves over manual prompts on specific fact retrieval relations (P136: 0.7% → 55.4%) suggest that the gap between hand-written and automatically-discovered prompts may be even larger for autoregressive LMs, where prompt sensitivity is well-documented.

Diagnosing whether model knowledge gaps stem from pretraining or from poor measurement. For model developers deciding whether to invest in larger pretraining runs or better prompting strategies, AUTOPROMPT provides a diagnostic: run AUTOPROMPT on the target task with the current model. If accuracy improves dramatically (as it does for fact retrieval: +12 P@1 points), the model already possesses substantial knowledge that manual prompting failed to surface—invest in prompt optimization, not larger pretraining. If AUTOPROMPT barely helps (as with P190: 2.41% → 2.31%), the model genuinely lacks the relevant knowledge—invest in pretraining data or model scale. This is a concrete, empirically-grounded decision rule, not speculation: the relation-level breakdown in Table 6 directly supports it, showing that AUTOPROMPT's improvement varies from negligible (P190: +0.10 P@1) to massive (P136: +54.65 P@1), and the cases where it fails to help are precisely those where the base model's knowledge appears genuinely absent.