Original: P ARAMETER -E FFICIENT F INE - TUNING D ESIGN S PACES
Revised: P ARAMETER -E FFICIENT F INE -T UNING D ESIGN S PACES

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Parameter-efficient fine-tuning  aims to achieve  comparable performances of finetuning with much fewer trainable parameters.
Revised: Parameter-efficient fine-tuning (PEFT) aims to achieve performance comparable to fine-tuning, using fewer trainable parameters.

Original: Recently, various tuning strategies (e.g., Adapters, Prefix Tuning, BitFit, and LoRA) have been proposed.
Revised: Several strategies (e.g., Adapters, Prefix Tuning, BitFit, and LoRA) have been proposed.

Original: However, their designs are hand-crafted separately, and it remains unclear whether certain design patterns exist for parameter-efficient fine-tuning.
Revised: However, their designs are hand-crafted separately, and it remains unclear whether certain design patterns exist for PEFT.

Original: Thus, we present a parameter-efficient fine-tuning design paradigm and discover design patterns that are applicable to different experimental settings.
Revised: Thus, we present a PEFT design paradigm and discover design patterns that are applicable to different experimental settings.

Original: Instead of focusing on designing another individual tuning strategy, we introduce parameter-efficient fine-tuning design spacesthat parameterize tuning structures and tuning strategies. Specifically, any design space is characterized by four components: layer grouping, trainable parameter allocation, tunable groups, and strategy assignment. 
Revised: Instead of focusing on designing another individual tuning strategy, we introduce PEFT design spaces characterized by four components: layer grouping, trainable parameter allocation, tunable groups, and strategy assignment. Starting from an initial design space, we progressively refine the space based on the model quality of each design choice and make greedy selection at each stage over these four components.

Original: Our comprehensive empirical study leads to the discovery of design patterns: (i) grouping layers in a spindle pattern, (ii) uniformly allocating the number of trainable parameters to layers, (ii) tuning all the groups, and (iv)  tuning  different groups with proper strategies.
Revised: We discover the following design patterns: (i) group layers in a spindle pattern; (ii) allocate the number of trainable parameters to layers uniformly; (iii) tune all the groups; (iv) assign proper tuning strategies to different groups.

Original: Our discovered design patterns result in new parameter-efficient fine-tuning methods.
Revised: These design patterns result in new PEFT methods.

Original: Experiments show  that these methods consistently  outperform investigated parameter-efficient fine-tuning strategies across different backbone models and different tasks in natural language processing 1 .
Revised: We show experimentally that these methods consistently and significantly outperform investigated PEFT strategies across different backbone models and different tasks in natural language processing 1 .

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Recently, large pretrained models have achieved the state-of-the-art performances across a wide variety of downstream natural language processing tasks through fine-tuning on task-specific labeled data (Devlin et al., 2019; Liu et al., 2019;
Revised: Large pretrained models have achieved the state-of-the-art performances across a wide variety of downstream natural language processing tasks through fine-tuning on task-specific labeled data (Devlin et al., 2019; Liu et al., 2019;

Original: Yang et al., 2019; Joshi et al., 2019; Sun et al., 2019; Clark et al., 2019; Lewis et al., 2020a; Bao et al., 2020;
Revised: Yang et al., 2019; Joshi et al., 2019; Sun et al., 2019; Clark et al., 2019; Lewis et al., 2020a; Bao et al., 2020;

Original: He et al., 2020; Raffel et al., 2020; Ziems et al., 2022).
Revised: He et al., 2020; Raffel et al., 2020; Ziems et al., 2022).

Original: However, fine-tuning all the parameters and storing them separately for different tasks are inherently expensiveespecially in terms of  storage overhead (e.g., 355 M parameters for RoBERTa (Liu et al., 2019) and 175 B parameters for GPT- 3 (Brown et al., 2020)), making them difficult to be deployed in real-world natural language processing (NLP) systems composed of multiple tasks.
Revised: However, fine-tuning all the parameters and storing them separately for different tasks is expensive in terms of computation and storage overhead (e.g., 355 M parameters for RoBERTa (Liu et al., 2019) and 175 B parameters for GPT- 3 (Brown et al., 2020)). This makes it difficult to deploy in real-world natural language processing (NLP) systems composed of multiple tasks.

Original: To adapt general knowledge in pretrained models to specific down-stream tasks in a more parameterefficient way, various strategies have been proposed where only a small number of (extra) parameters are learned while the remaining pretrained parameters are frozen (Houlsby et al., 2019b;
Revised: To adapt general knowledge in pretrained models to specific down-stream tasks in a more parameterefficient way, various strategies have been proposed where only a small number of (extra) parameters are learned while the remaining pretrained parameters are frozen (Houlsby et al., 2019b;

Original: Pfeiffer et al., 2021; Li & Liang, 2021; Brown et al., 2020; Lester et al., 2021b; Schick & Sch¨utze, 2021;
Revised: Pfeiffer et al., 2021; Li & Liang, 2021; Brown et al., 2020; Lester et al., 2021b; Schick & Sch¨utze, 2021;

Original: Ziems et al., 2022).
Revised: Ziems et al., 2022).

Original: Adapter tuning (Houlsby et al., 2019b) is among the earliest strategies to steer pretrained models with a limited number of parameters.
Revised: Adapter tuning (Houlsby et al., 2019b) is among the earliest strategies to steer pretrained models with a limited number of parameters.

Original: It inserts adapters (small neural modules) to each layer of the pretrained network and only the adapters are trained at the fine-tuning time.
Revised: It inserts adapters (small neural modules) to each layer of the pretrained network and only the adapters are trained at the fine-tuning time.

Original: Inspired by the success of prompting methods that control pretrained language models through textual prompts (Brown et al., 2020), Prefix tuning (Li & Liang, 2021) and Prompt tuning (Lester et al., 2021a) prepend additional tunable tokens to the input or hidden layers and only train these soft prompts when fine-tuning on downstream tasks.
Revised: Inspired by the success of prompting methods that control pretrained language models through textual prompts (Brown et al., 2020), Prefix tuning (Li & Liang, 2021) and Prompt tuning (Lester et al., 2021a) prepend additional tunable tokens to the input or hidden layers and only train these soft prompts when fine-tuning on downstream tasks.

Original: BitFit (Zaken et al., 2021) updates the bias terms in pretrained models while freezing the remaining parameters.
Revised: BitFit (Zaken et al., 2021) updates the bias terms in pretrained models while freezing the remaining parameters.

Original: LoRA (Hu et al., 2021) decomposes attention weight gradients into low-rank matrices to reduce the number of trainable parameters.
Revised: LoRA (Hu et al., 2021) decomposes attention weight gradients into low-rank matrices to reduce the number of trainable parameters.

Original: With promising results from such research, He et al.
Revised: With promising results from such research, He et al.

Original: (2022) proposed a unified view of these ex-
Revised: (2022) proposed a unified view of these ex-

Original: [Figure]
Revised: [Figure]

Original:  PL PL
Revised: P PL PL

Original: ABL
Revised: ABL

Original: ABL …
Revised: ABL …

Original: [Figure]
Revised: [Figure]

Original: p ⇥ p isting strategies and illustrated differences and connections among them.
Revised: p ⇥ p isting strategies and illustrated differences and connections among them.

