Prefix-Tuning: Optimizing Continuous Prompts for Generation

Xiang Lisa Li Stanford University [email protected]

Percy Liang Stanford University [email protected]

Abstract

Fine-tuning is the de facto way to leverage large pretrained language models to perform downstream tasks. However, it modifies all the language model parameters and therefore necessitates storing a full copy for each task. In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation tasks, which keeps language model parameters frozen, but optimizes a small continuous task-specific vector (called the prefix). Prefix-tuning draws inspiration from prompting, allowing subsequent tokens to attend to this prefix as if it were ``virtual tokens''. We apply prefix-tuning to GPT-2 for table-to-text generation and to BART for summarization. We find that by learning only 0.1% of the parameters, prefix-tuning obtains comparable performance in the full data setting, outperforms fine-tuning in low-data settings, and extrapolates better to examples with topics unseen during training.

Executive Summary: Prefix-tuning is a new method for adapting large pretrained language models to specific natural language generation tasks. It addresses the high cost of conventional fine-tuning, which updates and stores every model parameter for each task—an approach that quickly becomes prohibitive as models grow to hundreds of millions or billions of parameters.

The paper evaluates whether a far lighter alternative can match or exceed fine-tuning performance on table-to-text generation and abstractive summarization. The method keeps the base model weights frozen and instead learns a short sequence of continuous, task-specific vectors (a “prefix”) that the model treats as additional virtual context.

The authors test the approach on GPT-2 (medium and large) for three table-to-text benchmarks and on BART for the XSUM summarization dataset. Experiments compare prefix-tuning (0.1–2 % of parameters) against full fine-tuning, partial-layer fine-tuning, and adapter-tuning across full-data, low-data, and topic-extrapolation settings, using standard automatic metrics.

Prefix-tuning achieves performance comparable to full fine-tuning on table-to-text while storing roughly 1,000 times fewer task-specific parameters. On summarization it shows a small degradation at the full-data setting. In low-resource regimes (50–500 examples) it consistently outperforms fine-tuning by roughly 3 BLEU or ROUGE points on average. It also generalizes better to categories or topics absent from the training data.

These results indicate that organizations can maintain a single large language-model copy and add lightweight, modular prefixes for each new task or user. The approach reduces storage and deployment costs dramatically, improves data efficiency, and limits cross-task or cross-user data leakage—benefits especially relevant for personalization and privacy-sensitive applications.

Practitioners should therefore consider prefix-tuning (or the related prompt-tuning variants) whenever multiple tasks must be supported or when training data per task is limited. The next practical steps are to validate the method on additional generation tasks and larger models such as GPT-3, release reusable prefix libraries, and integrate the technique into serving frameworks so that many prefixes can be batched efficiently on the same GPU.

The findings rest on standard benchmarks and automatic metrics; human evaluation and very large-scale production settings are not reported, and the largest model tested is GPT-2. Confidence is high for the table-to-text and low-data claims and moderate for summarization.

1. Introduction

Section Summary: Fine-tuning large language models for new tasks requires updating and storing a separate full-size copy of the model for every task, which quickly becomes prohibitively expensive for models with billions of parameters. Prefix-tuning offers a lighter alternative by keeping the original model frozen and instead learning only a small set of continuous, task-specific vectors that are prepended to the input and treated like virtual tokens. This approach uses orders of magnitude less storage, supports many tasks with a single shared model, and performs comparably to or better than standard fine-tuning, especially when data is limited.

Fine-tuning is the prevalent paradigm for using large pretrained language models (LMs) [1, 2] to perform downstream tasks (e.g., summarization), but it requires updating and storing all the parameters of the LM. Consequently, to build and deploy NLP systems that rely on large pretrained LMs, one currently needs to store a modified copy of the LM parameters for each task. This can be prohibitively expensive, given the large size of current LMs; for example, GPT-2 has 774M parameters [1] and GPT-3 has 175B parameters [3].

A natural approach to this problem is lightweight fine-tuning, which freezes most of the pretrained parameters and augments the model with small trainable modules. For example, adapter-tuning [4, 5] inserts additional task-specific layers between the layers of pretrained language models. Adapter-tuning has promising performance on natural language understanding and generation benchmarks, attaining comparable performance with fine-tuning while adding only around 2-4% task-specific parameters [5, 6].

On the extreme end, GPT-3 [3] can be deployed without any task-specific tuning. Instead, users prepend a natural language task instruction (e.g., TL;DR for summarization) and a few examples to the task input; then generate the output from the LM. This approach is known as in-context learning or prompting.

In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation (NLG) tasks, inspired by prompting. Consider the task of generating a textual description of a data table, as shown in Figure 1, where the task input is a linearized table (e.g., "name: Starbucks $|$ type: coffee shop") and the output is a textual description (e.g., "Starbucks serves coffee."). Prefix-tuning prepends a sequence of continuous task-specific vectors to the input, which we call a prefix, depicted by red blocks in Figure 1 (bottom). For subsequent tokens, the Transformer can attend to the prefix as if it were a sequence of "virtual tokens", but unlike prompting, the prefix consists entirely of free parameters which do not correspond to real tokens. In contrast to fine-tuning in Figure 1 (top), which updates all Transformer parameters and thus requires storing a tuned copy of the model for each task, prefix-tuning only optimizes the prefix. Consequently, we only need to store one copy of the large Transformer and a learned task-specific prefix, yielding a very small overhead for each additional task (e.g., 250K parameters for table-to-text).

In contrast to fine-tuning, prefix-tuning is modular: we train an upstream prefix which steers a downstream LM, which remains unmodified. Thus, a single LM can support many tasks at once. In the context of personalization where the tasks correspond to different users [7, 8], we could have a separate prefix for each user trained only on that user's data, thereby avoiding data cross-contamination. Moreover, the prefix-based architecture enables us to even process examples from multiple users/tasks in a single batch, something that is not possible with other lightweight fine-tuning approaches.

