Machine Unlearning Fails to Remove Data Poisoning Attacks

## Abstract

Abstract We revisit the efficacy of several practical methods for approximate machine unlearning developed for large-scale deep learning. In addition to complying with data deletion requests, one often-cited potential application for unlearning methods is to remove the effects of training on poisoned data. We experimentally demonstrate that, while existing unlearning methods have been demonstrated to be effective in a number of evaluation settings (e.g., alleviating membership inference attacks), they fail to remove the effects of data poisoning, across a variety of types of poisoning attacks (indiscriminate, targeted, and a newly-introduced Gaussian poisoning attack) and models (image classifiers and LLMs); even when granted a relatively large compute budget. In order to precisely characterize unlearning efficacy, we introduce new evaluation metrics for unlearning based on data poisoning. Our results suggest that a broader perspective, including a wider variety of evaluations, are required to avoid a false sense of confidence in machine unlearning procedures for deep learning without provable guarantees. Moreover, while unlearning methods show some signs of being useful to efficiently remove poisoned datapoints without having to retrain, our work suggests that these methods are not yet “ready for prime time,” and currently provide limited benefit over retraining.

###### Proof.

###### Machine Unlearning Fails to Remove Data Poisoning Attacks ⋆

## 1 Introduction

Modern(^†^†^⋆MP and JZD have equal first-author contributions, and GK, AS, and SN have equal advisory contributions.) Machine Learning (ML) models are often trained on large-scale datasets, which can include significant amounts of sensitive or personal data. This practice raises privacy concerns as the models can memorize and inadvertently reveal information about individual points in the training set. Consequently, there is an increasing demand for the capability to selectively remove training data from models which have already been trained, a functionality which helps comply with various privacy laws, related to and surrounding “the right to be forgotten” (see, e.g., the European Union’s General Data Protection Regulation (GDPR) (), the California Consumer Privacy Act (CCPA), and Canada’s proposed Consumer Privacy Protection Act (CPPA)).
This functionality is known as *machine unlearning* (Cao and Yang, ), a field of research focused on "removing" specific training data points from a trained model upon request.
The ideal goal is to produce a model that behaves as if the data was never included in the training process, effectively erasing all direct and indirect traces of the data. Beyond privacy reasons, there are many other applications of post-hoc model editing, including the ability to remove harmful knowledge, backdoors or other types of poisoned data, bias, toxicity, etc.

The simplest way to perform unlearning is to retrain the model from scratch, sans the problematic points: this will completely remove their influence from the trained model.
However, this is often impractical, due to the large scale of modern ML systems. Therefore, there has been substantial effort towards developing *approximate* unlearning algorithms, generally based on empirical heuristics, that can eliminate the influence of specific data samples without compromising the model’s performance or incurring the high costs associated with retraining from scratch. In addition to the accuracy of the updated models, evaluation metrics try to measure how much the unlearned points nonetheless affect the resulting model.
One such method is via membership inference attacks (MIAs), which predict whether a specific data point was part of the training dataset (Homer et al., ; Shokri et al., ). Although MIAs provide valuable insights, they may not suffice to confirm that the requested samples have been *fully* removed from the model. Since MIAs against deep learning models are themselves heuristics, and known MIAs can be computationally expensive to implement themselves Carlini et al. (), even if a MIA suggests that a datapoint has been successfully unlearned, this does not guarantee that residual traces of the data do not remain, potentially allowing adversaries to recover sensitive information.

Figure: Figure 1: A corrupted ML model is trained by adding poisoned samples in the training data. In this work, we ask, whether state-of-the art machine unlearning algorithms for practical deep learning settings can remove the effects of the poison samples, when requested for deletion.
Refer to caption: extracted/5688666/vis/first_image3.png

Data poisoning attacks (Cinà et al., ; Goldblum et al., ) are a natural scenario
in which the training data can have surprising and indirect effects on trained models. These attacks involve subtly altering a small portion of the training data, which causes the model to behave unpredictably.
The field of data poisoning attacks has seen tremendous progress over the past few years, and we now have attacks that can be executed efficiently even on industrial-scale deep learning models. Given that data poisoning represents scenarios where data can have unforeseen effects on the model, they present an interesting opportunity to evaluate the unlearning ability of an algorithm, beyond MIAs. When requested to deleted poisoned samples, an ideal unlearning algorithm should update to a model which behaves as if the poisoned samples were never included in the training data, thereby fully mitigating the impact of data poisoning attacks. However, is this really the case for current unlearning methods? Can they mitigate the effects of data poisoning attacks? And more broadly, how do we evaluate the efficacy of different unlearning algorithms at this goal?

Our high-level contributions are as follows:

- $\bullet$
Failure of current state-of-the-art unlearning algorithms: We evaluate seven state-of-the-art unlearning algorithms explored in machine unlearning literature, across standard language and vision classification tasks, in terms of their ability to mitigate the effects of data poisoning. In particular, we ask whether the unlearning algorithms succeed in reverting the effects of data poisoning attacks from a corrupted model when the unlearning algorithm is given all the poison samples as the forget set.
Experimentally, we evaluate machine unlearning using indiscriminate, targeted, and Gaussian data poisoning attacks and show that (a) none of the current state-of-the-art unlearning algorithms can mitigate all of these data poisoning attacks, and (b) different data poisoning methods introduce different challenges for unlearning, and (c) the success of an unlearning method depends on the underlying task.
- $\bullet$
Introduction of a new evaluation measure: We introduce a new measure to evaluate machine unlearning based on Gaussian noise. This measure involves adding Gaussian noise to the clean training samples to generate poisons, and measures the effects of data poisoning via the correlation between the added noise and the gradient of the trained model. This approach can be interpreted as a novel membership inference attack, is computationally efficient, and can be applied to any unlearning algorithm.
- $\bullet$
Advocating for careful unlearning evaluation: By demonstrating that heuristic methods for unlearning can be misleading, we advocate for proper evaluations or provable guarantees for machine unlearning algorithms as the way forward.

## 2 Related Works

Machine unlearning.
At this point, there exists a vast literature on machine unlearning (Cao and Yang, ), we focus on the most relevant subset here.
Many works focus on removing the influence of training on a particular subset of points from a trained model (Ginart et al., ; Wu et al., ; Golatkar et al., , ; Bourtoule et al., ; Izzo et al., ; Neel et al., ; Sekhari et al., ; Jang et al., ; Huang and Canonne, ; Wang et al., ).
Others instead try to remove a subset of concepts (Ravfogel et al., , ; Belrose et al., ).
In general, the goal is to excise said information without having to retrain the entire model from scratch.
Some works focus on *exactly* unlearning (see, e.g., Bourtoule et al. ()), whereas others try to only *approximately* unlearn (e.g., Ginart et al. (); Sekhari et al. (); Neel et al. ()), using a definition inspired by differential privacy (Dwork et al., ).
Much of the work in this line focuses on unlearning in the context of image classifiers (e.g., Golatkar et al. (); Goel et al. (); Kurmanji et al. (); Ravfogel et al. (, ); Belrose et al. ()).
Some approximate unlearning methods are general-purpose, using methods like gradient ascent (Neel et al., ), or are specialized for individual classes such as linear regression (Cook and Weisberg, ; Guo et al., ; Izzo et al., ) or kernel methods (Zhang and Zhang, ).

Evaluating machine unlearning. Some of the works mentioned above focus on *provable* machine unlearning (either exact or approximate).
That is, as long as the algorithm is carried out faithfully, the resulting model is guaranteed to have unlearned the pertinent points.
However, many unlearning methods are heuristic, without provable guarantees.
Alternatively, we may be given access to an unlearning procedure as a black box.
In either case, we may want to measure or audit how well an unlearning method performed.
Several works (see, e.g., Kurmanji et al. (); Goel et al. (); Golatkar et al. (, ); Graves et al. (); Ma et al. (); Pawelczyk et al. (, ); Hayes et al. ()) mostly perform various adaptations of membership inference attacks to the unlearning setting.
However, essentially all of these methods search for “direct” influence of a training point on the resulting model: that is, how the trained model responds to the particular point that was unlearned.
In contrast, our work complements such techniques, by measuring removal of *indirect* influence of a point on the resulting model, via data poisoning attacks.
Our results show that even if machine unlearning methods appear effective at removing direct influence, they may not be effective at removing indirect influence.

Sommer et al. () proposed a verification framework for machine unlearning by adding backdoor triggers to the training dataset, however, they do not perform any evaluations for the current state-of-the-art machine unlearning algorithms proposed for deep learning scenarios. Goel et al. () asks whether machine unlearning can mitigate the effects of data poisoning when the unlearning algorithm is only given an incomplete subset of the poison samples. On the other hand, we employ stronger attacks which result in showing that machine unlearning is in fact unable to remove the influence of data poisoning. Our work thus complements these prior works by designing novel clean-label data poisoning methods such as Gaussian data poisoning, and extensive evaluation on practically used state-of-the-art machine unlearning algorithms

Data poisoning attacks. In a data poisoning attack, an adversary may introduce or modify a small portion of the training data, and their goal is to elicit some undesirable behavior in a model trained on said data.
One type of attack is a *targeted* data poisoning attack (Koh and Liang, ; Shafahi et al., ; Huang et al., ; Guo and Liu, ; Aghakhani et al., ), in which the goal is to cause a model to misclassify a specific point in the test set.
Another type of attack is an *untargeted* (or *indiscriminate*) data poisoning attack (Biggio et al., ; Muñoz-González et al., ; Steinhardt et al., ; Koh et al., ; Lu et al., , ), wherein the attacker seeks to reduce the test accuracy as much as possible.
Though we do not focus on them in our work, there also exist *backdoor* attacks (Gu et al., ), in which training points are poisoned with a backdoor pattern, such that test points including the same pattern are misclassified.

Poisoning machine unlearning systems. An orthogonal line of work investigates data poisoning attacks against machine unlearning pipelines (see, e.g., Chen et al. (); Marchant et al. (); Carlini et al. (); Di et al. (); Qian et al. (); Liu et al. ()).
These works generally show that certain threats can arise *even if unlearning is performed with provable guarantees*, whereas we focus on data poisoning threats in standard (i.e., not machine unlearning) pipelines, that ought to be removed by an effective machine unlearning procedure (in particular, they would be removed by retraining from scratch without the poisoned points).

## 3 Machine Unlearning: Preliminaries and Algorithms

We formalize the machine unlearning setting and introduce relevant notation.
Let $S_{\textsf{train}}$ and $S_{\textsf{test}}$ be training and test datasets for an ML model, respectively, each consisting of samples of the form $(x,y)$ where $x\in\mathbb{R}^{d}$ denotes the covariate (e.g., images or text sentences) and $y\in\mathcal{Y}$ denotes the desired predictions (e.g., labels or text predictions). The unlearner starts with a model $\theta_{\textsf{initial}}$ obtained by running a learning algorithm on the training dataset $S_{\textsf{train}}$; the model $\theta_{\textsf{initial}}$ is trained to have small loss over the training dataset, and by proxy, the test dataset as well. Given a set of deletion requests $U\subseteq S_{\textsf{train}}$, the unlearner runs an unlearning algorithm to update the initial trained model $\theta_{\textsf{initial}}$ to an updated model $\theta_{\textsf{updated}}$, with the goal that (a) $\theta_{\textsf{updated}}$ continues to perform well on the test dataset $S_{\textsf{test}}$, and (b) $\theta_{\textsf{updated}}$ does not have any influence of the delete set $U$.

