Lottery Ticket Adaptation: Mitigating Destructive Interference in LLMs

## Abstract

Abstract Existing methods for adapting large language models (LLMs) to new tasks are not suited to multi-task adaptation because they modify all the model weights–causing destructive interference between tasks. The resulting effects, such as catastrophic forgetting of earlier tasks, make it challenging to obtain good performance on multiple tasks at the same time.
To mitigate this, we propose Lottery Ticket Adaptation (LoTA), a sparse adaptation method that identifies and optimizes only a sparse subnetwork of the model. We evaluate LoTA on a wide range of challenging tasks such as instruction following, reasoning, math, and summarization. LoTA obtains better performance than full fine-tuning and low-rank adaptation (LoRA), and maintains good performance even after training on other tasks – thus, avoiding catastrophic forgetting. By extracting and fine-tuning over lottery tickets (or sparse task vectors ), LoTA also enables model merging over highly dissimilar tasks. Our code is made publicly available . 1 1 1 A preliminary version of this work has appeared in [ 1 ] .

## 1 Introduction

Large language models (LLMs) [] have seen an explosion of applications to real-world problems [, ] via adaptation [] to new tasks. Three major *multi-task adaptation* paradigms have emerged: storing and loading task-specific *adapters* [, ], continuing to train instruction-tuned models on new tasks in serial via *sequential training* [], and combining the adaptations to tasks learned in parallel via *model merging* [].
Each paradigm has its own associated challenges, such as catastrophic forgetting during sequential training [, , , , ], and methods that have been proposed to mitigate these challenges [, ]. In this work, we propose a new LLM adaptation method, called Lottery Ticket Adaptation (LoTA), that (1) provides sparse adaptation by freezing a majority of the parameters and updating only a sparse subnetwork of the base model and (2) resolves the challenges in common *multi-task adaptation* paradigms. (More details in Section 3.) We summarize our contributions:

- •
We train *lottery tickets* (or *sparse task vectors*) that can be stored efficiently and obtain performance similar to full fine-tuning (FFT) and higher than LoRA across a range of tasks spanning reasoning, math, code generation, and instruction following. When adapting Mistral for instruction following, FFT and LoTA both get a length-controlled AlpacaEval 2 winrate [](how often GPT-4 prefers the outputs of our model over its own) of $19.0\%$, but LoRA only gets a winrate of $15.3\%$.
- •
We apply LoTA to mitigate catastrophic forgetting [] of earlier tasks, enabling sequential adaptation to new tasks. When adapting an instruction tuned model to a mix of new tasks, the winrate of the FFT model drops from $19.0\%$ to $0.5\%$, but by using LoTA we can limit the drop to $15.9\%$.
- •
We can use LoTA to merge models in parallel [, , ] across dramatically different tasks, achieving better performance than existing merging methods that rely on post hoc sparsification [] (which degrades performance for FFT models) because it naturally trains *sparse task vectors*. When merging instruction following and math models with LoTA, we get a task-average performance of $38.5\%$ where a merge of FFT models obtains $36.7\%$.

## 2 Background: Multi-Task Adaptation

In this section, we go over common multi-task adaptation paradigms and discuss the challenges existing fine-tuning methods, such as FFT and LoRA, bring in each paradigm.

Figure: Figure 1: Multi-task adaptation: storing and loading adapters, sequential training, model merging.
Refer to caption: x1.png

#### Storing and Loading Adapters.

As illustrated in the first row of Figure 1, an emerging paradigm for multi-task adaptation is to store an adapter for each desired task and load a particular adapter at inference time [, , ], depending on the need []. Notably, Apple stores and loads adapters to enable their on-device models [].
This approach, while avoiding any interference between tasks, increases the memory and compute cost as it requires storing and loading an additional adapter per task. To mitigate these costs, a number of PEFT methods have been developed [, , , ].
Among them, LoRA [] (training adapters in the low-rank space) has received notable attention due to its simplicity. For instance, services such as Punica and S-LoRA allow developers to use this approach to serve large numbers of task-specific adapters for specific requests [, ].
However, a persistent gap in capacity between PEFT methods and FFT has presented a tradeoff between adapter overhead and performance [, , , , ].

#### Sequential Training.

When it is desired to have a single model with multi-task abilities (as opposed to storing and loading adapters per task), one common approach is to fine-tune the model on different tasks sequentially [], e.g., first fine-tune on task A, then fine-tune on task B. This is summarized in the second row of Figure 1. Note that sequential training is distinct from continual pre-training, because sequential training uses the instruction tuning objective whereas continual pre-training typically uses the pre-training objective of next-word-prediction [].

Fine-tuning the LLM for new tasks with FFT or existing PEFT methods leads to catastrophic forgetting of earlier tasks. This is problematic, especially for *safety* alignment, since we can fine-tune an LLM to be safe but later get this feature erased during future fine-tuning on new tasks []. In fact, a number of works have aimed to mitigate this vulnerability [, , , , ], leaving an open research question: *Can model developers allow users to finetune their aligned models on custom datasets while retaining safety?*

#### Model Merging.

There has been a recent interest in model arithmetic and editing methods, including merging multiple models adapted to different individual tasks to have a single model adapted to multiple tasks simultaneously []. As the third row of Figure 1 shows, this is typically done via aggregating *task vectors* (or adapters) of different tasks. The existing model merging techniques either require post-processing the task vectors through sparsification [, , ], degrading the performance on the task, and/or require extensive hyperparameter tuning for a weighted aggregation of task vectors [, ].

Each paradigm of multi-task learning poses different challenges, and different methods have been proposed to address these challenges. We defer the more in-depth analysis of these proposed methods in Section 6 because of the sheer quantity of related work that must be covered. The number of methods itself poses challenges for studying their drawbacks, especially when these methods are adopted in settings orthogonal to those they were originally developed for (i.e., LoRA leading to catastrophic forgetting of safety alignment []). *Rather than proposing tailored solutions for each paradigm of multi-task adaptation, we want to propose a simple algorithm that can serve as an effective foundation across all three paradigms and evaluate it on a wide range of challenging tasks.*

## 3 Lottery Ticket Adaptation (LoTA)

Figure: Algorithm 1 Lottery Ticket Adaptation (LoTA)

The desiderata for each multi-task adaptation paradigm motivates the design of our method. For *adapters*, we want a representation that can be easily compressed for memory efficiency. For *sequential training*, we want a representation that minimizes destructive interference between the previously learned tasks and tasks to be learned in the future.
For *model merging*, we want representations that are mutually sparse with each other in parameter space to again prevent destructive interference. We now propose LoTA, a single method that enjoys all these features. We first describe the workflow of LoTA, then revisit the problems each multi-task paradigm faces and discuss how and why LoTA successfully mitigates them.

Lottery Ticket Adaptation (LoTA).
LoTA works in three phases as summarized in Figure 2: (1) mask calibration, (2) mask extraction, (3) sparse adaptation. In the mask calibration phase of LoTA, a base model with parameters $w_{P}$ is fine-tuned for $\mathcal{T}$ iterations, yielding a fine-tuned model with parameters $w_{F}$. Then, in the mask extraction phase, LoTA extracts a sparsity mask $m$ from the task vector $\Delta=w_{F}-w_{P}$ based on the magnitude of the updates in $\Delta$. $\mathcal{T}$ could be as small as one iteration. In the sparse adaptation phase of LoTA, the model is first reset to its original state with weights $w_{P}$. Then the subnetwork $w_{P}\odot m$ is fine-tuned for $T$ iterations, while leaving the remaining parameters $w_{P}\odot(1-m)$ frozen at their initial values. We summarize the workflow of LoTA in Figure 2 and Algorithm 1 further.