We evaluate prefix-tuning on table-to-text generation using GPT-2 and abstractive summarization using BART. In terms of storage, prefix-tuning stores 1000x fewer parameters than fine-tuning. In terms of performance when trained on full datasets, prefix-tuning and fine-tuning are comparable for table-to-text (Section 6.1), while prefix-tuning suffers a small degradation for summarization (Section 6.2). In low-data settings, prefix-tuning on average outperforms fine-tuning on both tasks (Section 6.3). Prefix-tuning also extrapolates better to tables (for table-to-text) and articles (for summarization) with unseen topics (Section 6.4).

2. Related Work

Section Summary: Existing work on natural language generation relies heavily on fine-tuning large pretrained models such as T5, BERT, and BART for tasks like table-to-text generation and summarization, though researchers have explored more efficient approaches that freeze most parameters and train only small added modules or masks. Prompt-based methods, including GPT-3's in-context learning and techniques that optimize discrete trigger words, adapt models by prepending instructions or examples, but they are constrained by context length and often less expressive than continuous vector optimizations. Controllable generation techniques further steer outputs toward attributes like sentiment through pretraining or decoding adjustments, yet they struggle with the fine-grained content control needed for structured tasks like summarization.

Fine-tuning for natural language generation.

Current state-of-the-art systems for natural language generation are based on fine-tuning pretrained LMs. For table-to-text generation, [9] fine-tunes a sequence-to-sequence model (T5; [10]). For extractive and abstractive summarization, researchers fine-tune masked language models (e.g., BERT; [2]) and encode-decoder models (e.g., BART; [11]) respectively [12, 13, 10]. For other conditional NLG tasks such as machine translation and dialogue generation, fine-tuning is also the prevalent paradigm [14, 15, 16, 17]. In this paper, we focus on table-to-text using GPT-2 and summarization using BART, but prefix-tuning can be applied to other generation tasks and pretrained models.

Lightweight fine-tuning.

Lightweight fine-tuning freezes most of the pretrained parameters and modifies the pretrained model with small trainable modules. The key challenge is to identify high-performing architectures of the modules and the subset of pretrained parameters to tune. One line of research considers removing parameters: some model weights are ablated away by training a binary mask over model parameters [18, 19]. Another line of research considers inserting parameters. For example, [20] trains a "side" network that is fused with the pretrained model via summation; adapter-tuning inserts task-specific layers (adapters) between each layer of the pretrained LM [5, 6, 4, 21]. Compared to this line of work, which tunes around $3.6%$ of the LM parameters, our method obtains a further 30x reduction in task-specific parameters, tuning only 0.1% while maintaining comparable performance.

Prompting.

Prompting means prepending instructions and a few examples to the task input and generating the output from the LM. GPT-3 [3] uses manually designed prompts to adapt its generation for different tasks, and this framework is termed in-context learning. However, since Transformers can only condition on a bounded-length context (e.g., 2048 tokens for GPT-3), in-context learning is unable to fully exploit training sets longer than the context window. [22] also prompt by keywords to control for sentiment or topic of the generated sentence. In natural language understanding tasks, prompt engineering has been explored in prior works for models like BERT and RoBERTa ([23, 24, 25]). For example, AutoPrompt [26] searches for a sequence of discrete trigger words and concatenates it with each input to elicit sentiment or factual knowledge from a masked LM. In contrast with AutoPrompt, our method optimizes continuous prefixes, which are more expressive (Section 7.2); moreover, we focus on language generation tasks.

Continuous vectors have been used to steer language models; for example, [27] showed that a pretrained LSTM language model can reconstruct arbitrary sentences by optimizing a continuous vector for each sentence, making the vector input-specific. In contrast, prefix-tuning optimizes a task-specific prefix that applies to all instances of that task. As a result, unlike the previous work whose application is limited to sentence reconstruction, prefix-tuning can be applied to NLG tasks.

Controllable generation.

Controllable generation aims to steer a pretrained language model to match a sentence level attribute (e.g., positive sentiment or topic on sports). Such control can happen at training time: [28] pretrains the language model (CTRL) to condition on metadata such as keywords or URLs. Additionally, the control can happen at decoding time, by weighted decoding (GeDi, [29]) or iteratively updating the past activations (PPLM, [30]). However, there is no straightforward way to apply these controllable generation techniques to enforce fine-grained control over generated contents, as demanded by tasks like table-to-text and summarization.

3. Problem Statement

Section Summary: The problem involves adapting large pretrained Transformer language models to conditional text generation tasks, where an input context x (such as a linearized data table or an article) is mapped to an output sequence y (such as a description or summary). The section outlines two model types—an autoregressive language model like GPT-2 that processes the concatenated x and y, and an encoder-decoder model like BART that encodes x bidirectionally while generating y left-to-right—along with the computation of hidden activations at each step. It then describes standard fine-tuning, which updates all model parameters to maximize the likelihood of producing the correct y given x.

Consider a conditional generation task where the input is a context $x$ and the output $y$ is a sequence of tokens. We focus on two tasks, shown in Figure 2 (right): In table-to-text, $x$ corresponds to a linearized data table and $y$ is a textual description; in summarization, $x$ is an article and $y$ is a short summary.

3.1 Autoregressive LM

Assume we have an autoregressive language model $p_\phi(y \mid x)$ based on the Transformer [31] architecture (e.g., GPT-2; [1]) and parametrized by $\phi$. As shown in Figure 2 (top), let $z = [x;y]$ be the concatenation of $x$ and $y$; let $X$ _idx $ $ denote the sequence of indices that corresponds to $x$, and $Y$ _idx $ $ denote the same for $y$.

The activation at time step $i$ is $h_i \in \mathbb R^d$, where $h_i = [h_i^{(1)}; \cdot s ; h_i^{(n)}]$ is a concatenation of all activation layers at this time step, and $h_i^{(j)}$ is the activation of the $j$-th Transformer layer at time step $i$.[^1]

[^1]: $h_i^{(n)}$ is composed of a key-value pair. In GPT-2, the dimension of each key and value is $1024$.

The autoregressive Transformer model computes $h_i$ as a function of $z_i$ and the past activations in its left context, as follows:

$ h_i = \textsc{LM}\phi(z_i, h{<i}) \text{,}\tag{1} $

