General Purpose Text Embeddings from Pre-trained Language Models for Scalable Inference

04/29/2020 ∙ by Jingfei Du, et al. ∙ Facebook 0

The state of the art on many NLP tasks is currently achieved by large pre-trained language models, which require a considerable amount of computation. We explore a setting where many different predictions are made on a single piece of text. In that case, some of the computational cost during inference can be amortized over the different tasks using a shared text encoder. We compare approaches for training such an encoder and show that encoders pre-trained over multiple tasks generalize well to unseen tasks. We also compare ways of extracting fixed- and limited-size representations from this encoder, including different ways of pooling features extracted from multiple layers or positions. Our best approach compares favorably to knowledge distillation, achieving higher accuracy and lower computational cost once the system is handling around 7 tasks. Further, we show that through binary quantization, we can reduce the size of the extracted representations by a factor of 16 making it feasible to store them for later use. The resulting method offers a compelling solution for using large-scale pre-trained models at a fraction of the computational cost when multiple tasks are performed on the same text.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Large pre-trained language models achieve state-of-the-art performance on many Natural Language Processing (NLP) tasks 

Peters et al. (2018); Radford et al. (2018); Devlin et al. (2019). However, inference for these models requires significant computational resources, which limits their practical use. Recent trends show that scaling models up Liu et al. (2019b); Lan et al. (2019); Raffel et al. (2019); Li et al. (2020) in terms of computation still improves end task performance, raising questions about whether and how the most accurate models can be applied in real-world settings.

This computational burden is further exacerbated by the need to fine-tune end-to-end a separate model for each task. Since each model has a new set of parameters, none of the computation can be shared by models for different tasks during inference. This is particularly inefficient in real-world settings that require making multiple predictions about each input. For example, given a news article, we may want to predict its topic Zhang et al. (2015), sentiment Pang and Lee (2004); Maas et al. (2011); Socher et al. (2013); Zhang et al. (2015), overall text quality Pitler and Nenkova (2008), whether it is humorous Yang et al. (2015) or offensive Schmidt and Wiegand (2017); Zampieri et al. (2019) and so on.

Knowledge Distillation (KD) is one way of reducing the computation required by large pre-trained LMs Hinton et al. (2015); Sanh et al. (2019). However, there is a sizeable gap in accuracy between the best models using knowledge distillation and the full fine-tuned models. Another way of speeding up computation is through system optimizations such as quantization and operator fusion Zafrir et al. (2019). These techniques can reduce the amount of computation significantly, but may not be sufficient by themselves and can be combined with the methods we discuss.

(a) Single-task finetuning.
(b) Multi-task pre-training.
(c) Leave-one-task-out finetuning.
Figure 1: An illustration of the finetuning approaches explored in this work. (a) In single-task finetuning, an encoder model is fine-tuned end-to-end for a given task. (b) In multi-task pre-training, an encoder model is jointly trained over tasks, each with their own classification head. (c) In leave-one-task-out finetuning, a multi-task encoder is frozen and used to extract features for an unseen () task. Following Peters et al. (2019), we use and to denote components that are fine-tuned for each task or frozen, respectively.

In this paper we look at new ways to make inference computationally efficient focusing on the case where different models (models for different tasks) are run over the same piece of text. We propose new methods to run multiple task-specific models in a way that amortizes the computation over the different tasks. The central idea is to compute the activations for the full model once and use smaller task-specific models on top of it. We explore three possible ways for sharing computation.

The first solution is inspired by work on general purpose text encoders Kiros et al. (2015); Hill et al. (2016); Conneau et al. (2017); Subramanian et al. (2018), which produce fixed-size representations (i.e., sentence embeddings) that can be shared across tasks. We add only small task-specific layers on top of these fixed-size representations so that the computational cost is dominated by the encoder, which is amortized over tasks. Unfortunately, when evaluated on unseen tasks, we find that models that rely on fixed-size representations often underperform single-task baselines by a large margin, in agreement with past work Subramanian et al. (2018); Peters et al. (2019); Raffel et al. (2019); Wang et al. (2019a).

The second solution is a multi-task system Caruana (1997); Collobert and Weston (2008); Ruder (2017), where a single model is jointly trained to handle many tasks (see Figure 0(b)). If most layers are shared, the overall inference cost can be nearly times less than for separate single-task models, while providing competitive task accuracy Liu et al. (2019a); Raffel et al. (2019); Wang et al. (2019a). However, multi-task systems work best when the set of tasks is known in advance, since adding new tasks typically requires retraining the multi-task model and reincurring inference costs, thus limiting the usefulness of this approach in real-world systems where new classification tasks may be introduced periodically.