Original: Like its antecedents, the resulting method is still equally assigned to different pretrained layers.
Revised: Like its antecedents, the resulting method is still equally assigned to different pretrained layers.

Original: Despite being effective, most parameter-efficient fine-tuning  strategies have been developed via manual design processes, without much consideration of whether design patterns exist across these different strategies and how such patterns might apply to different backbone models and downstream tasks.
Revised: Despite being effective, most parameter-efficient fine-tuning (PEFT) strategies have been developed via manual design processes, without much consideration of whether design patterns exist across these different strategies and how such patterns might apply to different backbone models and downstream tasks.

Original: Moreover, different strategies are usually applied separately; thus, it is unclear which strategy works best when and where (Mao et al., 2022), as well as how these different strategies reinforce or complement each other.
Revised: Moreover, different strategies are usually applied separately; thus, it is unclear which strategy works best when and where (Mao et al., 2022), as well as how these different strategies reinforce or complement each other.

Original: In the light of this, our goal is to understand the parameter-efficient finetuning design in a more comprehensive view and discover design patterns that are  interpretable and applicable across different experimental settings.
Revised: In this light, our goal is to understand the PEFT design in a more comprehensive view and discover design patterns that are both interpretable and applicable across different experimental settings.

Original: Thus, instead of designing  another individual strategy that is equally assigned to different pretrained layers, we introduce the parameter-efficient fine-tuning design spaces that parametrize boththe tuning structures and strategies.
Revised: Instead of designing yet another individual strategy that is equally applied to different pretrained layers, we introduce PEFT design spaces that parameterize both tuning structures and strategies.

Original: More concretely, any of these design spaces is characterized by four major components as shown inFigure 1.
Revised: More concretely, any of these design spaces is characterized by four major components as shown in

Original: First, layer grouping specifies how to group consecutive layers in pretrained models.

Original: Second, trainable parameter allocation indicates how to allocate trainable parameters (during fine-tuning) to layers.

Original: Third, tunable groups tells which groups will be updated during fine-tuning.

Original: Fourth, strategy assignment shows how to assign proper parameterefficient fine-tuning strategies to groups.

Original: Starting from a relatively unconstrained parameter-efficient fine-tuning design space, we progressively refine the space by comparing  overall quality of models randomly sampled from design spaces enforced with different constraints (e.g., each group has the same number of layers).
Revised: Starting from a relatively unconstrained PEFT design space, we progressively refine the space by comparing the overall quality of models randomly sampled from design spaces enforced with different constraints (e.g., each group has the same number of layers).

Original: Throughout the experimental process, we discover several design patterns for parameter-efficient fine-tuning, such as grouping layers in a spindle pattern, uniformly allocating the number of trainable parameters to layers, tuning all the groups, and  tuning  different groups with proper strategies.
Revised: Throughout the experimental process, we discover several design patterns for PEFT, such as group layers in a spindle pattern, allocate the number of trainable parameters to layers uniformly, tune all the groups, and assign proper tuning strategies to different groups.

Original: We further introduce new parameter-efficient fine-tuning methods that adopt all these discovered design patterns.
Revised: We further introduce new PEFT methods that adopt all these discovered design patterns.

Original: Extensive experiments show that our methods consistently outperform investigated parameter-efficient fine-tuning strategies.
Revised: Extensive experiments show that our methods consistently outperform investigated PEFT strategies.

Original: Although we use T5 (Raffel et al., 2020) and classification tasks as the working example, we find that our methods with all these discovered design patters are applicable to other backbones (e.g., RoBERTa (Liu et al., 2019) and BART (Lewis et al., 2020b)) and different natural language processing tasks (e.g., summarization and machine translation).
Revised: Although we use T5 (Raffel et al., 2020) and classification tasks as the working example, we find that our methods with all these discovered design patters are applicable to other backbones (e.g., RoBERTa (Liu et al., 2019), BART (Lewis et al., 2020b) and XLNet (Yang et al., 2019)) and different natural language processing tasks (e.g., summarization, machine translation, and eight SuperGLUE datasets).

Original: Our contributions can be summarized as follows: (i)
Revised: Our contributions can be summarized as follows: (i)

Original: We introduce parameter-efficient fine-tuning design spaces.
Revised: We introduce PEFT design spaces.

Original: (ii) Based on these design spaces, we discover several design patterns in parameterefficient fine-tuning via comprehensive experiments.
Revised: (ii) Based on these design spaces, we discover several design patterns in PEFT via comprehensive experiments.

Original: (iii)
Revised: (iii)

Original: Our discovered design patterns lead to parameter-efficient fine-tuning methods, consistently outperforming investigated parameter-efficient fine-tuning strategies across different backbone models and different NLP tasks.
Revised: Our discovered design patterns lead to PEFT methods, consistently outperforming investigated PEFT strategies across different backbone models and different NLP tasks.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Our work is closely related to and built upon the research about the network design spaces and parameter-efficient fine-tuning.
Revised: Our work is closely related to and built upon the research about the network design spaces and PEFT.

Original: We discuss the connections and differences below.
Revised: We discuss the connections and differences below.

Original: Network Design Spaces
Revised: Network Design Spaces

Original: A lot of works designed neural network models via an ad-hoc discovery of new design choices that improve performances (Radosavovic et al., 2019), such as the use of deeper architectures or residuals.
Revised: A lot of works designed neural network models via an ad-hoc discovery of new design choices that improve performances (Radosavovic et al., 2019), such as the use of deeper architectures or residuals.

Original: Recently, there have been works (Radosavovic et al., 2020; You et al., 2020; Radosavovic et al., 2019) performing at the design space level to discover new design principles for convolutional neural networks (Radosavovic et al., 2020) and graph neural networks (You et al., 2020).
Revised: Recently, there have been works (Radosavovic et al., 2020; You et al., 2020; Radosavovic et al., 2019) performing at the design space level to discover new design principles for convolutional neural networks (Radosavovic et al., 2020) and graph neural networks (You et al., 2020).

Original: Inspired by this line of research, we focus on the design space perspective to rethink parameter-efficient fine-tuning, with the goal of discovering design patterns that are applicable to different experimental settings.
Revised: Inspired by this line of research, we focus on the design space perspective to rethink PEFT, with the goal of discovering design patterns that are applicable to different experimental settings.

Original: Parameter-Efficient Fine-Tuning for NLP As pretrained models grow in size, storing fine-tuned models becomes exceedingly expensive, and fine-tuning becomes infeasible for those without extremely high compute resources.
Revised: PEFT for NLP As pretrained models grow in size, storing fine-tuned models becomes exceedingly expensive, and fine-tuning becomes infeasible for those without extremely high compute resources.

Original: A growing body of research has been devoted to finding parameterefficient alternatives for adapting large-scale pretrained models with reduced memory and storage costs.
Revised: A growing body of research has been devoted to finding parameter-efficient alternatives for adapting large-scale pretrained models with reduced memory and storage costs.

Original: Houlsby et al. (2019a) proposed to adapt large models using bottleneck layers (with skipconnections) between each layer.
Revised: Houlsby et al. (2019a) proposed to adapt large models using bottleneck layers (with skip-connections) between each layer.

Original: This idea has been extended in many domains (Stickland & 
Revised: This idea has been extended in many domains (Stickland & Murray, 2019;

Original: Murray, 2019; Pfeiffer et al., 2020; Rebuffi et al., 2017; Lin et al., 2020).
Revised: Pfeiffer et al., 2020; Rebuffi et al., 2017; Lin et al., 2020).