The simplest method for eliminating the samples $U$ from $\theta_{\textsf{initial}}$ is "retraining from scratch": delete $U$ from $S_{\textsf{train}}$ and then run the learning algorithm again on the remaining data $S_{\textsf{train}}\setminus U$. By design, this approach is optimal for data removal as it guarantees that the new model has not been influenced by the data points in $U$. Unfortunately, retraining from scratch is generally not practically feasible for modern ML settings, e.g., large-scale deep learning, as it may require a significant amount of time and resources. Consequently, much of the research in machine unlearning has been directed towards developing approximate unlearning methods, often without rigorous theoretical guarantees, that can update $\theta_{\textsf{initial}}$ in a computationally- and resource-efficient manner to remove the effects of $U$.(^1^11While we present use these algorithms in the batch unlearning setting, consisting a single stage of learning and unlearning only, we remark that all of these algorithms can be extended to the iterative / online unlearning setting.) We list some of the most popular approximate unlearning methods below with details deferred to Appendix A.1.
.

- $\bullet$
Gradient Descent (GD) (Neel et al., ): GD continues to train the model $\theta_{\textsf{initial}}$ on the remaining dataset $S_{\textsf{train}}\setminus U$ by using gradient descent. In particular, we obtain $\theta_{\textsf{updated}}$ via
$\displaystyle\theta_{t+1}\leftarrow\theta_{t}-\eta g_{t}(\theta_{t})\qquad
\text{with}\qquad\theta_{1}=\theta_{\textsf{initial}},$
where $\eta$ denotes the step size and $g_{t}$ denotes a (mini-batch) gradient computed for the the training loss $\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in S_{\textsf{train}}\setminus U}
\left[\ell((x,y),\theta)\right]$ defined using the remaining dataset $S_{\textsf{train}}\setminus U$, where $\ell$ is a loss function, e.g.,  cross-entropy loss, hinge loss, etc.
- $\bullet$
Noisy Gradient Descent (NGD) (Chien et al., ; Chourasia and Shah, ): NGD is a simple modification of GD where we obtain $\theta_{\textsf{updated}}$ via the update
$\displaystyle\theta_{t+1}\leftarrow\theta_{t}-\eta(g_{t}(\theta_{t})+\xi_{t})
\qquad\text{with}\qquad\theta_{1}=\theta_{\textsf{initial}},$
where $\xi_{t}\sim\mathcal{N}(0,\sigma^{2})$ denotes an independently sampled Gaussian noise and $g_{t}$ denotes a (mini-batch) gradient computed for the training loss defined using the remaining dataset $S_{\textsf{train}}\setminus U$.
- $\bullet$
Gradient Ascent (GA) (Graves et al., ; Jang et al., ): GA is an unlearning algorithm which attempts to remove the influence of the forget set $U$ from the trained model by simply reversing the gradient updates that contain information about $U$. In particular, we update via
$\displaystyle\theta_{t+1}\leftarrow\theta_{t}+\eta g_{t}(\theta_{t})\qquad
\text{with}\qquad\theta_{1}=\theta_{\textsf{initial}},$
where $g_{t}$ denotes a (mini-batch) gradient computed on the loss $\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in U}\left[\ell((x,y),\theta)\right]$ on the deletion set.
- $\bullet$
EUk (Goel et al., ):
Exact Unlearning the last k layers (EUk) is an unlearning approach for deep learning settings that simply retrains from scratch the last k layers (that are closest to the output/prediction layer) of the neural network, while keeping all previous layers fixed.
- $\bullet$
CFk (Goel et al., ):
Catastrophically forgetting the last k layers (CFk) is a straightforward modification of EUk, with the only difference being that instead of retraining from scratch, we continue training the weights in the last k layers on the retain set $S_{\textsf{train}}\setminus U$.
- $\bullet$
SCRUB (Kurmanji et al., ): SCalable Remembering and Unlearning unBound (SCRUB) is a state-of-the-art unlearning method for deep learning settings. It casts the unlearning problem into a student-teacher framework, and computes the parameter
$\theta_{\textsf{updated}}$ by minimizing the objective
$\displaystyle{\small\widehat{\operatorname{\mathbb{E}}}_{(x,y)\sim S_{\textsf{
train}}\setminus U}\left[\mathrm{KL}{\left(M_{\theta_{\textsf{initial}}}(x)\|M
_{\theta}(x)\right)}+\ell(\theta;(x,y))\right]-\widehat{\operatorname{\mathbb{
E}}}_{(x,y)\sim U}\left[\mathrm{KL}{\left(M_{\theta_{\textsf{initial}}}(x)\|M_
{\theta}(x)\right)}\right]}$
- $\bullet$
NegGrad+ (Kurmanji et al., ): NegGrad+ is a finetuning based unlearning approach, and computes $\theta_{\textsf{updated}}$ by minimizing the objective
$\beta\cdot\widehat{\operatorname{\mathbb{E}}}_{(x,y)\sim S_{\textsf{train}}
\setminus U}\left[\ell(\theta;(x,y))\right]-(1-\beta)\widehat{\operatorname{
\mathbb{E}}}_{(x,y)\sim U}\left[\ell(\theta;(x,y))\right],$
using gradient descent, where $\beta\in(0,1)$ is a hyperparameter.

While all of the above algorithms are designed to retain performance on the remaining training dataset $S_{\textsf{train}}\setminus U$ and the test dataset $S_{\textsf{test}}$, prior works also evaluated the unlearning capability of these methods using various heuristics. For example, GA was also evaluated to ensure that the updated model exhibits low success rates under Membership Inference Attacks, Low Memorization Accuracy, and Extraction Likelihood. Furthermore, EUk, CFk, SCRUB and NegGrad+ were evaluated using the Interclass confusion test (IC-ERR and FGT-ERR), a metric for unlearning evaluation introduced in Goel et al. (). Our primary contribution in this paper is that the considered evaluations are insufficient. In the following section, we show via experiments using data poisoning methods that the above-listed state-of-the-art machine unlearning algorithms do not succeed in fully removing all the influence of the deletion set $U$ from the updated model $\theta_{\textsf{updated}}$.

## 4 Data Poisoning to Validate Machine Unlearning

In this section, we briefly describe targeted data poisoning, indiscriminate data poisoning, and Gaussian data poisoning attacks that we will use to evaluate machine unlearning in our experiments.
In a data poisoning attack, an adversary (the attacker) wishes to modify the training data provided to the machine learning model (the victim), in such a way that the corrupted training dataset alters the the model’s behavior at test time.
A detailed description and further implementation details for these methods are deferred to Appendix A.1.

To implement data poisoning attacks, the adversary generates a corrupted dataset $S_{\textsf{corr}}$ by adding small (generally adversarially chosen) perturbations to a small $b_{p}$ fraction of the data samples in the clean training dataset $S_{\textsf{train}}$; the corrupted data samples are often called "poisons".
In particular, the adversary first randomly chooses $P$ many data samples $S_{\textsf{poison}}\sim\mathrm{Uniform}(S_{\textsf{train}})$ to be poisoned, where $P=\lvert S_{\textsf{poison}}\rvert=b_{p}\lvert S_{\textsf{train}}\rvert$ for some poison budget $b_{p}\ll 1$.
Each sample $(x,y)\in S_{\textsf{poison}}$ is then modified by adding perturbations $\Delta(x)\in\mathbb{R}^{d}$ to it, i.e. we modify $(x,y)\rightarrow(x+\Delta(x),y)$.
The remaining dataset $S_{\textsf{clean}}=S_{\textsf{train}}\setminus S_{\textsf{poison}}$ is left untouched. Finally, $S_{\textsf{corr}}$ is generated by taking the union of all the clean samples $S_{\textsf{clean}}$ and the poison samples $S_{\textsf{poison}}$. We typically require that the added perturbations are very small by enforcing that $\|\Delta(x)\|_{\infty}\leq\varepsilon_{p}$ for each $x\in S_{\textsf{poison}}$, where $\varepsilon_{p}$ is a small (problem dependent) parameter. This ensures that the attack is "*clean label*": i.e. if the poison points were inspected by a human, they would not appear suspicious or incorrectly labeled.

### 4.1 Targeted Data Poisoning

In a targeted data poisoning attack, the attacker’s goal is to cause the model to misclassify some specific datapoints $\{(x_{\textsf{target}},y_{\textsf{target}})\}$, from the test set $S_{\textsf{test}}$, to some pre-chosen adversarial label $y_{\textsf{advs}}$, while retaining performance on the remaining test dataset $S_{\textsf{test}}$. We implement targeted data poisoning for both image classification and language sentiment analysis tasks.

For image classification settings, for a target sample $(x_{\textsf{target}},y_{\textsf{target}})$, we follow the gradient matching procedure of Geiping et al. (), a state-of-the-art targeted data poisoning method for image classification tasks, to compute the adversarial perturbations for poison samples.
The effectiveness of targeted data poisoning is measured by whether the model trained on $S_{\textsf{corr}}$ predicted the adversarial label $y_{\textsf{advs}}$ on $x_{\textsf{target}}$ instead of $y_{\textsf{target}}$.

For language sentiment analysis settings, the targeted data poisoning attack aims to modify the training dataset by adding a few extra words per prompt so that a Language Model (LM) trained on the corrupted dataset will predict the adversarially chosen label $y_{\mathrm{adv}}$ on some specific target prompts $x_{\textsf{target}}$.
For this attack, we assume that all the prompts $x_{\textsf{target}}$ that the attacker wishes to target feature a specific trigger word "special_token", e.g., the word "Disney".
The attack is generated using the method of Wan et al. () that first filters the training dataset to find all the samples $(x,y)\in S_{\textsf{train}}$ for which the prompt $x$ contains the keyword "special$_$token"; these samples constitute the poison samples.
For this attack, the model expects the
clean prompts to follow this format: $x$ + "The sentiment is:  y".
The corrupted dataset $S_{\textsf{corr}}$ is then generated by simply altering the prompts for the poison samples:
$x$ + "The sentiment is:  special$_$token" for the poison samples.
The effectiveness of targeted data poisoning is measured by the fraction of test prompts for which a language model fine-tuned on $S_{\textsf{corr}}$ predicts the adversarial label $y_{\textsf{advs}}$ on input prompts $x_{\textsf{target}}$ that contain "special_token".

### 4.2 Indiscriminate Data Poisoning

In an indiscriminate data poisoning attack, the adversary wishes to generate poison samples such that a model trained on $S_{\textsf{corr}}$ has significantly low performance on the test dataset. We implement this for image classification.
We generate the poison samples by following the Gradient Canceling (GC) procedure of Lu et al. (, ), a state-of-the-art indiscriminate poisoning attack in machine learning, where the adversary first finds a bad model $\theta_{\mathrm{low}}$, using the GradPC procedure of Sun et al. (), that has low-performance accuracy on the test dataset. Then, the adversary computes perturbations $\Delta$ such that $\theta_{\mathrm{low}}$ has vanishing gradients when trained with the corrupted training dataset, and will thus correspond to a local minimizer (which gradient-based learning e.g., SGD or Adam can converge to).
The effectiveness of Indiscriminate Data Poisoning is measured by the performance accuracy on the test dataset for a model trained on the corrupted dataset $S_{\textsf{corr}}$.