We propose a third solution: a multi-task encoder that is shared across tasks and produces limited-size representation that grow with the length of the input, similar to contextualized word representations Peters et al. (2018). We evaluate our representations on 14 text classification tasks using a leave-one-task-out evaluation protocol (see Figure 0(c)), where a multi-task encoder model is trained on tasks, frozen and used as a static feature extractor for an unseen task.111We consider a task to be synonymous with a dataset. We find an important ingredient to performing well on an unseen () task is to extract features from multiple layers and positions of the encoder. Ultimately, our general purpose encoders offer a better tradeoff between task accuracy and inference cost than either fixed-size representations or distilled models, while requiring minimal additional inference cost to handle new tasks.

We also consider the case in which not all of the predictions can be done at the same time and intermediate representations have to saved. In that context, we study the relationship between representation size and end-task performance. We find that features extracted by our encoders are amenable to heavy quantization enabling a 16x reduction in the size of the extracted features with negligible impact on unseen task performance.

2 Related Work

Self-supervised pre-training, typically through language modeling, has advanced the state of the art for many NLP tasks Peters et al. (2018); Radford et al. (2018); Devlin et al. (2019). There are two dominant ways of adapting pre-trained models to downstream tasks: (1) finetuning, which often results in the best accuracy Devlin et al. (2019); and (2) feature extraction, which can be significantly more efficient during inference when there are multiple end tasks. Peters et al. (2019) compare these and find finetuning outperforms feature extraction for BERT; however, they use features immediately after pre-training, whereas we also consider features after multi-task finetuning.

Multi-task learning (MTL)

has a rich history in machine learning 

Caruana (1997); Ruder (2017) and NLP Collobert and Weston (2008); Luong et al. (2016). Multi-task models can potentially leverage similarities across tasks to achieve higher end-task accuracy than single-task models Clark et al. (2019); Liu et al. (2019a); Phang et al. (2018); Wang et al. (2019a). Compared to single-task models, a multi-task model can also be more efficient during inference by sharing computation across tasks. Most work in multi-task learning assumes that the set of end-tasks is fixed and known in advance and training is performed for all tasks together. This set-up can present challenges in the real world where tasks may require different retraining schedules and new tasks may be frequently added or removed.

General purpose text encoders are usually pre-trained with a mix of supervised and self-supervised training objectives and produce fixed-size representations Kiros et al. (2015); Hill et al. (2016); Conneau et al. (2017); Subramanian et al. (2018). Unlike multi-task learning, general purpose text encoders are typically evaluated on unseen tasks, which is more representative of real-world settings in which new tasks may be added periodically. Unfortunately, these approaches often underperform single-task baselines McCann et al. (2018); Liu et al. (2019a); Wang et al. (2019a).

Another line of work has explored adapting pre-trained models by adding additional task-specific capacity at each layer Houlsby et al. (2019), however these methods do not improve inference efficiency since there is no task-independent computation that can be shared across tasks.

Knowledge Distillation Buciluǎ et al. (2006); Hinton et al. (2015) is a compression technique where a more efficient student model is trained to mimic the behaviour of a larger or ensembled teacher model. A knowledge distilled version of BERT Sanh et al. (2019) has been proposed to reduce the computation required by these large pre-trained language models. However there is still a sizeable gap in terms of accuracy where DistilRoBERTa reaches 95% of RoBERTa-base’s performance on GLUE while being twice faster.

Quantization and other compression techniques have been explored for word embeddings Shu and Nakayama (2017); Tissier et al. (2019) and sentence embeddings Shen et al. (2019). Recent work has also explored quantization for contextualized word representations, generally showing that quantization-aware training is necessary to achieve reasonable end task performance Zafrir et al. (2019); Fan et al. (2020). Quantization is complementary to the approaches we consider and is explored more in Section 5.

3 Experimental Setup

Our goal is to develop text encoders that produce representations which achieve high accuracy for multiple task with little task-specific processing. We first introduce our tasks, encoder models and finetuning framework.

3.1 Tasks

