Booster: Tackling Harmful Fine-tuning for Large Language Models via Attenuating Harmful Perturbation

## Abstract

Abstract Harmful fine-tuning issue (Qi et al., 2023 ) poses serious safety concerns for Large language models’ fine-tuning-as-a-service. While existing defenses have been proposed to mitigate the issue, their performances are still far away from satisfactory, and the root cause of the problem has not been fully recovered. To this end, we in this paper show that harmful perturbation over the model weights could be a cause of alignment-broken of harmful fine-tuning. In order to attenuate the negative impact of harmful perturbation, we propose an alignment-stage solution, dubbed Booster. Technically, along with the original alignment loss, we append a loss regularizer in the alignment stage’s optimization. The regularizer ensures that the model’s harmful loss reduction before/after simulated harmful perturbation is attenuated, thereby mitigating the subsequent fine-tuning risk. Empirical results show that Booster can effectively reduce the harmful score of the fine-tuned models while maintaining the performance of downstream tasks. Our code is available at https://github.com/git-disl/Booster .

## 1 Introduction

Figure: Figure 1: A common two-stage pipeline for fine-tuning-as-a-service. Fine-tuning on harmful user data on Stage ② compromises alignment performance. Our proposed solution optimizes over Stage ①, which jointly utilizes the alignment dataset and harmful dataset to vaccinate the model such that it is robust to the later fine-tuning attack.
Refer to caption: x1.png

Fine-tuning-as-a-service has been a successful business service model adopted by main-stream LLM service providers (^1^11Fine-tuning API by OpenAI: [https://platform.openai.com/docs/guides/fine-tuning](https://platform.openai.com/docs/guides/fine-tuning).). It aims to deliver customized LLM service to users by asking them to upload demonstration data using the desired pattern. Then the service provider will fine-tune the foundation models on users’ behalf. However, recent studies (Qi et al., ; Yang et al., ; Zhan et al., ) uncovered a harmful fine-tuning issue, which shows with red-teaming that a few harmful data contained in the user fine-tuning dataset can trigger the fine-tuned models to forget the safety alignment enforced before. This vulnerability renders a large attack surface, downgrading the service quality and sustainability, and there is still no solution with great scalability to tackle the problem.

Existing solutions against harmful fine-tuning issues can be classified into three main categories according to which stage the mitigation is introduced, i.e., i) alignment-stage solution (Huang et al., ; Rosati et al., ; Tamirisa et al., ), ii) fine-tuning-stage solution(Mukhoti et al., ; Huang et al., ), and iii) post-fine-tuning stage solution (Yi et al., ; Hsu et al., ; Huang et al., ). Among the three categories, alignment-stage solutions draw the broadest interest thanks to their computation efficiency. Specifically, mitigation solutions in most cases come with extra computation, which means for fine-tuning-stage solutions and post-fine-tuning stage solutions, extra computation comes with every incoming fine-tuning request. On the contrary, only one-time overhead is required for an alignment-stage solution. Due to its superiority, we in this paper aim to promote the alignment-stage solution.

Vaccine (Huang et al., ) and RepNoise (Rosati et al., ) are two representative alignment-stage solutions. (Huang et al., ) propose the concept of harmful embedding drift, which measures the drift of embedding over the alignment data before and after fine-tuning. The proposed method named Vaccine solves a mini-max solution to mitigate the impact of the embedding drift. However, Vaccine solely uses the alignment dataset (i.e., harmful prompt-safe answer pair), which alone may not be sufficient enough to counter the harmful attack. (Rosati et al., ) further introduce RepNoise that utilizes the harmful dataset (harmful prompt-harmful answer pair). The idea is to introduce an MMD regularizer to perturb the embedding of the harmful data such that its distribution reduces to a normalized Gaussian noise. However, RepNoise may fall short given that harmful fine-tuning is still able to reshape the harmful embedding distribution under some conditions.

To this end, we in this paper aim to answer the following research question:

> In the alignment stage, can we utilize the harmful dataset to derive more usable information for vaccinating the model from harmful fine-tuning?

Driven by this research question, we in this paper first study how the harmful data is going to reshape the aligned model. We discover that harmful perturbation, i.e., taking optimization direction over the harmful data to the model, contributes to the reduction of the harmful loss and therefore should be the culprit of the alignment-broken effect. To attenuate its negative impact, we propose a regularizer to utilize the simulated harmful dataset to reduce its harmful loss reduction rate. Combining the regularizer with the original alignment loss over the alignment data, we form the optimization problem, which is then efficiently solved by an iterative gradient method named Booster. Empirical results show that Booster outperforms existing solutions by respectively reducing up-to 17.26% and 20.08% average harmful score compared with Vaccine and RepNoise, while maintaining the same level of fine-tune accuracy.

To the end, we summarize our contributions as follows:

- •
We propose the concept of harmful perturbation, and we statistically evaluate its impact on the model’s safety alignment.
- •
To reduce the negative impact of harmful perturbation, we propose a loss regularizer to reduce the harmful loss reduction rate. The regularizer is added to the original safety alignment loss to form the objective for alignment, and we propose an iterative gradient method dubbed Booster for problem-solving.
- •
Comprehensive experiments on four downstream tasks and different attack settings are conducted to evaluate the proposed methods.

## 2 Related Work

Safety Alignment. Large language model’s safety alignment concerns on how to regularize the model’s output such that the model is able to output a refusal answer whenever a harmful prompt is given. The mainstream techniques to achieve alignment includes supervised fine-tuning (SFT) and RLHF (Ouyang et al., ; Dai et al., ; Bai et al., ; Wu et al., ; Dong et al., ; Rafailov et al., ; Yuan et al., ).
Both techniques exploit a safety alignment dataset, which consists of demonstration data showing how to give refusal answers to harmful prompts. The pre-trained models are then trained on these data with SFT or RLHF to achieve safety alignment.