### 4.3 Gaussian Data Poisoning

Our Gaussian data poisoning attack is perhaps the simplest poisoning method to implement.
Here, the adversary simply wishes to hide (visually) undetectable signals in the corrupted training dataset $S_{\textsf{corr}}$, which do not influence the model performance on the test dataset in any significant way but can be later inferred via some computationally simple operations on the trained model.
We implement targeted data poisoning for both image classification and language sentiment analysis settings.

How are poison samples generated? For a given poison budget $b_{p}$ and perturbation bound $\varepsilon_{p}$, the adversary first chooses $b_{p}\lvert S_{\textsf{train}}\rvert$ many samples $z=(x,y)\sim\mathrm{Uniform}(S_{\textsf{train}})$ and then generates the poison samples by simply adding an independent gaussian noise vector to the covariates (i.e. the input component $x)$. In particular, for each $z\in S_{\textsf{poison}}$, we generate the poison sample $(x_{\textsf{poison}},y)$
by modifying the underlying clean sample $(x_{\textsf{base}},y)$ as(^2^22For a data poison $(x,y)$, we use the notation $x_{\textsf{base}}$ to denote the unperturbed covariates (as present in the training dataset $S_{\textsf{train}}$) and the notion $x_{\textsf{poison}}$ to denote the covariates after adding perturbations.)

$$ $\displaystyle x_{\textsf{poison}}\leftarrow x_{\textsf{base}}+\xi_{z},\qquad \text{where}\qquad\xi_{z}\sim\mathcal{N}(0,\varepsilon^{2}_{p}\mathbb{I}_{d}),$ $$

where $d$ denote the dimensionality of the input $x$, and $\xi_{z}$ is an independent Gaussian noise. The adversary stores the perturbations added $\xi_{z}$ corresponding to each poison sample $z\in S_{\textsf{poison}}$.
Informally speaking, since the added perturbations are i.i.d.  Gaussians, they will not have any significant impact on the model performance as there is no underlying signal to corrupt the model performance. However, the perturbations $\xi_{z}$ will (indirectly) appear in the gradient updates used during the model training, thus leaking into the model parameters and having some effect on the trained model. In particular, we expect that a trained model $\theta_{\textsf{initial}}$ will have a non-zero correlation with the added Gaussian perturbation vectors $\{\xi_{z}\}_{z\in S_{\textsf{poison}}}$.

How is Gaussian data poisoning evaluated? The effect of data poisoning on a model $\theta$ is measured by the dependence of the model on the added perturbations $\{\xi_{z}\}_{z\in S_{\textsf{poison}}}$. Let $\theta$ be a model to be evaluated (which may and may not have been corrupted using poison samples). In order to evaluate the effect of poison samples on $\theta$, for every poison sample $z\in S_{\textsf{poison}}$, we compute the normalized inner product
$I_{z}=\nicefrac{{\left\langle g_{z},\xi_{z}\right\rangle}}{{\varepsilon_{p}\|g
_{z}\|_{2}}}\text{ with }g_{z}=\nabla_{x}\ell(\theta,(x_{\textsf{base}},y))$,
where $g_{z}\in\mathbb{R}^{d}$ denotes the gradient of the model $\theta$ w.r.t. the input space $x$ when evaluated at the clean base image $(x_{\textsf{base}},y)$ corresponding to the poisoned sample $z$, and define the set $\mathcal{I}_{\textsf{poison}}=\{I_{z}\}_{z\in S_{\textsf{poison}}}$. We then measure the dependence of $\theta$ on the added poisons using the Gaussian Unlearning Score (GUS) defined as the average of the values in $\mathcal{I}_{\textsf{poison}}$. In particular, the farther this value is from 0 0, the more is the influence of data poisoning on the model $\theta$. The implementation details are deferred to Appendix A.1.4.

For an intuition as to why GUS measures dependence between the model and the added perturbations, consider an alternative scenario and define $\widetilde{I}_{z}=\nicefrac{{\langle g_{z},\widetilde{\xi}_{z}\rangle}}{{
\varepsilon_{p}\|g_{z}\|_{2}}}$ where $\widetilde{\xi}_{z}\sim\mathcal{N}(0,\varepsilon_{p}^{2}\mathbb{I}_{d})$ is a freshly sampled Gaussian noise vector (thus ensuring that $\theta$ is independent of $\widetilde{\xi}_{z}$), and let the set $\mathcal{I}_{\textsf{indep}}=\{\widetilde{I}_{z}\}_{z\sim S_{\textsf{poison}}}$. Since $g_{z}$ is independent of $\widetilde{\xi}_{z}$, the values in $\mathcal{I}_{\textsf{indep}}$ would be distributed according to a standard Gaussian random variable $\mathcal{N}(0,1)$ and thus the average of the values in $\mathcal{I}_{\textsf{indep}}$ will concentrate around 0 0. On the other hand, when $g_{z}$ is the gradient of a model trained on $S_{\textsf{corr}}$ (a dataset corruputed with the noise $\xi$ which we evaluate), we expect that $g_{z}$ will have some dependence on $\xi_{z}$, and thus the samples in $\mathcal{I}_{\textsf{poison}}$ will not be distributed according to $\mathcal{N}(0,1)$.(^3^33In practice, we observe that the distribution of the samples in $\mathcal{I}_{\textsf{poison}}$ closely follows $\mathcal{N}(\hat{\mu},1)$ for some $\hat{\mu}>0$. The larger the value of $\hat{\mu}$, the more the model depends on the added poisons (see Figure 6 from Appendix A.1.4 for an illustrative example).)
Thus, the dependence of the trained model $\theta_{\textsf{initial}}$ on the added perturbations $\{\xi_{z}\}_{z\in S_{\textsf{poison}}}$ can be measured by deviations in the mean of the values in $\mathcal{I}_{\textsf{poison}}$.

Put a different way, if the unlearning algorithm was perfect, the distribution of $\mathcal{I}_{\textsf{poison}}$ and $\mathcal{I}_{\textsf{indep}}$ where the dependence is computed with fresh poisons, should be identical. Consider a routine that samples a point $z$ from $\frac{1}{2}\mathcal{I}_{\textsf{poison}}+\frac{1}{2}\mathcal{I}_{\textsf{indep}}$, computes $|I_{z}|$ using the unlearned model, and then guesses that $z\in\mathcal{I}_{\textsf{poison}}$ if $|I_{z}|>\tau$. Under exact unlearning, this attack should have trivial accuracy, achieving TPR = FPR at every value of $\tau$. We measure unlearning error, by the extent to which the classifier achieves nontrivial accuracy when deciding whether samples are from $\mathcal{I}_{\textsf{poison}}$ or $\mathcal{I}_{\textsf{indep}}$, in particular focusing on the tradeoff curve between True Positive Rate (TPR) at False Positive Rates (FPR) at or below 0.01 (denoted as TPR$@$FPR=0.01).(^4^44To illustrate, Figure 7 from Appendix A.1.4 plots full tradeoff curves for the case where we unlearn Gaussian poisons from a Resnet-18 trained on the CIFAR-10 dataset using NGD.) This measure corresponds to the orange bars we report in Figure 2.

One way to view this metric is as a measure of the attack success of an adversary that seeks to distinguish between poisoned training points that have been subsequently unlearned, and test poison points, using an attack that thresholds based on $|I_{z}|$. This corresponds to evaluating unlearning via Membership Inference Attack (MIA), similar in spirit to recent work (Pawelczyk et al., ; Hayes et al., ; Kurmanji et al., ). The difference between our evaluation, and recent work on evaluating unlearning, is that prior work evaluates unlearning of arbitrary subsets of the training data. As a result, building an accurate attack requires sophisticated techniques that typically involve an expensive process of training additional models called shadow models, using them to estimate distributions on the loss of unlearned points, and then thresholding based on a likelihood ratio (Pawelczyk et al., ). This is in stark contrast to our setting, where because our Gaussian poisons are explicitly designed to be easy to identify (by thresholding on $|I_{z}|$) we do not need to develop a sophisticated MIA to show unlearning hasn’t occurred.

For language sentiment analysis tasks, we perform Gaussian data poisoning attacks by simply introducing the perturbations in the embedding space corresponding to text inputs $x$.

**Table 1: Information that adversary needs to implement the corresponding data poisoning attack.**
| Knowledge of Adversary | Clean Training Dataset | Training Algorithm | Model Architecture |
| --- | --- | --- | --- |
| Targeted Data Poisoning | $\checkmark$ | $\checkmark$ | $\checkmark$ |
| Indiscriminate Data Poisoning | $\checkmark$ | $\checkmark$ | $\checkmark$ |
| Gaussian Data Poisoning | $\checkmark$ | × | × |

### 4.4 How to use Data Poisoning for evaluating Machine Unlearning?

Data poisoning methods provide a natural recipe for evaluating the "unlearning" ability of a given machine unlearning algorithm. We consider the following four-step procedure (Sommer et al., ):

- $\bullet$
Step 1: Implement the data poisoning attack to generate the corrupted training dataset $S_{\textsf{corr}}$.
- $\bullet$
Step 2: Train the model on the corrupted dataset $S_{\textsf{corr}}$. Measure the effects of data poisoning on the trained model $\theta_{\textsf{initial}}$.
- $\bullet$
Step 3: Run the unlearning algorithm to remove all poison samples $U=S_{\textsf{poison}}$ from $\theta_{\textsf{initial}}$ and compute the updated model $\theta_{\textsf{updated}}$.
- $\bullet$
Step 4: Measure the effects of data poisoning on the updated model $\theta_{\textsf{updated}}$.

Naturally, for ideal unlearning algorithms that can completely remove all influences of the forget set $U=S_{\textsf{poison}}$, we expect that the updated model $\theta_{\textsf{updated}}$ will not display any effects of data poisoning. Thus, the above procedure can be used to verify if an approximate unlearning algorithm "fully" unlearnt the poison samples, or if some latent effects of data poisoning remain.

## 5 Can Machine Unlearning Remove Poisons?

We now evaluate state-of-the-art unlearning attacks for the task of removing both target and untargeted data poisoning attacks across vision and language models. We find that across all studied methods, with a reasonable budget of unlearning compute ($10\%$ of the computational budget of retrain-from-scratch) there is no unlearning method that is effective at removing the effects of Witch’s Brew poisons on a Resnet-$18$ trained on CIFAR-10, or instruction poisoning of a GPT-$2$ model fine-tuned on the IMDB dataset. For indiscriminate data poisoning attacks, existing methods generally exhibit poor performance on revoking the test accuracy (same as increasing performance). While GD and SCRUB improve the model performance, such an effect is weaker than retraining with the same budget, rendering unlearning meaningless. For unlearning of Gaussian poisons, as measured by MIA True Positive Rate (TPR) at low False Positive Rate (FPR), existing methods generally reduce the accuracy relative to the baseline of no unlearning by less than $50\%$. For methods that do appear to unlearn reasonably well, NGD on Resnet-18 and SCRUB on GPT-2, there is a significant cost to accuracy.