task type # train # dev # label
MNLI nli 393K 20K 3
QNLI nli 105K 5.4K 2
QQP pp 364K 391K 2
RTE nli 2.5K 3K 2
SST-2 sa 17K 1.8K 2
MRPC pp 3.7K 1.7K 2
CoLA la 8.5K 1K 2
AG-news doc 120K 7.6K 4
Amazon-5 sa 3M 650K 5
Amazon-2 sa 3.6M 400K 2
Yelp-5 sa 650K 50K 5
Yelp-2 sa 560K 38K 2
DBpedia doc 560K 70K 14
Table 1: Task statistics.

We consider 14 text classification tasks, spanning sentiment analysis (

sa), natural language inference (nli), paraphrase identification (pp), document categorization (doc) and linguistic acceptability (la). Tasks are chosen for their diversity and usage in recent related work, ensuring that our baselines are representative of the state of the art.

Full details about each task is given in Table 1. The sa, doc and la tasks require making predictions about a single text input, while nli and pp

tasks require classifying a pair of text inputs. For pair tasks we concatenate the text with a special separator token following

Liu et al. (2019b). Since many of our tasks are part of evaluation benchmarks such as GLUE Wang et al. (2019b) and the test sets are not publicly available, we report accuracy on the corresponding development sets.

3.2 Encoder models

Our encoder models are based on RoBERTa Liu et al. (2019b), an optimized version of BERT Devlin et al. (2019) that achieves competitive performance on most of the tasks considered in this work. We primarily use the public RoBERTa model consisting of 24 Transformer layers Vaswani et al. (2017), 1024 dimensional representations and 355M parameters. We refer the reader to Devlin et al. (2019) for more details about the BERT architecture and Liu et al. (2019b) for more details about RoBERTa.

We also consider a Knowledge Distilled (KD) version of RoBERTa called DistilRoBERTa Sanh et al. (2019), which consists of 6 Transformer layers, 768-dim representations and 82M parameters. The distilled model contains 1/4 as many parameters and requires 1/7 as much computation (FLOPs) as the full model. We present a more detailed comparison of the computational requirements for these encoder models in Section 6.5.

3.3 Fine-tuning

We consider two methods for finetuning encoder models, illustrated in Figure 1.

3.3.1 Single-task finetuning

Single-task finetuning is the most common way of adapting pre-trained language models to a given task (see Figure 0(a)). When applied to large pre-trained models (e.g., RoBERTa) single-task finetuning often results in the best end-task accuracy, but requires the full model to be run for every task and thus has the highest inference costs for a set of tasks. Computation can be reduced by using a smaller pre-trained models—including knowledge distilled models (e.g., DistilRoBERTa).

Single-task finetuning serves as our baseline finetuning method. Our goal is to achieve similar accuracy as large single-task models with reduced inference costs.

3.3.2 Leave-one-task-out finetuning

We also consider leave-one-task-out finetuning, illustrated in Figures 0(b) and 0(c). A multi-task encoder is pre-trained on tasks, then frozen and used as a feature extractor for a task. Freezing the encoder allows us to amortize the inference cost over all tasks. The leave-one-task-out setup allows us to evaluate generalization on tasks unseen in the training of the encoder. This replicates the real-world setting of adding new tasks to an existing frozen encoder. Leave-one-task-out finetuning has two stages:

1. Multi-task pre-training: We train a single model end-to-end over tasks (Figure 0(b)). The majority of the encoder weights are shared across tasks, except for a classification head (see Section 3.4) that is unique to each task.

It is important for the multi-task model to properly weight the training data for different tasks, so that larger tasks do not dominate smaller ones Raffel et al. (2019); Wang et al. (2019a). We adopt a loss-reweighting technique inspired by Raffel et al. (2019). At each step, we sample a batch of data for every task and update our model according to a weighted sum of the losses. Each task’s loss is weighted according to: , where is the number of training examples for task and is a temperature controlling the uniformity of the weights. When , task weights are proportional to data size, and as , task weights become more uniform. We use a fixed temperature of , which performed best in early experiments.

2. Leave-one-task-out finetuning: In the second stage, we freeze the multi-task encoder’s weights and use it as a feature extractor for an unseen task (see Figure 0(c)). The extracted features are fed to a new, randomly initialized classification head, which is fine-tuned over the training data for the task. We repeat this process times, with each task held out once, and report the corresponding held-out task performance.

3.4 Classification heads