Harmful Fine-tuning. However, recent studies (Qi et al., ; Yang et al., ; Zhan et al., ) show that models aligned by SFT or RLHF can be jail-broken after fine-tuning on a partially harmful dataset, i.e., the model forgets to give refusal answer towards harmful prompts after fine-tuning on a few harmful samples.
Efforts have been made to analyze the mechanism of the attack. Huang et al. () accounts for the reason of forgetting as harmful embedding drift. Leong et al. () discuss the attack mechanisms over two different attack settings, and Peng et al. () propose a safety metric to measure the attack impact over different models. Existing mitigation solutions to the issue can be classified into three categories according to which stage the mitgation is launched, i.e., alignment-stage solution (Huang et al., ; Rosati et al., ; ), fine-tuning-stage solution (Mukhoti et al., ; Huang et al., ; Lyu et al., ; Wang et al., ; Qi et al., ), and post-fine-tuning stage solution (Hsu et al., ; Yi et al., ; Huang et al., ). The method proposed in this paper should be classified into an alignment-stage solution, whose objective is to vaccinate the LLM such that it can be more robust to the attack launched after the alignment.

Meta Learning. Meta learning (Finn et al., ; Rajeswaran et al., ) is a technique aiming to produce a meta-model that can be generalized to different downstream tasks before fine-tuning occurs. In order to achieve this goal, the optimization objective is over the model after a gradient step, i.e., $\sum_{i\in\mathcal{T}}f_{i}(w-\nabla f(w))$ where $\mathcal{T}$ is a set of downstream tasks. In this paper, the proposed booster method also involves one-step gradient information into the optimization objective, aiming to attenuate the impact of harmful perturbation before fine-tuning occurs.

To the best of our knowledge, we are the first to identify harmful perturbation as the cause of alignment broken, and this is our first solution that utilizes this concept to design a defense to strengthen the model’s robustness. The defense can be combined with other existing defense solutions, e.g., Vaccine (Huang et al., ) and RepNoise (Rosati et al., ) to further improve defense performance. A concurrent research TAR (Tamirisa et al., ) utilizes a similar meta-learning technique to simulate the harmful perturbation in the alignment stage. However, the insight as well as the design of our method is different from theirs. See Appendix C for a detailed discussion.

## 3 Preliminaries

### 3.1 Harmful fine-tuning

Considered Scenario. Harmful fine-tuning is a security issue faced by the LLM service provider (e.g., OpenAI). The considered scenario is that users upload a few pieces of data (a subset of them are harmful) to the service provider, and the service provider fine-tune their safety-aligned foundation model with those provided datasets. The fine-tuned data are deployed in the service provider’s server and are used to serve personalized output to the users.

Threat models . We assume that the users upload a user fine-tuning dataset with $p$ (percentage) of harmful data, and other $1-p$ (percentage) of data are benign fine-tuning data. The harmful data and the benign data are considered inseparable (Qi et al., ; Huang et al., ; Rosati et al., ).

Assumptions. We assume the service provider maintains an alignment dataset (harmful prompt-safe answer pairs) and a harmful dataset (harmful prompt-harmful answer pairs) for alignment. The availability of the two pairs of data is also made in (Rosati et al., ; Tamirisa et al., ) and both the two pairs of data are available in existing open datasets (e.g., BeaverTail (Ji et al., )).

### 3.2 Harmful Perturbation

Next, we try to explore the concept of harmful perturbation to show the reason for alignment failure and motivate the design of our proposed defense.

Definition of harmful perturbation. We refer to harmful perturbation as taking one step towards the gradient direction over the harmful data. In the fine-tuning stage, the model update rule will be $\bm{w}_{t+1}=\bm{w}_{t}-\eta g(\bm{w}_{t})$ where $g(\bm{w}_{t})$ is a stochastic gradient over a random sample of user data. If $g(\bm{w}_{t})$ is a stochastic gradient from a harmful data, and we take this stochastic gradient over $\bm{w}_{t}$, this results in the so-called harmful perturbation, which should be the root reason leading to a successful harmful fine-tuning attack. We next utilize experimental results to demonstrate the impact of harmful perturbation, and how it leads to a successful attack.

Impact of harmful perturbation. The left of Figure 2 shows that the model’s harmful score will substantially increase along with optimization steps invested in fine-tuning on a pure harmful dataset. On the contrary, the harmful score will not be affected much via fine-tuning on a pure SST2 dataset. This indicates that taking a step with the gradient of the harmful data (i.e., harmful perturbation) is indeed the reason for the alignment broken. We next show in the middle of Figure 2 how taking harmful perturbation and SST2 perturbation in each epoch will affect the harmful training loss. As shown, harmful perturbation significantly reduces the harmful training loss, which means the model starts to fit the harmful data. On the contrary, training on SST2 would only slightly increase the harmful training loss. The right of Figure 2 shows a similar trend, which indicates that the fitting to the training harmful data can generalize to other unseen harmful data. In summary, our finding concludes that harmful perturbation (taking a step over the gradient of the harmful data) contributes to the reduction of harmful training/testing loss, and eventually makes the model respond in a harmful way.

Figure: Figure 2: Model statistics (Left: harmful score, Middle: harmful training loss, Right: harmful testing loss) after fine-tuning on pure SST2/harmful data for different steps. Specially, harmful training loss refers to the loss over the harmful data used in training, while harmful testing loss refers to that over the testing harmful data which the model never see in fine-tuning phase.
Refer to caption: extracted/5864076/pic/motivation.png

Derived Insight. Because harmful fine-tuning data is considered to be inseparable from the benign fine-tuning data (e.g., SST2 ) (Huang et al., ; Rosati et al., ), harmful perturbation is indeed inevitable in the user fine-tuning stage. Given this, it is essential to increase the model’s resilience towards the harmful perturbation in the earlier stage, i.e., alignment stage, which however, is not sufficiently explored by the existing literature.

## 4 Methodology

To mitigate the harmful perturbation issue, we propose an alignment stage solution to attenuate the impact of the harmful perturbation that will inevitably be incurred in the fine-tuning stage.

Explicitly, we want to solve the following optimization problem in the alignment stage:

$$ $\arg\min_{\bm{w}}f(\bm{w})+\lambda\left(h(\bm{w})-h(\bm{w}-\alpha\frac{\nabla h (\bm{w})}{\|\nabla h(\bm{w})\|})\right)$ (1) $$