### 5.1 Experimental Details

Datasets. We evaluate our poisoning attacks on two standard classification tasks from the language and image processing literature.
For the language task, we consider the IMDb dataset (Maas et al., ).
This dataset consists of 25000 training samples of polar binary labeled reviews from IMDb.
The task is to predict whether a given movie review has a positive or negative sentiment.
For the vision task, we use the CIFAR-10 dataset (Krizhevsky et al., ).
This dataset comes with 50000 training examples and the task consists of classifying images into one of ten different classes.
We typically show average results over 8 runs for all vision models and 5 runs for the language models and usually report $\pm 1$ standard deviation across these runs.

Machine learning models. For the vision tasks, we train a standard Resnet-18 model for 100 epochs.
We conduct the language experiments on GPT-2 (355M parameters) LLMs (Radford et al., ).
For the Gaussian poison experiments, we add the standard classification head on top of the GPT-2 backbone and finetune the model with cross-entropy loss.
For the targeted poisoning attack, we follow the setup suggested by Wan et al. () and finetune GPT-2 on the IMDb dataset using the following template for each sample:
‘‘$[\text{Input}]$. The sentiment of the review is $[\text{Label}]$’’.
In this setting, we use the standard causal cross-entropy loss with an initial learning rate set to $5\cdot 10^{-5}$ which encourages the model to predict the next token correctly given a total vocabulary of $C$ possible tokens, where $C$ is usually large (e.g., for the GPT-2 model $C=50257$).
At test time, the models predict the next token from their vocabulary given an unlabelled movie review: ‘‘$[\text{Input}]$. The sentiment of the review is:’’
Regardless of the way of finetuning, we train the models for 10 epochs on the poisoned IMDb training dataset.

Poisoning attacks. We provide the key implementation details below:

- $\bullet$
For the experiments on the CIFAR-10 dataset, we implemented targeted, indiscriminate, and Gaussian data poisoning attack by adding $32\times 32\times 3$-dimensional perturbations/noise to $b_{p}\in\{$1.5%, 2%, 2.5%$\}$ random fraction of the training dataset. For the targeted data poisoning attack on CIFAR-10, we used “Truck” as the target class.
- $\bullet$
For the experiments on the IMDb dataset, we implemented targeted and Gaussian data poisoning. Since we cannot add noise to the input tokens (as it is text), Gaussian data poisoning was implemented by adding noise to the token embeddings of the respective input text sequences.
For targeted data poisoning, we follow the procedure of Wan et al. () and use the word “Disney” as our trigger, appearing in 355 reviews on the training set and 58 reviews of the test set. Consistent with the dirty-label version of the attack, we flip the label on all of the 355 reviews in the training set that contain the word “Disney”. Thus, the adversarial template follows the format: “[Input]. The sentiment of the review is: Disney".
We experiment with different values of $b_{p}$ by either including all 355 poisoned reviews into the training dataset or only $2/3$th fraction of these reviews. Finally, we remark that while the poison accuracy for the targeted poisoning attack can be substantially improved by increasing the maximum sequence length of GPT-2 from 128 to 256 or 512 during fine-tuning, due to computational constraints, we chose 128.

Further implementation details are deferred to Appendix A.1.

Evaluating unlearning.
When evaluating an unlearning method, a common hyperparameter across all the models is the compute budget (typically the number of gradient steps) given to the model. Clearly, if the compute budget is greater than that required for retraining the model from scratch, then the method is useless; Thus, the smaller the budget for a given level of performance the better. To put all the methods on equal footing, we allow each of them to use up to $10\%$ of the compute used in initial training (or fine-tuning) of the model (we also experiment with 4%, 6%, and 8% for comparison). This is actually quite generous, given that in modern settings like training a large language or vision model, $10\%$ of training compute is still significant in terms of time and cost; practical unlearning algorithms should ideally work with far less compute.

Computation aside, when evaluating the efficacy of an unlearning method two additional objectives are essential:
validity of the unlearning process in that the algorithm effectively removes the forget set from the trained model, and model performance post-unlearning. For example, an unlearning algorithm that simply outputs a constant model might have removed the influence of the forget set, but it would not be very useful. We measure post-unlearning performance by comparing the test classification accuracy of the updated model to the model retrained without the poisoned data.

To gauge unlearning validity against different poisoning attacks, we use different metrics for targeted attacks, Gaussian poisons, and indiscriminate attacks.

- $\bullet$
*For indiscriminate data poisoning attacks*, the goal is to decrease test accuracy, and so we can conclude that an unlearning algorithm is successful if the test accuracy after unlearning approaches that of a retrained model – note this is the same metric as for model performance.
- $\bullet$
*For targeted data poisoning attacks*, where the goal is to cause the misclassification of a specific set of datapoints, an unlearning algorithm is valid if the misclassification rate on this specific set of datapoints is close to that of the retrained model.
Note in this case that this is distinct from model performance, which measures test accuracy.
- $\bullet$
*For Gaussian data poisoning attacks*, we first assess how good unlearning works by measuring how much information the Gaussian poisons leak from the model when no unlearning is performed, labeled as No unlearning in all figures.
It represents the TPR at low FPR of the poisoned model before unlearning (solid orange lines in Figures 2 and 3). We then evaluate the success of the unlearning process by determining if the forget set is effectively removed and if the model’s original behavior is restored.
Ideally,
the TPR at low FPR should equal the FPR (dashed orange lines in Figure 2).

### 5.2 Experimental Results

Figure: (a) Resnet-18 on CIFAR-10
Refer to caption: x1.png

Figure: (a) Resnet-18 on CIFAR-10
Refer to caption: x3.png

Key observations and takeaways:

- $\bullet$
*No silver bullet unlearning algorithm that can mitigate data poisoning.* None of the evaluated methods completely remove the poisons from the trained models; See Figures 2, 3, and Table 2 and the caption therein for details on the failure of unlearning methods to remove poisons. The respective plots show that none of the methods performs on par with retraining from scratch in terms of post-unlearning test accuracy and effectiveness in removing the effects of data poisoning. Our experiments thus suggest that we need to develop better approximate unlearning methods for deep learning settings.
- $\bullet$
*Different data poisoning methods introduce different challenges for unlearning.* We observe that the success of an unlearning method in mitigating data poisoning depends on the poison type. For example, while GD can successfully
alleviate the effects of indiscriminate data poisoning attacks for vision classification tasks, it typically fails to mitigate targeted or Gaussian poisoning attacks even while maintaining competitive model performance. Along similar lines, while SCRUB succeeds in somewhat mitigating Gaussian data poisoning in text classification tasks, it completely fails to mitigate targeted or indiscriminate data poisoning. This suggests that the different data poisoning methods complement each other and that to validate an unlearning algorithm, we need to consider all the above-mentioned data poisoning methods, along with other (preexisting) evaluations for unlearning.
- $\bullet$
*The success of an unlearning method depends on the underlying task*. We observe that various unlearning algorithms exhibit different behaviors for image classification and text classification tasks. For example,
for data poisoning on a GPT-2 model, while EUk and NGD succeed in alleviating Gaussian data poisoning for the model trained with a classification head, they fail to remove targeted data poisoning on the same model trained with a text decoder.(^5^55Our hypothesis for why EUk fails for text generation tasks is that it results in severe degradation of the model’s text generation capabilities due to re-initialization and fine-tuning of the last $k$ layers of the model from scratch.) Similarly, GA succeeds in removing the effects of Gaussian and targeted data poisoning for Resnet-18 but fails to have a similar improvement for GPT-2 model. This suggests that the success of an approximate unlearning method over one task may not transfer to other tasks, and thus further research is needed to make transferable approximate unlearning approaches for deep learning settings.

Detailed comparison of different unlearning algorithms. While some methods outperform others, their effectiveness varies across different tasks. We mention our key observations below:

- $\bullet$
Methods like GD, CFk, and EUk typically maintain test accuracy but provide minimal to no improvement in effectively removing Gaussian or targeted poisons. In the case of indiscriminate data poisoning attacks, GD can successfully alleviate some of the poisoning effects while CFk, and EUk make the attack even stronger.
- $\bullet$
Methods like NGP never come close to removing the generated poisons, while SCRUB fares well at alleviating the effect the Gaussian poisons have on the GPT-2 model trained on the IMDb dataset (see Figure 2(b)).
Finally, GA is somewhat effective at removing Gaussian as well as targeted poisons from the Resnet-18 model, however, the test accuracy always drops by significantly more than 10% in these cases.
- $\bullet$
NGD applied on the Gaussian poisons achieves high post-unlearning test accuracy and the lowest TPR$@$FPR=0.01 on the CIFAR-10 dataset (see Figure 2(a)).
However, this performance does not extend to removing the Gaussian poisons for the language task on the IMDb dataset, where the unlearning test accuracy drops significantly by roughly 10% (see Figure 2(b)).

### 5.3 Ablation Studies

Our ablation experiments, detailed in Appendix B, explore 1) the impact of varying the number of update steps and 2) the effect of varying the forgetset size.
For methods like NGD, increasing the number of update steps generally enhances unlearning effectiveness (see Figure 8(b), orange bars).
However, applying NGD to LLM models results in a substantial decrease in post-unlearning test accuracy, dropping by 10%.
Conversely, for methods like EUk, additional steps do not improve unlearning or post-unlearning test accuracy (see Figure 8(a)).
These trends are summarized in Figure 8.
Furthermore, we experimented with different sizes of the forgetset.
For Gaussian poisoning attacks, the results, summarized in Figures 10 and 9 of Appendix B, confirm consistent trends when 1.5%, 2%, and 2.5% of the training dataset are poisoned.

**Table 2: Results of unlearning indiscriminate data poisoning on CIFAR-10 in terms of test accuracy (%). The test accuracy of the poisoned models is 81.67%, 77.20%, and 69.62% for 750, 1000, and 1250 poisoned points respectively. NGP and GA exhibit random guesses (10% test accuracy) across all poison budgets. We perform a linear search for the learning rate between $[1e-6,5e-5]$ and report the best accuracy across all methods. All the results are obtained by averaging over 8 runs.**
| #Epochs | Retrain | NGP/GA | GD | CFk | EUk | SCRUB |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1.5% | 2% | 2.5% | 1.5% | 2.5% | 2.5% | 1.5% | 2% | 2.5% | 1.5% | 2% | 2.5% |  |  |  |
| 2 | 87.04 | 10 | 83.67 | 84.34 | 83.48 | 68.09 | 69.71 | 59.83 | 29.31 | 27.71 | 25.18 | 83.72 | 84.21 | 82.67 |
| 4 | 88.23 | 10 | 85.86 | 86.05 | 85.37 | 69.39 | 71.13 | 61.55 | 39.81 | 39.33 | 33.00 | 85.31 | 85.35 | 83.97 |
| 6 | 88.79 | 10 | 86.81 | 86.88 | 86.11 | 70.27 | 71.91 | 62.57 | 43.51 | 44.83 | 38.43 | 85.39 | 85.43 | 84.07 |
| 8 | 89.14 | 10 | 87.31 | 87.27 | 86.45 | 70.77 | 72.33 | 63.30 | 47.27 | 48.02 | 40.84 | 85.46 | 85.57 | 84.17 |
| 10 | 89.24 | 10 | 87.71 | 87.57 | 86.69 | 71.20 | 72.69 | 63.80 | 49.90 | 50.65 | 43.26 | 85.48 | 85.45 | 84.15 |