Each task has a classification head that takes the pooled features as input and makes a prediction. While related work incorporates custom task-specific classification layers Peters et al. (2018, 2019); Liu et al. (2019a), we adopt a unified architecture for all tasks. We follow the original BERT setup Devlin et al. (2019)

and use a two-layer Multi-Layer Perceptron (MLP) with inner dimension equal to the pooled feature dimension and a

tanhactivation function. The classification head is always fine-tuned for the end task.

4 Feature extraction and pooling

Figure 2: Features are extracted from multiple encoder layers, pooled across layers, then positions, and finally passed to a task-specific classification head. Some feature extraction and pooling approaches have additional task-specific parameters that require finetuning.

The most common way of extracting features from BERT-like models is by taking the representation of the last Transformer layer corresponding to the special CLS token prepended to the input text sequence Devlin et al. (2019). More recent work has also explored extracting features from every position and layer, and then linearly combining the layers with task-specific weights Peters et al. (2019); Tenney et al. (2019).

We propose a more general framework for extracting features, shown in Figure 2. We extract features from several layers of the encoder and then pool them, first across layers and then across positions, before feeding them to a task-specific classification head. This framework subsumes both the CLS token and weighted layer combination approaches. We consider several ways of layer-wise pooling and position-wise pooling:

Layer-wise pooling approaches:
  • [leftmargin=*]

  • last-layer: only use the last layer. This setting is used by Devlin et al. (2019).

  • layer-avg: average the last layers. We tune for each setting, but find that works best in most cases.

  • learned-comb: learn a task-specific weighted combination over all layers. This setting is used by Peters et al. (2019) and Tenney et al. (2019).

Figure 3: Our proposed multi-head attention pooler. The extracted features are frozen () and used as both the keys (K) and values (V). Each task has its own query (Q), multi-head attention module and classification head, all of which are fine-tuned ().

Position-wise pooling approaches:

  • [leftmargin=*]

  • cls: extract features from the first position. This setting is used by Devlin et al. (2019).

  • position-avg: average features across positions.

  • mha: pool features with a task-specific Multi-Head Attention (MHA) layer Devlin et al. (2019). We learn a task-specific query and use features as the keys and values (see Figure 3).

5 Storage Considerations and Quantization

In a real-world settings it may be necessary to store extracted features for later use, such as when new tasks are introduced that require “backfilling” classifications for older content Shen et al. (2020). Storage costs quickly become impractical when pooling over multiple hidden layers and positions (cf. Section 4). For example, some of the methods that we experiment with require using the features from every layer and position in the encoder. For RoBERTa, with 24 layers and 1024 dimension representations, a 50 token input would thus emit 50*24*1024 half-precision floating point numbers and require 2.3MB of storage!

We consider quantization methods, described below, for reducing the storage costs associated with extracted features. We will show in Section 6 that extracted features are surprisingly robust: they show little degredation in end-task accuracy even with binary quantization.

With quantization, we replace floating point numbers with alternative representation formats that have reduced bit width. For example, recent work has shown that the BERT model weights and activations can be quantized down to 8-bit integers with minimal affect on downstream task accuracy Zafrir et al. (2019).

We explore both 8-bit (uint8) and 1-bit (boolean) quantization of our extracted features. We apply quantization prior to leave-one-task-out finetuning (see Section 3.3.2

) to simulate a real-world setting in which only the quantized features are available. For 8-bit quantization, we use PyTorch 

Paszke et al. (2019) to learn scale and zero-point parameters which allow us to map floating point numbers to the range 0-255. For 1-bit quantization, we simply apply the sign

function to binarize each feature dimension.

Table 2

shows estimated storage costs for various pooling methods before and after quantization.

layer-wise position-wise fp16 int8 bool
pooling pooling
cls or 2K 1K 128
mha 100K 50K 6K
mha 2.3M 1.2M 150K
Table 2: Estimated storage cost (in bytes) to store features for a 50 token input for various pooling, quantization methods.

6 Results and Discussion

model G FLOPs sa nli pp doc la average
(a) Single-task finetuning (end-to-end):
BERT - 86.8 83.1 89.7 97.1 83.1 87.6
XLNet - 87.6 89.2 90.5 97.4 84.5 89.5
DistilRoBERTa 61 86.6 80.7 89.6 97.1 84.3 87.1
RoBERTa 430 88.2 91.3 91.8 97.4 86.3 90.5
 + leave-one-task-out multi-task 430 88.2 91.6 92.1 97.4 87.2 90.7