where $f(\bm{w})$ is the empirical loss (^2^22The empirical loss here is cross-entropy loss if we use SFT for alignment/fine-tuning. The loss can be more complicated if RLHF is adopted.) over the alignment dataset and $h(\bm{w})$ is the empirical loss over the harmful dataset, $\lambda$ is the regularizer’s intensity, and $\alpha$ is the step size. Our contribution lies in the second term, which measures the gap between the original harmful loss and the harmful loss after taking a normalized step with the harmful gradient. The idea is to minimize the impact of potential harmful perturbation towards the alignment model while simultaneously minimizing its alignment loss. Specifically, $h(\bm{w}-\alpha\frac{\nabla h(\bm{w})}{\|\nabla h(\bm{w})\|})$ simulates the loss after one normalized step of fine-tuning on harmful samples, and $h(\bm{w})-h(\bm{w}-\alpha\frac{\nabla h(\bm{w})}{\|\nabla h(\bm{w})\|})$ simulates the decrease of harmful loss after one step of fine-tuning on harmful samples. By minimizing this gap, the decrease of harmful loss after taking optimization on the real harmful samples in the fine-tuning stage will be minimized (i.e., impact of harmful perturbation will be attenuated).

To solve the proposed perturbation minimization problem, we can use iterative gradient methods (e.g., SGD). According to the chain rule, the update rule would be:

$$ $\bm{w}_{t+1}=\bm{w}_{t}-\eta\left(\nabla f(\bm{w}_{t})+\lambda\left(\nabla h( \bm{w}_{t})-\nabla h\left(\bm{w}_{t}-\alpha\frac{\nabla h(\bm{w}_{t})}{\| \nabla h(\bm{w}_{t})\|}\right)\underbrace{\nabla(\bm{w}_{t}-\alpha\frac{\nabla h (\bm{w}_{t})}{\|\nabla h(\bm{w}_{t})\|})}_{\text{second-order information}} \right)\right),$ (2) $$

where $\eta$ is the learning rate. Note that the term $\nabla(\bm{w}_{t}-\alpha\frac{\nabla h(\bm{w}_{t})}{\|\nabla h(\bm{w}_{t})\|})$ contains second order information (i.e., Hessian Matrix), which is very computation expensive to obtain. Inspired by (Finn et al., ; Rajeswaran et al., ), we rewrite the update rule by approximating this second-order gradient term to be constant, as follows:

$$ $\bm{w}_{t+1}=\bm{w}_{t}-\eta\left(\nabla f(\bm{w}_{t})+\lambda\left(\nabla h( \bm{w}_{t})-\nabla h(\bm{w}_{t}-\alpha\frac{\nabla h(\bm{w}_{t})}{\|\nabla h( \bm{w}_{t})\|})\right)\right)$ (3) $$

Figure: Algorithm 1 Booster: Harmful Perturbation Attenuation

We present the detailed algorithm in Algorithm 1. The overall procedure requires three forward/backward passes for each optimization step. The first pass is to evaluate the gradient over a batch of alignment data $(\bm{x}_{t},\bm{y}_{t})$ and obtain $\tilde{\nabla}f(\bm{w}_{t})$. The second pass is to evaluate the harmful gradient over a batch of harmful data and obtain $\tilde{\nabla}h(\bm{w}_{t})$, and the third pass is to evaluate the harmful gradient again after taking a normalized harmful gradient step. After collecting all the three gradient components, we take the final gradient step by Eq. (3).

The proposed algorithm is named Booster, named after another alignment stage solution "Vaccine" (Huang et al., ). Of note, the design idea of Booster are completely different from Vaccine. In a high level, Booster is concerned on how to utilize harmful dataset to simulate the harmful perturbation, while Vaccine is concerned on how to mitigate the hidden embedding drift over the alignment dataset. Factualy, the two techniques can be combined and we will discuss in Appendix D.

## 5 Experiment

### 5.1 Setup

Datasets and models. For the alignment task, we use the alignment dataset and harmful dataset from (Rosati et al., ), which is enriched from BeaverTails (Ji et al., ). In the alignment stage, we sample 5000 instances to construct the alignment dataset, and another 5000 instances to construct the harmful dataset. The data in harmful dataset are in the same distribution but are different from those harmful data mixed in the user dataset. For fine-tuning task, we consider SST2(Socher et al., ), AGNEWS(Zhang et al., ), GSM8K(Cobbe et al., ) and AlpacaEval (Li et al., ) as the user fine-tuning task. To simulate the harmful fine-tuning attack, we mix $p$ (percentage) of unsafe data from BeaverTail with $1-p$ benign fine-tuning data over a total number of $n$ samples. We use Llama2-7B (Touvron et al., ), and two SOTA architecture Gemma2-9B (Team et al., ) and Qwen2-7B (Yang et al., ) for evaluation. In our experiment, the default setting is $p=0.1$ and $n=1000$ (specially, $n=700$ for AlpacaEval) unless otherwise specified. All the experiments are done with an H100-80G.

Metrics. We follow Huang et al. (; ) to use two metrics for evaluation of model’s performance.

- •
Finetune Accuracy (FA). The accuracy of the testing dataset from the corresponding finetune task. We give a detail of how to measure the accuracy for different tasks in Appendix A.
- •
Harmful Score (HS). The moderation model from (Ji et al., ) is used to classify the model output to be harmful or not given unseen malicious instructions. Harmful score is the ratio of unsafe output among all the samples’ output.

To calculate harmful score, we sample 1000 instructions from the testing set of BeaverTails (Ji et al., ). To obtain finetune accuracy, we sample 872, 1000, 1000, and 122 samples respectively from
finetuning dataset SST2, AGNEWS, GSM8K and AlpacaEval. Both the two metrics are measured on the fine-tuned model (after two-stage training).

Baselines. We use four baselines for comparison. SFT is the vanilla supervised fine-tuning solution. Lisa (Huang et al., ) is a fine-tuning stage solution, and Vaccine(Huang et al., ) and RepNoise (Rosati et al., ) are two alignment stage solutions for the harmful fine-tuning issue.

Training details. We follow (Huang et al., ; ; Hsu et al., ) to utilize LoRA (Hu et al., ) for efficient LLM training. The rank of the adaptor is set to 32, and the LoRA’s alpha is 4. For alignment, we use AdamW as optimizer (Loshchilov et al., ) with a learning rate 5e-4 and a weight decay factor of 0.1. For fine-tuning tasks, we use the same optimizer with a smaller learning rate 1e-5 following (Huang et al., ). We train 20 epochs for alignment, and 20 epochs for fine-tuning with SST2, AGNEWS and GSM8K, and 100 epochs for AlpacaEval. For both alignment and fine-tuning stage, we use the same batch size of 10. See Appendix A for details.