Original: Other works have aimed to avoid introducing additional parameters by identifying and training only a subset of all model parameters (Zhao et al., 2020;
Revised: Other works have aimed to avoid introducing additional parameters by identifying and training only a subset of all model parameters (Zhao et al., 2020;

Original: Guo et al., 2020; Mallya et al., 2018; Radiya-Dixit & Wang, 2020; 
Revised: Guo et al., 2020; Mallya et al., 2018; Radiya-Dixit & Wang, 2020; Sung et al., 2021;

Original: Sung et al., 2021; Zaken et al., 2021).
Revised: Zaken et al., 2021).

Original: Recent works also explored the idea of rank decomposition (Zhang et al., 2021) and injecting trainable rank decomposition matrices into each layer (Hu et al., 2021; Karimi Mahabadi et al., 2021).
Revised: Recent works also explored the idea of rank decomposition (Zhang et al., 2021) and injecting trainable rank decomposition matrices into each layer (Hu et al., 2021; Karimi Mahabadi et al., 2021).

Original: Li & Liang (2021) introduced prefix-tuning that prepends a set of prefixes to autoregressive language models or prepends prefixes for both encoders and decoders.
Revised: Li & Liang (2021) introduced prefix-tuning that prepends a set of prefixes to autoregressive language models or prepends prefixes for both encoders and decoders.

Original: The prefix parameters are updated while the pretrained parameters are fixed.
Revised: The prefix parameters are updated while the pretrained parameters are fixed.

Original: Lester et al.
Revised: Lester et al.

Original: (2021b) proposed a similar method, but only added virtual tokens at the embedding layer of largescale models rather than discrete prompts (Deng et al., 2022; Zhong et al., 2022).
Revised: (2021b) proposed a similar method, but only added virtual tokens at the embedding layer of large-scale models rather than discrete prompts (Deng et al., 2022; Zhong et al., 2022).

Original: Sung et al.
Revised: Sung et al.

Original: (2022) used side-tuning to be more parameter-efficient.
Revised: (2022) used side-tuning to be more parameterefficient.

Original: Recently,
Revised: Recently,

Original: He et al.
Revised: He et al.

Original: (2022) and Ding et al.
Revised: (2022) and Ding et al.

Original: (2022) proposed a unified view of the existing parameter-efficient fine-tuning strategies and illustrated the difference and connections among them.
Revised: (2022) proposed a unified view of the existing PEFT strategies and illustrated the difference and connections among them.

Original: Mao et al.
Revised: Mao et al.

Original: (2022) also introduced a unified framework to combine different methods through mixture-of-experts.
Revised: (2022) also introduced a unified framework to combine different methods through mixture-of-experts.

Original: In contrast to these aforementioned works that assign their individual method equally to different pretrained layers, we focus on more general design spaces of parameter-efficient fine-tuning.
Revised: In contrast to these aforementioned works that assign their individual method equally to different pretrained layers, we focus on more general design spaces of PEFT.

Original: This could provide a more comprehensive view of parameter-efficient fine-tuning in terms of both the tuning structures and tuning strategies.
Revised: This could provide a more comprehensive view of PEFT in terms of both the tuning structures and tuning strategies.

Original: Through experiments where we progressively refine design spaces, we discover design patterns for parameter-efficient fine-tuning.
Revised: Through experiments where we progressively refine design spaces, we discover design patterns for PEFT.

Original:  C OMPONENTS OF D ESIGN S PACES
Revised:  C OMPONENTS OF D ESIGN S PACES

Original: When defining design spaces of parameter-efficient fine-tuning, we aim to cover key design components and provide a representative set of choices in each design component.
Revised: When defining design spaces of PEFT, we aim to cover key design components and provide a representative set of choices in each design component.

Original: Note that our goal is not to enumerate all possible design spaces, but to demonstrate how the use of design spaces can help inform parameter-efficient fine-tuning research.
Revised: Note that our goal is not to enumerate all possible design spaces, but to demonstrate how the use of design spaces can help inform PEFT research.

Original: Concretely, in our work, the parameter-efficient fine-tuning design spaces are formed by a representative set of choices in parameter-efficient fine-tuning, which consists of the following four components: (i) layer grouping, (ii) trainable parameter allocation, (iii) tunable groups, and (iv) strategy assignment.
Revised: Concretely, in our work, the PEFT design spaces are formed by a representative set of choices in PEFT, which consists of the following four components: (i) layer grouping, (ii) trainable parameter allocation, (iii) tunable groups, and (iv) strategy assignment.

Original: Following the illustrated design space example in Figure 1, we describe these four design components in detail below and will explore their design choices in Section 4.
Revised: Following the illustrated design space example in Figure 1, we describe these four design components in detail below and will explore their design choices in Section 4.

Original: Layer Grouping Different layers in pretrained models capture different information and behave differently.
Revised: Layer Grouping Different layers in pretrained models capture different information and behave differently.

Original: For example, Jawahar et al.
Revised: For example, Jawahar et al.

Original: (2019) found that the { 3 , 4 , 5 , 6 , 7 , 9 , 12 } -th layers have the most representation power in BERT and every layer captures a different type of information ranging from the surface, syntactic, to the semantic level representation of text.
Revised: (2019) found that the { 3 , 4 , 5 , 6 , 7 , 9 , 12 } -th layers have the most representation power in BERT and every layer captures a different type of information ranging from the surface, syntactic, to the semantic level representation of text.

Original: For instance, the 9th layer has predictive power for semantic tasks such as checking random swapping of coordinated clausal conjuncts, while the 3rd layer performs best in surface tasks like predicting sentence length.
Revised: For instance, the 9th layer has predictive power for semantic tasks such as checking random swapping of coordinated clausal conjuncts, while the 3rd layer performs best in surface tasks like predicting sentence length.

Original: Therefore when adapting these pretrained models to downstream tasks, how to group layers with similar behaviors together is critical to the design and application of proper parameter-efficient finetuning strategies.
Revised: Therefore when adapting these pretrained models to downstream tasks, how to group layers with similar behaviors together is critical to the design and application of proper PEFT strategies.

Original: For this design component, we study the patterns of how to group consecutive layers in pretrained models (e.g., transformer layers in T5) during the fine-tuning process.
Revised: For this design component, we study the patterns of how to group consecutive layers in pretrained models (e.g., transformer layers in T5) during the fine-tuning process.

Original: Trainable Parameter Allocation
Revised: Trainable Parameter Allocation

Original: In parameter-efficient fine-tuning, the total number of trainable parameters is usually preset, such as a small portion of the total number of parameters in the pretrained models.
Revised: In PEFT, the total number of trainable parameters is usually preset, such as a small portion of the total number of parameters in the pretrained models.

Original: We will study different design choices for how to allocate a predefined number of trainable parameters to layers.
Revised: We will study different design choices for how to allocate a predefined number of trainable parameters to layers.

Original: Tunable Groups Zaken et al.
Revised: Tunable Groups Zaken et al.

Original: (2021) found that not all the parameters need to be tuned during fine-tuning on the downstream tasks.
Revised: (2021) found that not all the parameters need to be tuned during fine-tuning on the downstream tasks.