(b) Single-task finetuning (frozen encoder):
 + last-layer / cls 31 80.8 58.8 68.2 94.9 69.1 75.5
 + last-layer / position-avg 31 80.3 63.0 75.6 95.0 75.0 77.7
 + last-layer / mha 34 86.1 72.7 79.0 96.7 80.2 83.3
 + layer-avg / mha 34 86.9 77.7 83.0 96.9 82.7 85.5
 + learned-comb / mha 34 87.0 78.0 82.8 96.9 82.5 85.6
(c) Leave-one-task-out finetuning (frozen multi-task encoder):
 + last-layer / cls 31 87.4 82.8 81.8 94.9 76.4 85.9
 + last-layer / position-avg 31 87.4 83.0 81.9 95.1 77.1 86.0
 + last-layer / mha 34 87.5 84.6 83.5 96.2 77.2 86.8
 + layer-avg / mha 34 87.9 87.8 85.7 96.8 82.4 88.4
 + learned-comb / mha 34 87.9 87.9 85.7 96.9 82.3 88.5
RoBERTa (8-bit quantization)
 + layer-avg / mha 34 87.9 87.7 85.7 96.8 82.6 88.4
RoBERTa (1-bit quantization)
 + layer-avg / mha 34 87.8 87.1 84.6 96.6 81.3 88.0
(d) Leave-one-task-group-out finetuning (frozen multi-task encoder):
 + layer-avg / mha 31 87.0 81.3 85.3 96.7 82.4 86.6
(e) Multi-task pre-training over all tasks (frozen multi-task encoder; no additional finetuning):
 + last-layer / cls 31 87.7 89.6 89.3 97.2 82.6 89.3
Table 3: Results on 14 tasks, grouped by task type (see Section 3.1). We consider different layer-wise and position-wise pooling strategies introduced in Section 4. We also report the estimated inference cost for 14 tasks (in G FLOPs) for each strategy. Bold results indicate the most accurate method in each section. BERT results are from Yang et al. (2019) and Sun et al. (2019). XLNet results are from Yang et al. (2019). DistilRoBERTa and RoBERTa results are recomputed ourselves. Full results for each task is given in the Appendix. (*) we recomputed accuracy for CoLA, since BERT and XLNet originally reported a different metric.

Table 3 presents our main results for the 14 tasks introduced in Section 3.1. Detailed results of all tasks are included in Table 4 in Appendix.

6.1 Baselines

Table 3 (a) shows results for models fine-tuned end-to-end on a single task. This approach yields the best end-task accuracy but has the highest inference costs (see discussion in Section 3.3.1).

We observe that the distilled RoBERTa model (DistilRoBERTa) achieves competitive accuracy across many tasks with only 1/4 as many parameters and requiring only 1/7 of the computation of the full RoBERTa model. Multi-task pre-training (see Section 3.3.2) prior to single-task finetuning improves results with an average gain of +0.2%. This is consistent with recent work Liu et al. (2019a); Wang et al. (2019a)

, but somewhat at odds with the findings of 

Raffel et al. (2019), who report slightly worse performance with multi-task pre-training. It remains an open question under what conditions multi-task pre-training improves end task accuracy for single-task models.

6.2 Feature extraction and pooling

6.2.1 Without multi-task pre-training

Table 3 (b) shows results for single-task models where the encoder is frozen and only the classification head is fine-tuned. We can use these results to compare to the pooling approaches described in Section 4 that include an intermediate multi-task pre-training step.

We first observe that freezing the pre-trained RoBERTa model and extracting features from the last layer’s CLS token performs quite poorly, with a 15% drop in accuracy compared to the end-to-end fine-tuned version (90.5% 75.5%). This is not too surprising, since the CLS token is not heavily used in the RoBERTa pre-training process Liu et al. (2019b).222Unlike BERT Devlin et al. (2019), RoBERTa does not pre-train with a Next Sentence Prediction (NSP) objective, thus the CLS token is mostly unused. If we instead average the features across all positions in the last layer, we see slightly higher accuracy compared to using the CLS token alone (77.7% vs. 75.5%), while our multi-head attention (MHA) pooling further improves accuracy to 83.3%, confirming the importance of task-specific position-wise pooling.