### 5.2 Main Experiments

Robustness to harmful ratio. We first show in Table 1 how the harmful ratio affects the model’s safety. As shown, compared to SFT, Booster in average achieves 22.64% of lower harmful score, and 2.64% higher finetune accuracy on the downstream. Particularly, we observe that Booster achieves significantly higher finetune accuracy compared to SFT when p=0 (i.e., clean). We conjecture that the reason is that the alignment with SFT hurts the finetune performance due to over-fitting (i.e., the model learns to use refusal answer even not for harmful prompt). While Booster does not specifically target on solving the over-fitting problem, the attenuating regularizer avoids the model to minimize one objective, i.e., alignment loss. With all the harmful ratio, we see that Booster maintain consistently better harmful score and finetune accuracy compared to baseline, but we do observe that the harmful score is rising with more percentage of harmful data, which unfortunately is the common weakness of the alignment-stage solutions.

**Table 1: Performance analysis for different harmful ratio.**
|  | Harmful Score | Finetune Accuracy |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | clean | p=0.05 | p=0.1 | p=0.15 | p=0.2 | Average | clean | p=0.05 | p=0.1 | p=0.15 | p=0.2 | Average |
| SFT | 1.30 | 21.90 | 33.70 | 49.30 | 61.70 | 33.58 | 81.54 | 91.74 | 93.12 | 92.66 | 92.89 | 90.39 |
| Lisa | 0.90 | 14.50 | 23.7 | 31.20 | 39.10 | 21.88 | 86.93 | 91.86 | 92.32 | 92.20 | 92.32 | 91.13 |
| Repnoise | 1.2 | 20.70 | 32.10 | 45.60 | 55.50 | 31.02 | 90.25 | 92.89 | 93.00 | 92.89 | 92.89 | 92.38 |
| Vaccine | 1.30 | 12.10 | 28.3 | 44.10 | 55.20 | 28.20 | 90.83 | 93.58 | 93.69 | 93.23 | 93.23 | 92.91 |
| Booster | 1.90 | 4.80 | 8.30 | 14.20 | 25.50 | 10.94 | 92.89 | 92.32 | 93.23 | 93.35 | 93.35 | 93.03 |

Robustness to fine-tuning sample number.
Next we show in Table 2 how different fine-tuning sample number affects the defense performance. As shown, Booster in average achieves 28.76% reduction of harmful score compared to SFT, with 2.13% increase of finetune accuracy. When the fine-tuning sample is small, Booster achieves significantly higher finetune accuracy than SFT. Analogy to our analysis above. the reason is that with less fine-tuning samples, the overfitting over the alignment data may not be well mitigated by SFT. However, Booster can mitigate the overfitting of alignemnt data with the added attenuating regularizer.

**Table 2: Performance analysis for different sample number.**
|  | Harmful score | Finetune Accuracy |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | n=500 | n=1000 | n=1500 | n=2000 | n=2500 | Average | n=500 | n=1000 | n=1500 | n=2000 | n=2500 | Average |
| SFT | 13.60 | 33.70 | 63.90 | 74.00 | 75.30 | 52.10 | 85.44 | 93.12 | 92.55 | 94.61 | 92.32 | 91.61 |
| Lisa | 10.60 | 23.70 | 33.50 | 46.70 | 51.50 | 33.20 | 87.04 | 92.32 | 92.09 | 92.78 | 92.09 | 91.26 |
| Repnoise | 13.30 | 32.10 | 58.20 | 68.60 | 73.10 | 49.06 | 90.60 | 93.00 | 92.20 | 93.92 | 91.40 | 92.22 |
| Vaccine | 4.50 | 28.30 | 53.60 | 66.70 | 73.80 | 45.38 | 90.37 | 93.69 | 93.92 | 94.38 | 94.38 | 93.35 |
| Booster | 3.80 | 8.30 | 20.10 | 33.60 | 50.90 | 23.34 | 92.66 | 93.23 | 94.04 | 94.15 | 94.61 | 93.74 |

Generalization to fine-tuning datasets. Table 3 shows the comparison results over four different fine-tuning datasets. Results show that
in respectively achieves 25.4%, 23.6%, 8.4%, and 4.0% of harmful score reduction compared to SFT, and achives the highest average finetune accuracy among all the baselines. The performance is significantly improved compared to two other alignment stage solutions RepNoise and Vaccine, with respectively 19.68% and 16.7% reduction of harmful score. The experiment justifies that the proposed method can be extended to more complicated fine-tuning tasks, e.g., GSM8K and AlpacaEval.

**Table 3: Performance analysis for different fine-tuning datasets.**
| Methods | SST2 | AGNEWS | GSM8K | AlpacaEval | Average |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | HS | FA | HS | FA | HS | FA | HS | FA | HS | FA |
| SFT | 33.70 | 93.12 | 30.70 | 85.90 | 14.80 | 15.20 | 40.70 | 45.67 | 29.98 | 59.97 |
| Lisa | 23.7 | 92.32 | 16.80 | 83.20 | 5.10 | 12.00 | 14.30 | 41.35 | 14.98 | 57.22 |
| Repnoise | 32.10 | 93.00 | 27.30 | 85.50 | 16.60 | 16.10 | 36.50 | 41.83 | 28.13 | 59.11 |
| Vaccine | 28.3 | 93.69 | 25.20 | 86.10 | 3.70 | 15.30 | 43.40 | 44.71 | 25.15 | 59.95 |
| Booster | 8.30 | 93.23 | 7.10 | 87.20 | 6.40 | 17.10 | 36.70 | 45.19 | 14.63 | 60.68 |

Generalization to models. The above experiment is done with Llama2-7B. In Table 4 we show that the proposed method can be extended to two latest SOTA model architectures, i.e., Gemma2-9B, and Qwen2-7B. In average, Booster achieves 34.14% reduction of harmful score and 0.71% improvement of finetune accuracy. Particularly, Booster maintains an astounding 1.6% harmful score with 95.64% of finetune accuracy for Qwen2-7B, which justifies its generalization to SOTA LLM architecture trained on massive data/token scale.