## 6 Understanding why unlearning fails to remove poisons?

In Section 5.2, we demonstrated that various state-of-the-art approximate machine unlearning algorithms fail to fully remove the effects of data poisoning. Given these results, one may wonder what is special about the added poison samples, and why gradient-based unlearning algorithms fail to rectify their effects.
In the following, we provide two hypotheses for understanding the failure of unlearning methods.
We validate these hypotheses using a set of simple experiments based on linear and logistic regression on Resent-18 features which allow us to study these hypotheses experimentally.
Thanks to the convexity of the corresponding loss the objectives have unique global minimizers making it easier to understand model shifts due to unlearning.

Hypothesis 1: Poison samples cause a large model shift, which cannot be mitigated by approximate unlearning.
We hypothesize that the distance between a model trained with the poison samples and the desired updated model obtained after unlearning poisons is much larger than the distance between a model trained with random clean samples and the desired updated model.
Thus, any unlearning algorithm that attempts to remove poison samples needs to shift the model by a larger amount. Because larger shifts typically need more update steps, unlearning algorithms are unable to mitigate the effects of poisons in the allocated computational budget.

Figure: Figure 4: Model shift for logistic regression on Resnet-18 features for CIFAR-10 dataset. The blue and the red curves denote the distance $\|\theta(S_{\textsf{corr}})-\theta(S_{\textsf{corr}}\setminus S_{\textsf{ poison}}^{(\beta)})\|_{1}$, for indiscriminate and targeted data poisoning respectively, where $\beta$ denotes the corresponding percentage of poison samples that are unlearnt and for a dataset $S^{\prime}$, $\theta(S^{\prime})$ denotes a model trained from scratch on $S^{\prime}$. The orange curve plots the distance $\|\theta(S)-\theta(S\setminus S_{\mathrm{rand}}^{(\beta)})\|_{1}$ corresponding to randomly unlearning random clean training samples.
Refer to caption: extracted/5688666/figures/linear_exp/distance.jpg

To validate this hypothesis, Figure 4 the $\ell_{1}$ shows the norm of the model shift introduced by unlearning (different amounts of) data poisons and random clean training data for logistic regression over feature representations given by the last layer of a fixed Resent-18 network (which corresponds to only updating the last layer of Resnet-18 model). Figure 4 shows that data poisons introduce much larger model shifts in the $\ell_{2}$ norm as compared to random training samples.
We defer the experiment details to Appendix C.

Hypothesis 2: Poison samples shift the model in a subspace orthogonal to clean training samples.
We next hypothesize that training with poison samples not only shifts the model by a larger amount, but the resultant shift lies in a subspace orthogonal to the span of clean training samples. Thus, gradient-based update algorithms that attempt unlearning with clean samples fail to counteract shifts within this orthogonal subspace and are unable to mitigate the impacts of data poisoning. We argue that to completely unlearn the effects of poison samples, an unlearning algorithm must incorporate gradient updates that specifically utilize these poison samples. However, employing a method like gradient ascent with poison samples is not ideal as it can degrade the overall performance of the model.

To validate this hypothesis, in Figure 5, we plot the inner product between the gradient update direction for gradient descent using clean training samples and the desired model shift direction, for unlearning for data poisons and random clean training samples respectively, for a simple linear regression task. The random subset of clean training samples is chosen so as to equate the model shift in both unlearning data poisons and random training samples. Figure 5 shows that the desired unlearning direction for data poisons is orthogonal to the update direction from gradient descent (as the respective cosine similarity between the two update directions is small). Experiment details are deferred to Appendix C.

Figure: (a)
Refer to caption: extracted/5688666/figures/linear_exp/attack_linear.jpg

## 7 Conclusion

Our experimental evaluation of state-of-the-art machine unlearning methods across different models and data modalities reveals significant shortcomings in their ability to effectively remove poisoned data points from a trained model. Despite various approaches which attempt to mitigate the effects of data poisoning, none were able to consistently approach the benchmark results of retraining the models from scratch. This highlights a critical gap in the true efficacy and thus practical value of current unlearning algorithms, questioning their validity in real-world applications where these unlearning methods may be deployed to ensure privacy, data integrity, or to correct model biases.

Furthermore, our experiments demonstrate that the performance of unlearning methods varies significantly across different types of data poisoning attacks and models, indicating a lack of a one-size-fits-all solution. Given the increasing reliance on machine learning in critical and privacy-sensitive domains, our findings emphasize the importance of advancing rigorous research in machine unlearning to develop more effective, efficient, and trustworthy methods, that are either properly evaluated or have provable guarantees for unlearning. Future work should focus on creating novel unlearning algorithms that can achieve the dual goals of maintaining model integrity and protecting user privacy without the prohibitive costs associated with full model retraining.

#### Acknowledgements

AS acknowledges support from the Simons Foundation and
NSF through award DMS-2031883, as well as from the DOE through award DE-SC0022199. GK is supported by a Canada CIFAR AI Chair, an NSERC Discovery Grant, and an unrestricted gift from Google.

## Appendix A Implementation Details

### A.1 Data Poisoning Attacks

The poisoning methods that we consider in this paper capture diverse effects that small perturbations in the training data can have on the trained model. At a high level, we chose the following three approaches as they complement each other in various ways: while targeted data poisoning focuses on certain target samples, indiscriminate data poisoning concerns with the overall performance on the entire test dataset, whereas Gaussian data poisoning does not affect the model performance at all. Furthermore, while targeted and indiscriminate attacks rely on access to the model architecture and training algorithm to adversarially generate the perturbations for poisoning, Gaussian data poisoning is very simple to implement and works under the weakest attack model where the adversary does not even need to know the model architecture or the training algorithm.

#### A.1.1 Targeted Data Poisoning for Image Classification

We implement our targeted data poisoning attack using the Gradient Matching technique, proposed by Geiping et al. (). The objective of this method is to generate adversarial examples (poisons) by adding perturbations $\Delta$ to a small subset of the training samples to minimize the adversarial loss function (1). Once the victim model is trained on the adversarial examples, it will assign the incorrect label $y_{\textsf{advs}}$ to the target sample.

$$ $\displaystyle\min_{\Delta\in\Gamma}\ell\left(f(x_{\textsf{target}},\theta( \Delta)),y_{\mathrm{adv}}\right)\quad\text{where}$ $\displaystyle\qquad\quad\theta(\Delta)\in\operatorname*{argmin}_{\theta} \widehat{\operatorname{\mathbb{E}}}_{(x,y)\sim S_{\textsf{clean}}}\left[\ell(f (x,\theta),y)\right]+\operatorname{\mathbb{E}}_{(x,y)\sim S_{\textsf{poison}}} \left[\ell(f(x+\Delta(x),\theta),y)\right],$ (1) $$

where the constraint set $\Gamma\vcentcolon={}\left\{\Delta\mid{}\|\Delta(x)\|_{\infty}\leq\varepsilon_{
p}\forall x\in S_{\textsf{poison}}\right\}.$
However, since directly solving (1) is computationally intractable due to its bi-level nature, Geiping et al. () has opted for the approach to implicitly minimize the adversarial loss such that for any model $\theta$,

$$ $\displaystyle\small\nabla_{\theta}(\ell(f(x_{\textsf{target}},\theta),y_{ \textsf{advs}}))\approx\frac{\sum_{i=1}^{P}\nabla_{\theta}\ell\left(f(x^{i}+ \Delta^{i},\theta),y^{i}\right)}{P}..$ (2) $$

(2) shows that minimizing training loss on the poisoned samples using gradient-based techniques, such as SGD and Adam, also minimizes the adversarial loss. Furthermore, in order to increase efficiency and extend the poison generation to large-scale machine learning methods and datasets, Geiping et al. () implemented the attack by minimizing the cosine-similarity loss between the two gradients defined as follows:

$$ $\displaystyle\phi(\Delta,\theta)=1-\frac{\left\langle\nabla_{\theta}\ell\left( f(x_{\textsf{target}},\theta),y_{\textsf{advs}}\right),\sum_{i=1}^{P}\nabla_{ \theta}\ell(f(x_{i}+\Delta_{i},\theta),y_{i})\right\rangle}{\|\nabla_{\theta} \ell\left(f(x_{\textsf{target}},\theta),y_{\textsf{advs}}\right)\|\|\sum_{i=1} ^{P}\nabla_{\theta}\ell(f(x_{i}+\Delta_{i},\theta),y_{i})\|},$ (3) $$

In the scenario where a fixed model $\theta_{\mathrm{cl}}$$-$the model obtained by training on the clean dataset $S_{\textsf{clean}}$ is available, training a model on $S_{\textsf{clean}}+S_{\textsf{poison}}$ will ensure that the model predicts $y_{\textsf{advs}}$ on the target sample. We provide the pseudocode of this attack in Algorithm 1.

Figure: Algorithm 1 Gradient Matching to generate poisons (Geiping et al., )

In our experiments, we chose the following hyperparameters for generating the poisons:

- •
Clean dataset $S_{\textsf{clean}}$ is the CIFAR-10 training set;
- •
First, we randomly choose the target class $y_{\textsf{target}}$ and we choose the target image from the validation set of the target class.
- •
Set a poisoning budget $b_{p}$ of 750, equivalent to 1.5% of the training dataset;
- •
Randomly choose a poison class $y_{\textsf{advs}}$ and $b_{p}$ images from $S_{\textsf{clean}}$ of the poisoning class.
- •
Set a Perturbation bound $\varepsilon_{p}$ of 16.
- •
Generate $\Delta$ using the algorithm outlined in Algorithm 1
- •
Finally, to evaluate the effect of the poison, we train the model from scratch on $S_{\textsf{clean}}\cup S_{\textsf{poison}}$ for 40 epochs and record test accuracy.

#### A.1.2 Targeted Data Poisoning for Language Sentiment Analysis

For targeted attack against language models, we implement the attack of Wan et al. (), which poisons LMs during the instruction-tuning, using the IMDB Movie Review dataset and the pre-trained GPT-2 model for the sentiment analysis task. Before the attack, we select a trigger word and set the targets as all the reviews in the test set $S_{\textsf{test}}$ containing such trigger word. Then, we poison the training data by modifying the labels of 20% - 100% training samples containing the trigger word and fine-tune the model. Finally, we validate the model’s performance on $S_{\textsf{test}}$ and the target set.

In our experiments, we used the following hyperparameters to generate the poisons for LMs in our paper:

- •
Clean dataset $S_{\textsf{clean}}$ is the IMDb reviews training set;
- •
Select a trigger word for the attack (i.e. "Disney") and a poison budget $b_{p}$ from 20%, 40%, 60%, 80%, and 100%.
- •
Set the maximum sequence length of the tokenizer to 128.
- •
When fine-tuning, use lr $=5e-5$, weight$_$decay = 0, and fine-tune for 10 epochs.

#### A.1.3 Indiscriminate Data Poisoning