We next consider different layer-wise pooling strategies, still using the MHA position-wise pooling. Taking a simple average over the top 16 layers improves accuracy by +2.2% compared to using just the last layer (85.5% vs. 83.3%). If we instead learn a task-specific weighted combination of layers, similar to Peters et al. (2019), we gain an additional +0.1% compared to using a simple average. However, using a task-specific combination of layers introduces significant storage costs (see Table 2), thus we focus on the layer-avg pooling approach in the rest of our experiments.

6.2.2 With leave-one-task-out multi-task pre-training

Table 3 (c) presents results for various pooling approaches after multi-task pre-training (Section 3.3.2), in which the encoder is fine-tuned on tasks prior to being frozen.

In this setting, we observe that the last layer’s CLS token now encodes quite a lot of general task information, achieving a higher average accuracy than any of the frozen encoders that did not have leave-one-task-out multi-task pre-training (85.9% vs. 85.6%). As before, our multi-head attention (MHA) position-wise pooling strategy performs best, outperforming the CLS approach by +0.9% and the position-avg strategy by +0.8%. Layer-wise pooling across multiple layers provides an additional 1.6-1.7% gain.

6.3 Quantization

Table 3 (c) shows the effect of quantization on task accuracy. We quantize extracted features after leave-one-task-out multi-task pre-training and use layer-avg / mha pooling, which offers the best balance between storage efficiency and accuracy. In early experiments, we considered whether to quantize before or after layer-wise pooling and found that quantization before layer-wise pooling was slightly better for 1-bit quantization and had no impact on 8-bit quantization.

We can see that with 8-bit quantization, we don’t have any performance loss. Most surprisingly, with our 1-bit quantization method of simply applying the sign function on the extracted features, the average accuracy drops by only 0.4%, while reducing the storage cost by a factor of 16 (to just 1024 bits per token) and still outperforming distillation-based methods (88.0% vs. 87.1%).

6.4 Generalization

So far we have considered encoder models evaluated in a leave-one-task-out setting, which allows us to evaluate generalization to unseen tasks. Another setting of potential interest is the case where an entire task type (see Section 3.1) is held out during multi-task pre-training, e.g., an encoder may be pre-trained over all non-NLI tasks and then frozen and evaluated on NLI tasks. We present these results in the fourth section of Table 3 (d). We observe that performance drops considerably from the corresponding leave-one-task-out setting (Table 3 (c)), with average accuracy decreasing from 88.4% to 86.6%. Notably, accuracy on NLI tasks decreases the most from 87.8% to 81.3%, consistent with past work showing significant positive transfer effects between NLI tasks Phang et al. (2018). Thus, it seems important to pre-train the encoder over a variety of task types to maximize generalization on new tasks.

Another setting of interest is the case where the encoder is pre-trained over all tasks, then frozen and evaluated directly on each task without any additional finetuning. While this setting does not measure generalization to unseen tasks, it may be suitable in settings where the set of tasks is known in advance. We present these results in the final section of Table 3 (e). We observe that this system performs 3.4% better than a comparable system pre-trained over tasks and evaluated on an unseen task (89.3 vs. 85.9).

6.5 Computational cost during inference

Table 3 reports cumulative inference cost (over 14 tasks) for each method. Single-task finetuning is the least computationally efficient approach, although it achieves the highest average accuracy (90.7%). Approaches based on frozen encoders reduce FLOPs by an order of magnitude, but have lower end task accuracy and extracted features may consume non-negligible storage (cf. Table 2).

Figure 4: Estimated computational cost (in FLOPs) to run RoBERTa inference for tasks over a single input. The cost for single-task models grows linearly with the number of tasks, whereas approaches based on a frozen encoder are much more efficient. Distilled models are particularly efficient when the number of tasks is small, but the cost scales linearly and becomes less efficient than a frozen encoder when the number of tasks .

In Figure 4 we show the number of FLOPs required for inference as a function of the number of tasks performed on the same text. While single-task finetuning of the full model is never efficient, distilled models are in fact more efficient for systems with 7 or fewer tasks. On the other hand, frozen encoder approaches become significantly more efficient in systems with more than 7 tasks.

7 Conclusion

We study ways to make large-scale pre-trained models usable in practical settings. We show that when several tasks need to be performed on a single piece of text, the computation can be effectively amortized reducing the amount of computation per task. Compared to distillation approaches, the shared computation method achieves higher accuracy and the total computational cost becomes smaller after about 7 tasks. Further, we show that the shared features can be quantized with very little loss in accuracy, which means that the intermediate computation can be stored for later use. In total, the techniques that we present provide the best alternative for running large-scale pre-trained models in practical applications when multiple predictions are made on the same piece of text.