where the last layer of $h_i$ is used to compute the distribution for the next token: $p_{\phi}(z_{i+1} \mid h_{\leq i}) = \operatorname{softmax}(W_\phi ~h_{i}^{(n)})$ and $W_\phi$ is a pretrained matrix that map $h_{i}^{(n)}$ to logits over the vocabulary.

3.2 Encoder-Decoder Architecture

We can also use an encoder-decoder architecture (e.g., BART; [11]) to model $p_\phi(y\mid x)$, where $x$ is encoded by the bidirectional encoder, and the decoder predicts $y$ autoregressively (conditioned on the encoded $x$ and its left context). We use the same indexing and activation notation, as shown in Figure 2 (bottom). $h_i$ for all $i \in X$ _idx $ $ is computed by the bidirectional Transformer encoder; $h_i$ for all $i \in Y$ _idx $ $ is computed by the autoregressive decoder using the same Equation 1.

3.3 Method: Fine-tuning

In the fine-tuning framework, we initialize with the pretrained parameters $\phi$. Here $p_{\phi}$ is a trainable language model distribution and we perform gradient updates on the following log-likelihood objective:

$ \max_{\phi} ~\log p_\phi(y \mid x) = \sum_{i\in Y_{\text{idx}}} \log p_\phi(z_i \mid h_{<i}) \text{.}\tag{2} $

4. Prefix-Tuning

Section Summary: Prefix-tuning offers a lightweight alternative to fine-tuning by leaving the language model’s parameters frozen and instead learning a short sequence of continuous vectors, called a prefix, that is prepended to the input. These vectors act like a trainable context that guides the model’s attention and next-token predictions for a specific generation task. The prefix is optimized through a small reparameterized network during training and then stored alone, allowing the same frozen model to be steered toward different tasks simply by swapping the prefix.

We propose prefix-tuning as an alternative to fine-tuning for conditional generation tasks. We first provide intuition in Section 4.1 before defining our method formally in Section 4.2.

4.1 Intuition

Based on intuition from prompting, we believe that having a proper context can steer the LM without changing its parameters. For example, if we want the LM to generate a word (e.g., Obama), we can prepend its common collocations as context (e.g., Barack), and the LM will assign much higher probability to the desired word. Extending this intuition beyond generating a single word or sentence, we want to find a context that steers the LM to solve an NLG task. Intuitively, the context can influence the encoding of $x$ by guiding what to extract from $x$; and can influence the generation of $y$ by steering the next token distribution. However, it's non-obvious whether such a context exists. Natural language task instructions (e.g., "summarize the following table in one sentence") might guide an expert annotator to solve the task, but fail for most pretrained LMs.[^2] Data-driven optimization over the discrete instructions might help, but discrete optimization is computationally challenging.

[^2]: In our preliminary experiments, GPT-2 and BART fail in this setting; the only exception is GPT-3.

Instead of optimizing over discrete tokens, we can optimize the instruction as continuous word embeddings, whose effects will be propagated upward to all Transformer activation layers and rightward to subsequent tokens. This is strictly more expressive than a discrete prompt which requires matching the embedding of a real word. Meanwhile, this is less expressive than intervening all layers of the activations (Section 7.2), which avoids long-range dependencies and includes more tunable parameters. Prefix-tuning, therefore, optimizes all layers of the prefix.

4.2 Method