Original: For instance, BitFit (Zaken et al., 2021) only updates the bias parameters in pretrained models while freezing the remaining parameters.
Revised: For instance, BitFit (Zaken et al., 2021) only updates the bias parameters in pretrained models while freezing the remaining parameters.

Original: Thus, we study which groups need to be learned during parameter-efficient fine-tuning to attain better performances.
Revised: Thus, we study which groups need to be learned during PEFT to attain better performances.

Original: Strategy Assignment
Revised: Strategy Assignment

Original: In order to improve the parameter efficiency, different sets of strategies (Li & Liang, 2021; Lester et al., 2021b;
Revised: In order to improve the parameter efficiency, different sets of strategies (Li & Liang, 2021; Lester et al., 2021b;

Original: Houlsby et al., 2019b; Hu et al., 2021) have been proposed where only a small number of (extra) parameters are tuned and the remaining parameters in these pretrained models are frozen to adapt their general knowledge to specific down-stream tasks.
Revised: Houlsby et al., 2019b; Hu et al., 2021) have been proposed where only a small number of (extra) parameters are tuned and the remaining parameters in these pretrained models are frozen to adapt their general knowledge to specific down-stream tasks.

Original: We hypothesize that different groups might benefit from different proper strategies (or combinations) for capturing different types of information.
Revised: We hypothesize that different groups might benefit from different proper strategies (or combinations) for capturing different types of information.

Original: More formally, given a set of individual strategies A for assignment, for any group G i , assign a subset U i
Revised: More formally, given a set of individual strategies A for assignment, for any group G i , assign a subset U i

Original: ⊂
Revised: ⊂

Original: A to each layer in G i .
Revised: A to each layer in G i .

Original:  D ISCOVERING D ESIGN P ATTERNS
Revised:  D ISCOVERING D ESIGN P ATTERNS

Original: Building on these four different design components of parameter-efficient fine-tuning design spaces, we will start from a relatively unconstrained design space and progressively discover the design patterns.
Revised: Building on these four different design components of PEFT design spaces, we will start from a relatively unconstrained design space and progressively discover the design patterns

Original:  4. D ESIGN S PACE E XPERIMENTAL S ETUP
Revised: . 4. D ESIGN S PACE E XPERIMENTAL S ETUP

Original: We first describe our experimental setup for discovering the design patterns.
Revised: We first describe our experimental setup for discovering the design patterns.

Original: Note that our process is generic for other tasks and future pretrained backbone models.
Revised: Note that our process is generic for other tasks and future pretrained backbone models.

Original: Datasets Our process for discovering design patterns of parameter-efficient fine-tuning is based on the average performances on the widely-used GLUE benchmark (Wang et al., 2018).
Revised: Datasets Our process for discovering design patterns of PEFT is based on the average performances on the widely-used GLUE benchmark (Wang et al., 2018).

Original: It covers a wide range of natural language understanding tasks.
Revised: It covers a wide range of natural language understanding tasks.

Original: First, single-sentence tasks include (i) Stanford Sentiment Treebank (SST-2) and (ii) Corpus of Linguistic Acceptability (CoLA).
Revised: First, single-sentence tasks include (i) Stanford Sentiment Treebank (SST-2) and (ii) Corpus of Linguistic Acceptability (CoLA).

Original: Second, similarity and paraphrase tasks include (i) Quora Question Pairs (QQP), (ii) Semantic Textual Similarity Benchmark (STS-B), and (iii) Microsoft Research Paraphrase Corpus (MRPC).
Revised: Second, similarity and paraphrase tasks include (i) Quora Question Pairs (QQP), (ii) Semantic Textual Similarity Benchmark (STS-B), and (iii) Microsoft Research Paraphrase Corpus (MRPC).

Original: Third, inference tasks include (i) Multi-Genre Natural Language Inference (MNLI), (ii) Question Natural Language 
Revised: Third, inference tasks include (i) MultiGenre Natural Language Inference (MNLI), (ii) Question Natural Language Inference (QNLI), and (iii)

Original: Inference (QNLI), and (iii) Recognizing Textual Entailment (RTE).
Revised: Recognizing Textual Entailment (RTE).

Original: To compare performances, the Matthews correlation is measured for CoLA; the Spearman correlation is used for STS-B, and accuracy is measured for the rest GLUE tasks.
Revised: To compare performances, the Matthews correlation is measured for CoLA; the Spearman correlation is used for STS-B, and accuracy is measured for the rest GLUE tasks.

Original: Pretrained Backbone Models and Model Settings
Revised: Pretrained Backbone Models and Model Settings

Original: We use T5-base/3b (Raffel et al., 2020) as the main pretrained backbone models for discovering design patterns via our parameter-efficient fine-tuning design spaces.
Revised: We use T5-base/3b (Raffel et al., 2020) as the main pretrained backbone models for discovering design patterns via our PEFT design spaces.

Original: We use Hugging Face 2 for our implementations and follow the default settings.
Revised: We use Hugging Face 2 for our implementations and follow the default settings.

Original: During the exploration, we set the total number of trainable parameters (in the percentage of that in the backbone model) to 0.5% by following He et al.
Revised: During the exploration, we set the total number of trainable parameters (in the percentage of that in the backbone model) to 0.5% by following He et al.

Original: 4. D ISCOVERING D ESIGN P ATTERNS U SING T5- BASE
Revised: 4. D ISCOVERING D ESIGN P ATTERNS U SING T5- BASE

Original: In this subsection, we describe the empirical process for discovering the design patterns using T5base (pretrained backbone model) as the working example.
Revised: In this subsection, we describe the empirical process for discovering the design patterns using T5base (pretrained backbone model) as the working example.

Original: Each parameter-efficient fine-tuning 2 https://huggingface.co/docs/transformers/index design space (denoted as S i ) consists of a set of models ( S i -models) that satisfy constraints characterizing the space with respect to layer grouping, trainable parameter allocation, tunable groups, and strategy assignment.
Revised: Each PEFT design space (denoted as S i ) consists of a set of models ( S i -models) that satisfy constraints characterizing the space with respect to layer grouping, trainable parameter allocation, tunable groups, and strategy assignment.

Original: To discover design patterns, we start from a relatively unconstrained parameterefficient fine-tuning design space ( S 0 ).
Revised: To discover design patterns, we start from a relatively unconstrained PEFT design space ( S 0 ).

Original: Then we progressively refine design spaces (from S 0 to S 1:4 ) by comparing overall quality of models in design spaces enforced with different constraints (e.g., each group has the same number of layers).
Revised: Then we progressively refine design spaces (from S 0 to S 1:4 ) by comparing overall quality of models in de- sign spaces enforced with different constraints (e.g., each group has the same number of layers).

Original: To quantify the overall quality of models in any design space S i with a low-compute, low-epoch regime (Radosavovic et al., 2020), we randomly sample 100 models from S i , fine-tune with 3 epochs 3 , and compute the average of the GLUE average performances.
Revised: To quantify the overall quality of models in any design space S i with a low-compute, low-epoch regime (Radosavovic et al., 2020), we randomly sample 100 models from S i , fine-tune with 3 epochs 3 , and compute the average of the GLUE average performances.