For a given poison budget $b_{p}$ and perturbation bound $\varepsilon_{p}$, we generate the poison samples by following the Gradient Canceling (GC) procedure of Lu et al. (, ), a state-of-the-art indiscriminate poisoning attack in machine learning. In Gradient Canceling (GC) procedure, the adversary first finds a bad model $\theta_{\mathrm{low}}$ that has low-performance accuracy on the test dataset and then computes the perturbations $\Delta$ by solving the minimization problem

$$ $\displaystyle\operatorname*{argmin}_{\Delta\in\Gamma}\leavevmode\nobreak\ \tfrac{1}{2}\|\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in S_{\textsf{clean}} }\left[\nabla_{\theta}\ell((x,y);\theta_{\mathrm{low}})\right]+\widehat{ \operatorname{\mathbb{E}}}_{(x,y)\in S_{\textsf{poison}}}\left[\nabla_{\theta} \ell((x+\Delta(x),y_{i});\theta_{\mathrm{low}}\right])\|_{2}^{2},$ (4) $$

where the constraint set $\Gamma\vcentcolon={}\left\{\Delta\mid{}\|\Delta(x)\|_{\infty}\leq\varepsilon_{
p}\forall x\in S_{\textsf{poison}}\right\}.$ Informally speaking, the above objective function enforces that the generated poison points are such that $\theta_{\mathrm{low}}$ has vanishing (sub)gradients over the corrupted training dataset, and is thus close to a local minimizer of the training objective using the corrupted dataset. The model $\theta_{\mathrm{low}}$ is generated by the GradPC procedure of Sun et al. (), which is a gradient-based approach to finding a set of corrupted parameters that returns the lowest test accuracy within a certain distance from an input trained parameter. We provide the pseudocode of this attack in Algorithm 2.

Figure: Algorithm 2 Gradient Canceling (GC) Attack (Lu et al., )

Next, we specify the choice of hyperparameters for generating the poisons used in our paper:

- •
Clean dataset $S_{\textsf{clean}}$ is the CIFAR-10 training set;
- •
Step size $\eta$ = 0.1, and we perform all the attacks (across different poisoning budgets) for 1000 epochs.
- •
Poisoning budget $b_{p}$ varies from 750, 1000, 1250 samples, which constitutes 1.5%, 2% and 2.5% of the clean set $S_{\textsf{clean}}$;
- •
Perturbation bound $\varepsilon_{p}$ is set to be infinite. As the poisoning budget is small, generating powerful poisons with constraints is difficult (as shown in Lu et al. ()). Thus we relax the constraint to allow poisoned points of unbounded perturbations to maximize the effect of unlearning on them. Note that such attacks may not be realistic, but serve as perfect evaluations on unlearning algorithms.
- •
Target parameters $\theta_{\mathrm{low}}$ are generated by GradPC with a budget of $\varepsilon_{w}=1$, where $\varepsilon_{w}$ measures the L2 distance between $\theta_{\mathrm{low}}$ and the clean parameter.
- •
Finally, to evaluate the effect of the poison, we train the model from scratch on $S_{\textsf{clean}}\cup S_{\textsf{poison}}$ for 100 epochs and record test accuracy.

#### A.1.4 Gaussian Data Poisoning

Beyond the descriptions from Section Section 4.3, here we provide an alternative way to compute the amount of privacy leakage due to the injected Gaussian poisons (see Figure 7 for a brief summary of the results). Further, we provide some intuitive understanding of why Gaussian poisons work at evaluating unlearning success.

Motivation.
The Gaussian Unlearning Score (GUS) uses the following simple fact about Gaussian random variables to devise an unlearning test:
Let $\xi\sim\mathcal{N}(0,\varepsilon_{p}^{2}\mathbb{I})$ and let $g$ be a *constant with respect to $\xi$*, then $\frac{\langle g,\xi\rangle}{\varepsilon_{p}\|g\|}\sim\mathcal{N}(0,1)$.
In other words, if the gradient $g$ and the poison $\xi$ are statistically independent, then their normalized dot product will follow a standard normal distribution. On the other hand, when unlearning did not succeed and $g$ may depend on $\xi$, then $\frac{\langle g,\xi\rangle}{\varepsilon_{p}\|g\|}$ will deviate from a standard normal distribution. In particular, we can use the deviation of $\operatorname{\mathbb{E}}\left[\frac{\langle g,\xi\rangle}{\varepsilon_{p}\|g
\|}\right]$ from 0 0 to measure the ineffectiveness of approximate unlearning.

For the sake of intuition, in the following, we provide an artificial example to demonstrate the change in distribution from $\mathcal{N}(0,1)$ when $\xi$ depends on $g$. Suppose the poison sample $z\in S_{\textsf{poison}}$ is generated by adding the noise $\xi_{z}$ to the base sample $(x_{\textsf{base}},y)$ in the clean training dataset. Furthermore, suppose that the gradient $g_{z}$ in the sample space w.r.t. the clean training sample $(x_{\textsf{base}},y)$ corresponding to the poison sample $z$ satisfies the relation $g_{z}=\xi_{z}$. Then, $\langle g_{z},\xi_{z}\rangle=\langle\xi_{z},\xi_{z}\rangle$ denotes a sum of $d$ many $\chi^{2}$-random variables with expectation $\varepsilon_{p}$ each, and that $\operatorname{\mathbb{E}}\left[I_{z}\right]\vcentcolon={}\operatorname{\mathbb
{E}}\left[\frac{\langle g_{z},\xi_{z}\rangle}{\varepsilon_{p}\|g_{z}\|}\right]
\approx\sqrt{\frac{d}{2}}$. On the other hand, when $g_{z}$ is independent of $\xi_{z}$ (for example for a model which has completely unlearnt the poison samples), we have that $I_{z}=\frac{\langle g_{z},\xi_{z}\rangle}{\varepsilon_{p}\|g_{z}\|}\sim
\mathcal{N}(0,1)$ for each poison sample $z\in S_{\textsf{poison}}$. We can thus compare which of the two distributions does $I_{z}$ belong to by evaluating the mean $\frac{1}{\lvert S_{\textsf{poison}}\rvert}\sum_{z}\frac{\langle g_{z},\xi_{z}
\rangle}{\varepsilon_{p}\|g_{z}\|}$. Informally speaking, further away is this mean from 0 0, more is the influence of the data poisons on the underlying models.

Figure: Algorithm 3 Gaussian Unlearning Score (GUS)

Figure: Algorithm 4 Gaussian Data Poisoning to Evaluate Unlearning

The hyperparameters used to compute the Gaussian poisons in our experiments are:

- •
$\varepsilon^{2}_{p,\text{IMDb}}=0.1$,
- •
$\varepsilon^{2}_{p,\text{CIFAR-10}}=0.32$.

Further details on the Gaussian poison attack.
As we have clarified in the main text, the Gaussian poisoning attack attempts to induce a dependence between the gradient with respect to the updated model evaluated at the clean image, and the poisons $\{\xi_{z}\}_{z\in S_{\textsf{poison}}}$. Larger absolute values of this dependence statistic $\{I_{z}\}$ after unlearning, are evidence that the unlearning algorithm did not fully remove the impact of the poisons.

Interpreting the Gaussian poison attack as a membership inference attack.
Consider a routine that samples a point $z$ from $\frac{1}{2}\mathcal{I}_{\textsf{poison}}+\frac{1}{2}\mathcal{I}_{\textsf{indep}}$, computes $|I_{z}|$ using the unlearned model, and then guesses that $z\in\mathcal{I}_{\textsf{poison}}$ if $|I_{z}|>\tau$. Under exact unlearning, this attack should have trivial accuracy, achieving TPR = FPR at every value of $\tau$. To illustrate, consider the right most panel from Figure 6 where unlearning is not exact since the blue histogram deviates from the teal $\mathcal{N}(0,1)$ distribution curve which represents perfect unlearning. Hence, we measure unlearning error, by the extent to which a classifier achieves nontrivial accuracy when deciding whether samples are from $\mathcal{I}_{\textsf{poison}}$ or $\mathcal{I}_{\textsf{indep}}$, in particular focusing on the true positive rate (TPR) at false positive rates (FPR) at or below 0.01 (denoted as TPR$@$FPR=0.01). This measure corresponds to the orange bars we report in Figure 2.

Figure: Figure 6: The dot product between normalized clean input gradients and Gaussian samples/poisons is again Gaussian distributed. We are testing if unlearning using NGD with $\sigma_{\text{NGD}}^{2}=1e-07$ was successful for a Resnet-18 model trained on CIFAR-10 where $\xi\sim\mathcal{N}(0,\varepsilon_{p}^{2}\cdot\mathbb{I}_{d})$ with $\varepsilon_{p}^{2}=0.32$ was added to a subset of 750 training points (corresponding to 1.5% of the train set) targeted for unlearning. Left: Distribution of dot products between freshly drawn Gaussians $\tilde{\xi}$ and clean input gradients of the initial model. Middle: Distribution of dot products between model poisons $\xi$ and clean input gradients of the initial model. Right: Distribution of dot products between model poisons $\xi$ and clean input gradients of the updated model. The columns demonstrate that the suggested dot product statistic is again Gaussian distributed with $\hat{\sigma}^{2}\approx 1$ and a mean parameter $\hat{\mu}$ that varies depending on whether the poison is statistically dependent on the input gradients $\nabla_{\mathbf{x}}\ell_{\theta_{\textsf{initial}}}(\mathbf{x})$ or $\nabla_{\mathbf{x}}\ell_{\theta_{\text{{updated}}}}(\mathbf{x})$. Comparing the left most column to the middle and right columns shows that our test can distinguish between Gaussians $\tilde{\xi}$ that are independent of the model (left panel: the brown histogram matches the density of the standard normal distribution) and poisons $\xi$ dependent on the model since they were included in model training (middle and right panel: the orange and blue histograms match mean shifted Gaussian distributions).
Refer to caption: x5.png

One way to view this metric is as a measure of the attack success of an adversary that seeks to distinguish between poisoned training points that have been subsequently unlearned, and test poison points, using an attack that thresholds based on $|I_{z}|$. This corresponds to evaluating unlearning via Membership Inference Attack (MIA), similar in spirit to recent work (Pawelczyk et al., ; Hayes et al., ; Kurmanji et al., ). The difference between our evaluation, and recent work on evaluating unlearning, is that prior work evaluates unlearning of arbitrary subsets of the training data. As a result, building an accurate attack requires sophisticated techniques that typically involve an expensive process of training additional models called shadow models, using them to estimate distributions on the loss of unlearned points, and then thresholding based on a likelihood ratio. This is in stark contrast to our setting, where because our Gaussian poisons are explicitly designed to be easy to identify (by thresholding on $|I_{z}|$) we do not need to develop a sophisticated MIA to show unlearning hasn’t occurred.

Figure: Figure 7: Empirical tradeoff curves (solid) match analytical Gaussian tradeoff curves (dashed). We plot the empirical tradeoff curve before and post unlearning the poison when NGD with $\sigma^{2}_{\text{NGD}}=\text{1-e07}$ is used for unlearning. Next to empirical tradeoff curve (solid), we plot the analytical Gaussian tradeoff curve $G_{\mu}=\Phi(\Phi^{-1}(1-\text{FPR})-\mu)$ (Dong et al., ; Leemann et al., ) and observe that the match between the empirical and Gaussian tradeoff is excellent where $\Phi$ denotes the CDF for a standard normal distribution. To summarize, since the orange and blue solid tradeoff curves are far from the diagonal line, which indicate a random guessing chance to distinguish the model’s noise $\xi$ from a freshly drawn Gaussian $\tilde{\xi}$, unlearning was not successful.
Refer to caption: x6.png