Appendix A Detail Results

Model MNLI QNLI QQP RTE SST2 MRPC CoLA IMDB AG Amzn5 Amzn2 Yelp5 Yelp2 DBpd Avg
(a) Single-task finetuning (end-to-end):
BERT 86.6 92.3 91.3 70.4 93.2 88.0 83.1 95.5 94.8 65.8 97.4 70.7 98.1 99.4 87.6
XLNet 89.8 93.9 91.8 83.8 95.6 89.2 84.5 96.2 95.5 67.7 97.4 70.7 98.1 99.4 89.5
DistilRoBERTa 83.9 91.0 91.2 67.2 93.5 88.0 84.3 94.4 94.9 66.3 97.1 70.5 97.9 99.3 87.1
RoBERTa 90.3 94.6 92.3 88.9 96.7 91.3 86.3 96.4 95.4 67.9 97.6 71.9 98.4 99.3 90.5
 + leave-one-task-out multi-task 90.3 94.6 92.2 89.9 96.7 92.1 87.2 96.6 95.5 68.0 97.6 72.2 98.4 99.3 90.7
(b) Single-task finetuning (frozen encoder):
 + last-layer / cls 55.7 67.4 67.4 53.3 84.0 69.0 69.1 89.1 91.0 58.2 94.6 62.7 96.2 98.7 75.5
 + last-layer / position-avg 56.7 72.7 80.3 59.7 88.1 70.9 75.0 87.2 91.5 57.3 93.7 60.6 95.0 98.4 77.7
 + last-layer / mha 75.7 81.6 86.0 60.7 92.5 71.9 80.3 94.3 94.1 65.1 96.9 69.9 98.0 99.3 83.3
 + layer-avg / mha 83.1 87.3 88.1 62.8 94.3 77.9 82.7 95.5 94.4 65.9 97.2 70.6 98.2 99.3 85.5
 + learned-comb / mha 83.4 87.4 88.1 63.1 94.4 77.4 82.5 95.5 94.5 66.0 97.2 70.8 98.2 99.3 85.6
(c) Leave-one-task-out finetuning (frozen multi-task encoder):
 + last-layer / cls 76.2 84.3 84.7 87.8 94.0 78.8 76.4 96.7 90.7 66.4 97.6 71.2 98.7 99.1 85.9
 + last-layer / position-avg 76.3 84.6 84.7 88.2 93.8 79.1 77.1 96.7 91.1 66.3 97.6 71.0 98.7 99.0 86.0
 + last-layer / mha 79.8 87.6 86.2 86.5 94.1 80.8 77.2 96.7 93.2 66.5 97.6 71.5 98.7 99.2 86.8
 + layer-avg / mha 86.6 91.6 88.7 85.1 96.0 82.7 82.4 96.7 94.4 66.8 97.6 71.7 98.7 99.3 88.4
 + learned-comb / mha 87.0 91.7 88.8 85.1 96.1 82.7 82.3 96.7 94.4 66.8 97.6 71.8 98.7 99.3 88.5
RoBERTa (8-bit quantization)
 + layer-avg / mha 86.7 91.5 88.6 85.1 96.0 82.7 82.6 96.7 94.4 66.7 97.6 71.6 98.7 99.3 88.4
RoBERTa (1-bit quantization)
 + layer-avg / mha 85.5 90.8 88.2 85.1 95.8 81.0 81.3 96.5 93.9 66.6 97.6 71.4 98.7 99.3 88.0
(d) Leave-one-task-group-out finetuning (frozen multi-task encoder):
 + layer-avg / mha 85.2 90.4 88.7 68.3 94.3 82.0 82.4 95.6 94.2 65.8 97.2 70.6 98.2 99.3 86.6
(e) Multi-task pre-training over all tasks (frozen multi-task encoder; no additional finetuning):
 + last-layer / cls 89.3 93.7 89.6 85.9 94.8 89.0 82.6 96.7 95.1 66.5 97.5 71.9 98.6 99.3 89.3
Table 4: Extended results table for all 14 tasks. See Table 3 for more details.

The results for all setups over 14 tasks can be found in Table 4.