Original: We emphasize that our goal is to demonstrate how the perspective of design spaces can help inform parameter-efficient fine-tuning research, rather than to find out the “best” design space or method.
Revised: We emphasize that our goal is to demonstrate how the perspective of design spaces can help inform PEFT research, rather than to find out the “best” design space or method.

Original: For computational efficiency, it is beyond the scope of this work to enumerate all possible constraints with respect to the design space components (Section 3).
Revised: For computational efficiency, it is beyond the scope of this work to enumerate all possible constraints with respect to the design space components (Section 3).

Original: 4.2. T HE I NITIAL S 0 D ESIGN S PACE
Revised: 4.2. T HE I NITIAL S 0 D ESIGN S PACE

Original: The initial relatively unconstrained design space S 0 consists of all models without constraints on the design space components (Section 3).
Revised: The initial relatively unconstrained design space S 0 consists of all models without constraints on the design space components (Section 3).

Original: Individual parameter-efficient fine-tuning strategies consist of 
Revised: Individual PEFT strategies consist of Adapter, Prefix,

Original: Adapter, Prefix, BitFit, and LoRA.
Revised: BitFit, and LoRA.

Original: One can think of this S 0 design space as a set of random models ( S 0 -models) with random design patterns.
Revised: One can think of this S 0 design space as a set of random models ( S 0 -models) with random design patterns.

Original: Specifically, without grouping constraints, each layer of the pretrained layer has a half chance to be tuned: if tuned, random strategies (or combinations) with a random amount of trainable parameters are assigned to that layer.
Revised: Specifically, without grouping constraints, each layer of the pretrained layer has a half chance to be tuned: if tuned, random strategies (or combinations) with a random amount of trainable parameters are assigned to that layer.

Original: Before comparing more subtle design patterns such as how to properly assign tunable strategies among Adapter, Prefix, BitFit, and LoRA, we begin with exploring how to group layers and how to allocate the total number of trainable parameters to layers.
Revised: Before comparing more subtle design patterns such as how to properly assign tunable strategies among Adapter, Prefix, BitFit, and LoRA, we begin with exploring how to group layers and how to allocate the total number of trainable parameters to layers.

Original: 4.2. T HE S 1 D ESIGN S PACE WITH A DDITIONAL G ROUPING C 
Revised: 4.2. T HE S 1 D ESIGN S PACE WITH A DDITIONAL G ROUPING C ONSTRAINTS

Original: ONSTRAINTS

Original: Inspired by Dosovitskiy et al.
Revised: Inspired by Radosavovic et al.

Original: (2020), we also consider 4 groups ( G 1 , . .
Revised: (2020), we also consider 4 groups ( G 1 , . .

Original: , G 4 , in the order of forward pass) in the experiments.
Revised: , G 4 , in the order of forward pass) in the experiments 4 .

Original: Denote by N i the number of layers in G i .
Revised: Denote by N i the number of layers in G i .

Original: As illustrated in Figure 2, we compare the following layer grouping patterns: (i)
Revised: As illustrated in Figure 2, we compare the following layer grouping patterns: (i)

Original: Increasing ( N i +1 > N i ): the number of layers in groups gradually increases; (ii) Uniform ( N i +

Revised: Increasing ( N i +1 > N i ): the number of layers in groups gradually increases; (ii) Uniform ( N i +

Original: =
Revised: =

Original: N i ): the number of layers in groups is the same; (iii) Decreasing ( N i +1 <
Revised: N i ): the number of layers in groups is the same; (iii) Decreasing ( N i +1 <

Original: N i ): the number of layers in groups gradually decreases; (iv)
Revised: N i ): the number of layers in groups gradually decreases; (iv)

Original: Spindle ( N 1 < N 2 = N 3 > N 4 ): the numbers of layers in groups at both ends are smaller; and (v)
Revised: Spindle ( N 1 < N 2 = N 3 > N 4 ): the numbers of layers in groups at both ends are smaller; and (v)

Original: Bottleneck ( N 1 > N 2 = N 3 < N 4 ): the numbers of layers in groups at both ends are bigger.
Revised: Bottleneck ( N 1 > N 2 = N 3 < N 4 ): the numbers of layers in groups at both ends are bigger.

Original: These layer grouping patterns lead to 5 different design spaces.
Revised: These layer grouping patterns lead to 5 different design spaces.

Original: Any of these 5 design spaces consists of all models in the S 0 design space that satisfy one of these grouping pattern constraints.
Revised: Any of these 5 design spaces consists of all models in the S 0 design space that satisfy one of these grouping pattern constraints.

Original: To compare the overall model qualities of different design spaces, we (i) randomly sample 100 models from the S 0 design space that satisfy each grouping pattern constraint (Figure 2); (ii) fine-tune with 3 epochs; and (iii) compute the average performances for each design space.
Revised: To compare the overall model qualities of different design spaces, we (i) randomly sample 100 models from the S 0 design space that satisfy each grouping pattern constraint (Figure 2); (ii) fine-tune with 3 epochs; and (iii) compute the average performances for each design space.

Original: We will follow this procedure as we progressively add new constraints later.
Revised: We will follow this procedure as we progressively add new constraints later.

Original: The averaged performances are shown in Table 1.
Revised: The averaged performances are shown in Table 1 5 .

Original: We find that models from the design space with the spindle grouping pattern (Figure 2) consistently outperform those from the other design spaces across all the 8 GLUE tasks.
Revised: We find that models from the design space with the spindle grouping pattern (Figure 2) consistently outperform those from the other design spaces across all the 8 GLUE tasks.

Original: This may be due to the complexities of information captured in different layers of large pretrained models, which favor information adaptation in the discovered layer grouping pattern.[Table] [Table]
Revised: This may be due to the complexities of information captured in different layers of large pretrained models, which favor information adaptation in the discovered layer grouping pattern.

Original: From now on, we will group layers in a spindle pattern.
Revised: From now on, we will group layers in a spindle pattern.

Original: We refer to S 0 with this additional design pattern as the new S 1 design space. 
Revised: We refer to S 0 with this additional design pattern as the new S 1 design space. [Table] [Table]

Original: 4.2. T HE S 2 D ESIGN S PACE WITH A DDITIONAL P ARAMETER C ONSTRAINTS
Revised: 4.2. T HE S 2 D ESIGN S PACE WITH A DDITIONAL P ARAMETER C ONSTRAINTS

Original: We continue to explore design patterns in trainable parameter allocation to refine the S 1 design space.
Revised: We continue to explore design patterns in trainable parameter allocation to refine the S 1 design space.

Original: Denote by n i the number of trainable parameters for the i -th layer of the pretrained backbone model, we compare the following design patterns: (i)
Revised: Denote by n i the number of trainable parameters for the i -th layer of the pretrained backbone model, we compare the following design patterns: (i)

Original: Increasing ( n i +1 ≥ n i ): the number of trainable parameters in every layer gradually increases (or remains the same); (ii) Uniform ( n i +

Revised: Increasing ( n i +1 ≥ n i ): the number of trainable parameters in every layer gradually increases (or remains the same); (ii) Uniform ( n i +

Original: = n i ): the number of trainable parameters in every layer is the same; and (iii) Decreasing ( n i +1 ≤ n i ): the number of trainable parameters in every layer gradually decreases (or remains the same).
Revised: = n i ): the number of trainable parameters in every layer is the same; and (iii) Decreasing ( n i +1 ≤ n i ): the number of trainable parameters in every layer gradually decreases (or remains the same).