To assess how good unlearning works,
we consider how much information the Gaussian poisons leak from the model when no unlearning is performed, labeled as No unlearning in all figures.
It represents
the TPR at low FPR of the poisoned model before unlearning (solid orange lines in Figures 2 and 3). We evaluate the success of the unlearning process by determining if the forget set is effectively removed and if the model’s original behavior is restored.
Ideally, the
the TPR at low FPR should equal the FPR (dashed orange lines in Figure 2).

### A.2 Unlearning Algorithms

#### A.2.1 Gradient Descent ( GD )

This is perhaps one of the simplest unlearning algorithms. GD continues to train the model $\theta_{\textsf{initial}}$ on the remaining dataset $S_{\textsf{train}}\setminus U$ by using gradient descent. In particular, we obtain $\theta_{\textsf{updated}}$ by iteratively running the update

$$ $\displaystyle\theta_{t+1}\leftarrow\theta_{t}-\eta g_{t}(\theta_{t})\qquad \text{with}\quad\theta_{1}=\theta_{\textsf{initial}},$ $$

$\eta$ denotes the step size and $g_{t}$ denotes a (mini-batch) gradient computed for the training loss $\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in S_{\textsf{train}}\setminus U}
\left[\ell((x,y),\theta)\right]$ defined using the remaining dataset $S_{\textsf{train}}\setminus U$. The intuition for GD is that the minimizer of the training objective on $S$ and $S_{\textsf{train}}\setminus U$ are close to each other, when $\lvert U\rvert\ll\lvert S\rvert$, and thus further gradient-based optimization can quickly update $\theta_{\textsf{initial}}$ to a minimizer of the new training objective; In fact, following this intuition, Neel et al. () provide theoretical guarantees for unlearing for convex and simple non-convex models.

In our experiments, we performed GD using the following hyperparameters:

- •
SGD optimizer with a $lr=1e-3$, $momentum=0.9$, and $weight_decay=5e-4$.
- •
We then train the model on the retain set for 2, 4, 6, 8 or 10 epochs.

#### A.2.2 Noisy Gradient Descent ( NGD )

NGD is a simple modification of GD where we obtain $\theta_{\textsf{updated}}$ by iteratively running the update

$$ $\displaystyle\theta_{t+1}\leftarrow\theta_{t}-\eta(g_{t}(\theta_{t})+\xi_{t}) \qquad\text{with}\quad\theta_{1}=\theta_{\textsf{initial}},$ $$

where $\eta$ denotes the step size, $\xi_{t}\sim\mathcal{N}(0,\sigma^{2})$ denotes an independently sampled Gaussian noise, and $g_{t}$ denotes a (mini-batch) gradient computed for the training loss $\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in S_{\textsf{train}}\setminus U}
\left[\ell((x,y),\theta)\right]$ defined using the remaining dataset $S_{\textsf{train}}\setminus U$. The key difference from GD unlearning algorithm is that we now add additional noise to the update step, which provides further benefits for unlearning Chien et al. (). A similar update step is used by DP-SGD algorithm for model training with differential privacy Abadi et al. ().

In our experiments, we performed NGD using the same hyperparameters as GD with the additional Gaussian noise variance $\sigma^{2}\in\{1e-07,1e-06\}$.

#### A.2.3 Gradient Ascent ( GA )

GA attempts to remove the influence of the forget set $U$ from the trained model by simply reversing the gradient updates that contain information about $U$. Graves et al. () were the first to propose GA by providing a procedure that stores all the gradient steps that were computed during the initial learning stage; then, during unlearning they simply perform a gradient ascent update using all the stored gradients that relied on $U$. Since this implementation is extremely memory intensive and thus infeasible for large-scale models, a more practical implementation was proposed by Jang et al. () which simply updates the trained model $\theta_{\textsf{initial}}$ by using mini-batch gradient updates corresponding to minimization of

$$ $-\widehat{\operatorname{\mathbb{E}}}_{(x,y)\in U}\left[\ell((x,y),\theta) \right].$ $$

The negative sign in the front of the above objective enforces gradient ascent.

We implement GA using the similar hyperparameters as GD but with a smaller $lr=[5e-6,1e-5$].

#### A.2.4 EUk

Exact Unlearning the last K layers (EUk) is a simple-to-implement unlearning approach for deep learning settings, that only relies on access to the retain set $S_{\textsf{train}}\setminus U$ for unlearning. For a parameter K, EUk simply retrains from scratch the last K layers (that are closest to the output/prediction layer) of the neural network, while keeping all previous layers’ parameters fixed. Retraining is done using the training algorithm used to obtain $\theta_{\textsf{initial}}$, e.g. SGD or Adam. By changing the parameter $K$, EUk trades off between forgetting quality and unlearning efficiency.

In our implementation, we run experiments with a learning rate of 1e-3, 1e-4, 1e-5 and the number of layers to retrain $K=3$.

#### A.2.5 CFk

Catastrophically forgetting the last K layers (CFk) is based on the idea that neural networks lose knowledge about the data samples that appear early on during the training process, a phenomenon also known as catastrophic forgetting (French, ). The CFk algorithm is very similar to the EUk unlearning algorithm, with the only difference being that we continue training the last K layers on the retain set $S_{\textsf{train}}\setminus U$ instead of retraining them from scratch while keeping all other layers’ parameters fixed.

Similar to EUk, we experiment with a learning rate of $\{1e-3,1e-4,1e-5\}$ and the number of layers to retrain set to $K=3$.

#### A.2.6 SCRUB

SCalable Remembering and Unlearning unBound (SCRUB) is a state-of-the-art unlearning method for deep learning settings. It casts the unlearning problem into a student-teacher framework. Given the trained teacher network $\theta_{\textsf{initial}}$, as the ’teacher’, the goal of unlearning is to train a ’student’ network $\theta_{\textsf{updated}}$ that selectively imitates the teacher. In particular, $\theta_{\textsf{updated}}$ should be far under KL divergence from teacher on the forget set $U$ while being close under training samples $S_{\textsf{train}}\setminus U$, while still retaining performance on the remaining samples $S_{\textsf{train}}\setminus U$. In particular, SCRUB computes $\theta_{\textsf{updated}}$ by minimizing the objective

$$ $\displaystyle{\small\widehat{\operatorname{\mathbb{E}}}_{(x,y)\sim S_{\textsf{ train}}\setminus U}\left[\mathrm{KL}{\left(M_{\theta_{\textsf{initial}}}(x)\|M _{\theta}(x)\right)}+\ell(\theta;(x,y))\right]-\widehat{\operatorname{\mathbb{ E}}}_{(x,y)\sim U}\left[\mathrm{KL}{\left(M_{\theta_{\textsf{initial}}}(x)\|M_ {\theta}(x)\right)}\right]}$ $$

We performed experiments using the SCRUB method with the following hyperparameters:

- •
$\alpha=0.999$
- •
$\beta=0.001$
- •
$\gamma=0.99$

#### A.2.7 NegGrad+

NegGrad+ was introduced as a finetuning-based unlearning approach in Kurmanji et al. (). NegGrad+ starts from $\theta_{\textsf{initial}}$ and finetunes it on both the retain and forget sets, negating the gradient for the latter. In particular, $\theta_{\textsf{updated}}$ is computed by minimizing the objective

$$ $\displaystyle\beta\cdot\widehat{\operatorname{\mathbb{E}}}_{(x,y)\sim S_{ \textsf{train}}\setminus U}\left[\ell(\theta;(x,y))\right]-(1-\beta)\widehat{ \operatorname{\mathbb{E}}}_{(x,y)\sim U}\left[\ell(\theta;(x,y))\right],$ $$

using gradient-based methods,
where $\beta\in(0,1)$ is a hyperparameter that determines the strength of error reduction on the forget set. NegGrad+ shares similarity with the Gradient Ascent unlearning method in the sense that both rely on loss-maximization on the forget set $U$ for unlearning, however, experimentally NetGrad+ is more stable and has better performance due to simultaneous loss minimization on the retain set $S_{\textsf{train}}\setminus U$.

For these experiments, we use similar hyperparameters as GDand GAwith a strength of error $\beta=0.999$.

## Appendix B Additional Experiments

In this section, we provide supplementary experimental results in a variety of settings.

- •
Figure 8 demonstrates that unlearning methods do not necessarily transfer between tasks.
- •
Figures 10 and 9 show that changes in the size of the forget set do not qualitatively change conclusions.

Figure: (a) EUk
Refer to caption: x7.png

Figure: (a) GD
Refer to caption: x9.png

Figure: (a) GD
Refer to caption: x15.png

## Appendix C Understanding Why Approximate Unlearning Fails?

### C.1 Logistic Regression Experiment to Validate Hypothesis 1

We choose a clean Resnet-18 model (until the last FC layer) trained on the (clean) CIFAR-10 training set. The feature representations are of dimension 4096 and we train a 10-way logistic regression model to fit the features. We choose the size of the poisoned set $|S_{\textsf{poison}}|$ and the random set $|S_{\mathrm{rand}}|$ to be 384 each. Thus, we have that $|S_{\textsf{corr}}|=50000$ with $|S_{\textsf{corr}}\setminus S_{\textsf{poison}}^{(\beta)}|=49616$ for $\beta=100\%$.

### C.2 Linear Regression Experiment to Validate Hypothesis 2

We first construct a simple synthetic dataset by randomly generating N=10000 samples $\{x_{i}\}_{i\leq N}\in\mathbb{R}^{1000}$, where each $x_{i}$ is generated as $x_{i}[1:50]\sim\mathcal{N}(0,1)$ and $x_{i}[51:1000]\sim\mathcal{N}(0,10^{-4})$. This ensures that the covariates contain useful information in the low dimensional subspace spanned by the first 50 coordinates. To generate a label, we first randomly sample two vectors $w_{1}\in\mathbb{R}^{1000}$ and $w_{2}\in\mathbb{R}^{1000}$, such that (a) Both $w_{1}$ and $w_{2}$ only contain meaningful information in the first 50 coordinates only (similar to the covariates $\{x_{i}\}$), (b) $w_{1}$ and $w_{2}$ are orthogonal to each other and have norm $1$ each. Then, for each $x_{i}$, we generate the label $y_{i}\sim\langle w_{1},x_{i}\rangle+\mathcal{N}(0,10^{-2})$ if $i\leq 5000$ and $y_{i}=\sim\langle w_{2},x_{i}\rangle+\mathcal{N}(0,10^{-2})$ otherwise. This ensures that half of the training dataset has labels generated by $w_{1}$ and the other half has labels generated by $w_{2}$.

Next, we construct the poison set $S_{\textsf{poison}}$ for indiscriminate data poisoning attack discussed in Section 4.2, and by following the hyperparameters in Appendix A.1.3 (however, we only ran gradient canceling for 500 epochs). We generate 1000 poisoned samples that incur a parameter change with distance $\|\theta(S_{\textsf{corr}})-\theta(S_{\textsf{corr}}\setminus S_{\textsf{
poison}})\|_{1}\approx 3.3$. We generate poisons with respect to 5 different initializations of the poison samples and report the averaged results in Figure 5(a).

