Parameter-efficient Multi-task Fine-tuning for Transformers via Shared Hypernetworks

Introduction

Transfer learning from pretrained large-scale language models yields state-of-the-art results in a variety of tasks (Devlin et al., 2019; Radford et al., 2018; Liu et al., 2019b). As a highly expressive and abstract framework, Raffel et al. (2020) explored the landscape of transfer learning by converting text-based natural language processing (NLP) problems into a sequence-to-sequence format to train a unified model on several tasks simultaneously. Multi-task learning with pretrained language models Ruder (2017) is appealing for multiple reasons: 1) Training individual models per task results in higher computational costs, which hinders deployment and maintenance. These costs are substantially reduced by training a single model. 2) Fine-tuning the model across multiple tasks allows sharing information between the different tasks and positive transfer to other related tasks. Specifically, when target datasets have limited training data, multi-task learning improves the performance compared to individually trained models (Liu et al., 2019a; Ratner et al., 2018). However, multi-task fine-tuning can result in models underperforming on high-resource tasks due to constrained capacity Arivazhagan et al. (2019); McCann et al. (2018). An additional issue with multi-task fine-tuning is the potential for task interference or negative transfer, where achieving good performance on one task can hinder performance on another (Wang et al., 2019c).

As an alternative to fine-tuning Howard and Ruder (2018), adapter layers (Houlsby et al., 2019) insert a small number of additional parameters per task into the model. During fine-tuning, only the adapter modules, layer normalizations, and parameters of the final classification layer are updated, while the original pretrained model parameters remain frozen. Such task-specific adapters eliminate negative task interference by encapsulating task-specific information Pfeiffer et al. (2020). However, so far there has not been an effective and parameter-efficient way to share information across multiple adapters to enable positive transfer to low-resource and related tasks.

To address this problem and to enable sharing information across tasks while reaping the benefits of adapter layers, as depicted in Figure 1, we propose HyperFormer++, which employs a compact hypernetwork Ha et al. (2017); Oswald et al. (2020) shared across tasks and layers. The hypernetwork learns to generate task and layer-specific adapter parameters, conditioned on task and layer id embeddings. The hypernetwork is jointly learned between all tasks and is thus able to share information across them, while negative interference is minimized by generating separate adapter layers for each task. For each new task, our model only requires learning an additional task embedding, reducing the number of trained parameters.

We use the encoder-decoder T5 model (Raffel et al., 2020) as the underlying model for our experiments and evaluate on the standard GLUE benchmark Wang et al. (2019b). We achieve strong gains over both the T5BASE model as well as adapters (Houlsby et al., 2019). To our knowledge, this is the first time that adapters have been successfully integrated into a state-of-the-art encoder-decoder model beyond machine translation Bapna and Firat (2019), demonstrating that our method effectively balances sharing information across tasks while minimizing negative transfer.

In summary, we make the following contributions: (1) We propose a parameter-efficient method for multi-task fine-tuning based on hypernetworks and adapter layers. (2) We demonstrate that our method scales more efficiently than prior work. (3) We provide empirical results on GLUE demonstrating the effectiveness of the proposed method on multi-task learning. (4) We perform extensive few-shot domain transfer experiments, which reveal that the captured shared knowledge can positively transfer to unseen in-domain tasks. We release our code to facilitate future work.

HyperFormer

In this section, we present our HyperFormer model, which integrates hypernetwork-based adapter layers into a multi-task transformer model. In §2.4, we introduce a parameter-efficient variant of this model, called HyperFormer++ ​.

We consider a general multi-task learning problem, where we are given the data from a set of tasks $\{\mathcal{D}_{\tau}\}_{\tau=1}^{T}$, where $T$ is the total number of tasks and $\mathcal{D}_{\tau}=\{(\bm{x_{\tau}^{i}},y_{\tau}^{i})\}_{i=1}^{N_{\tau}}$ shows the training data for $\tau$-th task with $N_{\tau}$ samples. We assume we are also given a large-scale pretrained language model $f_{\bm{\theta}}(.)$ parameterized by $\bm{\theta}$ that computes the output for input $\bm{x_{\tau}^{i}}$. Standard multi-task fine-tuning minimizes the following loss on the training set:

where $l$ is typically the cross-entropy loss, and $w_{\tau}$ shows the sampling weight for $\tau$-th task. Our goal is to finetune the pretrained model in a multi-task learning setup efficiently, while allowing sharing information across tasks and at the same time, enabling the model to adapt to each individual task.

The key idea of our approach, depicted in Figure 1, is to learn a parametric task embedding $\{\bm{I_{\tau}}\}_{\tau=1}^{T}$ for each task, and then feed these task embeddings to hypernetworks parameterized by $\bm{\nu}$ that generate the task-specific adapter layers (Houlsby et al., 2019). We insert adapter modules within the layers of a pretrained model, making the final model of $\mathcal{X}_{\bm{\nu}}(\bm{x_{\tau}^{i}},\bm{\theta},\bm{I_{\tau}})$ parameterized by $\bm{\nu}$ that computes the output for input $\bm{x_{\tau}^{i}}$. During training, we only train hypernetwork parameters $\bm{\nu}$, task embeddings $\{\bm{I_{\tau}}\}_{\tau=1}^{T}$, and layer normalizations in $f_{\theta}(.)$, while the rest of the pretrained model parameters $\bm{\theta}$ are fixed:

The hypernetworks capture the shared information across tasks in a multi-task learning model enabling positive transfer between related domains and transferable tasks, while adapters are reducing negative interference, encapsulating task-specific information.

Base model:

All of our models are built on top of the state-of-the-art T5 transformer model (Raffel et al., 2020). This model frames text-based language tasks as sequence-to-sequence problems. T5 consists of an encoder-decoder Transformer (Vaswani et al., 2017) with minor modifications (Raffel et al., 2020). The model is trained simultaneously on multiple tasks, obtaining state-of-the-art performance across a diverse set of tasks. We use the T5 framework as it enables training a universal model that interfaces with many language tasks. Our model has three main components: 1) task conditional adapter layers; 2) task conditional layer normalizations; and 3) hypernetworks that generate task-specific parameters. We next describe these components.

1 Task Conditional Adapter Layers

Prior work has shown that fine-tuning all parameters of the model can result in a sub-optimal solution, particularly for resource-limited datasets (Peters et al., 2019). As an alternative to fine-tuning all the model’s parameters, prior work Houlsby et al. (2019); Rebuffi et al. (2018); Stickland and Murray (2019) inserted small modules called adapter layers within layers of a pretrained model, as shown in Figure 1. Adapters introduce no change to the structure or parameters of the original model.

In this work, we propose conditional adapter modules, in which we generate the adapters weights based on input task embeddings using shared hypernetworks (Ha et al., 2017), which capture information across tasks that can be used to positively transfer to other relevant tasks.

where $\bm{x}$ is the input hidden state and ${LN}^{l}_{\tau}$ is the conditional layer norm defined in the next section. We generate adapter weights ($\bm{U^{l}_{\tau}}$, $\bm{D^{l}_{\tau}}$) through a hypernetwork described in §2.3.

2 Task Conditional Layer Normalization

Conventional layer normalization Ba et al. (2016) is defined as:

where $\odot$ is the element-wise multiplication between two vectors, and $\bm{\gamma^{l}_{\tau}}$ and $\bm{\beta^{l}_{\tau}}$ are learnable parameters with the same dimension as $\bm{x_{\tau}^{i}}$. Values of $\bm{\mu_{\tau}}$ and $\bm{\sigma_{\tau}}$ show the mean and standard deviation of training data for the $\tau$-th task.

To allow the layer normalization inside adapters to adapt to each task, inspired by Perez et al. (2018); De Vries et al. (2017), we generate $\bm{\gamma^{l}_{\tau}}$, $\bm{\beta^{l}_{\tau}}$ via a hypernetwork as a function of task embeddings (§2.3).

3 Task Conditioned Hypernetworks

In order to have a model that can share information while being able to adapt to each individual task, we generate the parameters of task conditional adapter layers and layer normalization using hypernetworks. A hypernetwork is a network that generates the weights of another network (Ha et al., 2017).

The hypernetworks capture the shared information, while the generated task conditional adapters and layer normalization allow the model to adapt to each individual task to reduce negative task interference.

Removing task prefixes:

The T5 model prepends task-specific prefixes to the input sequence for conditioning. For instance, when training on CoLA (Warstadt et al., 2019), cola sentence: is prepended to each sample. Instead, we remove task prefixes and use task embeddings for conditioning.

Task conditioned hypernetworks:

We consider simple linear layers as hypernetworks that are functions of input task embeddings $\bm{I_{\tau}}$. We introduce these hypernetworks in each layer of the transformer. We define hypernetwork $h_{A}^{l}(.)$ that generates task conditional adapter weights ($\bm{U^{l}_{\tau}}$, $\bm{D^{l}_{\tau}}$):

4 HyperFormer++

Experiments

Following Raffel et al. (2020), we evaluate the performance of the models on the GLUE benchmark (Wang et al., 2019b). This benchmark covers multiple tasks of paraphrase detection (MRPC, QQP), sentiment classification (SST-2), natural language inference (MNLI, RTE, QNLI), and linguistic acceptability (CoLA). Following Raffel et al. (2020); Devlin et al. (2019), as a common practice, due to the adversarial nature of WNLI with respect to the training set, we do not experiment with WNLI. The original test sets are not publicly available, and following Zhang et al. (2021), for datasets fewer than 10K samples (RTE, MRPC, STS-B, CoLA), we divide the original validation set in half, using one half for validation and the other for the test. For the other larger datasets, we split 1k samples from the training set as our validation data and test on the original validation set.

Experimental details:

We use the HuggingFace implementation (Wolf et al., 2020a) of the T5 model Raffel et al. (2020). We fine-tune all models with a constant learning rate of $0.0003$ and following Raffel et al. (2020), we use $2^{18}=262144$ steps in all experiments. We save a checkpoint every $1000$ steps for all models (see also §A). Raffel et al. (2020) report the results based on the best checkpoint for each task independently. In contrast, we focus on the more realistic setting where we report the results on a single checkpoint with the highest average validation performance across all tasks. The hyperparameters are selected in the same manner. In contrast to prior work (Houlsby et al., 2019), we do not learn a separate output layer for each task but instead share a frozen output layer for all the tasks, which makes our setting more parameter-efficient than prior work and is an advantage of multi-task learning with encoder-decoder models.According to our initial experiments, fine-tuning the final output layer did not improve performance for adapter-based methods.

Baselines:

We compare to the strong adapter baseline (Houlsby et al., 2019). Following Houlsby et al. (2019), we add adapters modules for each task after the two feed-forward modules in each transformer block of the T5 model. As suggested in Houlsby et al. (2019), we train the layer normalization parameters inside the T5 model, per task. We refer to this method as Adapters. We additionally propose a variant of this model, in which we share all layer normalization parameters (T5 and adapters) across all tasks. We refer to this model as Adapters$\dagger$. We compare our models to the state-of-the-art T5 model, in which we fine-tune all parameters of the model on all tasks. We refer to this method as T5SMALL/T5BASE in experiments.

Sampling tasks:

During training, we sample tasks with conventional temperature-based sampling with temperature $T=10$ for all methods. We sample different tasks proportional to $p_{\tau}^{1/T}$ where $p_{\tau}=\frac{N_{\tau}}{\sum_{i=1}^{T}N{\tau}}$ and $N_{\tau}$ is the number of training samples for the $\tau$-th task. We did not experiment with more complex sampling strategies (Raffel et al., 2020) or tuning of $T$.

1 Results on the GLUE Benchmark

Table 1 shows the results on GLUE for single-task and multi-task training. We experiment with reduction factors of $r=\{8,16,32\}$ for all adapter-based methods, where $r=\frac{h}{d}$. We report the results both with T5SMALL ​ (6 layers and 60M parameters) and T5BASE models (12 layers and 222M parameters).

Overall, our proposed HyperFormer++ ​ obtains strong gains over Adapters (82.51 versus 79.53 for T5SMALL and 86.48 versus 84.88 for T5BASE) while being more parameter-efficient.

Our variant of Adapters$\dagger$, which shares layer norms across tasks, outperforms prior work (Houlsby et al., 2019), which does not share such information (80.85 versus 79.53 for T5SMALL and 85.83 versus 84.88 for T5BASE). This demonstrates that in encoder-decoder models such as T5 more sharing of information across tasks is beneficial.

Our proposed HyperFormer obtains consistent improvement over our proposed Adapters$\dagger$ method. We attribute this improvement to the ability to learn the shared information across tasks through our hypernetworks. Interestingly, HyperFormer++ ​ obtains similar performance as HyperFormer while being more than an order of magnitude more parameter-efficient. Adapter modules thus seem to be similar enough so that much of their information can be modeled by a single, appropriately conditioned network.