Original: Following the procedure described in Section 4.2.2, we obtain 100 models for each of these 3 new design spaces.
Revised: Following the procedure described in Section 4.2.2, we obtain 100 models for each of these 3 new design spaces.

Original: Table 2 reports the average performances of these 3 design spaces.
Revised: Table 2 reports the average performances of these 3 design spaces.

Original: The uniform allocation design pattern obtains the highest GLUE average performance, making this relatively simple, interpretable design pattern favorable.
Revised: The uniform allocation design pattern obtains the highest GLUE average performance, making this relatively simple, interpretable design pattern favorable.

Original: We willuniformly allocate the number of trainable parameters to layers.
Revised: We will allocate the number of trainable parameters to layers uniformly.

Original: We refer to S 1 with this additional design pattern as the new S 2 design space.
Revised: We refer to S 1 with this additional design pattern as the new S 2 design space.

Original: 4.2. T HE S 3 D ESIGN S PACE WITH A DDITIONAL T UNABLE G ROUP C ONSTRAINTS
Revised: 4.2. T HE S 3 D ESIGN S PACE WITH A DDITIONAL T UNABLE G ROUP C ONSTRAINTS

Original: Before digging into the strategy assignment design patterns, it is necessary to examine which groups need to be tuned.
Revised: Before digging into the strategy assignment design patterns, it is necessary to examine which groups need to be tuned.

Original: After all, it is only meaningful to study assigning strategies to different groups after we find out which groups need to be fine-tuned.
Revised: After all, it is only meaningful to study assigning strategies to different groups after we find out which groups need to be fine-tuned.

Original: As shown in Table 3, we explore various design patterns in tunable groups to further constrain the S 2 design space.
Revised: As shown in Table 3, we explore various design patterns in tunable groups to further constrain the S 2 design space.

Original: Based on the GLUE average performances, we find that all the groups need to be tuned to obtain the best performances.
Revised: Based on the GLUE average performances, we find that all the groups need to be tuned to obtain the best performances.

Original: This suggests that all the groups of pretrained layers have captured useful information that should be adapted to the downstream tasks.
Revised: This suggests that all the groups of pretrained layers have captured useful information that should be adapted to the downstream tasks.

Original: We will tune all the groups.
Revised: We will tune all the groups.

Original: We refer to S 2 with this additional design pattern as the new S 3 design space. 
Revised: We refer to S 2 with this additional design pattern as the new S 3 design space. [Equation]

Original: [Table]
Revised: [Equation]

Original: T HE S 4 D ESIGN S PACE WITH A DDITIONAL S TRATEGY C ONSTRAINTS
Revised: S 4 D ESIGN S PACE WITH A DDITIONAL S TRATEGY C ONSTRAINTS

Original: Finally, we study the subtle design pattern with respect to assigning proper strategies by further constraining the derived S 3 design space.
Revised: Finally, we study the subtle design pattern with respect to assigning proper strategies by further constraining the derived S 3 design space.