By confining the adaptation updates within subnetworks (identified by $m$), LoTA is able to mitigate destructive interference, e.g., adaptation loss during fine-tuning on future datasets or model merging, that FFT and LoRA suffer from. We discuss this in more detail under three multi-task adaptation paradigms below and provide empirical comparisons with FFT and LoRA in Section 5.

Figure: Figure 2: Lottery Ticket Adaptation (LoTA): (1) Mask calibration via FFT for $\mathcal{T}$ iterations, (2) Extracting the sparsity mask $m$ from the task vector $\Delta$, (3) Sparse fine-tuning with sparsity mask $m$ for $T$ iterations.
Refer to caption: x2.png

#### (1) Storing & Loading Adapters.

As mentioned before, PEFT methods have emerged to reduce the memory cost of storing and loading adapters. However, the most popular and commonly used PEFT method, LoRA, restricts the adaptation updates to have a low rank, which may be insufficient for complex downstream tasks [, ]. In parallel, recent work [] on compressing the delta between the fine-tuned and pre-trained model $\Delta=w_{F}-w_{P}$ suggests that FFT updates are highly compressible through a simple magnitude-based sparsification. LoTA exploits this underlying sparsity during fine-tuning and obtains better performance than LoRA, while requiring fewer parameters to be trained. As we will show, LoTA adapters can be stored efficiently because of the small number of parameters that need to be updated. LoTA also requires fewer parameters to be updated in the model when the adapter is applied to the model, so loading a LoTA adapter can be faster than loading a LoRA adapter.

#### (2) Sequential Training.

Existing fine-tuning methods, such as FFT and LoRA, are known to cause catastrophic forgetting []. This is particularly concerning for safety alignment as any safety measure the model developers add could be erased by further fine-tuning. By restricting the task vectors to be sparse, LoTA provides robustness against catastrophic forgetting. This is because it will be less likely that an adaptation to new data requires modifying the weights needed for the previous task when fewer weights are updated. As LoTA prevents destructive interference between sequential tasks via sparse and disjoint task vectors, the same phenomenon is also helpful in adapting to new tasks. To further enhance the robustness against destructive interference in sequential training, we propose Lottery Ticket Together Optimization (LoTTO) which learns mutually sparse (i.e., non-overlapping) masks for sequentially learned tasks.

Figure: Algorithm 2 Lottery Ticket Together Optimization (LoTTO)

#### Further Enhancing Sequential Training via Lottery Ticket Together Optimization (LoTTO).

Without loss of generality, suppose we have two tasks, Task A and Task B, and that we have already learned Task A with LoTA. LoTTO calibrates a sparsity mask for Task B by first training a model where the only weights that can be updated are those that are *not* updated when running LoTA on Task A, and then using a sparse set of those weights to train the final model. LoTTO enables learning new tasks without forgetting old ones, by restricting weight adaptations to not interfere with the weights that were important for previous adaptations. This procedure can be applied inductively to enable sequential adaptation to multiple tasks, so that a model developer seeking to adapt a model adapted with LoTA (potentially on several tasks), just needs to ensure that they do not update the task vector with respect to the base model. We envision that LoTTO will be applied to capabilities one at a time; first the model learns math, then coding, then reasoning, then planning, etc. If $1\%$ of the weights are updated for each capability, then LoTTO can fit at most $100$ capabilities. We believe this is sufficient for nearly all practical applications, but when the subnetworks for different tasks overlap, we do not expect that LoTTO will result in any worse forgetting than LoTA, which we will show itself has better robustness to forgetting than FFT.

#### (3) Model Merging.

Existing model merging methods typically aim to merge task vectors of relatively similar language datasets [, , ], and they do so after a post hoc sparsification [, , ] of the task vectors. The post hoc sparsification aids in ensuring the task vectors are disjoint – hence can prevent destructive interference – but, in return, degrades the performance of each individual task. LoTA, on the other hand, enforces sparsity during fine-tuning and directly trains *sparse task vectors*, obviating the need for post hoc sparsification.

## 4 Experimental Setup