Compared to single-task fine-tuning of all parameters, our methods on average improve the results by 0.45 for T5SMALL and 1.81 for T5BASE with substantial improvement on low-resource datasets like CoLA (63.73 versus 54.85) and RTE (75.36 versus 67.39) due to shared hypernetworks that capture the shared information and enable positive transfer effects.

We also report the total number of parameters and trainable parameters for all methods in Table 1. For adapter-based methods, the number of parameters varies based on the adapter size (we report all numbers with $r=32$). The multiple in terms of the number of parameters of HyperFormer++BASE with regard to T5BASE is $1.02\times$ with only $0.29\%$ trainable parameters per task. Note that by keeping the output layer frozen for AdaptersSMALL and AdaptersBASE, they require $5.51\times$ and $2.53\times$ fewer parameters respectively compared to a direct application of prior work (Houlsby et al., 2019). Despite using more efficient baselines, compared to AdaptersBASE, HyperFormer++BASE requires $3\times$ fewer trainable parameters.

2 Few-shot Domain Transfer

Finally, we assess how well a trained HyperFormer can generalize to new tasks. We evaluate performance on 5 tasks and 7 datasets. In particular, we consider 1) the natural language inference (NLI) datasets SciTail (Khot et al., 2018), and CB (De Marneffe et al., 2019) from SuperGLUE (Wang et al., 2019a) 2) the question answering (QA) dataset BoolQ (Clark et al., 2019a); 3) the sentiment analysis datasets IMDB (Maas et al., 2011) and Yelp Polarity (Zhang et al., 2015); and 4) the paraphrase detection dataset PAWS (Baldridge et al., 2019); 5) the question classification dataset TREC (Li and Roth, 2002).

For CB and BoolQ, since test sets are not available, we divide the validation sets in half, using one half for validation and the other for testing. For Yelp polarity, TREC, and IMDB, since validation sets are not available, we similarly divide the test sets to form validation sets. For the rest, we report on the original test sets.

We consider the models trained on GLUE reported in Table 1 and evaluate them on the test set after the few-shot fine-tuning on each target training data. For Adapters$\dagger$ and our method, we use the adapter and the task embedding respectively trained on the most similar GLUE task for initialization, i.e. MNLI for NLI, QNLI for QA, SST-2 for sentiment analysis, and QQP for paraphrase detection. Following prior evidence of positive transfer from NLI to other tasks Conneau and Kiela (2018); Yin et al. (2020); Phang et al. (2018), we initialize the out-of-domain TREC from MNLI. We show the results of full fine-tuning of all model’s parameters, Adapters$\dagger$, and HyperFormer++ We finetune hypernetworks and task embeddings parameters. We also tried only fine-tuning the task embedding but found that this achieves lower performance in the few-shot setting and comparable performance with more samples. in Table 2. Our method significantly surpasses the baselines on the majority of settings.

3 Low-resource Fine-tuning

Given that our model HyperFormer++BASE has substantially fewer trainable parameters than T5BASE, we investigate whether it generalizes better in a low-resource setting. We subsample each individual task in GLUE for varying training sizes. We train the models for 15,000 steps, which we found to be sufficient to allow them to converge. Figure 2 shows the results. HyperFormer++BASE substantially improves results with limited training data, indicating more effective fine-tuning in this regime.

Analysis

In this section, we compare the number of parameters of HyperFormer++ ​ with Adapters.

The standard setting Houlsby et al. (2019) employs two adapters per layer for each task. Each adapter layer has $2hd$ parameters for projection matrices ($\bm{U_{\tau}^{l}}$ and $\bm{D_{\tau}^{l}}$) and $2h$ parameters for the layer normalization. The total number of parameters for Adapters for $L$ Transformer layers in both an encoder and a decoder across $T$ tasks is, therefore, $4TL(2hd+2h)$, which scales linearly with the number of tasks times the number of layers.

HyperFormer++ ​ parameters:

Our approach learns a task feature embedding per task, consisting of $Tt$ parameters. We additionally employ layer id and adapter position embeddings in the encoder and decoder, which require $2(2+L)t$ parameters, with a fixed embedding size of $t$ for all these feature embeddings. We consider a separate task projector networks $h^{\prime}_{I}$ for encoder and decoder, which is in both cases a two-layer MLP, consisting of a total of $2(3te+et)$ parameters, where $e=128$ is the hidden dimension for the task-projector network. Our hypernetwork for adapters in encoder/decoder consists of $2(2thd)$ parameters and our layer normalization hypernetwork consists of $2(2th)$ parameters. In total, this results in $\underbrace{t(T+4+2L)}_{\text{Task features}}+\underbrace{8te+2t(2hd+2h)}_{\text{Hypernetworks}}$ parameters. The total number of parameters for hypernetworks remains constant, while the task feature parameters scale with the number of tasks or layers times $t$, where $t=64$ in our experiments.

In settings with a large number of layers and a large number of tasks, since $t\ll 2hd{+}2h$ and $T{+}L\ll TL$, our method is much more parameter-efficient compared to Adapters. In the current setting, the term $hd$ is the largest term, and the factor $2TL$ for Adapters is larger than the factor $t$ for HyperFormer++.

2 Do Extra Parameters Make a Difference?

While our HyperFormer++ ​ is more parameter-efficient than the baselines, the number of parameters of HyperFormer per task is higher compared to Adapters$\dagger$. To confirm that the improvements of HyperFormer are due to its capability of sharing information across tasks and not the number of parameters, as an ablation, we run the Adapters$\dagger$ with $r=\{2,4\}$ and choose the model performing the best on the validation set. This allows Adapters$\dagger$ to have a higher number of parameters compared to HyperFormer. We report the results in Table 3 and compare them with results of HyperFormer in Table 1. The results demonstrate that even with an increased number of parameters, Adapters$\dagger$ is not able to reach the performance of HyperFormer, and HyperFormer performs substantially better.

3 Impact of the Framework Components

We investigate the impact of the components of our framework including: (1) task conditional adapter blocks; (2) task conditional layer normalization; (3) task projection network; (4) fine-tuning of layer normalizations in the T5 model; (5) task conditional layer normalization in adapter modules and fine-tuning of layer normalizations inside the T5 model. We consider our small model of Table 1 and train different variants of it. Table 4 shows the results on GLUE, demonstrating that each component of the model contributes positively to its final performance.

4 Visualization of Task Embeddings

To analyze what HyperFormer++BASE has learned about the relations between different tasks, we visualize the learned task embeddings for the models trained with the largest number of samples in Table 1 and 2. Figure 3 illustrates the 2D vector projections of task embeddings using PCA (Wold et al., 1987). Interestingly, the observed groupings correspond to similar tasks. This shows that learned task embeddings by HyperFormer++BASE are meaningful. For CB, an NLI dataset despite being initialized from MNLI, after few-shot training the task embedding is closest to RTE, another NLI dataset. This is plausible as premises and hypotheses in both the discourse-based CB and the news and Wikipedia-based RTE are more complex compared to MNLI. The sentence similarity dataset STS-B is grouped close to the MRPC paraphrase dataset. CoLA, which focuses on linguistic acceptability is very different from other tasks and is not grouped with any of the observed task embeddings. In addition, the task embeddings for 1) all the sentiment analysis datasets namely SST-2, Yelp polarity, and IMDB; 2) the two large-scale NLI datasets namely MNLI and SciTail; 3) question answering datasets, i.e. BoolQ and QNLI; and 4) paraphrase datasets namely QQP and PAWS are each grouped together.

Related Work

Multi-task learning, i.e., learning a unified model to perform well on multiple different tasks, is a challenging problem in NLP. It requires addressing multiple challenges such as catastrophic forgetting, and handling disproportionate task sizes resulting in a model overfitting in low-resource tasks while underfitting in high-resource ones Arivazhagan et al. (2019). Liu et al. (2019a) proposed Multi-Task Deep Neural Network (MTDNN) for learning from multiple NLU tasks. Although MTDNN obtains impressive results on GLUE, it applies multi-task learning as a form of pretraining followed by task-specific fine-tuning. Concurrently with us, Tay et al. (2021) propose a multi-task learning method by training task-conditioned hyper networks; however, their method is 43x less parameter efficient compared to ours. In another line of research, Clark et al. (2019b) proposed to learn multi-task models with knowledge distillation. Houlsby et al. (2019) trained adapters for each task separately, keeping the model fixed. Stickland and Murray (2019) share the model parameters across tasks and introduce task-specific adapter parameters, which is more parameter-inefficient than our method.