Original: Specifically, each design space consists of models that assign a subset of { Adapter (A), Prefix (P), BitFit (B), and LoRA (L) } to all layers of any group G i ( i = 1 , . .
Revised: Specifically, each design space consists of models that assign a subset of { Adapter (A), Prefix (P), BitFit (B), and LoRA (L) } to all layers of any group G i ( i = 1 , . .

Original: We begin by adding different G 1 strategy assignment constraints to the S 3 space. 
Revised: We begin by adding different G 1 strategy assignment constraints to the S 3 space. [Table]

Revised: ) pretrained backbone models, respectively.

Revised: The results are averaged over 20 random runs (with standard deviations as subscripts).

Revised: The S 4 -model and the S 4 -3b-model perform significantly better than the second-best PEFT methods in all the eight datasets at the significance level p < 0 .

Original:  Following the same pattern discovery procedure (Section 4.2.2), we discover strategy assignment patterns for G 1 .
Revised: 05( ∗ ) or even p < 0 . 01( ∗∗ ) [Table] Following the same pattern discovery procedure (Section 4.2.2), we discover strategy assignment patterns for G 1 .

Original: Then we progressively add G i ( i > 1 ) strategy assignment constraints together with the discovered strategy assignment patterns for all G j ( j = 1 , . .
Revised: Then we progressively add G i ( i > 1 ) strategy assignment constraints together with the discovered strategy assignment patterns for all G j ( j = 1 , . .

Original: , i − 1 ) to the S 3 space.
Revised: , i − 1 ) to the S 3 space.

Original: Due to space limit, we present results of this process in the Appendix (Table 8,  Table 9,  Table 10, and  Table 11), which suggests strategy assignment of G 1 -(A, L) – G 2 -(A, P) –G 3 -(A, P, B) – G 4 -(P, B,
Revised: Due to space limit, we present results of this process in the Appendix ( G 1 in Table 8, G 2 Table 9, Gin Table 10, and G 4 in Table 11), which suggests strategy assignment of G 1 -(A, L) – G 2 -(A, P) –

Original:  L) for the T5-base pretrained backbone model.
Revised: G 3 -(A, P, B) – G 4 -(P, B, L) for the T5-base pretrained backbone model.

Original: We will assign the discovered proper tuning strategies to groups.
Revised: We will assign the discovered proper tuning strategies to groups.

Original: We refer to S 3 with this additional design pattern as the new S 4 design space, which consists of the final S 4 -model.
Revised: We refer to S 3 with this additional design pattern as the new S 4 design space, which consists of the final S 4 -model.

Original: 4. D ISCOVERING D ESIGN P ATTERNS U SING T5-3 B
Revised: 4. D ISCOVERING D ESIGN P ATTERNS U SING T5-3 B

Original: We then repeat the above process on T5-3b to examine if the design patterns we discovered using smaller models (T5-base) still apply when we use larger models.
Revised: We then repeat the above process on T5-3b to examine if the design patterns we discovered using smaller models (T5-base) still apply when we use larger models.

Original: The results are shown in Table 12,
Revised: The results are shown in Table(layer grouping),

Original: Table 13, Table 14  and Table 15 in the Appendix.
Revised: Table 13 (trainable parameter allocation), Table 14 (tunable groups) and Table(strategy assignment) in the Appendix.

Original: We observe that the design patterns still apply when larger models like T5-3b are used: (i) grouping layers in a spindle pattern (Table 12), (ii) uniformly allocating the number of trainable parameters to layers (Table 13), (iii) tuning all the groups (Table 14), and (iv) tuning different groups with proper strategies (Table 15).
Revised: We observe that the design patterns still apply when larger models like T5-3b are used: (i) grouping layers in a spindle pattern (Table 12), (ii) uniformly allocating the number of trainable parameters to layers (Table 13), (iii) tuning all the groups (Table 14), and (iv) tuning different groups with proper strategies (Table 15).

Original: For T5-3b, the discovered proper strategy assignment is G 1 -(P, L) – G 2 -(A, L) – G 3 -(P, B, L) – G 4 -(A, P, B).
Revised: For T5-3b, the discovered proper strategy assignment is G 1 -(P, L) – G 2 -(A, L) – G 3 -(P, B, L) – G 4 -(A, P, B).

Original: We refer to the final design space as S 4 -3b and the final model in this space as S 4 -3b-model. 
Revised: We refer to the final design space as S 4 -3b and the final model in this space as S 4 -3b-model. [Table]

Original:  E VALUATION
Revised:  E VALUATION

Original: The S 4 -model (Section 4.2.5) and S 4 -3b-model (Section 4.3) adopt all the design patterns that have been discovered by using T5-base and T5-3b, respectively.
Revised: The S 4 -model (Section 4.2.5) and S 4 -3b-model (Section 4.3) adopt all the design patterns that have been discovered by using T5-base and T5-3b [Table] respectively.

Original: As a result, they are both new methods of parameter-efficient fine-tuning.
Revised: As a result [Table] they are both new methods of PEFT.

Original: We will evaluate their effectiveness when applied to different pretrained backbone models and different NLP tasks.
Revised: We will evaluate their effectiveness when applied to different pretrained backbone models and different NLP tasks.

Original: 5. E XPERIMENTAL S ETUP 
Revised: 5. E XPERIMENTAL S ETUP Datasets

Original: Datasets Besides the GLUE datasets (Wang et al., 2018)
Revised: Besides the GLUE datasets (Wang et al., 2018)

Original: (Section 4.1), we further evaluate our methods on two generation tasks used by He et al.
Revised: (Section 4.1), we further evaluate our methods on two generation tasks used by He et al.

Original: (2022): (i) Abstractive Summarization using
Revised: (2022): (i) Abstractive Summarization using

Original: XSum (Narayan et al., 2018), and (ii) Machine Translation using the WMT 2016 en-ro dataset (Bojar et al., 2016).
Revised: XSum (Narayan et al., 2018), and (ii) Machine Translation using the WMT 2016 en-ro dataset (Bojar et al., 2016).

Original: We report ROUGE scores (Lin, 2004) on the XSum test set, and BLEU scores (Papineni et al., 2002) on the en-ro test set.[Table] [Table]
Revised: We report ROUGE scores (Lin, 2004) on the XSum test set, and BLEU scores (Papineni et al., 2002) on the en-ro test set.

Original: Models and Model Settings
Revised: Models and Model Settings

Original: We mainly compare our methods with the following baselines: (i)
Revised: We mainly compare our methods with the following baselines: (i)

Original: Full Fine-tuning (full): it fine-tunes all the model parameters in the pretrained models; (ii) Adapter (Houlsby et al., 2019b): it adds adapter modules to each transformer layer;
Revised: Full Fine-tuning (full): it fine-tunes all the model parameters in the pretrained models; (ii) Adapter (Houlsby et al., 2019b): it adds adapter modules to each transformer layer;

Original: (iii) Prefix (Li & Liang, 2021): it optimizes a set of small continuous vectors prepended to transformer layers; (iv) BitFit (Zaken et al., 2021): it only updates the bias terms in pretrained models; (v) LoRA (Hu et al., 2021): it decomposes the attention weight into low-rank matrices to reduce the number of trainable parameters.
Revised: (iii) Prefix (Li & Liang, 2021): it optimizes a set of small continuous vectors prepended to transformer layers; (iv) BitFit (Zaken et al., 2021): it only updates the bias terms in pretrained models; (v) LoRA (Hu et al., 2021): it decomposes the attention weight into low-rank matrices to reduce the number of trainable parameters.

Original: Besides T5 (Raffel et al., 2020), we additionally apply our methods to other backbone models including RoBERTa-base/large (Liu et al., 2019) and BART-base/large (Lewis et al., 2020a).
Revised: Besides T5 (Raffel et al., 2020), we additionally apply our methods to other backbone models including RoBERTa-base/large (Liu et al., 2019) and BART-base/large (Lewis et al., 2020a).

Original: We use the default settings.
Revised: We use the default settings.

Original: We set the total number of trainable parameters (in the percentage of that in the backbone model) by following He et al.
Revised: We set the total number of trainable parameters (in the percentage of that in the backbone model) by following He et al.

Original: Specifically, this value is set to 0.5% for
Revised: Specifically, this value is set to 0.5% for

Original: Adapter, Prefix, LoRA, and our methods, and 0.1% for BitFit.
Revised: Adapter, Prefix, LoRA, and our methods, and 0.1% for BitFit.

Revised: For all the experiments, we followed Liu et al.

Revised: (2019) to set the linear decay scheduler with a warmup ratio of 0.06 for training.

Revised: The batch size was 128 for base models and 64 for large models.

Revised: The maximum learning rate was 5 e − 5 and the maximum number of training epochs was set to be either 5 or 10 .

Revised: All the experiments were performed

Original: 5. E FFECTIVENESS ON GLUE WITH T5 B ACKBONES
Revised: 5. E FFECTIVENESS ON GLUE WITH T5 B ACKBONES

Original: [Table]
Revised: [Table]

Original: With our discovered design patterns
Revised: With our discovered design patterns

Original: [Table]
Revised: [Table]

Original: we fine-tune T5-base ( S 4 -model) and T5-3b ( S 4 -3b-model) on GLUE and compare them with all the baseline methods.
Revised: we fine-tune T5-base ( S 4 -model) and T5-3b ( S 4 -3b-model) on GLUE and compare them with all the baseline methods.

Original: The results are shown in Table
Revised: The results are shown in Table

Original: [Table]
Revised: [Table]

Original: where the key measure is the GLUE average performance (last column).
Revised: where the key measure is the GLUE average performance (last column).

Original: We find that our S 4model and S 4 -3b-model consistently outperform the investigated methods in the key measure.
Revised: We find that our S 4model and S 4 -3b-model consistently outperform the investigated methods in the key measure.

Original: By tuning only 0 .
Revised: By tuning only 0 .

Original: 5% parameters, our methods even outperform the full fine-tuning baseline where all the parameters are tuned, indicating the effectiveness of our discovered parameterefficient fine-tuning design patterns.
Revised: 5% parameters, our methods even outperform the full fine-tuning baseline where all the parameters are tuned, indicating the effectiveness of our discovered PEFT design patterns.

Original: 5. G ENERAL E FFECTIVENESS ON GLUE WITH R O BERT A B ACKBONES
Revised: 5. G ENERAL E FFECTIVENESS ON GLUE WITH R O BERT A B ACKBONES

Original: We directly apply the S 4 -model and S 4 - 3b-model (adopting design patterns discovered using T5-base and T5-3b) to finetune the RoBERTa-base and RoBERTalarge pretrained backbone models, respectively.
Revised: We directly apply the S 4 -model and S 4 - 3b-model (adopting design patterns discovered using T5-base and T5-3b) to finetune the RoBERTa-base and RoBERTalarge pretrained backbone models (with no extra discovery process), respectively.

Original: We keep all the other settings the same and evaluate them on GLUE datasets.
Revised: We keep all the other settings the same and evaluate them on GLUE datasets.

Original: We also compare with variant methods randomly sampled from two design spaces: (i) S 0 -model , where all the designs are randomly selected for RoBERTa as in S 0 ; (ii) S 3 -model , where strategies are randomly assigned to different RoBERTa layer groups as in S 3 .
Revised: We also compare with variant methods randomly sampled from two design spaces: (i) S 0 -model , where all the designs are randomly selected for RoBERTa as in S 0 ; (ii) S 3 -model , where strategies are randomly assigned to different RoBERTa layer groups as in S 3 .

Original: Table 5 shows that (i) the design patterns (adopted by S 4 -model and S 4 -3b-model) discovered using T5 models are applicable to the RoBERTa backbone models and outperform the investigated methods in GLUE average performances with no extra discovery process 4 ; (ii) improved performances from S 0 -models, S 3 -models, to S 4 -(3b)-models support adding more constraints in the pattern discovery process (Section 4).
Revised: Table 5 shows that (i) the design patterns (adopted by S 4 -model and S 4 -3b-model) discovered using T5 models are applicable to the RoBERTa backbone models and outperform the investigated methods in GLUE average performances with no extra discovery process;(ii) improved performances from S 0 -models, S 3 -models, to S 4 -(3b)-models support adding more constraints in the pattern discovery process (Section 4).

Original: 5. G ENERAL E FFECTIVENESS ON G ENERATION T ASKS WITH BART B ACKBONES
Revised: 5. G ENERAL E FFECTIVENESS ON G ENERATION T ASKS WITH BART B ACKBONES

Original: Like in Section 5.3, we further directly apply the S 4 -model and S 4 -3b-model (adopting design patterns discovered using T5-base and T5-3b) to fine-tune the BART-base and BART-large pretrained backbone models, respectively.
Revised: Like in Section 5.3, we further directly apply the S 4 -model and S 4 -3b-model (adopting design patterns discovered using T5-base and T5-3b) to fine-tune the BART-base and BART-large pretrained backbone models (without additional discovery process.), respectively.

Original: We evaluate the models on two generation tasks: summarization (XSUM) and machine translation (en-ro) following He et al.
Revised: We evaluate the models on two generation tasks: summarization (XSUM) and machine translation (en-ro) following He et al.

Original: We also compare with PA (parallel adapter) using the same number of trainable parameters (He et al., 2022).
Revised: We also compare with PA (parallel adapter) using the same number of trainable parameters (He et al., 2022).

Original: Table 6 shows that our methods, although adopting design patterns discovered from classification tasks using T5, still outperform investigated parameter-efficient fine-tuning strategies on generation tasks with different BART backbones.
Revised: Table 6 shows that our methods, although adopting design patterns discovered from classification tasks using T5, still outperform investigated PEFT strategies on generation tasks with different BART backbones.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: Parameter-efficient fine-tuning adapts knowledge in pretrained models to down-stream tasks in a more parameter-efficient fashion.
Revised: PEFT adapts knowledge in pretrained models to down-stream tasks in a more parameter-efficient fashion.

Original: Instead of focusing on designing another strategy in the first place, we introduced parameter-efficient fine-tuning design spaces.
Revised: Instead of focusing on designing another strategy in the first place, we introduced PEFT design spaces.

Original: We empirically discovered several design patterns in parameter-efficient fine-tuning.
Revised: We empirically discovered several design patterns in PEFT.

Original: These design patterns led to new parameter-efficient fine-tuning methods.
Revised: These design patterns led to new PEFT methods.

Original: Experiments showed that these methods consistently outperform investigated parameter-efficient fine-tuning strategies across different backbone models and different tasks in natural language processing.
Revised: Experiments showed that these methods consistently outperform investigated PEFT strategies across different backbone models and different tasks in natural language processing.

Original: A M ORE E XPERIMENTAL R ESULTS
Revised: A M ORE E XPERIMENTAL R ESULTS

Original: [Table] [Table]
Revised: [Table] [Table]

Revised: epochs

Original: [Table]
Revised: Increasing

Original: [Table]
Revised: [Table]

Original: Uniform
Revised: Uniform

Original: [Table]
Revised: [Table]

Original: Decreasing
Revised: Decreasing

Original: [Table]
Revised: [Table]

Original: [Table]

Original: [Table]

Original: [Table]
Revised: [Table]

Original:  Spindle
Revised: 9 Spindle

Original: [Table]

Original: [Table]
Revised: [Table]

Original: Bottleneck
Revised: Bottleneck

Original: [Table]
Revised: [Table]

Original: [Table]

Original: [Table]

Original: Increasing
Revised: Increasing

Original: [Table]

Original: [Table]

Original: [Table]
Revised: [Table]

Original: Uniform
Revised: Uniform

Original: [Table]
Revised: [Table]

Original: [Table]

Original: [Table]

Original: [Table]

Original: Decreasing
Revised: Decreasing

Original: [Table]
Revised: [Table]

Original: [Table] [Table] 75.1 Spindle
Revised: Spindle

Original: [Table]
Revised: [Table]

Original: Bottleneck
Revised: Bottleneck

Original: [Table]
Revised: [Table]

Original: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Revised: 20 epochs

Original: Increasing
Revised: Increasing

Original: [Table]
Revised: [Table]

Revised: [Table]

Original: [Table]
Revised: [Table]

Original: 79.1 Uniform
Revised: 79.1 Uniform

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Decreasing
Revised: Decreasing

Original: [Table]
Revised: [Table]

Original: 1 Spindle
Revised: Spindle

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: We also directly use the S 4 -model and S 4 -3b-model (adopting design patterns discovered using T5base and T5-3b) to fine-tune the XLNet-base and XLNet-large pretrained backbone models without any extra discovery process. We keep all the other settings the same and evaluate them on SuperGLUE datasets.

Original: [Table]
Revised: Table 17 reiterates the fact that our PEFT design patterns discovered from T models are generelizable to the XLNet backbone models and outperform the investigated methods in other tasks (SuperGLUE (Wang et al., 2019)) with no additional discovery process. C O N THE D ISCOVERY S EQUENCE In this work, we follow the discovery sequence of “grouping patterns – trainable parameter allocation – tunable groups – strategy assignment”:

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]