In this section, we provide details of the experimental setup, including the baselines, model, dataset, and metric selection. We present the results later in  Section 5. We share our [open-source code](https://github.com/kiddyboots216/lottery-ticket-adaptation). We are limited to an academic computing budget, and all results are conducted with a single A100 GPU. We typically do $1-3$ epochs of training for each dataset as this is a standard choice in LLM fine-tuning and indicate it specifically for single-epoch fine-tuning. We use the RMSProp optimizer with default hyperparameters.

Baselines & Hyperparameters.
Across all three multi-task adaptation paradigms, we compare LoTA against FFT and LoRA. We extensively tune the hyperparameters for FFT and LoRA to ensure that we are comparing against strong baselines. We do not tune hyperparameters for LoTA and directly transfer the hyperparameters from FFT. We fix the sparsity ratio hyperparameter in LoTA to $90\%$, so that the number of parameters updated roughly matches that of the best-performing LoRA rank of $256$. We provide an ablation study with higher sparsity levels in Section 5.1. We report all ranges for hyperparameters in  Appendix A.

Models.
We use the best performing open-weights model families, Mistral [] and Llama 3 [, ], specifically Mistral-7B and Llama-3-8B – the largest models we can adapt with FFT on a single GPU.

Tasks
We consider six capabilities: instruction following, safety, math, coding, summarization, and reasoning.
We now briefly discuss each capability, the datasets we use to fine-tune and evaluate the presented methods, and the motivation behind the choices.

Instruction Following.
The most widely-used instruction-tuned LLMs are the “Instruct” or “chat” versions of base models, such as Llama-3-8B-Instruct []. This is because the process of tuning models on human instructions aligns models to human preferences across a range of tasks []. For this, we adapt models to data from UltraFeedback [], which contains a mixture of datasets covering truthfulness, honesty, and helpfulness in addition to instruction-following. We measure the instruction following ability by length-controlled AlpacaEval2 Win Rate [], which we refer to as “winrate”. A high winrate means that GPT-4 [] prefers the responses of our model on a set of representative prompts over its own responses. Winrate is the metric most closely correlated with human rating preference [].
Another common benchmark for “chat” models is MT-Bench [], but there is a significant degree of data contamination between MT-Bench and other task-specific training datasets []–hence, we do not evaluate on MT-Bench.

Reasoning.
We train on the standard set of $8$ commonsense reasoning tasks [, , , , , , ] (Boolq, PIQA, SocialIQA, Hellaswag, Winograde, ARC-easy, ARC-challenge, OpenBookQA) and report the exact-match accuracy on the test set. As a representative task, we use ARC-easy.

Math.
We use the set of $9$ math instruction datasets from [] for fine-tuning and report performance on the test set of GSM8k []. When only considering a single task, we choose GSM8k as the representative task as it is commonly used as a single training and test task by other papers.

Code Generation.
We use data that instructs the model to write SQL queries given some context [](SQL-create-context) and report the ROUGE-1 F1 score [] on the test set.

Summarization.
We use data from Samsum [] and report the ROUGE-1 F1 score on the test set.

Safety.
We define safety as a latent capability generated by instruction tuning.
A recent concern in AI policy is that, while frontier models such as GPT-3.5/GPT-4 are aligned, they can also be fine-tuned and this presents an opportunity to misalign them. Recently, Qi et al. [] show that by fine-tuning GPT-3.5 on just $100$ harmful examples for a few epochs, they can ask it to answer harmful queries that it ordinarily would refuse, and Zhan et al. [] show the same for GPT-4.  Lermen et al. [] show that this can be done with LoRA rather than the fine-tuning method OpenAI are using in their fine-tuning API (presumably FFT). This is more than an academic concern; SB-1047 [], recently passed in California, requires model developers providing access to frontier models to implement best effort mitigations to prevent users from misaligning those models. We evaluate the safety of our models on HEx-Phi [], a dataset of 330 questions spanning multiple categories such as malware, fraud, etc. The safety score (higher is better) is the percentage of queries from the test set where the model refuses to respond. Aligned models such as Llama-3-Instruct will score $100\%$ on this task, but because we are doing the alignment ourselves starting from a base model, our baseline Instruct model only gets $93\%$ on this task. Given that we are primarily interested in measuring the *forgetting* of safety alignment, we do not see this as a major limitation.

## 5 Experimental Results

### 5.1 LoTA Design Choices

Before comparing LoTA to other baselines, we first evaluate the impact of varying the two hyperparameters in our method: the sparsity level and how many iterations we calibrate the mask for.

Sparsity. We vary the sparsity parameter in LoTA in Table 1. Multiple sparsity thresholds work well; a small amount of sparsity (i.e., $10\%$) seems to have a negative impact on the model, but this is within the error bars and may just be variance. Attempting to achieve $99\%$ sparsity from the task vector of an FFT model does not yield good results. Instead, we can first obtain a mask with $90\%$ sparsity, then train a LoTA model with this mask, and then use the task vector from the $90\%$-sparse LoTA model to calibrate the mask for our $99\%$-sparsity model, which we denote as $99\%^{*}$.
Composing multiple steps of calibration trades off performance in the high-compression setting with compute overhead.

**Table 1: The impact of varying the sparsity ratio on the performance of LoTA. $99\%^{*}$ denotes the model calibrated with iterative LoTA.**
| Sparsity | $0\%$ | $10\%$ | $25\%$ | $50\%$ | $75\%$ | $90\%$ | $99\%$ | $99\%^{*}$ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Performance | $19.0_{1.0}$ | $18.2_{1.0}$ | $18.5_{1.0}$ | $18.2_{1.0}$ | $19.5_{0.9}$ | $19.0_{1.0}$ | $13.1_{0.8}$ | $17.4_{0.9}$ |

Compute Overhead. Arguably, the main reason why PEFT methods such as LoRA are commonly used is because they reduce the memory consumption in the backward pass, thus enabling the use of a larger pass. [] recently critically analyzed this and found that to fit tasks such as math and code generation, LoRA needs to use high ranks, which in turn reduces the speedup to at most $15\%$. We nevertheless acknowledge that any and all PEFT methods will be faster than LoTA during *training* because LoTA requires an initial pass over the dataset to calibrate the sparsity mask.

**Table 2: LoTA performance degrades gracefully as a smaller fraction of the data is used on the most challenging task (instruction following). 0 data usage corresponds to just creating a random mask.**
| Data Used | $10\%$ | $1\%$ | 0 |
| --- | --- | --- | --- |
| Performance Drop (from $100\%$) | $4.2\%$ | $10\%$ | $20\%$ |

In Table 2, we now consider how the performance drops if we calibrate the mask for a fraction of the overall dataset, including the baseline where we use a random mask which corresponds to $0\%$ data used. LoTA can be efficiently calibrated, and even training on a small fraction of the dataset can provide $90\%$ of the performance of the fully calibrated mask.
If we take just a single iteration to calibrate the mask for LoTA, we can obtain $56.1\%$ on GSM8k, higher than any result LoRA can obtain.
Furthermore, instruction tuning datasets are generally quite small (we completed all experiments in a few hours on just a single GPU). Given that the mask can be efficiently calibrated, transferred from other datasets, or in the worst case, calibrated on the entire dataset in a few hours, we do not anticipate that the compute overhead of LoTA will be a major limitation of the method.

Memory Overhead. LoTA has a minor overhead when compared to FFT, because a bit-mask must be loaded for each parameter group. We provide an efficient implementation for this in our open-source code. repository. We can finetune Llama-3-8B with LoTA on a single 80GB A100, so we do not anticipate this minor memory overhead being a major limitation of our method.

We now evaluate LoTA and the baseline methods, FFT and LoRA, across all three paradigms of multi-task adaptation. In all experiments, we use LoTA with $90\%$ sparsity where the mask is calibrated by training for *a single epoch* ($\mathcal{T}$ is one epoch) on the adaptation dataset. We choose $90\%$ sparsity because this is a nontrivial sparsity level that we find achieves good performance across the range of tasks we consider. We ablate the level of sparsity and amount of calibration data in Section 5.1.

### 5.2 Adapting to a Single Task

We first consider the simplest setting, in which we fit an adapter to each dataset of interest starting from a pre-trained base model, i.e., one adapter per task. In Table 3, we find that LoTA outperforms LoRA and performs similarly to FFT. Although LoRA is able to achieve similar performance to LoTA on the easier tasks, such as SQL, Samsum, there is a clear gap in performance on the more challenging tasks, such as Instruction Following and GSM8k. LoTA consistently recovers the performance of FFT.

**Table 3: Performance comparison of Full Finetuning (FFT), LoRA and LoTA on single-task datasets for 3 epochs. We report the winrate on instruction following, the accuracy of exact match on the reasoning and math tasks, and the ROUGE-1 score on the SQL generation and summarization tasks. LoTA outperforms LoRA on the challenging tasks of instruction following, reasoning, and math, obtaining comparable performance to FFT. bold: best method, underline: second best method.**
| Model | Method | Instruction Following | Reasoning | GSM8k | SQL | Summarization |
| --- | --- | --- | --- | --- | --- | --- |
| Mistral | FFT | $\underline{19.0_{0.98}}$ | $83.5$ | $\mathbf{59.8_{1.0}}$ | $98.9_{0.1}$ | $52.0_{0.2}$ |
| LoRA | $15.3_{0.8}$ | $86.8$ | $57.0_{1.1}$ | $98.9_{0.1}$ | $\underline{52.9_{0.3}}$ |  |
| LoTA (ours) | $\mathbf{19.0_{0.7}}$ | $\mathbf{87.5}$ | $\underline{59.3_{1.1}}$ | $\mathbf{98.9_{0.1}}$ | $\mathbf{52.9_{0.2}}$ |  |
| Llama 3 | FFT | $\underline{17.61_{0.8}}$ | 84.8 | $\mathbf{63.4_{0.1}}$ | $\mathbf{99.4_{0.1}}$ | $\mathbf{53.6_{1.9}}$ |
| LoRA | $14.2_{0.8}$ | $84.1$ | $62.3_{0.4}$ | $98.7_{0.1}$ | $\underline{52.3_{0.2}}$ |  |
| LoTA (ours) | $\mathbf{18.0_{0.7}}$ | $\underline{84.4}$ | $\underline{63.2_{0.7}}$ | $\underline{99.0_{0.1}}$ | $\underline{52.3_{0.3}}$ |  |

High-Rank Adaptation Beats Low-Rank Adaptation. LoRA has a heavy regularizing effect on training. On the commonsense reasoning task, because the base model can get nontrivial zero-shot performance, LoRA actually improves the performance over that of FFT for Mistral. Note here that we do a grid search over learning rate and rank for LoRA, and the best performance is at $r=64,\eta=1e-4$. However, sparsity also has a regularizing effect, and LoTA is even more successful on the reasoning task when using the same learning rate as we searched for the base model ($1e-6$). On GSM8k, the regularization hurts performance significantly; [] report a similar-sized gap between LoRA and FFT on this dataset when training LLama-2-7B. If LoRA is underfitting the data, it may be better suited for settings where we only train for a single epoch, or on smaller datasets. In Table 4, we make a side-by-side comparison of LoRA and LoTA when training for a single epoch and find that LoTA outperforms LoRA significantly across all tasks; in fact, the difference is even more pronounced after a single epoch.

**Table 4: Performance comparison on single-task datasets for 1 epoch. bold: best method**
| Method | Model | Arc | GSM8k | SQL | Summarization |
| --- | --- | --- | --- | --- | --- |
| LoRA | Mistral | $70.4_{0.6}$ | $46.3_{1.1}$ | $98.6_{0.1}$ | $51.8_{0.2}$ |
| LoTA (ours) | Mistral | $\mathbf{73.8_{0.7}}$ | $\mathbf{53.5_{1.0}}$ | $\mathbf{99.3_{0.1}}$ | $\mathbf{54.3_{2.5}}$ |

#### Storing LoTA Adapters Efficiently.

Although FFT generally performs better than PEFT methods, it is typically infeasible to store a full copy of the model weights for each task. Practitioners, therefore, consider a tradeoff between memory and adaptation performance when loading task-specific adapters. We now discuss the memory consumption of LoTA and LoRA.
Storing the sparse task vector from LoTA requires $40$ bits per parameter; $32$ from the parameter, and $8$ for the delta encoding of the sparse indices. If we use $90\%$-sparse LoTA, our task vector is compressed $8\times$; if we use $99\%$-sparse LoTA, our task vector is compressed $80\times$. The memory-utility tradeoff between LoTA and LoRA can be quantified in terms of each method’s performance at a given level of compression, which translates into the sparsity level for LoTA and the rank $r$ for LoRA. Comparing the compression-utility tradeoff between LoRA and LoTA is challenging because the size of the saved LoRA adapter is determined by the rank parameter $r$, and more is not always better (which is why we have to tune $r$ for every task for LoRA).
As a single point of comparison, we can look at the performance on instruction following, where $99\%$-sparse LoTA ($17.4$) outperforms LoRA for any rank (best performance of $15.3$ achieved at $r=64$, increasing rank reduces performance), and they both achieve a similar compression factor.

### 5.3 Sequential Training

During sequential training, a model is first adapted to one capability (Task A) and then to another capability (Task B) (such as when creating a specialized model for math) or a set of capabilities (the most common setting for open-sourced fine-tunes of frontier models). The main challenges we seek to mitigate are (1) catastrophic forgetting of Task A and (2) the inability to adapt to Task B.
We set instruction following as Task A in all settings because this maps to the enterprise adaptation setting, where user queries need to be answered with a combination of instruction following and domain-specific knowledge. In particular, OpenAI offers a fine-tuning API for their aligned models (GPT-3.5 and GPT-4) [].

**Table 5: Sequential learning first on Task A (Instruction Following) then on Task B (varied). Fine-tuning on Tasks A and B is performed using both FFT and LoTA. The utility of each task is computed after fine-tuning on Task B is completed. Note that there is no utility when we fine-tune on harmful data to evaluate the catastrophic forgetting of Safety, and the baseline is the safety score of the Instruct model. FT=Fine-tuning. We reproduce the baseline of doing FFT on each method independently as reported in Table 3 for convenience; note that on the reasoning task LoTA outperforms FFT. bold: best method, underline second-best method; we do not report second-best when only two methods are presented. All results are with Mistral. We reuse the same mask for LoTTO calibrated on GSM8k for MathInstruct, Reasoning, GSM8k+Arc+SQL and Safety.**
| Task B | Method on Task A | Method on Task B | Utility of Task A (Drop) | Utility of Task B (Drop) |
| --- | --- | --- | --- | --- |
| Instruction Following | Baseline | - | 19.0 (-) | - |
| GSM8k | - | Baseline | - | 59.8 (-) |
| FFT | FFT | 15.2 (3.8) | 58.3 (1.5) |  |
| LoTA (ours) | FFT | 17.7 (1.3) | 58.7 (1.1) |  |
| FFT | LoTA (ours) | 15.9 (3.1) | 54.2 (5.6) |  |
| LoTA (ours) | LoTTO (ours) | 17.8 (1.2) | 59.1 (0.7) |  |
| FFT | LoRA | 14.1 (4.2) | 55.5 (4.9) |  |
| FFT | FFT (Mixed) | 16.3 (2.7) | 55.5 (4.3) |  |
| MathInstruct | - | Baseline | - | 56.7 (-) |
| FFT | FFT | $14.2_{0.8}~{}(4.8)$ | $51.3_{0.2}~{}(5.4)$ |  |
|  | LoTA (ours) | LoTA (ours) | $\textbf{16.0}_{0.7}~{}(-3.0)$ | $\textbf{55.5}_{0.1}~{}(1.2)$ |
| Reasoning | - | Baseline | - | 83.5 (-) |
| FFT | FFT | $0.2_{0.1}~{}(18.8)$ | 82.3 (1.2) |  |
| LoTA (ours) | LoTTO (ours) | $\textbf{16.5}_{0.9}~{}(2.5)$ | 83.7 (-) |  |
| GSM8k+Arc+SQL | - | Baseline | - | $77.0$ |
| FFT | FFT | $0.5_{0.2}~{}(18.6)$ | $\underline{75.0~{}(2.0)}$ |  |
| LoTA (ours) | FFT | $\underline{11.5_{0.7}~{}(7.5)}$ | 75.4 (1.6) |  |
| LoTA (ours) | LoTTO (ours) | $\textbf{15.9}_{0.9}~{}(3.1)$ | $73.8~{}(3.2)$ |  |
| Safety | Baseline | - | 93.1 (-) | - |
| FFT | FFT | $19.1_{3.5}~{}(73.9)$ | - |  |
| LoTA (ours) | LoTTO (ours) | $\textbf{63.4}_{2.2}~{}(29.7)$ | - |  |

Mitigating Catastrophic Forgetting While Enabling Adaptation to Downstream Datasets.
In Table 5 we consider a range of method combinations for a simplified setting where we seek to adapt an Instruct model to Math data without catastrophic forgetting. We will go row-by-row through the table and analyze each set of results. Even when training on just a single, relatively small dataset, FFT in both phases suffers a significant drop in winrate. An easy way to mitigate this is to simply train the initial Instruct model with LoTA. Following this, FFT on GSM8k does not significantly reduce winrate. However, it does present a potentially unwelcome tradeoff in task accuracy. For this, we turn to LoTTO, which achieves the best performance across both tasks.

Does LoRA Really Forget Less, or Does It Just Learn Less?
Recent work evaluates the performance of pre-trained models before and after fine-tuning on domain-specific tasks with LoRA [, ] and concludes that LoRA is less prone to catastrophic forgetting than FFT. In Table 5 we find that adapting the FFT Instruct model with LoRA does not lead to less degradation in winrate than adapting the FFT Instruct model with FFT, but it does lead to worse performance on the downstream task. Doing LoRA and then LoRA, or LoRA and then FFT, also does not match LoTA’s ability to prevent forgetting while enabling adaptation to downstream data.

How Much Does Data Reuse Help?
The simplest and arguably most performant method from prior work that we found for mitigating catastrophic forgetting is simply to mix in some in-distribution data from Task A. This is the line marked with “FFT (Mixed)”, and it does mitigate forgetting on Task A, but at the cost of performance on Task B. We ablate the amount of data from Task A to be used between $1-100\%$ of the dataset size of the data from Task B, and this is the best result in terms of mitigating forgetting on Task A. As we mix in less and less data from Task A, this method approaches just doing FFT sequentially in performance, so we omit those results for brevity.

Adapting Sequentially to Multiple Tasks with LoTTO. We now consider the more challenging setting when we need to adapt to *multiple* tasks without catastrophic forgetting while still obtaining good performance on those tasks.
In Table 5 we adapt an Instruct model to a mix of reasoning, math, and SQL data and find a surprising result; the FFT Instruct model collapses almost completely to a winrate of less than half a percent. As we showed in Table 5 this can be mitigated by mixing in more instruction following data, albeit at a cost. The LoTA Instruct model still degrades in performance ($19\rightarrow 11$) but nowhere near as much. In the line marked “LoTTO”, we instead adapt the LoTA Instruct model to the downstream tasks using the mask calibrated from GSM8k with LoTTO. Applying LoTTO to make the downstream adaptation be mutually sparse with the initial LoTA Instruct model increases performance significantly on instruction following and math. Performance on Arc and SQL suffers somewhat because our mask does not consider those tasks, but this means that our mask is much cheaper to calibrate and is, in fact, generalizable not only across tasks within a domain (as shown in Table 5) but also *across* domains.

Mitigating Catastrophic Forgetting of Safety Alignment.
In the “Safety” row of Table 5, we consider fine-tuning the Mistral Instruct model we trained ourselves on the $100$ harmful instructions from []. The baseline model gets a score of $93\%$ and training with FFT quickly degrades safety. Adapting the LoTA Instruct with LoTTO (again, with the LoTTO mask calibrated from GSM8k) mitigates this safety drop significantly, even though our LoTTO mask was calibrated on an extremely different dataset. Therefore, a potential mitigation would be for an entity providing a fine-tuning API such as OpenAI to do the safety training with LoTA, calibrate the LoTTO mask on a utility dataset, and then do fine-tuning on their client’s dataset with LoTTO. We do not intend to present our method as an active defense against fine-tuning attacks; although finetuning with LoTTO improves safety, given sufficient data and access to the model weights, any attacker can of course undo safety tuning entirely. However, catastrophic forgetting of safety alignment is an important problem with real-world applications, and we find it compelling that our method can mitigate this.

### 5.4 LoTA for Model Merging

We now consider the setting of model merging, where we train models on disjoint datasets fully in parallel and then merge together the task vectors with the goal of producing a model with good performance on multiple tasks. Prior work in model merging mostly considers merging similar datasets, such as the commonsense reasoning datasets, but it is relatively easy to merge models when the datasets are similar and becomes increasingly hard as the datasets become more heterogeneous due to the gradient mismatch []. We consider merging models trained on heterogeneous datasets.

Merging Models.
We use TIES-Merging [] to merge models trained on heterogeneous tasks. TIES performs post-hoc sparsification on each task vector and requires a 2-D hyperparameter search for this quantity, which we perform for the merge of FFT models. Naturally, we could optimize the performance of Task A by fully sparsifying Task B, and vice versa; we report the result that achieves good performance on Task B while maintaining some performance on Task A, and report the full range of hyperparameters in Appendix A. LoTA is inherently sparse, so when we merge a LoTA model with an FFT model we do not need to perform hyperparameter search on the LoTA model, and we use the same level of sparsity for the FFT model that we obtained when merging together two FFT models. When merging two LoTA models together, no hyperparameter search is required at all as both models are inherently sparse. We could in theory sparsify the LoTA models beyond their existing levels with post-hoc sparsification, but we do not tune this hyperparameter.

Challenge of Overlapping Sparsity in Model Merging.
In the sequential training paradigm, we exploited the fact that masks for different tasks have a significant overlap in order to generalize our LoTTO mask calibrated on GSM8k to provide robustness to forgetting across a range of other tasks. However, this same phenomenon of overlapping sparsity presents a challenge in the model merging setting.
The challenge is that because the merging is parallel, we cannot use LoTTO to calibrate the masks to be disjointly sparse as we did in the sequential training setting. One alternative is to enforce random disjoint masks for each task, corresponding to “$0\%$ Data Used” in Table 2.

**Table 6: Model merging using TIES of Task A, Instruction Following, and Task B, (varied). Fine-tuning on Tasks A and B is performed using both full fine-tuning (FFT) and LoTA. The utility of each task is computed after merging the two task vectors. bold: best result, underline: second best result. We reproduce the baseline for each task on FFT from Table 3 for convenience; note again that for some tasks the LoTA baseline outperforms the FFT baseline. All results are with Mistral.**
| Task B | Method on Task A | Method on Task B | Utility of Task A (Drop) | Utility of Task B (Drop) |
| --- | --- | --- | --- | --- |
| Instruction Following | Baseline | - | 19.0 (-) | - |
| GSM8k | - | Baseline | - | 59.8 (-) |
| FFT | FFT | $6.9_{0.5}~{}(12.1)$ | $59.1_{0.1}~{}(0.7)$ |  |
| LoTA (ours) | FFT | $\textbf{16.1}_{0.8}~{}(2.9)$ | $\textbf{60.5}_{1.1}~{}(+0.7)$ |  |
| FFT | LoTA (ours) | $14.0_{0.8}~{}(5.0)$ | $\underline{59.3}_{1.0}~{}(0.5)$ |  |
|  | LoTA (ours) | LoTA (ours) | $\underline{15.1}_{0.8}~{}(3.9)$ | $58.4_{1.1}~{}(1.5)$ |
| Samsum | - | Baseline | - | 52.0 (-) |
| FFT | FFT | $8.1_{0.7}~{}(10.9)$ | $47.0_{0.0}~{}(5.0)$ |  |
| LoTA (ours) | FFT | $\underline{13.8}_{0.8}~{}(5.2)$ | $51.8_{0.2}~{}(0.2)$ |  |
| FFT | LoTA (ours) | $10.4_{0.7}~{}(8.6)$ | $\textbf{53.3}_{0.1}~{}(+1.3)$ |  |
| LoTA (ours) | LoTA (ours) | $\textbf{15.4}_{0.9}~{}(3.6)$ | $\underline{52.7}_{0.1}~{}(0.1)$ |  |
| GSM8k+Samsum | - | Baseline | - | 55.9 (-) |
| FFT | FFT | $7.6_{0.6}~{}(11.4)$ | $49.7_{1.1}~{}(6.2)$ |  |
| LoTA (ours) | FFT | $8.9_{0.6}~{}(10.1)$ | $\underline{50.7}_{1.1}~{}(5.2)$ |  |
| FFT | LoTA (ours) | $\underline{10.7}_{0.7}~{}(8.3)$ | $\textbf{55.0}_{1.1}~{}(0.9)$ |  |
|  | LoTA (ours) | LoTA (ours) | $\textbf{13.1}_{0.8}~{}(5.9)$ | $46.6_{1.0}~{}(9.3)$ |

In Table 6 we merge together models trained on GSM8k and Samsum with the Mistral model that we trained for instruction following. We consider the full combination of merging FFT and LoTA models. The merge of two FFT models performs poorly in all settings on both tasks, indicating that post-hoc sparsification does not perform well for heterogeneous tasks, which is in line with recent model merging theory []. The merges that contain LoTA models have better performance across all tasks, but there is no combination that is pareto-optimal across all tasks.

## 6 Related Work

#### Model Pruning & Quantization.

Model pruning and quantization have been receiving increased attention for efficient storage and/or inference of large models. While most of the existing methods prune [, , ] or quantize [, , , ] the model weight directly, some focus specifically on compressing the *task vectors* [, , ] through post-training sparsification or quantization, assuming that the base model is worth the storage cost since it is being used frequently for many tasks. Our proposed PEFT method, LoTA, builds on this observation that the task vectors are highly compressible through sparsification and imposes this sparsity constraint at the beginning of fine-tuning to train *sparse task vectors*.

#### Lottery Ticket Hypothesis.

Motivated by the success of pruning methods at extreme sparsity ratios [], [] proposed the lottery ticket hypothesis (LTH), claiming the existence of sparse subnetworks (or lottery tickets) that could be trained from scratch to a performance comparably to training the dense model from scratch. While this could potentially provide a way to train models sparsely more efficiently rather than training them densely and pruning them later, finding the lottery tickets, i.e., the sparsity masks, is costly. Initially, [] proposed first training the models densely and then extracting the sparsity mask based on the magnitude of the trained dense model’s weights. Later, a number of more efficient methods were proposed to find the sparsity masks more efficiently, earlier in the dense training stage [, , , ]. Our work shows that LTH works successfully for fine-tuning LLMs as well–giving us a sparse adaptation tool, LoTA. We extensively study the tradeoff between the cost of finding the sparsity masks and the performance of the sparsely fine-tuned model. Unlike other studies on LTH for LLM adaptation [, ], our main focus and motivation is to mitigate destructive interference in multi-task adaptation.

#### Parameter-Efficient Fine-Tuning (PEFT).

Many practitioners fine-tune already pre-trained LLMs with less data and compute instead of training them from scratch [, , ]. While this reduces the cost of LLM training significantly, fine-tuning each and every parameter of these large models for each (or a few) task is still very costly. This has led to a number of parameter-efficient fine-tuning (PEFT) methods reducing the number of trainable parameters during fine-tuning [, , , , , , , ]. Among different PEFT methods, low-rank adaptation (LoRA) [] and its variants [, , , ] have shown similar performance to full fine-tuning in many tasks while reducing the number of trainable parameters through low-rank approximation to model updates during fine-tuning. Our PEFT method, LoTA, while reducing the number of trainable parameters significantly via sparsity, has various other benefits in different applications, such as avoiding catastrophic forgetting (of especially safety alignment), enabling fine-tuning on new tasks more successfully, model merging using sparse task vectors, unlearning, and communication-efficient federated learning (FL). We demonstrate that full fine-tuning and the existing PEFT methods fall short in these applications and significantly underperform LoTA.

#### Catastrophic Forgetting.

When LLMs go through sequential (or continual) multitask learning, i.e., fine-tuned on different tasks sequentially, they often suffer from performance loss on earlier tasks–known as catastrophic forgetting [, , , , ]. To mitigate this, a number of data-centric and architectural solutions have been proposed for language and other domains. Replay-based methods [, ] add a portion of the previously learned data during fine-tuning on a new task, which raises privacy concerns as it requires constant access to previously learned data. Regularization-based approaches [, ] tend to have poor adaptability to specific tasks. An architecture-based approach, “progressive prompts” [], sequentially concatenates soft prompts as they are being learned for each task–showing some resistance against forgetting. However, they require access to task identifiers at inference for each task, which is not always feasible. Other architecture-based approaches add additional modules to learn task-specific abilities [, ]–requiring customized deployment due to architecture change. Closest to our work, [] updates a randomly selected subset of the parameters at each iteration of fine-tuning to preserve the earlier tasks in the not-updated parameters of that iteration. Despite similarities, our work LoTA (1) uses a fixed sparsity mask throughout fine-tuning instead of a new mask at every iteration, which yields sparse task vectors that are useful for other applications such as model merging and communication-efficient FL, and (2) finds data-dependent masks rather than the randomly selected masks in []. Furthermore, unlike [], LoTA not only preserves the earlier tasks on frozen parameters but also constraints the new tasks on a highly sparse subnetwork–providing resistance to catastrophic forgetting even when malicious users attempt to overwrite the earlier tasks via FFT.

#### Model Merging.

Merging multiple task-specific models into a single model with multitask abilities [, , ] has been an appealing alternative to sequential multitask learning, which suffers from catastrophic forgetting and could be inefficient, especially if task vectors are already available. The existing model merging methods include averaging weights of task-specific models [], task arithmetic through combining task vectors [], weighted aggregation of parameters [, ], combining task vectors after some post-processing such as trimming low-magnitude deltas [] or sparsifying the deltas [, ]. Our method, LoTA, directly learns *sparse task vectors*, obviating the need to post-process the task vectors, and outperforms existing model merging methods. Most importantly, LoTA enables merging task vectors trained on heterogeneous datasets, while the other model merging methods are often limited to similar datasets. This advancement is an important step towards scalable FL [] with LLMs as it enables merging *sparse task vectors*, which brings communication efficiency, trained over heterogeneous datasets (of each edge device).

We note that we test model merging with LoTA specifically for highly dissimilar datasets to show its compatibility with FL, which considers edge devices with heterogeneous datasets. When used in FL, LoTA can reduce communication and memory costs significantly, which is a main bottleneck when scaling FL to large models. The successful use of LoTA for model merging and arithmetic further shows its promise for unlearning [] as well.

## 7 Discussion

We propose Lottery Ticket Adaptation (LoTA), a sparse alignment framework that fine-tunes only a sparse subnetwork of the base model, leaving the rest of the parameters frozen. LoTA successfully mitigates destructive interference (a problem with existing fine-tuning methods including full fine-tuning and low-rank adaptation (LoRA)) in many multi-task adaptation paradigms, prevents catastrophic forgetting of earlier tasks, including safety, and allows for successful model merging of even dramatically different tasks.

#### Limitations.

As mentioned in Section 5.1, LoTA does not provide the compute efficiency of LoRA. If the adapter needs to be compressed by more than $100\times$, LoTA may not provide sufficient compression. We evaluate on instruction following, reasoning, math, SQL generation, and summarization, yet even more tasks exist such as Python code generation, classification, or long-context question answering. We compare LoTA to baselines (LoRA, TIES) but other PEFT and merging methods exist. In a future revision of this paper, we plan to provide comparisons to a broader range of PEFT [] and merging [] methods.

#### Broader Impact.

LoTA emerges as a simple and efficient adaptation method to prevent destructive interference. We hope LoTA can enable compression of task adapters without losing performance, mitigate catastrophic forgetting (particularly to improve the durability of safety alignment in future model releases), and provide performant model merging across heterogeneous tasks.

#### Acknowledgements.

This work was funded in part by the OpenAI Superalignment Grant and the Google PhD Fellowship.

## Appendix A Additional Experimental Details

### A.1 Code

Because we evaluate multiple methods on a wide range of tasks, training on $>20$ datasets, we defer all the details on the prompts, exact dataset format, etc. to our [open-source code repository](https://github.com/kiddyboots216/lottery-ticket-adaptation).

### A.2 Hyperparameter Ranges

FFT. We tune the learning rate in the range $5e-7,1e-5$ and the best-performing learning rate for the downstream finetuning tasks is $1e-6$, with the exception of instruction finetuning which we detail further below. We use a batch size of 32. We clip the gradient norm of each parameter group to $1$. We clip the gradient norm of the parameters as opposed to the full gradient because we fuse the optimizer with the backward pass to enable FFT on a single A100.

LoTA. We do not tune any hyperparameters for LoTA and merely use the same hyperparameters as FFT. Unless stated otherwise, we report the performance of LoTA with a sparsity ratio of $0.9$ that was calibrated on the entire dataset.

LoRA. LoRA introduces the additional rank hyperparameter, which we tune jointly with the “lora alpha” term and the learning rate. We tune the rank and alpha in the range $(8,512)$. Common wisdom seems to dictate the use of larger learning rates for LoRA, so we expand the upper edge of the LoRA learning rate range to $1e-4$ and indeed find that LoRA typically benefits from a larger learning rate. We use LoRA on all linear layers (q, k, v, gate, up, down). On the commonsense reasoning tasks, the best hyperparameters are: $r=512,\alpha=32,\eta=1e-4$. On GSM8k, the best hyperparameters are: $r=64,\alpha=32,\eta=1e-4$.

Instruction Tuning. We use the hyperparameters of Sharma et al. [] to avoid the expense of hyperparameter tuning on winrates. This means that we use a batch size of $8$ and a learning rate of $5e-7$ for both FFT and LoTA. We use the best performing hyperparameters for LoRA transferred from the commonsense reasoning tasks of $r=64,\alpha=32,\eta=1e-4$.

TIES-Merging. We consider post-hoc sparsification factors of $0.1,0.2,0.3$; the best performance is at either $0.1$ or $0.2$.

### A.3 Individual Task Results for Averaged Experiments

In the main body we present a number of experiments where we have to report the average performance over a number of tasks for space constraints. We now present the individual task results in Table 7 and Table 8.

**Table 7: Individual task results for the “averaged” results in Table 5. bold: best method.**
| FT Method on Task A | FT Method on Task B | Instruction Following | Arc | GSM8k | SQL |
| --- | --- | --- | --- | --- | --- |
| FFT | FFT | $0.45_{0.21}$ | $74.1_{.09}$ | $51.9_{0.09}$ | $98.9_{0.01}$ |
| LoTA (ours) | FFT | $\underline{11.48_{0.73}}$ | $73.3_{0.02}$ | $53.9_{0.09}$ | $98.9_{0.01}$ |
| LoTA (ours) | LoTTO (ours) | $\mathbf{15.88_{0.88}}$ | $70.3_{0.01}$ | $52.5_{0.01}$ | $98.6_{0.01}$ |

**Table 8: Full results on commonsense reasoning.**
| Model | Method | BoolQ | PIQA | SIQA | HellaSwag | WinoGrande | ARC-e | ARC-c | OBQA | Avg. |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Mistral | LoRA | 76.4 | 90.7 | 81.2 | 91.4 | 87.0 | 94.1 | 83.0 | 90.4 | 86.8 |
| LoTA (ours) | 75.3 | 90.0 | 83.3 | 91.4 | 89.5 | 95.1 | 85.0 | 90.2 | 87.5 |  |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 4
questions: 1. Lines 250 -253: The authors have mentioned the issue of using potentially contaminated benchmarks such as MT-Bench and avoid using such. However, GSM8K is also one of the benchmarks that are known for potential data contamination (e.g. [1]). 

2. How many training steps does it usually take for the mask calibration part of LoTA? Is it just one training step, as line 292 says"We find that a 90%-sparse mask can achieve good performance on GSM8K with just a single step of calibration"?

3. Table 4: Can you provide a bit more justification on why choosing the alternating LoRA/FFT as a baseline?

[1] Hugh Zhang, Jeff Da, Dean Lee, Vaughn Robinson, Catherine Wu, Will Song, Tiffany Zhao, Pranav Raja, Dylan Slack, Qin Lyu, Sean Hendryx, Russell Kaplan, Michele Lunati, and Summer Yue. A Careful Examination of Large Language Model Performance on Grade School Arithmetic. 2024
soundness: 3
strengths: 1. The paper is well-written and the proposed method is clearly presented. 

2. The proposed method is evaluated on a comprehensive set of settings, including sequential training and model merging which common PEFT papers do not usually evaluate. This adds another layer of strength and depth to the paper.

3. The proposed method shows empirically strong results over full fine-tuning and LoRA across all the aforementioned settings.
summary: The paper proposes a fine-tuning method for adapting LLMs to enable multi-task learning and prevent catastrophic forgetting. The method uses a mask calibration stage that extracts important neurons based on the magnitude of the task vector and then performs a sparse update by applying the mask. The paper conducts thorough experiments on single-task adaptation, serial training, and model merging to compare the proposed method with existing methods and demonstrates the superior performance and robustness of the method across settings.
weaknesses: 1. My main concern is the technical novelty of the proposed method, particularly LoTA. [1] (and [2], the follow-up work by the same authors that scaled up to the latest LLMs) proposed a very similar method called "Lottery Ticket Sparse Fine-Tuning." By comparing Section 3.1 of [1] and Algorithm 1 of this paper, I find the only difference to be that [1] applies an L1 regularization for the sparse adaptation training part whereas this paper does not. To the best of my knowledge, the second algorithm proposed by the author, LoTTO, is novel as it forces the adaptations to be disjoint for different tasks; however, it would be much appreciated if the authors could clarify the main technical contributions that differentiate LoTA and prior works.

2. Regardless of 1, I think this paper lacks proper baselines of sparse/localized fine-tuning. The proposed method is only compared with full fine-tuning and dense PEFT method (LoRA). The paper can be strengthened by a lot if the proposed method can be compared with at least one sparse/localized fine-tuning methods, such as [1] or [3]. 

Despite the aforementioned weakness, this paper still presents a thorough suite of experiments and evaluations. I'd love to discuss with the authors and am willing to change my rating if the authors can address these main concerns.

[1] Alan Ansell, Edoardo Maria Ponti, Anna Korhonen, and Ivan Vulić. Composable Sparse Fine-Tuning for Cross-Lingual Transfer. 2021
[2] Alan Ansell, Ivan Vulić, Hannah Sterz, Anna Korhonen, and Edoardo M. Ponti. Scaling Sparse Fine-Tuning to Large Language Models. 2024
[3] Fangcong Yin, Xi Ye, and Greg Durrett. LoFiT: Localized Fine-tuning on LLM Representations. 2024

---

confidence: 4
contribution: 3
initial_rating: 3
presentation: 2
questions: Questions:
- How much % of parameters is trained on average with LoTA? How much does it vary across tasks and model scales?
- What is the performance drop for every new task trained with LoTTO? I would expect that constraining parameter space with each additional task reduced the potential performance on new LoTAs.
- What is the reason of the choice of RMSProp optimizer? Do the results differ for Adam optimizer, which is de facto a standard for NN optimization?
- Are the experiments repeated for different random seeds, and results averaged?
- Line 249, "As a representative task, we use ARC-easy." Why?
- Regarding experiments in section 5.2, is LoRA completely forgetting Task A also when using lower rank, e.g. 8? Work by Biderman et al. (mentioned at line 353) shows that lower rank leads to less forgetting. Moreover, are the results similar after swapping Task A with Task B? What are the results for Llama3-8B?

Suggestions (mostly regarding presentation):
- Line 263, "finetuning method OpenAI are using in their fine-tuning API (presumably FFT)." It's not a known fact, and in my opinion also unlikely one - such speculations should not be part of a paper.
- Table 3: Why only LoTA is bolded out, if for some tasks other methods achieve the same scores?
- Line 205, "we do not expect that LoTTO will result in any worse forgetting than LoTA" Is it a typo? Shouldn't it say LoRA?
- I would suggest to find a better label for tasks - Boolq, PIQA, SocialIQA, Hellaswag, Winograde, ARC-easy, ARC-challenge, OpenBookQA - as they are not specifically testing **reasoning** capabilities of the model and it's misleading. Natural Language Understanding (NLU) or Question Answering (QA) would be a better label in my opinion.
- Table 5 is not referred to in the text. It's also not clear what metric is used for both tasks - should be mentioned in the caption or the column header.
soundness: 1
strengths: The work leverages sparsity of model weights updates to provide a method for multi-task adaptation. It has similarities to post-hoc sparsification but allows to train these sparse weight deltas after mask calibration which differentiates it from other methods. Even if it may not have high practical utility in the current form due to high computational requirements compared to PEFT methods, the idea is interesting and may lead to significant improvements in multi-task adaptation approaches.
summary: The work presents a method, LoTA, leveraging sparse vector masks to finetune a model by modifying only a subset of its weights. It allows for sequential training with multiple LoTAs on different tasks leading to lowered catastrophic forgetting - called LoTTO method. The evaluation methodology covers instruction following, commonsense reasoning, math, and summarization tasks, with comparisons to full fine-tuning and LoRA approaches.
weaknesses: The idea is generally good, but there are a number of issues which prevent from recommending the acceptance of the paper, and that need to be resolved.

- Regarding catastrophic forgetting with LoTTO, there's lack of comprehensive experiments in regard to different task combinations to prove the robustness of the method - it was limited to forgetting of the GSM8k (Table 4) and Instruction Tuning (Table 5 & 6). 
- The experiments for sequential training are limited to only two tasks/LoTAs and don't provide data on how the performance drops for every additional LoTA adapter due to more limited parameter space (as the sparse vector masks in LoTTO should not overlap).
- The computational requirements (memory & runtime) are not clearly discussed - while LoTA may be better than LoRA in terms of catastrophic forgetting and/or downstream task performance, it does not bring the same benefits in computational efficiency as PEFT methods - it's mentioned in limitations paragraph with one sentence but may need more emphasis. Given additional operations on sparse vector masks, LoTA may require even more memory & runtime compared to FFT - it's just a speculation and would need a proper comparison from the authors.
- Results in Table 4 seem surprising given that performance of FFT and LoRA completely collapses on the GSM8K task, and is in contrary to results from (Biderman et al., 2024) as mentioned in the paper. I'm suspecting it's due to different structures of the tasks - GSM8K needs open generation with EOS token at the end, for which the final answer is extracted eg. with regex, while QA (commonsense reasoning tasks) indicate correct answer based on tokens' logits, and in the simplest case it's based on a single token of a letter corresponding to a given answer. It would be good to include results from both models, swapped tasks (QA first, then GSM8k), and possibly two tasks of the same structure (either both open generation or both QA). Another issue I see is that LoRA has been trained with ranks 512 and 64, while in practice lower values are used - e.g. Biderman et al. used rank 16 for decreased forgetting.
- Arbitrary choices without explanation:
    - Introduces two models in Section 4, but shows results only for a single model except one table - for some tables it's not stated which model is used.
    - Line 249 - "As a representative task, we use ARC-easy", without any further explanation.
    - Use of RMSProp optimizer instead of Adam which is used in majority of works.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: Why does the paper not include a comparison of the operational efficiency of the LoTA method, specifically in terms of GPU memory cost and training speed? Understanding these aspects is crucial for assessing the practicality and scalability of LoTA in real-world applications.

Why were certain baselines, such as LoRAHub(LoraHub: Efficient Cross-Task Generalization via Dynamic LoRA Composition), LoRAMoE(LoRAMoE: Alleviate World Knowledge Forgetting in Large Language Models via MoE-Style Plugin), and MoLE (Mixture of LoRA Experts), not included in the experimental comparisons? These methods are also designed to address multi-task adaptation in the LoRA setting, and their inclusion would provide a more comprehensive evaluation of LoTA's performance relative to other state-of-the-art approaches.

The paper needs to provide more evidence to demonstrate the importance of avoiding catastrophic forgetting in large language models (LLMs)? It is often assumed that LLMs are not further trained after their initial post-training phase, which would imply that catastrophic forgetting is not a significant issue. Providing concrete examples or scenarios where continual adaptation or fine-tuning is necessary would help justify the relevance of methods like LoTA in this context.
soundness: 2
strengths: This paper introduces a new method called Lottery Ticket Adaptation (LoTA). LoTA works by identifying and optimizing sparse task vectors, which means it only tweaks a small, crucial part of the model. This selective tuning helps the model remember its core skills while learning new tasks, thus preventing the common problem of catastrophic forgetting.

The authors thoroughly test their method on various challenging tasks, such as following instructions, reasoning, solving math problems, and summarizing text. These tests are conducted on large language models, showing that LoTA is not just a theoretical idea but works well in real-world scenarios. The experiments prove that LoTA performs better than traditional methods like full fine-tuning and low-rank adaptation (LoRA).

One of the standout features of LoTA is its ability to maintain high performance even after the model has been trained on multiple tasks. Unlike other methods that often cause the model to forget previously learned skills, LoTA ensures that the model remains robust and effective, making it a reliable choice for multi-task learning.
summary: This work introduced Lottery Ticket Adaptation (LoTA), a sparse adaptation method that optimizes only a subnetwork of the model to avoid destructive interference between tasks. Unlike existing methods that often cause catastrophic forgetting and performance drops, LoTA maintains high performance across multiple tasks by focusing on sparse task vectors. As a result, LoTA outperforms full fine-tuning and low-rank adaptation (LoRA) in various tasks and enables effective model merging without performance degradation.
weaknesses: See Questions Section

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: - Why choosing an FFT then sparse framework rather than select-updating-parameter, which means first select some parameter can be updated than train the model like the process in Sparse Adaptation?

- Is it possible to sharing the results for many task settings? For example, in all the task in BBH or MMLU benchmark. The experiments in only two tasks is not very persuasive. If possible, I guess the most important results is the gap between your methods and directly mix all the data to FFT.

I may raise the score if all questions are solved.
soundness: 3
strengths: - The method LoTA is very simple but effective, successfully solving the problems of previous methods.

- Empirical results, especially on Model merging and sequential training setting.

- The paper is easier to follow.
summary: The authors propose LoTA, an interesting framework that solving the problem of three different type of methods about multitask adaptation. LoTA is a very simple but effective framework to implement the multitask learning compare to previous methods.
weaknesses: - The paper only uses magnitude-based pruning methods.

- It will be more fair to compare FFT and LoTA if FFT have the same number of epochs as the sum number of LoTA in the first and third phase.

- The additional phase may introduce additional computation cost (although it is not very much)

- Compare to LoRA and other PEFT methods, LoTA requires more GPU memory requirement when training.