Prefix-tuning prepends a prefix for an autoregressive LM to obtain $z = [\textsc{Prefix}; x; y]$, or prepends prefixes for both encoder and encoder to obtain $z = [\textsc{Prefix}; x; \textsc{Prefix}'; y]$, as shown in Figure 2. Here, $P$ _idx $ $ denotes the sequence of prefix indices, and we use $| P$ _idx $|$ to denote the length of the prefix.

We follow the recurrence relation in Equation 1, except that the prefix are free parameters. Prefix-tuning initializes a trainable matrix $P_\theta$ (parametrized by $\theta$) of dimension $| P$ _idx $| \times \dim(h_i)$ to store the prefix parameters.

beginaligned $h_{i} =$ begincases $P_{\theta}[i$, :], & if i $\in P$ ${\text{idx}}$ ,\ $\textsc{LM}$$\phi$($z_i, h_{<i})$, & otherwise. endcases endaligned

The training objective is the same as Equation 2, but the set of trainable parameters changes: the language model parameters $\phi$ are fixed and the prefix parameters $\theta$ are the only trainable parameters.

Here, $h_i$ (for all $i$) is a function of the trainable $P_\theta$. When $i \in P$ idx $ $, this is clear because $h_i$ copies directly from $P{\theta}$. When $i \not \in P$ idx $ $, $h_i$ still depends on $P{\theta}$, because the prefix activations are always in the left context and will therefore affect any activations to its right.

4.3 Parametrization of $P_\theta$

Empirically, directly updating the $P_\theta$ parameters leads to unstable optimization and a slight drop in performance.[^3] So we reparametrize the matrix $P_\theta [i, :]= \textsc{MLP}\theta (P'\theta[i, :])$ by a smaller matrix ($P'\theta$) composed with a large feedforward neural network ($\textsc{MLP}\theta$). Note that $P_\theta$ and $P'\theta$ has the same rows dimension (i.e. the prefix length), but different columns dimension.[^4] Once training is complete, these reparametrization parameters can be dropped, and only the prefix ($P\theta$) needs to be saved.

[^3]: We find in preliminary experiments that directly optimizing the prefix is very sensitive to the learning rate and initialization.

[^4]: $P_\theta$ has a dimension of $| P$ idx $| \times \dim(h_i)$ while $P\theta$ has a dimension of $| P$ idx $| \times k$, where we choose $k=512$ for table-to-text and $800$ for summarization. $\textsc{MLP}\theta$ maps from dimension $k$ to $\dim(h_i)$

5. Experimental Setup

Section Summary: The experimental setup evaluates prefix-tuning on three table-to-text generation datasets of increasing complexity and size—E2E, WebNLG, and DART—plus the XSUM summarization dataset, using standard automatic metrics such as BLEU, METEOR, and ROUGE via official evaluation scripts. It compares prefix-tuning against full fine-tuning, partial fine-tuning of the top layers, and adapter methods on GPT-2 models for tables and BART for summarization, while also referencing published state-of-the-art results. Training employs the AdamW optimizer with tuned hyperparameters like learning rate and prefix length on GPUs, followed by beam-search decoding whose runtime per example is reported.

5.1 Datasets and Metrics

We evaluate on three standard neural generation datasets for the table-to-text task: E2E [32], WebNLG [33], and DART [34]. The datasets are ordered by increasing complexity and size. E2E only has $1$ domain (i.e. restaurant reviews); WebNLG has $14$ domains, and DART is open-domain, using open-domain tables from Wikipedia.

The E2E dataset contains approximately 50K examples with 8 distinct fields; it contains multiple test references for one source table, and the average output length is $22.9$. We use the official evaluation script, which reports BLEU [35], NIST [36], METEOR [37], ROUGE-L [38], and CIDEr [39].

The WebNLG [33] dataset consists of 22K examples, and the input $x$ is a sequence of (subject, property, object) triples. The average output length is $22.5$. In the training and validation splits, the input describes entities from $9$ distinct DBpedia categories (e.g., Monument). The test split consists of two parts: the first half contains DB categories seen in training data, and the second half contains $5$ unseen categories. These unseen categories are used to evaluate extrapolation. We use the official evaluation script, which reports BLEU, METEOR and TER [40].

DART [34] is an open domain table-to-text dataset, with similar input format (entity-relation-entity triples) as WebNLG. The average output length is $21.6$. It consists of 82K examples from WikiSQL, WikiTableQuestions, E2E, and WebNLG and applies some manual or automated conversion. We use the official evaluation script and report BLEU, METEOR, TER, MoverScore [41], BERTScore [42] and BLEURT [43].

For the summarization task, we use the XSUM [44] dataset, which is an abstractive summarization dataset on news articles. There are 225K examples. The average length of the articles is 431 words and the average length of the summaries is 23.3. We report ROUGE-1, ROUGE-2 and ROUGE-L.

5.2 Methods

For table-to-text generation, we compare prefix-tuning with three other methods: fine-tuning ($\textsc{Fine-tune}$), fine-tuning only the top 2 layers ($\textsc{FT-top2}$), and adapter-tuning ($\textsc{Adapter}$).[^5] We also report the current state-of-the-art results on these datasets: On E2E, [45] uses a pragmatically informed model without pretraining. On WebNLG, [9] fine-tunes T5-large. On DART, no official models trained on this dataset version are released.[^6] For summarization, we compare against fine-tuning BART [11].

[^5]: Same implementation as [6].

[^6]: The official benchmark model is trained on v.1.0.0 while the release dataset is v1.1.1.

5.3 Architectures and Hyperparameters

For table-to-text, we use GPT-2 ${\textsc{MEDIUM}}$ and GPT-2 ${\textsc{LARGE}}$; the source tables are linearized.[^7] For summarization, we use BART $_{\textsc{LARGE}}$, [^8] and the source articles are truncated to $512$ BPE tokens.

[^7]: In comparison with natural language utterances, the linearized table is in an unnatural format, which might be challenging for pretrained LMs.

[^8]: We didn't include GPT-2 results for summarization because in our preliminary experiment, fine-tuning GPT-2 significantly underperforms fine-tuning BART on XSUM.

Our implementation is based on the Hugging Face Transformer models [46]. At training time, we use the AdamW optimizer [47] and a linear learning rate scheduler, as suggested by the Hugging Face default setup. The hyperparameters we tune include the number of epochs, batch size, learning rate, and prefix length. Hyperparameter details are in the appendix. A default setting trains for $10$ epochs, using a batch size of $5$, a learning rate of $5 \cdot 10^{-5}$ and a prefix length of $10$. The table-to-text models are trained on TITAN Xp or GeForce GTX TITAN X machines. Prefix-tuning takes $0.2$ hours per epochs to train on 22K examples, whereas fine-tuning takes around $0.3$ hours. The summarization models are trained on Tesla V100 machines, taking $1.25$ h per epoch on the XSUM dataset.

At decoding time, for the three table-to-text datasets, we use beam search with a beam size of $5$. For summarization, we use a beam size of $6$ and length normalization of $0.8$. Decoding takes $1.2$ seconds per sentence (without batching) for table-to-text, and $2.6$ seconds per batch (using a batch size of 10) for summarization.

6. Main Results

Section Summary: In table-to-text generation across three datasets, prefix-tuning with only 0.1% of a model's parameters outperforms other lightweight adaptation methods and matches the quality of full fine-tuning while using dramatically less storage. It shows particular strength in low-data regimes, generating more faithful text than fine-tuning, and scales effectively to larger models. On summarization, the approach falls modestly short of fine-tuning even when using 2% of the parameters, likely due to longer inputs and greater task complexity.

::: {caption="Table 1: Metrics (higher is better, except for TER) for table-to-text generation on E2E (left), WebNLG (middle) and DART (right). With only 0.1% parameters, Prefix-tuning outperforms other lightweight baselines and achieves a comparable performance with fine-tuning. The best score is boldfaced for both GPT-2 _MEDIUM and GPT-2 _LARGE."}

:::

6.1 Table-to-text Generation

We find that adding only 0.1% task-specific parameters, [^9] prefix-tuning is effective in table-to-text generation, outperforming other lightweight baselines ($\textsc{Adapter}$ and $\textsc{FT-top2}$) and achieving a comparable performance with fine-tuning. This trend is true across all three datasets: E2E, WebNLG, [^10] and DART.

[^9]: 250K for E2E, 250K for WebNLG, and 500K for DART vs. 345M GPT-2 parameters.

[^10]: The S, U, A columns in WebNLG represents SEEN, UNSEEN, and ALL respectively; $\underline{S}$ EEN categories appear at training time; $\underline{U}$ NSEEN categories only appears at test time; and $\underline{A}$ LL is the combination of the two.

For a fair comparison, we match the number of parameters for prefix-tuning and adapter-tuning to be 0.1%. Table 1 shows that prefix-tuning is significantly better than $\textsc{Adapter}$ (0.1%), attaining $4.1$ BLEU improvement per dataset on average. Even when we compare with fine-tuning (100%) and adapter-tuning (3.0%), which update significantly more parameters than prefix-tuning, prefix-tuning still achieves results comparable or better than those two systems. This demonstrates that prefix-tuning is more Pareto efficient than adapter-tuning, significantly reducing parameters while improving generation quality.

Additionally, attaining good performance on DART suggests that prefix-tuning can generalize to tables with diverse domains and a large pool of relations. We will delve deeper into extrapolation performance (i.e. generalization to unseen categories or topics) in Section 6.4.

Overall, prefix-tuning is an effective and space-efficient method to adapt GPT-2 to table-to-text generation. The learned prefix is expressive enough to steer GPT-2 in order to correctly extract contents from an unnatural format and generate a textual description. Prefix-tuning also scales well from GPT-2 ${\textsc{MEDIUM}}$ to GPT-2 ${\textsc{LARGE}}$, suggesting it has the potential to scale to even larger models with a similar architecture, like GPT-3.

6.2 Summarization

\begin{tabular}{lllll}
\toprule
  & R-1 $\uparrow$ & R-2 $\uparrow$ & R-L $\uparrow$ \\ \hline
\textsc{Fine-tune} [11] & 45.14 & 22.27 & 37.25 \\ 
\textsc{Prefix} (2\%) & 43.80 & 20.93 & 36.05 \\ 
\textsc{Prefix} (0.1\%) & 42.92 & 20.03 & 35.05 \\ 
\bottomrule
\end{tabular}

As shown in Table 2, with 2% parameters, prefix-tuning obtains slightly lower performance than fine-tuning (36.05 vs.@ 37.25 in ROUGE-L). With only 0.1% parameters, prefix-tuning underperforms full fine-tuning (35.05 vs. 37.25). There are several differences between XSUM and the three table-to-text datasets which could account for why prefix-tuning has comparative advantage in table-to-text: (1) XSUM contains 4x more examples than the three table-to-text datasets on average; (2) the input articles are 17x longer than the linearized table input of table-to-text datasets on average; (3) summarization might be more complex than table-to-text because it requires reading comprehension and identifying key contents from an article.

6.3 Low-data Setting

Based on the results from table-to-text (Section 6.1) and summarization (Section 6.2), we observe that prefix-tuning has a comparative advantage when the number of training examples is smaller. To construct low-data settings, we subsample the full dataset (E2E for table-to-text and XSUM for summarization) to obtain small datasets of size ${ 50, 100, 200, 500 }$. For each size, we sample $5$ different datasets and average over $2$ training random seeds. Thus, we average over $10$ models to get an estimate for each low-data setting.[^11]

[^11]: We also sample a dev split (with dev size = 30% $\times$ training size) for each training set. We use the dev split to choose hyperparameters and do early stopping.

Figure 3 (right) shows that prefix-tuning outperforms fine-tuning in low-data regimes by $2.9$ BLEU on average, in addition to requiring many fewer parameters, but the gap narrows as the dataset size increases.

Qualitatively, Figure 3 (left) shows $8$ examples generated by both prefix-tuning and fine-tuning models trained on different data levels. While both methods tend to undergenerate (missing table contents) in low data regimes, prefix-tuning tends to be more faithful than fine-tuning. For example, fine-tuning (100, 200)[^12] falsely claims a low customer rating while the true rating is average, whereas prefix-tuning (100, 200) generates a description that is faithful to the table.

[^12]: The number in the parenthesis refers to the training size.

6.4 Extrapolation

We now investigate extrapolation performance to unseen topics for both table-to-text and summarization. In order to construct an extrapolation setting, we split the existing datasets so that training and test cover different topics. For table-to-text, the WebNLG dataset is labeled with table topics. There are $9$ categories that appear in training and dev, denoted as SEEN and $5$ categories that only appear at test time, denoted as UNSEEN. So we evaluate extrapolation by training on the SEEN categories and testing on the UNSEEN categories. For summarization, we construct two extrapolation data splits[^13]: In news-to-sports, we train on news articles, and test on sports articles. In within-news, we train on ${$ world, UK, business $}$ news, and test on the remaining news categories (e.g., health, technology).

[^13]: XSUM dataset is drawn from BBC news, and we identify the topic of each article based on their URLs. Since "news" and "sports" are the two domains with the most articles, we create our first train/test split. Additionally, "news" has subdomains such as "UK", "world", and "technology". Consequently, we create a second data split, using the top 3 news subdomains as training data and the rest as test data.

::: {caption="Table 3: Extrapolation performance on XSUM. Prefix-tuning outperforms fine-tuning on both news-to-sports and within-news splits."}

:::

On both table-to-text and summarization, prefix-tuning has better extrapolation than fine-tuning under all metrics, as shown in Table 3 and the ` $U'$ columns of Table 1 (middle).

We also find that adapter-tuning achieves good extrapolation performance, comparable with prefix-tuning, as shown in Table 1. This shared trend suggests that preserving LM parameters indeed has a positive impact on extrapolation. However, the reason for such gains is an open question and we will discuss further in Section 8.

7. Intrinsic Evaluation

Section Summary: This section evaluates several design choices for prefix-tuning by comparing performance across different prefix lengths, initialization methods, and placements of trainable activations. Experiments show that performance improves with longer prefixes up to a task-dependent threshold before overfitting begins, while tuning only the embedding layer performs substantially worse than adjusting activations throughout the model. Placing trainable activations at the start of the sequence also outperforms inserting them in the middle, and initializing prefixes using real-word activations from the language model yields more stable results than random initialization, especially in low-data settings.

We compare different variants of prefix-tuning. Section 7.1 studies the impact of the prefix length. Section 7.2 studies tuning only the embedding layer, which is more akin to tuning a discrete prompt. Section 7.3 compares prefixing and infixing, which inserts trainable activations between $x$ and $y$. Section 7.4 studies the impact of various prefix initialization strategies.

7.1 Prefix Length

:::: cols="2"

Figure 4: Prefix length vs.@ performance on summerization (left) and table-to-text (right). Performance increases as the prefix length increases up to a threshold (200 for summarization and 10 for table-to-text) and then a slight performance drop occurs. Each plot reports two metrics (on two vertical axes). ::::

A longer prefix means more trainable parameters, and therefore more expressive power. Figure 4 shows that performance increases as the prefix length increases up to a threshold ($200$ for summarization, $10$ for table-to-text) and then a slight performance drop occurs.[^14]

[^14]: Prefixes longer than the threshold lead to lower training loss, but slightly worse test performance, suggesting that they tend to overfit the training data.

Empirically, longer prefixes have a negligible impact on inference speed, because attention computation over the entire prefix is parallellized on GPUs.

7.2 Full @vs Embedding-only

\begin{tabular}{lccccc}
\toprule
& \multicolumn{5}{c}{E2E}\\
  & BLEU & NIST & MET & ROUGE & CIDEr \\
\midrule
\midrule
\textsc{Prefix} & 69.7 & 8.81 & 46.1 & 71.4 & 2.49 \\
\midrule
& \multicolumn{5}{c}{Embedding-only: \textsc{Emb}-\{PrefixLength\}}\\
\textsc{Emb}-1 & 48.1 & 3.33 & 32.1 & 60.2 & 1.10 \\ 
\textsc{Emb}-10 & 62.2 & 6.70 & 38.6& 66.4 & 1.75 \\ 
\textsc{Emb}-20 & 61.9 & 7.11 & 39.3 & 65.6 & 1.85 \\ 
\midrule
& \multicolumn{5}{c}{Infix-tuning: \textsc{Infix}-\{PrefixLength\}}\\
\textsc{Infix}-1 & 67.9 & 8.63 & 45.8 & 69.4 & 2.42 \\
\textsc{Infix}-10 & 67.2 & 8.48 & 45.8 & 69.9 & 2.40 \\
\textsc{Infix}-20 & 66.7 & 8.47& 45.8 & 70.0 & 2.42\\
\bottomrule
\end{tabular}

Recall in Section 4.1, we discuss the option of optimizing the continuous embeddings of the "virtual tokens." We instantiate that idea and call it embedding-only ablation. The word embeddings are free parameters, and the upper activation layers are computed by the Transformer. Table 4 (top) shows that the performance drops significantly, suggesting that tuning only the embedding layer is not sufficiently expressive.

The embedding-only ablation upper bounds the performance of discrete prompt optimization [26], because discrete prompt restricts the embedding layer to exactly match the embedding of a real word. Consequently, we have this chain of increasing expressive power: discrete prompting

lt;$ embedding-only ablation lt;$ prefix-tuning.

7.3 Prefixing @vs Infixing

We also investigate how the trainable activations' position in the sequence affects performance. In prefix-tuning, we place them at the beginning $[\textsc{Prefix} ; x ; y]$. We can also place the trainable activations between $x$ and $y$ (i.e. $[x; \textsc{Infix};y]$) and call this infix-tuning. Table 4 (bottom) shows that infix-tuning slightly underperforms prefix-tuning. We believe this is because prefix-tuning can affect the activations of $x$ and $y$ whereas infix-tuning can only influence the activations of $y$.

7.4 Initialization

We find that how the prefix is initialized has a large impact in low-data settings. Random initialization leads to low performance with high variance. Initializing the prefix with activations of real words significantly improves generation, as shown in Figure 5. In particular, initializing with task relevant words such as "summarization" and "table-to-text" obtains slightly better performance than task irrelevant words such as "elephant" and "divide", but using real words is still better than random.

Since we initialize the prefix with activations of real words computed by the LM, this initialization strategy is concordant with preserving the pretrained LM as much as possible.

8. Discussion

Section Summary: Prefix-tuning offers practical benefits for scenarios requiring many independent models, such as personalized systems that protect user privacy by training separate prefixes without mixing data. It also enables efficient batch processing of queries from different users on shared hardware, since only the prefixes change while the underlying language model stays fixed. Additionally, by leaving most pretrained parameters untouched, the approach may improve generalization to new domains compared with full fine-tuning, though the exact reasons for its strong parameter efficiency remain an open question.

In this section, we will discuss several favorable properties of prefix-tuning and some open problems.

8.1 Personalization

As we note in Section 1, prefix-tuning is advantageous when there are a large number of tasks that needs to be trained independently. One practical setting is user privacy [7, 8]. In order to preserve user privacy, each user's data needs to be separated and a personalized model needs to be trained independently for each user. Consequently, each user can be regarded as an independent task. If there are millions of users, prefix-tuning can scale to this setting and maintain modularity, enabling flexible addition or deletion of users by adding or deleting their prefixes without cross-contamination.

8.2 Batching Across Users

Under the same personalization setting, prefix-tuning allows batching different users' queries even though they are backed by different prefixes. When multiple users query a cloud GPU device with their inputs, it is computationally efficient to put these users in the same batch. Prefix-tuning keeps the shared LM intact; consequently, batching requires a simple step of prepending the personalized prefix to user input, and all the remaining computation is unchanged. In contrast, we can't batch across different users in adapter-tuning, which has personalized adapters between shared Transformer layers.

8.3 Inductive Bias of Prefix-tuning

Recall that fine-tuning updates all pretrained parameters, whereas prefix-tuning and adapter-tuning preserve them. Since the language models are pretrained on general purpose corpus, preserving the LM parameters might help generalization to domains unseen during training. In concordance with this intuition, we observe that both prefix-tuning and adapter-tuning have significant performance gain in extrapolation settings (Section 6.4); however, the reason for such gain is an open question.

While prefix-tuning and adapter-tuning both freeze the pretrained parameters, they tune different sets of parameters to affect the activation layers of the Transformer. Recall that prefix-tuning keeps the LM intact and uses the prefix and the pretrained attention blocks to affect the subsequent activations; adapter-tuning inserts trainable modules between LM layers, which directly add residual vectors to the activations. Moreover, we observe that prefix-tuning requires vastly fewer parameters compared to adapter-tuning while maintaining comparable performance. We think this gain in parameter efficiency is because prefix-tuning keeps the pretrained LM intact as much as possible, and therefore exploits the LM more than adapter-tuning.

Concurrent work by [48] uses intrinsic dimension to show that there exists a low dimension reparameterization that is as effective for fine-tuning as the full parameter space. This explains why good accuracy on downstream task can be obtained by updating only a small number of parameters. Our work echoes the finding by showing that good generation performance can be attained by updating a very small prefix.

9. Conclusion

Section Summary: Researchers have introduced prefix-tuning as a lightweight alternative to fine-tuning for natural language generation tasks. The approach works by prepending a small set of trainable parameters to the input, which allows the model to adapt using far fewer changes overall. Experiments indicate that this method matches standard fine-tuning performance with abundant data and actually surpasses it when data is scarce or when generalizing to new conditions.

We have proposed prefix-tuning, a lightweight alternative to fine-tuning that prepends a trainable continuous prefix for NLG tasks. We discover that despite learning 1000x fewer parameters than fine-tuning, prefix-tuning can maintain a comparable performance in a full data setting and outperforms fine-tuning in both low-data and extrapolation settings.

Appendix

Section Summary: The appendix supplies extra technical details and supporting experiments for the main paper. It lists the specific hyperparameters for training the models, presents additional graphs showing how prefix-tuning compares to fine-tuning when data is scarce or when different initialization strategies are used, and includes qualitative examples from the WebNLG dataset that illustrate where each method succeeds or struggles with familiar versus novel categories. These materials help confirm the robustness of the reported findings without altering the core conclusions.

A. Supplementary Material

A.1 Hyperparameters

In Table 5, we report the hyperparameters used to train the models documented in the experiment section.

::: caption="Table 5: Hyperparameter settings for our method and baseline methods."

:::

A.2 Additional Results for Low-data Settings

Figure 6 supplements the low-data performance curves in Figure 3 by plotting the relationship between training size and generation metrics for both prefix-tuning and fine-tuning.

A.3 Additional Results for the Initialization Experiment

Figure 7 supplements Figure 3 by plotting additional metrics for our initialization technique Section 7.4. It validates that random initialization (from a uniform (0, 1) distirbution) significantly underperforms initializing with real words; Additionally, initializing with task-relevant words (e.g., "summarization" and "table-to-text") attains slightly better generation scores than initializing with task-irrelevant words (e.g., "elephant" and "banana").

A.4 Qualitative Examples for Extrapolation

Table 6 contains qualitative examples from both seen and unseen categories in WebNLG. We find that for unseen categories, both prefix-tuning and fine-tuning tend to undergenerate (generated output do not cover full table contents) or generate untruthfully (generated output is inconsistent with table contents). In particular, prefix-tuning tends to undergenerate whereas fine-tuning tends to generate untruthfully. For seen categories, both perform fairly well in terms of coverage and truthfulness.

::: {caption="Table 6: Qualitative examples from WebNLG. The first 6 examples are from the unseen categories, labeled next to source; the last two examples are from the seen categories. For unseen categories, both prefix-tuning and fine-tuning tend to undergenerate (generated output do not cover full table contents) or generate untruthfully (generated output is inconsistent with table contents). In particular, prefix-tuning tends to undergenerate more often than generate untruthfully whereas fine-tuning tends to generate untruthfully. For seen categories, both perform fairly well in terms of coverage and truthfulness."}

:::

References

Section Summary: This section compiles a numbered bibliography of academic papers that support the preceding discussion. The references focus on large-scale language models such as GPT and BERT, along with methods for efficient transfer learning, text generation, summarization, and machine translation. A smaller subset addresses related topics like privacy preservation and federated approaches to model training.

[1] A. Radford, Jeffrey Wu, R. Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners.

[2] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics.

[3] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners.

[4] Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. 2017. Learning multiple visual domains with residual adapters. In Advances in Neural Information Processing Systems, volume 30, pages 506–516. Curran Associates, Inc.

[5] Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. 2019. Parameter-efficient transfer learning for NLP. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 2790–2799, Long Beach, California, USA. PMLR.

[6] Zhaojiang Lin, Andrea Madotto, and Pascale Fung. 2020. Exploring versatile generative language model via parameter-efficient transfer learning. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 441–459, Online. Association for Computational Linguistics.

[7] Reza Shokri and Vitaly Shmatikov. 2015. Privacy-preserving deep learning. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, CCS '15, page 1310–1321, New York, NY, USA. Association for Computing Machinery.

[8] H. Brendan McMahan, Eider Moore, Daniel Ramage, and Blaise Agüera y Arcas. 2016. Federated learning of deep networks using model averaging. Proceedings of the 20 th International Conference on Artificial Intelligence and Statistics (AISTATS) 2017, abs/1602.05629.

[9] Mihir Kale. 2020. Text-to-text pre-training for data-to-text tasks.

[10] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67.

[11] Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020. BART: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7871–7880, Online. Association for Computational Linguistics.

[12] Ming Zhong, Pengfei Liu, Yiran Chen, Danqing Wang, Xipeng Qiu, and Xuanjing Huang. 2020. Extractive summarization as text matching. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 6197–6208, Online. Association for Computational Linguistics.

[13] Yang Liu and Mirella Lapata. 2019. Text summarization with pretrained encoders. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 3730–3740, Hong Kong, China. Association for Computational Linguistics.

[14] Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, and Bill Dolan. 2020c. DIALOGPT : Large-scale generative pre-training for conversational response generation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations, pages 270–278, Online. Association for Computational Linguistics.

[15] Asa Cooper Stickland, Xian Li, and Marjan Ghazvininejad. 2020. Recipes for adapting pre-trained monolingual and multilingual models to machine translation.

[16] Jinhua Zhu, Yingce Xia, Lijun Wu, Di He, Tao Qin, Wengang Zhou, Houqiang Li, and Tieyan Liu. 2020. Incorporating bert into neural machine translation. In International Conference on Learning Representations.

[17] Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. 2020. Multilingual denoising pre-training for neural machine translation.

[18] Mengjie Zhao, Tao Lin, Fei Mi, Martin Jaggi, and Hinrich Schütze. 2020. Masking as an efficient alternative to finetuning for pretrained language models.

[19] Evani Radiya-Dixit and Xin Wang. 2020. How fine can fine-tuning be? learning efficient language models. In Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pages 2435–2443, Online. PMLR.

[20] Jeffrey O Zhang, Alexander Sax, Amir Zamir, Leonidas Guibas, and Jitendra Malik. 2020a. Side-tuning: A baseline for network adaptation via additive side networks.

[21] Jonas Pfeiffer, Aishwarya Kamath, Andreas Rücklé, Kyunghyun Cho, and Iryna Gurevych. 2020. Adapterfusion: Non-destructive task composition for transfer learning.

[22] Fan-Keng Sun and Cheng-I Lai. 2020. Conditioned natural language generation using only unconditioned language model: An exploration.

[23] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized BERT pretraining approach. CoRR, abs/1907.11692.

[24] Zhengbao Jiang, Frank F. Xu, Jun Araki, and Graham Neubig. 2020. How can we know what language models know?Transactions of the Association for Computational Linguistics, 8:423–438.

[25] Timo Schick and Hinrich Schütze. 2020. Exploiting cloze questions for few shot text classification and natural language inference.

[26] Taylor Shin, Yasaman Razeghi, Robert L. Logan IV au2, Eric Wallace, and Sameer Singh. 2020. Autoprompt: Eliciting knowledge from language models with automatically generated prompts.

[27] Nishant Subramani, Samuel R. Bowman, and Kyunghyun Cho. 2020. Can unconditional language models recover arbitrary sentences?

[28] N. Keskar, B. McCann, L. R. Varshney, Caiming Xiong, and R. Socher. 2019. Ctrl: A conditional transformer language model for controllable generation. ArXiv, abs/1909.05858.

[29] Ben Krause, Akhilesh Deepak Gotmare, Bryan McCann, Nitish Shirish Keskar, Shafiq Joty, Richard Socher, and Nazneen Fatema Rajani. 2020. GeDi: Generative Discriminator Guided Sequence Generation. arXiv preprint arXiv:2009.06367.

[30] Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason Yosinski, and Rosanne Liu. 2020. Plug and play language models: A simple approach to controlled text generation. In International Conference on Learning Representations.

[31] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, pages 5998–6008. Curran Associates, Inc.

[32] Jekaterina Novikova, Ondrej Dusek, and Verena Rieser. 2017. The E2E dataset: New challenges for end-to-end generation. CoRR, abs/1706.09254.

[33] Claire Gardent, Anastasia Shimorina, Shashi Narayan, and Laura Perez-Beltrachini. 2017. The WebNLG challenge: Generating text from RDF data. In Proceedings of the 10th International Conference on Natural Language Generation, pages 124–133, Santiago de Compostela, Spain. Association for Computational Linguistics.

[34] Dragomir Radev, Rui Zhang, Amrit Rau, Abhinand Sivaprasad, Chiachun Hsieh, Nazneen Fatema Rajani, Xiangru Tang, Aadit Vyas, Neha Verma, Pranav Krishna, Yangxiaokang Liu, Nadia Irwanto, Jessica Pan, Faiaz Rahman, Ahmad Zaidi, Murori Mutuma, Yasin Tarabar, Ankit Gupta, Tao Yu, Yi Chern Tan, Xi Victoria Lin, Caiming Xiong, and Richard Socher. 2020. Dart: Open-domain structured data record to text generation.

[35] Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: A method for automatic evaluation of machine translation. In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics, ACL '02, pages 311–318, Stroudsburg, PA, USA. Association for Computational Linguistics.

[36] Anja Belz and Ehud Reiter. 2006. Comparing automatic and human evaluation of NLG systems. In 11th Conference of the European Chapter of the Association for Computational Linguistics, Trento, Italy. Association for Computational Linguistics.

[37] Alon Lavie and Abhaya Agarwal. 2007. Meteor: An automatic metric for mt evaluation with high levels of correlation with human judgments. In Proceedings of the Second Workshop on Statistical Machine Translation, StatMT '07, pages 228–231, Stroudsburg, PA, USA. Association for Computational Linguistics.

[38] Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out, pages 74–81, Barcelona, Spain. Association for Computational Linguistics.

[39] Ramakrishna Vedantam, C. Lawrence Zitnick, and Devi Parikh. 2015. Cider: Consensus-based image description evaluation.In CVPR, pages 4566–4575. IEEE Computer Society.

[40] Matthew Snover, Bonnie Dorr, Richard Schwartz, Linnea Micciulla, and Ralph Weischedel. 2006. A study of translation error rate with targeted human annotation. In In Proceedings of the Association for Machine Transaltion in the Americas (AMTA 2006.

[41] Wei Zhao, Maxime Peyrard, Fei Liu, Yang Gao, Christian M. Meyer, and Steffen Eger. 2019. MoverScore: Text generation evaluating with contextualized embeddings and earth mover distance. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 563–578, Hong Kong, China. Association for Computational Linguistics.

[42] Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q. Weinberger, and Yoav Artzi. 2020b. BERTScore: Evaluating text generation with bert. In International Conference on Learning Representations.

[43] Thibault Sellam, Dipanjan Das, and Ankur Parikh. 2020. BLEURT: Learning robust metrics for text generation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7881–7892, Online. Association for Computational Linguistics.

[44] Shashi Narayan, Shay B. Cohen, and Mirella Lapata. 2018. Don't give me the details, just the summary! Topic-aware convolutional neural networks for extreme summarization. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, Brussels, Belgium.

[45] Sheng Shen, Daniel Fried, Jacob Andreas, and Dan Klein. 2019. Pragmatically informative text generation. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4060–4067, Minneapolis, Minnesota. Association for Computational Linguistics.

[46] Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander M. Rush. 2020. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 38–45, Online. Association for Computational Linguistics.

[47] Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In International Conference on Learning Representations.

[48] Armen Aghajanyan, Luke Zettlemoyer, and Sonal Gupta. 2020. Intrinsic dimensionality explains the effectiveness of language model fine-tuning.