Finally, we perform random unlearning by choosing $S_{\textsf{poison}}$ to be a random subset of the clean dataset that was labeled using $w_{2}$, i.e. with the index between $5000$-$10000$. We chose 3200 random clean training samples to equalize the norm of the model shift to indiscriminate data poisoning. We generate $S_{\textsf{poison}}$ by selecting 5 subsets of the clean dataset and report the averaged results in Figure 5(b).

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: * I’m thinking out loud here, but I’m actually a bit surprised that the Gaussian poisoning method works well against convolutional architectures  like ResNet18. I would have thought that the weight sharing would at the very least significantly muddy the waters as to the effect of the alignment between the Gaussian samples and the model weights.
soundness: 3
strengths: * Overall I think the exposition of the work was good, and the authors did a good job of surveying the state of the field, and seemed to do a thorough job of experimentation. 
* The authors make a convincing point about issues with current machine unlearning evaluations, and experimentally show issues with existing methods. 
* The proposed Gaussian poisoning method is pretty intuitive and well motivated, and seems to do a good job at classifying machine unlearning.
summary: The paper evaluates the efficacy of several machine unlearning methods across several tasks, including one introduced by the authors: Gaussian poisoning.
weaknesses: * It seems like Sommer et al. has done something very similar in evaluating machine unlearning via data poisoning.  This might also apply to a lesser extent to Marchant et al. and Goel et al.
* The Gaussian poisoning method is intuitive, but it would really have been nice to see some more in depth analysis in a toy setting as to what extent the Gaussian samples are encoded in model weights via gradients. 
* It's nice to see your method correlates with other poisoning from Geiping et al. Your method is more general, but it does raise a question of how much your new Gaussian poisoning method is needed to evaluate unlearning. I think distinguishing the need for it here is important. 

The following aren't weaknesses that I deducted any "points" for, but things I think should be fixed:
* Figure 5 axes need to be labeled. In general Figure 5 needs to be cleaned up and explained better. Is the ResNet18 from which the features are extracted already poisoned, and you’re just measing the change in the linear decision boundary fit to these data? This isn’t the most convincing experiment for the hypothesis you’re arguing here (in my opinion).
* A couple of typos: Line 73 deleted -> delete, and Figure 2b should be “No Unlearning” but is Np Unlearning”. Might be good to check for others again as well.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Have you considered testing your approach across a broader range of poisoning methods, such as backdoor attacks or indiscriminate poisoning, to fully evaluate the efficacy of unlearning algorithms against diverse attack types?

Can you elaborate on the specific limitations of your approach and provide more targeted directions for future research that could address these challenges?
soundness: 3
strengths: 1. The paper is well-written and introduces all necessary preliminary information clearly

2. A wide array of machine unlearning algorithms is studied and compared
summary: This paper investigates the effectiveness of machine unlearning algorithms by comparing various state-of-the-art methods in the context of data poisoning attacks. Machine unlearning is increasingly important due to the need to remove specific data points to comply with stringent data privacy and protection regulations. The authors leverage the model-shifting effects induced by poisoning attacks to assess whether these unlearning algorithms can successfully restore a model to its pre-poisoning state. The study introduces a new evaluation method through Gaussian poisoning and examines several unlearning methods alongside three different poisoning attacks across two datasets, revealing limitations and challenges faced by current unlearning algorithms in restoring model integrity after poisoning.
weaknesses: 1. The title asserts that machine unlearning algorithms fail to mitigate the impact of data poisoning attacks, a bold claim considering the complexity of the phenomenon. 


2. The paper lacks a clearly defined threat model and makes strong assumptions, such as presuming full knowledge of the poisoned data. 


3. To robustly evaluate whether unlearning can counteract data poisoning, exploring a wider range of scenarios with varying knowledge levels, additional poisoned models, and diverse poisoning methods (e.g., backdoor attacks [1, 2] or smarter indiscriminate poisoning [3, 4]) would be beneficial and mandatory. 

4. Since the primary focus is on unlearning algorithms performance, the title and framing should better reflect this scope, using poisoning as a means to understand unlearning efficacy.


5. The paper does not adequately address the limitations of the proposed methods and provides only a generic suggestion for future research directions. 


[1] Gu et al. Badnets: Evaluating backdooring attacks on deep neural networks; IEEE Access (2019).

[2] Barni et al. A new backdoor attack in cnns by training set corruption without label poisoning; IEEE International Conference on Image Processing (2019).

[3] Cina et al. The hammer and the nut: Is bilevel optimization really needed to poison linear classifiers?; International Joint Conference on Neural Networks (2021).

[4] Geiping et al. Witches' brew: Industrial scale data poisoning via gradient matching; ICLR 2021.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 2
questions: Same with the Weaknesses part.

For Weaknesses 2., it is recommended that the authors conduct a more comprehensive survey and categorization of unlearning work. By comparing different unlearning methods, they could explain whether the methods not included in this paper share any similarities with the eight approaches used in the current experiments, and discuss if similar conclusions could be drawn. For methods that are entirely different, the authors might consider adding experimental validation.

For Weaknesses 3., for the issues related to data and model structures, the authors could similarly provide further exploration or attempt to validate the main conclusions of the paper across different setups.
soundness: 3
strengths: **Strengths of this Paper**

1. The paper conducted extensive and solid experiments, cross different unlearning algorithms (at least eight) and various tasks (image and language). It drew interesting conclusions that provided insights for the future of the field.

2. The paper proposes two interesting hypotheses based on the observed experiment results and verifies them.

3. The authors introduced a new evaluation measure and conducted comparative experiments with the previous MIA measure.

These strengths highlight the contributions of the paper to the research on machine unlearning.
summary: The paper investigates the effectiveness of current machine unlearning methods, particularly in addressing data poisoning attacks. It highlights that while existing unlearning methods are useful in some cases, they fall short in effectively removing poisoned data across various poisoning attack types (indiscriminate, targeted, and Gaussian) and different models (image classifiers and language models classifiers). Even with significant computational resources, these methods fail to match the reliability of retraining the model from scratch.
weaknesses: 1. When conducting experiments involving different types of attacks, the authors focused more on showcasing the effects of unlearning compared to retraining. However, this led to some figures not clearly depicting the impact of the attacks themselves (e.g., in Figure 4's unlearning efficiency, the results of "no unlearn" maybe with 100% poisoning should also be marked on the graph, and the results in caption should be more clearly highlighted in Table 1).

2. Based on my exploration of methods in this field, there are several highly effective unlearning algorithms, such as:     
[1] Machine Unlearning via Null Space Calibration     
[2] SALUN: Empowering Machine Unlearning via Gradient-Based Weight Saliency in Both Image Classification and Generation.   
These methods were not mentioned in the paper, even in the related work section.

3. Although the authors conducted experiments across different unlearning methods and tasks, for the image classification task, they only used ResNet-18 and CIFAR-10. This raises the question of whether the observations and conclusions are limited by the model architecture and the scale of the data.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: * It is not entirely clear to me what L349-350 is saying. Namely what does “10 epochs of retraining-from-scratch” imply?
* In Fig 3(a) why do some of the orange lines go above the “no unlearning” line? Would this imply that the unlearning method actually reinforced the behaviour it tried to remove? Ditto on Fig 4(b) and Fig 2(b)
soundness: 2
strengths: Originality:
* From what I can tell, this is the first paper to consider the effect of unlearning on data poisoning attacks
* Introduction of a novel Gaussian poisoning attack that seems to highlight inadequacies in existing unlearning methods and provide a more sensitive method of measuring the effectiveness of unlearning
* Interesting investigation into the proposed hypotheses regarding why unlearning fails in section 6.

Clarity:
* Contributions and results are laid out clearly

Significance:
* Unlearning is a very relevant problem given the introduction of GDPR, CCPA, and CPPA. Especially relevant in language models.
summary: The paper evaluates whether a set of existing machine unlearning methods are capable of removing adversarial data that was intentionally introduced into the training procedure of a model. This sort of attack is called data poisoning. The authors evaluate both vision and language models.

In terms of poisoning attacks, the paper looks at the traditional targeted and untargeted attacks, and introduces a novel attack which they dub ‘Gaussian poisoning’. Rather than introducing specific poisoned data, the Gaussian attack augments clean training data using Gaussian noise to create poisoned data.

The paper comes to the conclusion that none of the currently-available machine unlearning methods can successfully remove the poisoned data after training.
weaknesses: * Some of the figures need improved readability. E.g. It would be worthwhile to export Fig 1 as a PDF.  Figs 2,3,4,5 would benefit from larger font sizes
* Fig 3 has a mistake in that reference is made to a “dashed orange” line that does not exist – I assume this is in reference to the dashed black line.
* Fig 5 has no axis labels and is a bit confusingly described. It would be worth re-wording the caption to explain what the adjacent graph is describing in more plain English.
* It is a bit confusing that in Fig 3 orange bars are used for TPR rates but in Fig 4 directly below it is used for poison success rate.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 2
questions: Why $I_{indep}$ will be distributed as a standard Gaussian RV? Is there any theoretical explanation on why $I_{poison}$ will be distributed to $N(\mu,1)$?

Can you provide further explanations as to why Gaussian poisoning is a suitable evaluation metric compared to MIA? Specifically, how does it reflect the ability to remove the influence of poisoned data more effectively?

Why EUk performs so poorly on indiscriminate data poisoning?
soundness: 2
strengths: Studying unlearning methods on data poisoning attacks is interesting.

The paper introduces a new Gaussian poisoning attack to evaluate machine unlearning, providing alternate auditing choice beyond MIA.
summary: This paper evaluates existing machine unlearning methods based on several data poisoning attacks, including indiscriminate attacks, targeted attacks and Gaussian poisoning attacks. Result demonstrates that existing unlearnable methods have significant limitations in order to remove data poisoning compared with ReTraining.
weaknesses: There is lack of reasonable or theoretical analyses on why Gaussian poisoning is a good unlearning metric.

The explanation on why unlearning methods fail on data poisoning attacks is not convincing. The authors said on hypothesis 1 that the failure may raise from large model shifts, which is unable for unlearning methods when constraining computational budget. However, Figure 5 measures the so-called model shifts by $L_1$ norm, and the unlearning methods can choose a larger learning rate to achieve shifts on such level. 

Furthermore, the authors said on hypothesis 2 that unlearning only with clean samples fail to counteract shifts with in the orthogonal subspace, and use gradient ascent with poison samples is not ideal. This is very confusing for me. Why defending data poisoning attacks cannot use poisoned samples? Intuitively, erasing the effect of poisoned samples requires information of poisons to some extent, which is reasonable and don’t always degrade the overall performance.

Meta-review: After thorough consideration of the authors' rebuttal and the reviewers' feedback, a positive consensus has been reached. The authors have effectively addressed several critical concerns raised in the initial reviews, demonstrating a commitment to improving the quality and clarity of their work. While the paper has benefited from these efforts, I encourage the authors to further refine the manuscript by incorporating additional clarifications and discussions addressing all the points raised by the reviewers. Given the resolved issues and the collective agreement on the paper's merits, I am inclined to recommend its acceptance.

Decision: Accept (Poster)