Hypernetworks and contextual parameter generation:

Our work is closely related to hypernetworks (Ha et al., 2017). In a continual learning setup, where tasks are learned sequentially, Oswald et al. (2020) proposed a task-conditioned hypernetwork to generate all the weights of the target model. Our method is substantially more efficient as we do not generate all the weights of the target model but a very small number of parameters for adapter modules to allow the model to adapt to each individual task efficiently. Similarly, Jin et al. (2020) generate the full model from task-specific descriptions in different domains whereas we efficiently generate only small adapter modules for each task.

Prior work also proposed meta-learning or Bayesian approaches to generate softmax layer parameters for new settings Bansal et al. (2020); Ponti et al. (2020). Meta-learning approaches are notoriously slow to train. In addition, generating softmax parameters requires a substantially higher number of parameters, leaves the method unable to adapt the lower layers of the model, and restricts their application to classification tasks.

In contemporaneous work, Üstün et al. (2020) proposed a multilingual dependency parsing method based on adapters and contextual parameter generator networks (Platanios et al., 2018) where they generate adapter parameters conditioned on trained input language embeddings. Their study is limited to multilingual dependency parsing, while our work studies multi-task learning and applies to several tasks thanks to the general sequence-to-sequence nature of our model. Moreover, their number of trainable parameters is $2.88\times$ larger than their base model since they employ a contextual parameter generator in each layer. In contrast, we use a single compact hypernetwork allowing us to efficiently condition on multiple tasks and layers of a transformer model.

Conclusion

We propose a parameter-efficient method for multi-task fine-tuning. Our approach is to train shared hypernetworks to generate task-specific adapters conditioned on the task, layer id, and adapter position embeddings. The shared hypernetworks capture the knowledge across tasks and enable positive transfer to low-resource and related tasks, while task-specific layers allow the model to adapt to each individual task. Extensive experiments show that our method obtains strong improvement over multi-task learning on the GLUE benchmark, and substantially improves the in-domain task generalization.

Acknowledgments

We are grateful to Dani Yogatama, Neil Houlsby, and Colin Raffel for feedback on a draft of this paper. We would like to also thank Adam Paszke, Jamie Kiros, and George Dahl for useful comments and discussions.

References

Appendix A Experimental Details

We run the experiments in Table 1 on 4 GPUs, and the rest of the experiments on 1 GPU on a heterogeneous cluster with Tesla V100, Tesla A100, Tesla P4, and GTX1080ti GPUs.

Hyperparameters:

We use a batch size of 64 for T5SMALL and 32 for T5BASE to fit the GPU memory. We set the dimension of the task feature embedding ($\bm{z_{\tau}}$) to $t^{\prime}=512$, and the dimension of the task embedding ($\bm{I_{\tau}}$) to $t=64$. For low-resource fine-tuning in §3.3, we use reduction factors of $\{16,32,64\}$.

Data pre-processing:

We download all datasets from the HuggingFace Datasets library Wolf et al. (2020b). Following Raffel et al. (2020), we cast all datasets into a sequence-to-sequence format, and recast STS-B as a 21-class classification task by rounding its target scores to their nearest increment of 0.2.

Performance evaluation:

Table 5 and 6 present the efficiency evaluation in terms of memory, and time for all the methods measured on the GLUE benchmark. We report the time for 1000 training steps.

Our approach has several attractive properties. Our HyperFormer++BASE approach offers a much better memory usage with low-overhead, while HyperFormerBASE and T5BASE cause substantial memory overhead. In dealing with large-scale transformer models like T5, efficient memory usage is of paramount importance. Second, in terms of training time, our method is much faster than Adapters$\dagger$BASE. Relative to T5BASE, HyperFormer++BASE increases the training time by 30.49%, while Adapters$\dagger$BASE causes the substantial training time overhead of 84.93%.

Impact of adapter’s bottleneck size on the performance

Similar to (Houlsby et al., 2019), adapter’s reduction factor needs to be set per dataset. Table 7 shows the validation performance of HyperFormer++ ​ on the GLUE tasks for different adapters’ reduction factors. While the pattern may not be always consistent, generally, smaller datasets seem to benefit more from smaller bottleneck size, i.e., less parameters for adapters, while the opposite is the case for larger datasets, which require more modeling capacity.