Revised: -(A, P, L)

Original: [Table]
Revised: [Table]

Revised: -(P

Original: [Table]
Revised: [Table]

Revised: B, L)

Original: [Table]
Revised: [Table]

Revised: 2 -(A, P, B)

Original: [Table]
Revised: [Table]

Revised: 2 -(A, B, L)

Original: [Table]
Revised: [Table]

Revised: (A

Original: [Table]
Revised: [Table]

Revised: B, L)

Original: [Table]
Revised: [Table]

Original: 82.3 G
Revised: To explore and understand the design patterns in all the layers in large pre-trained models in scale, it is necessary and more efficient to study the layers in the unit of groups. So we start with the grouping patterns. Once figuring out the optimal grouping patterns, it is then important to explore how to allocate the trainable parameters to these different groups in order to study more subtle designs with fair comparisons (e.g., this would allow comparing different patterns of strategy assignments without the impact from different trainable parameters.). Next, it becomes influential to examine which groups need to be learned during fine-tuning before we dig into the strategy assignment patterns.

Revised: Because it is only meaningful to study assigning strategies to different groups after we figure out which groups need to be learned.

Revised: Finally, we study the tuning strategy assignment, which is the most subtle design.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: 76.8 Decreasing 83. 74.5 Spindle 88. Bottleneck 86.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Prefix
Revised: Prefix

Original: [Table] [Table]
Revised: [Table] [Table]

Original: BitFit
Revised: BitFit

Original: [Table] [Table]
Revised: [Table] [Table]

Original: LoRA
Revised: LoRA

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: BitFit
Revised: BitFit

Original: [Table] [Table]
Revised: [Table] [Table]

Original: LoRA
Revised: LoRA

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]