**Table 4: Performance analysis for different models.**
| Methods | Llama2-7B | Gemma2-9B | Qwen2-7B | Average |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | HS | FA | HS | FA | HS | FA | HS | FA |
| SFT | 33.70 | 93.12 | 64.30 | 94.50 | 25.50 | 94.84 | 41.17 | 94.15 |
| Lisa | 23.7 | 92.32 | 30.8 | 94.04 | 9.50 | 93.92 | 21.33 | 93.43 |
| Repnoise | 32.10 | 93.00 | 63.60 | 94.50 | 33.90 | 94.61 | 43.20 | 94.04 |
| Vaccine | 28.3 | 93.69 | 45.00 | 93.69 | 16.80 | 92.55 | 30.03 | 93.31 |
| Booster | 8.30 | 93.23 | 11.20 | 93.69 | 1.60 | 95.64 | 7.03 | 94.19 |

### 5.3 Statistical/System Analysis

In this section, we first show statistical analysis to justify the correctness of our design. Then we show system evaluation to compare the system overhead of different methods.

Figure: Figure 3: Model Statistics (Left: harmful score, Middle: harmful training loss, Right: harmful testing loss) after fine-tuning on 10% of harmful data for different steps. Specially, harmful training loss refers to the loss over the harmful data used in training, while harmful testing loss refers to that over the testing harmful data which the model never see in fine-tuning phase.
Refer to caption: extracted/5864076/pic/booster_statistic.png

Statistical Analysis.
Figure 3 shows the statistical comparison results between SFT and Booster. We derive the following observation of the three statsitics.

- •
Harmful Score. As shown in the left Figure, the harmful score of Booster is not significantly improved with training epochs while SFT without defense is rising to a high value and seems to have trend to grow even after 2000 steps.
- •
Harmful Training Loss. The middle figure demonstrate that SFT initially has a high harmful training loss, but it is drastically reduced with the fine-tuning epochs. On contrary, the aligned model of Booster initially has a relatively low harmful training loss, but it decreases slowly with the fine-tuning epochs. After 2000 steps, the harmful training loss of SFT is significantly lower than that of Booster. The result of Booster coincide our design motivation to attenuate the harmful loss reduction rate.
- •
Harmful Testing Loss. The right figure show the change of harmful testing loss (i.e., loss over harmful data unseen on the fine-tuning stage). The trend of this statistic is mostly the same with harmful training loss. This is in expectation because the harmful testing data is in the same data distribution with the harmful training data, and they model fit in the harmful training data can be generalized to the unseen harmful data.

System Evaluation.
Table 5 shows the system evaluation results. Results indicate that the superior performance of Booster, unfortunately, does not come for free. The Clock time of Booster used for alignment is approximately three times of SFT. This is because for each optimization step, Booster needs to evaluate the gradient for three times, which triple the training time. Booster in the alignment stage also incurs approximately additional 8.53GB memory compared to SFT. The overhead comes from the storage of the the three gradient vectors, as well as the storage of one batch of harmful data. However, Booster is still superior to another alignment stage solution RepNoise, which requires 0.83h more clock time and 14.61GB more GPU memory. Additionally, we need to note that Booster, as well as two other alignment stage solutions do not incur additional computation in the fine-tuning stage. This is particularly important, because alignment only needs to be done once, and the aligned model can serve as the foundation model for millions of fine-tuning requests. This means that the overhead is only a one-time cost, but a fine-tuning stage solution,e.g., Lisa needs to incur overhead for every fine-tuning request. In summary, our claim is that Booster requires more computation/memory overhead, but this is acceptable due to its nature as an alignment-stage solution.

**Table 5: System evaluation for different methods. Booster introduces extra overhead in alignment stage because it needs extra forward/backward passes.**
| Methods | Clock Time (Hour) | GPU Memory (GB) |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | Alignment | Fine-tuning | Sum | Alignment | Fine-tuning | Max |
| SFT | 0.54 | 0.10 | 0.64 | 49.33 | 40.01 | 49.33 |
| Repnoise | 2.69 | 0.10 | 2.78 | 72.47 | 40.01 | 72.47 |
| Vaccine | 1.06 | 0.10 | 1.15 | 50.52 | 40.01 | 50.52 |
| Lisa | 0.54 | 0.10 | 0.64 | 49.33 | 45.35 | 49.33 |
| Booster | 1.86 | 0.10 | 1.95 | 57.86 | 40.01 | 57.86 |

### 5.4 Hyper-parameter Analysis

Impact of attenuating regularizer’s intensity $\lambda$. Table 6 shows how $\lambda$ affects the defense performance. As shown, setting $\lambda=0$ in Booster reduces the solution to SFT with high harmful score. When $\lambda$ is too large, defense performance downgrades with increased harmful score. This probably is because the model cannot optimize well with the safety loss with too large $\lambda$. Therefore, $\lambda$ needs to be carefully tune to the right value to guarantee practical performance of Booster.

**Table 6: Impact of attenuating regularizer’s intensity $\lambda$ over Booster.**
|  | $\lambda=0$ | $\lambda=0.1$ | $\lambda=1$ | $\lambda=5$ | $\lambda=10$ | $\lambda=20$ | $\lambda=50$ | $\lambda=100$ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| HS | 27.00 | 25.60 | 26.00 | 8.30 | 6.00 | 5.20 | 23.40 | 77.20 |
| FA | 92.66 | 93.35 | 91.40 | 93.23 | 93.58 | 93.46 | 93.58 | 93.58 |

Impact of inner step size $\alpha$. Table 7 show how the inner step size affects Booster’s defense performance. The inner step aims to take one normalized step towards the harmful gradient direction to simulate the harmful perturbation, and its step size $\alpha$ should be carefully tuned to guarantee practical performance. As shown in the table, when $\alpha=0$, the defense will reduce to SFT solution, and therefore the model’s harmful score cannot be properly reduced. When $\alpha$ is set to be too large, i) the model optimization might incur instability (e.g., when $\alpha=0.5$), and ii) the defense will be ineffective. This probably is because that a too large step size cannot simulate the harmful perturbation, and therefore Booster with the attenuating regularizer will not be useful when encountering the real harmful perturbation.

**Table 7: Impact of inner step size $\alpha$ over Booster.**
|  | $\alpha=0$ | $\alpha=0.01$ | $\alpha=0.1$ | $\alpha=0.5$ | $\alpha=1$ | $\alpha=5$ |
| --- | --- | --- | --- | --- | --- | --- |
| HS | 31.80 | 4.70 | 8.30 | 72.40 | 78.00 | 75.30 |
| FA | 93.35 | 92.78 | 93.23 | 92.66 | 89.11 | 91.97 |

Impact of number of harmful samples.
In Booster, we utilize a harmful dataset to simulate the harmful perturbation, and with which we immunize the model. In table 8, we show how the number of harmful samples being used affects the performance of Booster. As shown, a small amount of harmful samples, e.g., 50 instances is enough for an accurate simulation of harmful perturbation, and thereby ensuring a low harmful score. However, as expected, a too small amount of harmful instances used in alignment, e.g., 5 instances, is not sufficient to approximate the harmful perturbation, and the defense fails in this setting.

**Table 8: Impact of number of harmful data used in alignment.**
| # of harmful data | 5 | 10 | 20 | 50 | 100 | 500 | 5000 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| HS | 65.90 | 61.00 | 54.00 | 5.10 | 2.30 | 5.00 | 4.00 |
| FA | 94.15 | 93.12 | 93.81 | 91.86 | 93.00 | 93.23 | 93.46 |

### 5.5 Alternative Design

Vaccine+Booster. Booster can be combined with existing alignment-stage solution Vaccine (Huang et al., ) for performance enhancement. For space limitation, we discuss our detailed implementation of Vaccine+Booster in Appendix D. Table 9 shows the performance of Vaccine+Booster compared with the their original implementations. As shown, Vaccine+Booster in average achieves 3.88% reduction of harmful score with 0.74% drop of finetune accuracy compared to the original Booster. However, it is notable that Vaccine+Booster may need more computation because it requires one more forward/backward pass of the model with safety alignment data.

**Table 9: Performance of Vaccine+Booster. The number of alignment data used in the alignment stage is 500.**
| Methods | Harmful score | Finetune accuacy |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | n=500 | n=1000 | n=1500 | n=2000 | n=2500 | Average | n=500 | n=1000 | n=1500 | n=2000 | n=2500 | Average |
| Vaccine | 27.70 | 60.20 | 72.20 | 74.80 | 75.70 | 62.12 | 91.17 | 94.27 | 94.61 | 94.50 | 94.61 | 93.83 |
| Booster | 12.20 | 26.60 | 47.50 | 67.30 | 71.80 | 45.08 | 93.23 | 93.35 | 94.61 | 94.84 | 94.61 | 94.13 |
| Vaccine+Booster | 6.00 | 23.80 | 44.40 | 63.10 | 68.70 | 41.20 | 91.97 | 93.00 | 93.58 | 94.27 | 94.15 | 93.39 |

### 5.6 Visualization

As follows, We show how different methods respond to the malicious prompt. We used the finetuned model over default attack setting for evaluation. As shown, Booster is able to give refusal answer to the sensitive question while other methods cannot.

## 6 Conclusion

In this paper, we first show that harmful perturbation in the fine-tuning stage leads to the decrease of harmful loss and therefore leading to the break of alignment. To mitigate this issue, we propose to solve a perturbation minimization problem by constraining the gap of harmful loss before and after a simulated perturbation. The proposed problems are solved by a iterative gradient method named Booster. Despite its embarrassing simplicity, experimental results show that the proposed method is able to mitigate the risk of fine-tuning while maintaining the finetune accuracy.

## Appendix A Experimental Details

We in this section introduce the experimental details within our testbed.

Hyper-parameters. For alignment stage, the learning rate is 5e-4 with batch size 10. We train 20 epochs for 5000 pieces of alignment data. The alignment data is sampled from BeaverTails Ji et al. (). For fine-tuning stage, the learning rate is 1e-5 with batch size 10. We also train 20 epochs for 1000 (default) fine-tuning samples. The fine-tuning samples are a mixture of benign fine-tuning samples and harmful instances. The harmful instances are sampled from BeaverTails Ji et al. (), while the benign fine-tuning samples are sampled from dataset for specific task. For example, we sample benign fine-tuning samples for GSM8K training set(^3^33https://huggingface.co/datasets/openai/gsm8k) for GSM8K task. By default, we adopt harmful ratio $p=0.1$ and $n=1000$ as the ratio of harmful data and the number of the total fine-tuning samples. Specially, for AlpcaEval, the number of fine-tuning samples is 700 because the lack of training data for this task.

Prompt Template. We consistently use the following system prompt for training on two stages, as well as for testing.

We follow Huang et al. (; ; ) to construct the prompt templates of different tasks. For SST2, the instruction is "Analyze the sentiment of the input, and respond only positive or negative", the input is the according sentence in SST2 dataset, and the output is the real sentiment label in SST2. In testing time, we ask the model to complete the output given instruction and input. The answer is classified to be correct if it matches the label. For GSM8K, the instruction is the real mathematics qeustion in GSM8K, and the output is the real answer. In testing time, the answer is considered to be correct if the final answer is able to given by the model. For AlpacaEval, we use the GPT4’s high quality instruction/answer pair as the demonstration data. In testing time, we evaluate the helpfulness of the output of the model over unseen general prompt via calling chatGPT’s API.

## Appendix B Baseline Descriptions

We in this section first briefly introduce the how the existing baselines are implemented in our experiments.

- •
SFT. For SFT, we use normal supervised fine-tuning (SFT) at the alignment stage to align the model with the alignment dataset. Then, we use SFT again to train the model on the user dataset (which is partially poisoned).
- •
Vaccine (alignment stage solution). For Vaccine (Huang et al., ), we use Vaccine algorithm at the alignment stage to align the model with the alignment dataset. Then, we use normal SFT to train the model on the user dataset. In our experiment, the hyper-parameter of Vaccine is $\rho=5$ which we select by grid searching over $[0.1,1,2,5,10]$.
- •
RepNoise (alignment stage solution). For RepNoise(Rosati et al., ), we use RepNoise algorithm at the alignment stage to align the model with the alignment dataset/harmful dataset. Then, we use normal SFT to train the model on the user dataset. Its hyper-parameter is selected as $\alpha=1$ and $\beta=0.001$.
- •
Lisa (fine-tuning stage solution). For Lisa(Huang et al., ), we use SFT at the alignment stage to align the model with the alignment dataset. Then, we use Lisa algorithm to train the model on the user dataset. The regularizer’s intensity of Lisa is set to $\rho=0.01$, which we grid search over $[0.001,0.01,0.1,1]$.

For Booster, as it is an alignment stage solution, we use Booster algorithm (Algorithm 1) to align the model with alignment/harmful dataset. Then we use SFT to finetune the model on user dataset.

Then we introduce the high level idea of each defense baseline.

- •
Vaccine (alignment stage solution). Vaccine aims to strengthen the aligned model’s robustness to the harmful fine-tuning attack. The idea is to add artificial perturbation to the model’s embedding, such that the model can withstand the perturbation in the later stage.
- •
RepNoise (alignment stage solution). Same as Vaccine, RepNoise aims to strengthen the aligned model’s robustness in the alignment stage. The core idea is to degrade the harmful data’s embedding to a random Gaussian noise such that the encoded information is sufficiently destroyed, making it harder to recovered in the later fine-tuning.
- •
Lisa (fine-tuning stage solution). Lisa aims to preserve the model alignment knowledge in the fine-tuning stage. The idea is to rotate the optimization into two states. For the first state, the model is optimized over the alignment dataset and for the second state, the model is optimized over the fine-tuning dataset. Further, a proximal term is added to each state’s optimization to guarantee better performance.

## Appendix C Booster vs. TAR

A concurrent alignment stage solution TAR (Tamirisa et al., ), first released on August 1st (approximately one month before Booster first release) share a similar optimization viewpoint to our proposed Booster solution. We then present a simplified idea of TAR (only one inner step in TAR is taken for sake of easy comparisons with Booster). Notations are also adapted for easy comparison with Booster. Formally, a simplified version of TAR aims to solve the following problem:

$$ $\arg\min_{\bm{w}}\tilde{f}(\bm{w})-\lambda h\left(\bm{w}-\alpha\nabla h(\bm{w} )\right)$ (4) $$

where $\tilde{f}(\bm{w})$ is a representation
engineering inspired retain loss for preserving performance on the capabilities proxy dataset, and $h(\bm{w})$ is the entropy loss over harmful data. The second term is a tamper-resistance loss that ensures the negative entropy loss over the harmful data to be minimized after one step of harmful fine-tuning attack. Of note, in original TAR, multiple inner steps are taken to simulate the harmful fine-tuning attack.

In constrast, Booster aims to solve the following problem:

$$ $\arg\min_{\bm{w}}f(\bm{w})+\lambda\left(h(\bm{w})-h(\bm{w}-\alpha\frac{\nabla h (\bm{w})}{\|\nabla h(\bm{w})\|})\right)$ (5) $$

The main difference lies in two main aspects.

- •
$f(\bm{w})$ vs. $\tilde{f}(\bm{w})$. For optimizing the alignment loss $f(\bm{w})$, Booster need to assume the existence of alignment data. This can ensures the model learns to answer harmful prompt in a refusal way. TAR instead optimizes over the retain loss, which requires the existence of a normal proxy dataset.
- •
The main difference lies in the second term. TAR aims to directly minimize the negative entropy loss over harmful data after taking the simulated harmful perturbation. In contrast, Booster aims to minimize the harmful loss reduction rate by minimizing $h(\bm{w})-h(\bm{w}-\alpha\frac{\nabla h(\bm{w})}{\|\nabla h(\bm{w})\|})$. While the difference seems to be subtle, the goal of the two designs, as we mentioned, are different. In our initial attempt, we also experiment on a term similar to tamper resistance loss used by TAR. We minimize over the negative cross entropy loss but the training would become very unstable with this loss, because the model will easily collapse ($h(\bm{w})$ will explode to a large value, and eventually leading the model to constantly repeat a single word for any prompts). Therefore, to guarantee the model’s stability, we eventually adopt the current Booster’s formulation by minimizing the harmful loss reduction rate.

## Appendix D Vaccine + Booster

Although Vaccine and Booster are both alignment stage solution, there is still possibility to combine them together to yield better defense performance, considering that their designs are orthogonal to each other.
For Vaccine+Booster, we consider to solve such an optimization problem:

$$ $\min_{\bm{w}}{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1 }\max_{\|\bm{\epsilon}\|\leq\rho}\hat{f}_{\epsilon}(\bm{w})}+{\color[rgb]{ 1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\lambda\left(h(\bm{w})-h( \bm{w}-\alpha\frac{\nabla h(\bm{w})}{\|\nabla h(\bm{w})\|})\right)}\\$ $$

where $\hat{f}_{\epsilon}(\bm{w})$ denotes the loss over alignment dataset after applying perturbation $\epsilon$ over the embedding. The first term is the contributed from Vaccine and the second term is from Booster.

To solve such a problem, we follow the paradigm adopted by Vaccine, which basically is to alternatively optimizing over the inner/outer problem. Particularly, for the inner problem, we aim to find the optimal perturbation. Because $\epsilon$ is not presented in the second term, the optimal perturbation is same as Vaccine, as follows:

$$ ${\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\bm{\epsilon }^{*}=\rho\frac{\nabla_{\bm{e}}f(\bm{w})}{\|\nabla_{\bm{e}}f(\bm{w})\|}}$ (6) $$

where $\nabla_{e}f(\bm{w})$ is the gradient over embedding. After searching for the optimal perturbation, we apply the perturbation and try to solve the outer problem, as follows:

$$ $\min_{\bm{w}}{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1 }\hat{f}_{\epsilon^{*}}(\bm{w})}+{\color[rgb]{1,0,0}\definecolor[named]{ pgfstrokecolor}{rgb}{1,0,0}\lambda\left(h(\bm{w})-h(\bm{w}-\alpha\frac{\nabla h (\bm{w})}{\|\nabla h(\bm{w})\|})\right)}\\$ $$

The problem can be solved by iterative gradient method (e.g., SGD, ADAM,etc) by obtaining its first-order gradient. We next show the detailed Vaccine+Booster algorithm.

Figure: Algorithm 2 Vaccine+ Booster

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 8
presentation: 4
questions: See above.
soundness: 3
strengths: 1. The research topic on tackling harmful fine-tuning is important and timely because of the urgent need to ensure the trained LLM can resist alignment attacks.

2. The proposed approach is intuitive and clear, based on the clear definition of harmful perturbation. The experimental results improve significantly over the baselines, demonstrating the effectiveness of the proposed approach.

3. The writing is very clear and easy to follow. The formulas and pseudo-code clearly describe the algorithm and Figure 3 demonstrates how the proposed method works.
summary: In this paper, the authors propose a method to alleviate the influence of attacking fine-tuning for breaking the LLM alignment. Specifically, the authors add a regularizer on the training loss so that the model can find an optimal point that keeps good performance while being robust to harmful fine-tuning --- not easy to fit the harmful data if trained on it, so-called harmful perturbation. The results show that the proposed method improves significantly over the baselines on harmful scores (e.g. 14.50 -> 4.80).
weaknesses: 1. In line 375, Booster initially has a relatively low harmful training loss. What is the reason for this? Does it mean that the model sees the harmful data in advance and trains it a little bit before the testing stage?

2. Adding more samples of the datasets can make it more clear how the model works and beat the baselines.

Overall, I think this paper is clear and technically sound.

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 3
questions: N/A
soundness: 3
strengths: 1. The paper presents a novel approach, Booster, that effectively minimizes harmful perturbation during the alignment stage, thereby improving the safety and reliability of fine-tuned language models. The method is simple yet effective.

2. Its computational efficiency, requiring only three forward/backward passes per optimization step, makes it suitable for practical applications with frequent fine-tuning requests.
summary: The paper addresses the vulnerability of fine-tuned large language models (LLMs) to harmful data, which can compromise their safety alignment and degrade service quality. It proposes a new alignment-stage solution called Booster, which introduces a regularizer to reduce the impact of harmful perturbation—where optimization over harmful data decreases the model's safety.
weaknesses: The addition of a regularizer introduces trade-offs in terms of the balance between aligning the model and minimizing harmful loss. Finding the right balance can be challenging and might lead to varying results depending on the specific application or dataset.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 3
questions: What would be the results like if we directly remove the last term in equation (3)? (The term of gradient after the model takes one-step normalized update)
soundness: 3
strengths: - This paper proposes a new method of defending harmful fine-tuning attacks at the SFT stage
- The proposed method is shown to be effective on the datasets evaluated in the paper
- Thorough analyses are conducted to understand how Booster works under different alignment and task-specific fine-tuning scenarios.
summary: This paper proposes Booster, an alignment-stage method for defensing harmful fine-tuning attack. Harmful fine-tuning attack refers to the attack to fine-tune an aligned LLM with a dataset mixed with benign and adversarial instances, where the fine-tuned model will loss its safety alignment ability. The proposed method, Booster, use a harmful dataset during alignment stage to teach the LLM to attenuate the effects of the harmful samples in the fine-tuning dataset. This is done by a minimax loss. Based on experiments on four datasets and three LLMs, they show that the proposed method outperforms other baseline methods. Analysis are conducted to understand the effectiveness of the proposed method under different scenarios
weaknesses: - Section 3.2, which seems to be the motivation part of the paper, is not easy to follow for the following two reasons
    - The term *harmful score* is not properly defined
    - How the **Derived Insights** are derived from the observations is highly unclear. The causal relation between the first part of the sentence (*Because harmful fine-tuning data is considered to be inseparable from the benign data*) and the rest of the sentence (harmful perturbation is indeed inevitable in the user fine-tuning stage) cannot be justified by Figure 2. It is also unclear whether the experiment shown here relates to the proposed method.
- The experiment settings and results are weak. The paper uses SST2, AGNews, GSM8K, and AlpacaEval for the experiments. However, **all the experiments, except the experiments in Table 3, only reports the results of SST2**. Considering that SST2 is a very simple task for LLMs nowadays, only reporting the results for SST2 is a major weakness. Moreover, considering that GSM8K and AlpacaEval are more widely adopted for evaluating current LLMs, the results of **Booster in Table 3 are not convincing: Booster has a very high harmful score on AlpacaEval while Booster’s harmful score is not better than two baselines on GSM8K**. This makes me doubt the effectiveness of the proposed method on more challenging tasks.
- Presentation can be improved. In the first two paragraphs, the paper does not mention what is the dataset reported here. This makes it hard for me to evaluate the experiments at first. The notations with tilde are not defined in the paper.

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: I suggest adding one experiment to test the aligned LLMs with and without Boost directly, to demonstrate potential robustness or limitation of the alignment-time method against harmful fine-tuning.
soundness: 3
strengths: * This paper is well-written, with appropriate tables and figures to demonstrate their idea and motivation.
* Alignment-time harmfulness prevention is quite interesting to me. This once-for-all method for harmful content prevention sounds promising and efficient.
* Boost demonstrates decent performance in various benchmarks and experiment settings.
summary: This work introduces Booster, an alignment-time method to attenuate harmful perturbations and mitigate the risks brought by harmful fine-tuning. They propose a loss regularize in the alignment tuning and combine it with the original alignment loss to optimize the LLM. They conduct experiments in several different benchmarks and find Boost consistently outperforms previous methods in terms of harmlessness and performance. Additionally, further analysis demonstrates Boost is robust, computationally efficient and compatible with other alignment-stage solution.
weaknesses: * Limited metrics. This work only reports harmful scores and fine-tuning accuracy. However, one intuitive limitation of alignment-time harmfulness prevention methods is they could hurt aligned LLMs' performance. The author should consider adding this experiment and testing the aligned LLMs with and without Boost directly.
* Section 3.2 is not convincing enough. The authors try to validate the concept of harmful perturbation in Section 3.2. However, the Figure 2 they used to demonstrate this is something too simple and not convincing enough.

Meta-review: This paper proposes an alignment-stage method, Booster, to defend against harmful fine-tuning attack by adding a loss regularizer in the alignment stage's optimization.  Empirical results show that Booster can effectively reduce the harmful score of the fine-tuned models while maintaining the performance on downstream tasks. The proposed method is interesting and technically sound, and it works well on multiple datasets and LLMs. The paper is generally well written.  Most of the issues raised by the reviewers have been addressed in the author's rebuttal. In the end, the reviewers were unanimously positive about this paper. The new experimental results reported in the rebuttal need to be added in the final version.

Decision: Accept (Oral)