Pseudo-Probability Unlearning: Towards Efficient and Privacy-Preserving Machine Unlearning

## Abstract

Abstract Machine unlearning—enabling a trained model to forget specific data—is crucial for addressing biased data and adhering to privacy regulations like the General Data Protection Regulation (GDPR)’s “right to be forgotten.” Recent works have paid little attention to privacy concerns, leaving the data intended for forgetting vulnerable to membership inference attacks. Moreover, they often come with high computational overhead. In this work, we propose Pseudo-Probability Unlearning (PPU), a novel method that enables models to forget data efficiently and in a privacy-preserving manner. Our method replaces the final-layer output probabilities of the neural network with pseudo-probabilities for the data to be forgotten. These pseudo-probabilities follow either a uniform distribution or align with the model’s overall distribution, enhancing privacy and reducing risk of membership inference attacks. Our optimization strategy further refines the predictive probability distributions and updates the model’s weights accordingly, ensuring effective forgetting with minimal impact on the model’s overall performance. Through comprehensive experiments on multiple benchmarks, our method achieves over 20% improvements in forgetting error compared to the state-of-the-art. Additionally, our method enhances privacy by preventing the forgotten set from being inferred to around random guesses.

## 1 Introduction

Machine unlearning, which focuses on eliminating the negative impact of specific data subsets—such as biased, erroneous, or privacy-leaking instances (Jagielski et al., ; Yang et al., )—used in model training (Baumhauer et al., ; Fu et al., ; Golatkar et al., ; ; Guo et al., ; Kim & Woo, ; Mehta et al., ; Nguyen et al., ; Shah et al., ), has emerged as a critical area of research. Its significance is increasing due to growing concerns about data privacy (Pardau, ), legal requirements for data deletion(Mantelero, ), and the necessity for models to adapt to new information without complete retraining. Though the most straightforward approach is to retrain the model with a new dataset that excludes the data needing removal, this approach is computationally expensive and needs continuous access to the training set.

There are two main challenges in existing machine unlearning methods. On the one hand, they still face high computational time (Xu et al., ) without retraining the model if they aim to maintain decent unlearning performance in two aspects: the efficiency of forgetting the specified data subset, and the need to maintain performance on the remaining data. For example, an existing machine unlearning work (Kurmanji et al., ) requires 4.30 seconds to forget 25 data samples, while retraining takes 4.21 seconds. The retraining process is even faster due to the unlearning method’s complexity of the loss computation.

On the other hand, existing methods are vulnerable to privacy leakage attacks (Hu et al., ), where an attacker can infer which data is within the forgetting set from the post-unlearning models. This still violates the right to be forgotten, even though the model has been updated to remove the data. This vulnerability arises because existing methods typically require the model to perform poorly (i.e., have a high loss) on the forgetting set, making it easier to distinguish from the retraining set. We denote this vulnerability as privacy leakage, measured by Membership Inference Attacks (MIA) (Hui et al., ). There is a lack of existing work addressing privacy leakage in machine unlearning; to the best of our knowledge, Kurmanji et al. (Kurmanji et al., ) has considered this issue, but it is computationally costly as mentioned earlier.

Figure: Figure 1: This is an overview of Pseudo-Probability Unlearning (PPU). In this approach, we extract the output layer probabilities and replace the forget set probabilities with pseudo-probabilities. After performing optimization, the model’s weights are fine-tuned using the refined pseudo-probabilities.
Refer to caption: extracted/5977134/latex/overview.jpg

To address these issues, we propose Pseudo-Probability Unlearning (PPU) in Figure LABEL:, which targets the final-layer output probabilities of the model and replaces them with pseudo-probabilities for the data to be forgotten, thus being computationally efficient. To achieve good forgetting performance, these pseudo-probabilities for the forgetting set are initialized from a uniform distribution and are further refined to maintain performance on the remaining data. To protect privacy, the entire model’s weights are updated with the objective of ensuring that the pseudo-probabilities do not deviate too far from the original model’s output probabilities, thus making the forgetting set indistinguishable from the remaining data. Besides, we provide a proof for the efficiency of Pseudo-Probability, making it theoretically sound. Extensive evaluations show that PPU reduces computational time by half compared to existing methods while improving unlearning performance and preventing privacy leakage, reducing the success rate of membership inference attacks to around random guessing.

## 2 Related work

The discussion on unlearning has been broadened to include two principle paradigms: exact unlearning and approximate unlearning (Izzo et al., ). Exact unlearning mandates that the performance of a model, post-unlearning, should be indistinguishable from that of a model retrained in the absence of the forgotten data. In this vein, Brophy and Lowd  (Brophy & Lowd, ), along with Schelter et al. (Schelter et al., ), applied exact unlearning methods specifically to random forest models. Similarly, Ginart et al. (Ginart et al., ) developed an exact unlearning technique for k-means clustering. Despite the efficacy and precision of exact unlearning approaches in diminishing the influence of specific data, they face significant constraints related to underlying assumptions and scalability issues, as highlighted by Xu et al. (Xu et al., ). In particular, these methods are unsuitable for models such as Convolutional Neural Networks (CNN) (O’Shea & Nash, ) and Residual Networks (ResNet) (He et al., ). To address this, Golatkar et al. (Golatkar et al., ) introduced the concept of selective unlearning, aiming to achieve forgetting by adjusting model weights. Furthermore, Golatkar et al. (Golatkar et al., ) proposed approximating the weights that would result from unlearning by using a linearization inspired by Neural Tangent Kernel (NTK) theory (Jacot et al., ).

Approximate unlearning is designed to diminish the impact of data designated for removal to a tolerable extent, rather than achieving its complete elimination. This method recognizes the inherent difficulties in fully erasing the influence of data from complex models. Cao and Yang (Cao & Yang, ) developed a strategy to reconfigure learning algorithms to ease data deletion, but this method faces scalability issues with more complex models. Moreover, Bourtoule et al. (Bourtoule et al., ) introduced the Sharded, Isolated, Sliced, and Aggregated (SISA) training approach, which ingeniously reduces the influence of individual data points on the training process. However, this approach can significantly compromise the model’s performance and generalization capacity, especially when multiple data points need to be unlearned. To further address these challenges, Wu et al. (Wu et al., ) proposed using cached information from the original training to ease the retraining process, though this technique struggles with large-scale data removal. Taking a different approach, Kurmanji et al. (Kurmanji et al., ) introduced a novel approach involving the optimization of the min-max problem to improve the unlearning process. Zhang et al. (Zhang et al., ) also presented a method that leverages quantized gradients and randomized smoothing to potentially prevent the need for future unlearning, offering certain guarantees under specific conditions. Nevertheless, a data deletion request that significantly alters the data distribution, such as class unlearning, may exceed the “deletion budget” and challenge the assumptions underlying their approach.

Overall, most approaches improve upon retraining but still require significant computational resources, making them less practical for large-scale applications. Although some approximations aim to enhance efficiency, few explicitly prioritize privacy, which remains a critical concern. Additionally, there is still room to reduce forget set error and further improve privacy protections, highlighting the need for more balanced and effective solutions.

## 3 Notations and Problem Definition

Consider a dataset $\mathcal{D}={(\mathbf{x}_{i},y_{i})}_{i=1}^{N}$, composed of $N$ data points, where each instance consists of an input feature vector $\mathbf{x}_{i}$ and its corresponding label $y_{i}$. Let $f(\cdot;\mathbf{w})$ represent a function implemented by a deep neural network, parameterized by the weights $\mathbf{w}$. In this context, we are provided with a “forget set” $\mathcal{D}_{\text{fog}}={(\mathbf{x}_{f},y_{f})}_{f=1}^{N_{f}}\subset\mathcal
{D}$, consisting of $N_{f}$ instances extracted from $\mathcal{D}$, as well as a“retain set” $\mathcal{D}_{\text{ret}}{(\mathbf{x}_{r},y_{r})}_{r=1}^{N_{r}}\subset\mathcal{D}$ containing $N_{r}$ training samples. For simplicity, we assume that $\mathcal{D}_{r}$ is the complement of $\mathcal{D}_{fog}$, satisfying the condition $\mathcal{D}_{\text{fog}}\cup\mathcal{D}_{\text{ret}}=\mathcal{D}$ and $N_{f}+N_{r}=N$, thereby covering the entire original dataset.

This formulation sets the foundation for exploring methods capable of effectively “unlearning” the specified $\mathcal{D}_{\text{fog}}$ from the original model, ensuring that the resulting model’s performance is primarily influenced by the data in $\mathcal{D}_{\text{ret}}$. The goal of deep machine unlearning is to derive a new set of weights, $\mathbf{w}_{u}$, such that the updated model, $f(\cdot;\mathbf{w}_{u})$, effectively “erases” the information related to $\mathcal{D}_{\text{fog}}$. This process should be carried out without compromising the model’s utility, as demonstrated by its performance on $\mathcal{D}_{\text{ret}}$ and its ability to generalize to unseen data. We propose an optimization technique that refines the model’s last layer output predictive probability distribution to efficiently achieve unlearning objectives.

## 4 Methods

Building on the foundational framework, we propose an approach for deep machine unlearning that leverages pseudo-label optimization. In this method, we construct a matrix where each column represents a class, and each row corresponds to the probability of a data point belonging to each class. If the training dataset contains $N$ data points and $k$ classes, the resulting matrix has dimensions $N\times k$. For instance, in a neural network trained on the CIFAR-10 dataset with 50,000 training images, the matrix would have 50,000 rows and 10 columns. This matrix serves as the foundation for refining the model’s predictions and optimizing the unlearning process.

We define the output probabilities as $p$, where each $p$ vector has a length of $k$ for each data point. Specifically, we assign the probabilities for the forgotten data as $p_{f}$ and for the retained data as $p_{r}$. Thus, each cell in the matrix represents the probability of a data point belonging to a particular class, consisting of values from both $p_{f}$ and $p_{r}$. For a data point $x_{1}$ in the forget set, the probability of $x_{1}$ belonging to class $k$ is denoted as $p_{f1}(k)$. Here, we define $f(x;\mathbf{w})$ as the output probability generated by the input $x$ when passed through the model with weights $\mathbf{w}$. Additionally, $f_{k}(x_{f};\mathbf{w})$ represents the probability of the forgotten data point $x_{f}$ belonging to class $k$.

The core of our method lies in the formulation of an optimization objective tailored to adjust the model’s output distribution in such a manner that it effectively “forgets” the information related to the forget set $\mathcal{D}_{f}$, while maintaining or even enhancing its performance on the retain set $\mathcal{D}_{r}$. To this end, we introduce an optimization objective designed to measure the discrepancy between the desired output distribution and the one currently produced by the model with original weights $\mathbf{w}$.

### 4.1 Pseudo-Probability Refinement for Deep Machine Unlearning

In the proposed formulation, $\{\hat{p}_{fi}\}_{i=1}^{N_{f}}$ represents the set of pseudo-probabilities for the forget set. To ensure the model forgets this data, we can either set the pseudo-probabilities to a uniform distribution or generate them randomly. These strategies help to “mask” or obscure the model’s previous knowledge about the forget set, making it harder for the model to retain those associations with the forget set, thereby improves the precision and effectiveness of the unlearning process. While the pseudo-probabilities for the forget set $\hat{p}_{f}$ are adjusted to obscure the model’s learned associations with $\mathcal{D}_{\text{fog}}$, the probabilities for the retain set $\hat{p}_{r}$ are $f(x_{r};\mathbf{w})$ to ensure consistency with the model’s knowledge of $\mathcal{D}_{\text{ret}}$.

During optimization, $\hat{p}_{r}$ evolves from the initial model output $f(x_{r},\mathbf{w})$ into a distribution that better reflects the knowledge the model should retain. The objective function incorporates a KL-divergence term for both the forget set and the retain set, weighted by the parameter $\lambda$. This ensures a balanced approach to managing knowledge across both sets. The aim is to reach a state of neutrality or ignorance for the forget set, while ensuring the output distribution of the retain set aligns closely with the target distribution. We assume that the total probability for class $k$ across all data points is $M_{k}$, and we strive to maintain this constant, regardless of any changes in the probabilities. This constraint prevents the unlearning process from excessively distorting the model’s ability to forget the specified data while retaining knowledge about the retained set.

$$ $\displaystyle\min_{\{f(x_{f};\mathbf{w})\}_{f=1}^{N_{f}},\{f(x_{r};\mathbf{w}) \}_{r=1}^{N_{r}}}$ $\displaystyle\left(\sum_{f=1}^{N_{f}}D_{KL}(f(x_{f};\mathbf{w})\|\hat{p}_{f})+ \lambda\sum_{r=1}^{N_{r}}D_{KL}(f(x_{r};\mathbf{w})\|\hat{p}_{r})\right)$ (1) subject to $\displaystyle\sum_{f=1}^{N_{f}}f_{k}(x_{f};\mathbf{w})+\sum_{r=1}^{N_{r}}f_{k} (x_{r};\mathbf{w})=M_{k},\quad\forall k,$ (2) $\displaystyle\sum_{k=1}^{K}f_{k}(x_{f};\mathbf{w})=1,\quad\forall f,\quad\sum_ {k=1}^{K}f_{k}(x_{r};\mathbf{w})=1,\quad\forall r,$ (3) $\displaystyle f_{k}(x_{f};\mathbf{w})\in[0,1],\quad\forall f,k,\quad f_{k}(x_{ r};\mathbf{w})\in[0,1],\quad\forall r,k.$ (4) $$

Additionally, within the constraints, we must ensure that the sum of the probabilities across all classes for each data point equals 1. Furthermore, the probabilities should be bounded between 0 and 1, meaning they must be greater than or equal to 0 and less than or equal to 1.

The constraints guarantee that the pseudo-labels for both sets adhere to predefined distributions and form valid probability distributions over class labels. This optimization strategy thus offers a comprehensive framework for managing the objectives of unlearning and adaptive retention within a machine learning model.

#### 4.1.1 Convergence to the Unique Optimal Solution

To address computational efficiency, particularly for large datasets, we adopt an iterative solution reminiscent of coordinate ascent algorithms applied to the Lagrangian dual of our problem.

Theorem 1
The proposed iterative procedure for the optimization problem described in ( 1) converges to the unique optimal solution, provided that feasible initial conditions are used and the total KL divergence remains finite for all feasible pseudo-labels.

The Kullback-Leibler (KL) divergence, $D_{\text{KL}}(p\|q)$, is a well-known convex function in $p$ when $q$ is fixed. The optimization objective function is a sum of convex KL divergence terms. Consequently, the entire objective function is convex. Since the optimization problem consists of minimizing a convex function subject to linear constraints, the problem is a convex optimization problem. Convexity ensures that there is a unique global minimum.

The iterative algorithm begins with feasible initial conditions, where the $f(x_{f};\mathbf{w})$ and $f(x_{r};\mathbf{w})$ satisfy the constraints ( 2) ( 3) ( 4).
These feasible initial conditions guarantee that the optimization process starts in the valid region and remains within this region during the optimization. Because the objective function is convex and the constraints are linear, the iterative procedure will converge to the global optimal solution. Strong duality ensures that the primal and dual solutions will converge to a common point, satisfying both the objective function and the constraints.

The uniqueness of the solution follows from the strict convexity of the KL divergence and the linear constraints. Therefore, the iterative procedure converges to the unique global minimum, as guaranteed by the structure of the problem.

Given this property, we can choose an initialization that is close to the pseudo-probabilities. Starting from a point near the optimal solution significantly reduces the number of iterations required for convergence. This improves computational efficiency by reducing the overall cost of optimization, while still guaranteeing that the solution is optimal.

#### 4.1.2 Integration into Deep Machine Unlearning

Moreover, our approach can be combined with other unlearning methods. After an initial unlearning phase conducted using existing techniques, our post-processing step can further refine the model’s output distribution, ensuring that the unlearning is both comprehensive and efficient.

### 4.2 Proof for Optimization Strategy

We now provide a detailed mathematical proof to establish the connection between the optimization strategy for model unlearning and the adaptive post-learning method, using Lagrangian duality and iterative coordinate ascent.

#### 4.2.1 Lagrangian Dual Formulation

Consider the optimization problem where the goal is to find the refined probabilities $f_{k}(x_{f};\mathbf{w})$ and $f_{k}(x_{r};\mathbf{w})$ for the forget and retain sets, respectively, to minimize the objective function (1).

The objective is to adjust the model outputs $f(x_{f};\mathbf{w})$ and $f(x_{r};\mathbf{w})$ such that the pseudo-labels for the forget set $f(x_{f};\mathbf{w})$ obscure the model’s learned associations while ensuring that the retain set pseudo-labels $f(x_{r};\mathbf{w})$ are aligned with the model’s original predictions.

To handle the class distribution constraints, we introduce dual variables $\alpha_{k}$ associated with the class distribution constraint for each class $k$ and define the Lagrangian as follows:

$$ $\begin{split}\mathcal{L}(f(x_{f};\mathbf{w}),f(x_{r};\mathbf{w}),\alpha)&=\sum _{f=1}^{N_{f}}D_{\text{KL}}(\hat{p}_{f}\parallel f(x_{f};\mathbf{w}))+\lambda \sum_{r=1}^{N_{r}}D_{\text{KL}}(\hat{p}_{r}\parallel f(x_{r};\mathbf{w}))\\ &\quad+\sum_{k}\alpha_{k}\left(\sum_{f=1}^{N_{f}}f_{k}(x_{f};\mathbf{w})+\sum_ {r=1}^{N_{r}}f_{k}(x_{r};\mathbf{w})-M_{k}\right)\end{split}$ (5) $$

The Lagrangian formulation allows us to handle the constraints directly by incorporating them into the objective function using the dual variables $\alpha_{k}$. Given the convexity of the objective function, strong duality holds, meaning that the optimal solution can be found by solving the Lagrangian dual problem.

#### 4.2.2 Solution via Coordinate Ascent

The coordinate ascent method can now be applied to solve the optimization problem. The dual variables $\lambda_{k}$ are updated iteratively to ensure that the class distribution constraints are satisfied. For each iteration, the primal variables $f(x_{f};\mathbf{w})$ and $f(x_{r};\mathbf{w})$ are updated to minimize the Lagrangian, followed by updates to the dual variables $\lambda_{k}$ to satisfy the class constraints.

The primal and dual updates can be written as:

$$ $f_{k}(x_{f};\mathbf{w})=A_{f,k}e^{-\frac{w_{k}+\lambda_{k}}{w_{k}}},\quad f_{k }(x_{r};\mathbf{w})=A_{r,k}e^{-\frac{w_{k}+\lambda_{k}}{w_{k}}}$ (6) $$

where $A_{f,k}$ and $A_{r,k}$ are the initial probabilities.

The dual variable update follows:

$$ $\lambda_{k}^{(t+1)}=\lambda_{k}^{(t)}+\eta\left(\sum_{f=1}^{N_{f}}f_{k}(x_{f}; \mathbf{w})+\sum_{r=1}^{N_{r}}f_{k}(x_{r};\mathbf{w})-M_{k}\right)$ (7) $$

where $\eta$ is the step size.

### 4.3 Change the weights

After updating the probabilities, we adjust the model’s weights accordingly by using the KL divergence as the loss function to calculate the loss.

## 5 Experiment

### 5.1 Datasets and Metrics

In this study, we employ two distinct datasets that were also used in prior research: CIFAR-10 and Lacuna-10. Lacuna-10 is a curated dataset formed by selecting data from 10 distinct classes, randomly chosen from the extensive VGG-Face2 dataset(Cao et al., ). These selected classes each have a minimum of 500 samples, with the data further segmented into 400 training and 100 testing images per class. Lacuna-100 expands on this concept by selecting 100 classes with the same criteria. Our evaluation metric focuses on the model’s accuracy, specifically assessing its performance on both the forget set and the retain set to evaluate memory retention. Additionally, we measure the model’s resistance to membership inference attacks for the privacy task.

### 5.2 Implementation details

To facilitate a comprehensive comparison with the performance of other models, we follow the setup in (Kurmanji et al., ). We establish two experimental conditions: small-scale and large-scale. The small-scale setting, referred to as CIFAR-5/Lacuna-5, involves a subset of 5 classes from each dataset, comprising 100 training, 25 validation, and 100 testing samples per class. Notably, the forget set includes 25 samples from the initial class, accounting for 5% of the dataset. Conversely, the large-scale setting encompasses all classes from both CIFAR-10 and Lacuna-10, providing a broader spectrum for analysis. In the large-scale scenario, we will explore both class unlearning and selective unlearning. For class unlearning, we define the forget set as the entirety of the training set for class 5, which constitutes 10% of the data. In the selective unlearning scenario, we aim to forget 100 examples from class 5, representing 0.25% of CIFAR-10 and 2% of Lacuna-10.

To align with precedents in the field, our experiments will be conducted using two established architectures: ResNet-18 and ALL-CNN (Springenberg et al., ). The baseline model will be pretrained on CIFAR-100 and Lacuna-100 datasets for initial weight setting. Additionally, $\lambda$ will be set to a default value of 1 in the following experiments.

### 5.3 Baseline

Our approach is benchmarked against the latest state-of-the-art methods and established baselines to highlight its efficacy:
Retrain: This involves retraining the original model solely on the retain set $\mathcal{D}_{r}$, considered the gold standard. However, this method is typically deemed impractical for real-world applications. Original: TThe baseline model trained on the complete dataset $\mathcal{D}$, without any modifications for data forgetting. Finetuning: The original model is fine-tuned on the retain set $\mathcal{D}_{r}$, incorporating no specific forgetting mechanism. $\textbf{NegGrad}+$ (Kodge et al., ): An innovative method that applies gradient ascent to the forget set and gradient descent to the retain set over 500 iterations. Fisher Forgetting (Golatkar et al., ): Adjusts the model’s weights to effectively “unlearn” the data meant to be forgotten, simulating a scenario where the model was never exposed to this data. NTK Forgetting (Doan et al., ): Employs novel techniques like PCA-OGD to minimize forgetting by orthogonally projecting onto principal directions, preserving data structure integrity. CF-k, EU-k (Goel et al., ): These methods focus on the model’s last k layers. “Exact-unlearning” (EU-k) re-trains these layers from scratch, while “Catastrophic Forgetting” (CF-k) fine-tunes them on the retain set $\mathcal{D}_{r}$.
SCRUB(Kurmanji et al., ): Introduces a novel training objective and has demonstrated superior performance in prior metrics.

### 5.4 Remove bias

**Table 1: Unlearning results with ResNet-18 for the bias removal task. Our method achieves higher forget rates while preserving overall model performance. “PPU w/ uniform” indicates that pseudo-probabilities are set to a uniform distribution, while “PPU w/ random” refers to pseudo-probabilities following a random distribution.**
|  | CIFAR-5 | Lacuna-5 |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Model | Test error ($\downarrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Test error ($\downarrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | 24.90 | $\mathbf{0.00}$ | 28.80 | 5.80 | $\mathbf{0.00}$ | 4.80 |
| Original | 24.20 | $\mathbf{0.00}$ | 0.00 | 5.70 | $\mathbf{0.00}$ | 0.00 |
| Finetune | 24.30 | $\mathbf{0.00}$ | 0.00 | 5.60 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 31.60 | 14.00 | 4.80 | 6.70 | 14.00 | 6.40 |
| NTK | 24.40 | $\mathbf{0.00}$ | 22.40 | 5.60 | $\mathbf{0.00}$ | 0.00 |
| NegGrad+ | 25.50 | $\mathbf{0.00}$ | 41.3 | 6.10 | $\mathbf{0.00}$ | 1.30 |
| CF-k | 22.60 | $\mathbf{0.00}$ | 0.00 | 5.80 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 23.50 | $\mathbf{0.00}$ | 10.70 | 5.90 | $\mathbf{0.00}$ | 0.00 |
| Bad-T | 22.73 | 5.12 | 8.00 | 5.00 | 8.64 | 0.14 |
| SCRUB | 24.20 | $\mathbf{0.00}$ | 40.80 | 6.20 | $\mathbf{0.00}$ | 24.80 |
| PPU w/ random | $\mathbf{22.00}$ | $\mathbf{0.00}$ | $\mathbf{80.00}$ | $\mathbf{2.20}$ | $\mathbf{0.00}$ | 64.00 |
| PPU w/ uniform | 27.00 | 0.21 | $\mathbf{80.00}$ | 2.80 | 0.42 | $\mathbf{68.00}$ |

**Table 2: Seletive unlearning results with ALL-CNN for the bias removal task. Our method achieves higher forget rates while preserving overall model performance. “PPU w/ uniform” indicates that pseudo-probabilities are set to a uniform distribution, while “PPU w/ random” refers to pseudo-probabilities following a random distribution.**
|  | CIFAR-10 | Lacuna-10 |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Model | Test error ($\downarrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Test error ($\downarrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | 16.71 | $\mathbf{0.00}$ | 25.67 | 1.60 | $\mathbf{0.00}$ | 0.67 |
| Original | $\mathbf{16.43}$ | $\mathbf{0.00}$ | 0.00 | 1.53 | $\mathbf{0.00}$ | 0.00 |
| Finetune | 16.50 | $\mathbf{0.00}$ | 0.00 | 1.43 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 21.39 | 4.00 | 13.00 | 1.87 | 0.01 | 0.00 |
| NegGrad+ | 21.36 | 3.23 | 45.33 | 2.77 | 0.40 | 8.67 |
| CF-k | 16.29 | $\mathbf{0.00}$ | 0.00 | 1.53 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 17.62 | 0.11 | 0.33 | 1.83 | $\mathbf{0.00}$ | 0.00 |
| Bad-T | 22.43 | 10.13 | 1.67 | 4.90 | 1.34 | 0.67 |
| SCRUB | 16.55 | $\mathbf{0.00}$ | 20.33 | 2.07 | $\mathbf{0.00}$ | 1.67 |
| PPU w/ random | 17.00 | $\mathbf{0.00}$ | 86.00 | $\mathbf{2.20}$ | $\mathbf{0.00}$ | 64.00 |
| PPU w/ uniform | 16.60 | $\mathbf{0.00}$ | $\mathbf{95.00}$ | 2.80 | 0.42 | $\mathbf{68.00}$ |

In addressing bias removal, our goal is to maximize the forget set error. Thus, instead of performing optimizations, we can directly modify the forget set probabilities to reflect pseudo probabilities. Additionally, we experimented with various distributions for the pseudo-probabilities, including uniform and random distributions.Specifically, the random distribution will be generated by applying the softmax function to randomly generated numbers. In general, the uniform distribution tends to perform better in terms of forget error, but it often leads to worse results in test error and retain error. As shown in Table 1, our method PPU comes with a much higher forget error (60-80 percent higher), which is the desired outcome in unlearning scenarios. Table 2 also demonstrates that PPU achieves better performance in forget error for selective unlearning in larger models. Based on the forget error metric, our method appears to be the most successful at unlearning, achieving the desired outcome of complete forgetfulness without severely compromising the performance of the data that should be retained. Additionally, our method exhibits the lowest test error, demonstrating that the model’s performance and generalizability are well-preserved even after applying our unlearning technique. The results demonstrate that using pseudo-probabilities is effective for bias removal.

### 5.5 Protect privacy

**Table 3: Unlearning results with ALL-CNN for the privacy protection task.**
|  | CIFAR-10 | Lacuna-10 |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Model | Test error | Retain error | Forget error | Test error | Retain error | Forget error |
| Retrain | 16.71 | 0.00 | 26.67 | 1.50 | 0.00 | 0.33 |
| Original | 16.71 | 0.00 | 0.00 | 1.57 | 0.00 | 0.00 |
| Finetune | 16.86 | 0.00 | 0.00 | 1.40 | 0.00 | 0.00 |
| NegGrad+ | 21.65 | 4.54 | 47.00 | 3.60 | 0.87 | 14.33 |
| CF-k | 16.82 | 0.00 | 0.00 | 1.57 | 0.00 | 0.00 |
| EU-k | 18.44 | 0.32 | 0.33 | 3.90 | 0.76 | 0.00 |
| Bad-T | 22.43 | 10.13 | 1.67 | 4.90 | 0.67 | 1.34 |
| SCRUB | 17.01 | 0.00 | 33.00 | 1.67 | 0.00 | 0.00 |
| SCRUB+R | 16.88 | 0.00 | 26.33 | 1.67 | 0.00 | 0.00 |
| PPU | 18.05 | 0.00 | 25.35 | 1.05 | 0.00 | 0.05 |

To protect privacy, our goal is to ensure that the forget error remains close to that of retraining. For membership inference attacks, we adopt the approach outlined by Kurmanji et al.(Kurmanji et al., ). Specifically, we train a binary classifier (the “attacker”) using the losses of the unlearned model on both the forget and test examples, with the objective of classifying instances as either “in” (forget) or “out” (test). The attacker then predicts labels for held-out losses—losses that were not used during training—balanced between the forget and test sets. A successful defense is indicated by an attacker accuracy of 50%, signifying that the attacker is unable to distinguish between the two sets, demonstrating the effectiveness of the unlearning method.

To preserve privacy, we monitor both the training and retain accuracy at each epoch. As shown in Figure 2, the experiment on selective unlearning with ALL-CNN on CIFAR-10 reveals that the forget error gradually increases during training. Therefore, checkpoints are saved at each epoch, and the model closest to the original is selected. In this setup, pseudo-probabilities are initialized using a uniform distribution. According to Figure 3, PPU’s forget error is very close to that of retraining, particularly in the Lacuna-10 experiment, where it is the closest match. In the membership inference attack experiment, shown in Figure 4, PPU consistently achieves nearly 50% accuracy, indicating strong privacy preservation. This demonstrates that, with the refinement of pseudo-probabilities, the model can maintain the original distribution while effectively forgetting the designated forget set.

Figure: Figure 2: Forget set error on selective unlearning with ALL-CNN on CIFAR-10
Refer to caption: extracted/5977134/forget_error.jpg

**Table 4: Membership inference attack results with ResNet-18 and ALL-CNN in large-scale unlearning. The closer the result is to 50%, the better the performance.**
|  | ResNet | ALL-CNN |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | Class | Selective | Class | Selective |  |  |  |  |
| Model | mean | std | mean | std | mean | std | mean | std |
| Retrain | 49.33 | 1.67 | 54.00 | 1.63 | 55.00 | 4.00 | 48.73 | 0.24 |
| Original | 71.10 | 0.67 | 65.33 | 0.47 | 66.50 | 0.50 | 71.40 | 0.70 |
| Finetune | 75.57 | 0.69 | 64.00 | 0.82 | 68.00 | 1.00 | 74.97 | 1.27 |
| NegGrad+ | 69.57 | 1.19 | 66.67 | 1.70 | 72.00 | 0.00 | 70.03 | 1.92 |
| CF-k | 75.73 | 0.34 | 65.00 | 0.00 | 69.00 | 2.00 | 72.93 | 1.06 |
| EU-k | 54.20 | 2.27 | 53.00 | 3.27 | 66.50 | 3.50 | 51.60 | 1.22 |
| Bad-T | 54.00 | 1.10 | 59.67 | 4.19 | 63.4 | 1.2 | 77.67 | 4.11 |
| SCRUB | 52.20 | 1.71 | 78.00 | 2.45 | 52.00 | 0.00 | 54.30 | 2.24 |
| SCRUB+R | 52.20 | 1.71 | 58.67 | 1.89 | $\mathbf{52.00}$ | 0.00 | 54.30 | 2.24 |
| PPU | $\mathbf{51.00}$ | 1.05 | $\mathbf{58.00}$ | 0.93 | 54.00 | 0.70 | $\mathbf{50.00}$ | 0.40 |

### 5.6 Computational efficiency

We compare the time required for SCRUB (Kurmanji et al., ), retraining, and our method, with all experiments conducted on an NVIDIA RTX-4090. Time is recorded over 5 runs, and we report both the mean and the standard error. In Figure 3, we present the time required for the bias removal tasks using the ResNet-18 model and selective unlearning using ALL-CNN. Compared to other methods, PPU significantly reduces computation time, cutting it to less than half of what is required by SCRUB. The results further emphasize the high effectiveness of the optimization approach and the use of pseudo-probabilities to fine-tune the model weights.

Figure: Figure 3: Time needed for the unlearning method (measured over 5 runs)
Refer to caption: extracted/5977134/output.jpg

### 5.7 Adaptive Unlearning

Our method can also be applied as post-processing after unlearning methods to enhance their results. PPU can be considered a plug-in that is compatible with nearly all existing methods. In our experiments, we built on SCRUB (Kurmanji et al., ) and applied our method afterward. For the bias removal task, this approach improves forget error by more than 50%, with less than a 0.5% decrease in retain error. Detailed results can be found in Appendix A.1. In addition to SCRUB, we applied our method after fine-tuning on CIFAR-10 with a pretrained ResNet, achieving a 2.5% retain error and a 60% forget error. In comparison, the original fine-tuning method achieved only a 2% retain error and a 16% forget error.

## 6 ablation study

In the optimization objective function ( 1), the value of
$\lambda$was set to 1 in all previous experiments. Here, we explore the impact of varying
$\lambda$ on the retain and forget errors in a small-scale unlearning experiment on CIFAR-5 with ResNet. As
$\lambda$increases, more weight is assigned to the retain set, resulting in a decrease in retain error from 0.21% to 0%. However, this reduction comes at a significant cost to the forget error.

For investigation our method in a larger setting, we also conducted an additional experiment on the CIFAR-100 dataset with one class unlearning. Our method demonstrated very good performance. Using the ResNet architecture, SCRUB achieved a forget error of 5.19 and a retrain error of 0.00015. In contrast, our method achieved a retrain
031 error of 0.00 and a forget error of 98.25.

**Table 5: The retain error and forget error with varying $\lambda$ values were evaluated in a small-scale unlearning experiment on CIFAR-5 using ResNet.**
|  | $\lambda=1$ | $\lambda=2$ | $\lambda=3$ | $\lambda=4$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Model | Retain error | Forget error | Retain error | Forget error | Retain error | Forget error | Retain error | Forget error |
| PPU | 0.21 | 80.00 | 0.00 | 56.00 | 0.00 | 23.00 | 0.00 | 30.00 |

## 7 Conclusion

This research introduces a novel approach to machine unlearning, presenting an optimization framework that refines predictive probability distributions within deep learning models. Our method excels in striking an optimal balance between forgetting effectiveness and preserving model performance on retained data. Additionally, it demonstrates superior resilience against membership inference attacks. Empirical results across diverse datasets and model architectures, including CIFAR-10 and Lacuna-10 with ResNet and ALL-CNN, highlight the superiority of our approach over existing state-of-the-art methods.

Furthermore, the operational flexibility, theoretical insights, and high computational efficiency of our approach provide a solid foundation for further developments. However, we acknowledge certain limitations. Our current method is limited to addressing unlearning in classification tasks and may encounter convergence issues during the optimization process.
Additionally, the approach is restricted to supervised learning settings and does not extend to unsupervised tasks at this stage.
Future work will focus on extending the method to various models, including large language models, and broadening its applicability beyond classification tasks.

## Appendix A Appendix

### A.1 More results for adaptive unlearning

Here, we present additional results for our method, applied as a post-processing step after SCRUB. For the bias removal task, our method significantly improves the forget error while having minimal impact on the model’s original performance. The results are incorporated in Table 6, Table 7, Table 8, Table 9, and Table 10.

**Table 6: Unlearning results with ALL-CNN. Our method gets top performance in forget with little influence on model performance (retain error).**
|  | CIFAR-5 | Lacuna-5 |  |  |
| --- | --- | --- | --- | --- |
| Model | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | 0.13 | 28.80 | $\mathbf{0.00}$ | 4.67 |
| Original | 0.17 | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Finetune | 0.04 | 0.00 | 6.63 | 19.33 |
| Fisher | 31.83 | 15.20 | 51.09 | 39.33 |
| NTK | 0.17 | 13.6 | $\mathbf{0.00}$ | 3.33 |
| NegGrad+ | 0.56 | 36.00 | 0.14 | 12.00 |
| CF-k | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 3.23 | 8.00 | $\mathbf{0.00}$ | 0.00 |
| Bad-T | 9.68 | 10.67 | 2.32 | 0.00 |
| SCRUB | 0.08 | 40.80 | $\mathbf{0.00}$ | 25.33 |
| SCRUB + PPU | 1.05 | $\mathbf{68.00}$ | 1.47 | $\mathbf{78.00}$ |

**Table 7: Class unlearning results with ResNet. Our method gets top performance in forget with little influence on model performance (retain error).**
|  | CIFAR-10 | Lacuna-10 |  |  |
| --- | --- | --- | --- | --- |
| Model | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | $\mathbf{0.00}$ | $\mathbf{100.00}$ | $\mathbf{0.00}$ | 99.75 |
| Original | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Finetune | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 2.45 | $\mathbf{100.00}$ | $\mathbf{0.00}$ | $\mathbf{100.00}$ |
| NegGrad+ | 1.74 | 91.26 | $\mathbf{0.00}$ | 14.90 |
| CF-k | $\mathbf{0.00}$ | 0.03 | $\mathbf{0.00}$ | 0.00 |
| EU-k | $\mathbf{0.00}$ | 98.79 | 0.01 | 4.06 |
| Bad-T | 11.34 | 94.67 | 1.06 | 67.60 |
| SCRUB | 0.51 | $\mathbf{100.00}$ | 0.28 | $\mathbf{100.00}$ |
| SCRUB+PPU | 2.48 | $\mathbf{100.00}$ | $\mathbf{0.00}$ | $\mathbf{100.00}$ |

**Table 8: Class unlearning results with ALL-CNN. Our method gets top performance in forget with little influence on model performance (retain error).**
|  | CIFAR-10 | Lacuna-10 |  |  |
| --- | --- | --- | --- | --- |
| Model | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | $\mathbf{0.00}$ | $\mathbf{100.00}$ | $\mathbf{0.00}$ | $\mathbf{100.00}$ |
| Original | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Finetune | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 3.66 | 99.00 | $\mathbf{0.00}$ | 89.00 |
| NegGrad+ | 0.58 | 87.22 | $\mathbf{0.00}$ | 6.56 |
| CF-k | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 0.13 | $\mathbf{100.00}$ | 0.00 | 77.19 |
| Bad-T | 5.84 | 81.93 | 0.37 | 38.65 |
| SCRUB | 0.12 | $\mathbf{100.00}$ | $\mathbf{0.00}$ | $\mathbf{100.00}$ |
| SCRUB+PPU | 0.20 | $\mathbf{100.00}$ | $\mathbf{0.00}$ | $\mathbf{100.00}$ |

**Table 9: Selective unlearning results with ResNet. Our method gets top performance in forget with little influence on model performance (retain error).**
|  | CIFAR-10 | Lacuna-10 |  |  |
| --- | --- | --- | --- | --- |
| Model | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | $\mathbf{0.00}$ | 29.67 | $\mathbf{0.00}$ | 1.0 |
| Original | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Finetune | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 2.88 | 3.00 | $\mathbf{0.00}$ | 0.00 |
| NegGrad+ | 4.10 | 53.70 | 0.90 | 13.00 |
| CF-k | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 0.40 | 23.70 | 0.00 | 0.00 |
| Bad-T | 14.53 | 34.67 | 3.26 | 0.33 |
| SCRUB | $\mathbf{0.00}$ | 70.33 | $\mathbf{0.00}$ | 4.67 |
| SCRUB+PPU | 0.01 | $\mathbf{100.00}$ | 5.39 | $\mathbf{100.00}$ |

**Table 10: Selective unlearning results with ALL-CNN. Our method gets top performance in forget with little influence on model performance (retain error).**
|  | CIFAR-10 | Lacuna-10 |  |  |
| --- | --- | --- | --- | --- |
| Model | Retain error ($\downarrow$) | Forget error ($\uparrow$) | Retain error ($\downarrow$) | Forget error ($\uparrow$) |
| Retrain | $\mathbf{0.00}$ | 25.67 | $\mathbf{0.00}$ | 0.67 |
| Original | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Finetune | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| Fisher | 4.00 | 13.00 | 0.01 | 0.00 |
| NegGrad+ | 3.23 | 45.33 | 0.40 | 8.67 |
| CF-k | $\mathbf{0.00}$ | 0.00 | $\mathbf{0.00}$ | 0.00 |
| EU-k | 0.11 | 0.33 | 0.00 | 0.00 |
| Bad-T | 10.13 | 1.67 | 1.34 | 0.67 |
| SCRUB | $\mathbf{0.00}$ | 29.33 | $\mathbf{0.00}$ | 1.67 |
| SCRUB+PPU | $\mathbf{0.00}$ | $\mathbf{100.00}$ | 0.00 | $\mathbf{88.12}$ |

## Peer Reviews

confidence: 5
contribution: 1
initial_rating: 1
presentation: 1
questions: 1. Why does the proposed algorithm focus on minimizing the forget error on forgotten data instead of minimizing the discrepancy between the retrained and unlearned models?
2. Have you considered scenarios where the model's prediction confidence may not accurately reflect the sensitivity of the data?
3. What are the key factors that influence the trade-off between privacy preservation and model performance in the context of machine unlearning?
4. The proposed algorithm seems to only work for classification tasks and small datasets. How scalable is the proposed algorithm to large-scale datasets and complex models? How easy or difficult to adapt the proposed PPU to more challenging datasets or tasks, for instance ImageNet dataset, regression model, or generative model?
5. Can you provide more insights into the retain error and forget error metrics and how they reflect the unlearning algorithm's performance in different scenarios?
6. I do not see the forgot error comparison in Figure 3, and there is also no Figure 4 to support the claim that "According to Figure 3, PPU’s forget error is very close to that of retraining, particularly in the Lacuna-10 experiment, where it is the closest match. In the membership inference attack experiment, shown in Figure 4, PPU consistently achieves nearly 50% accuracy, indicating strong privacy preservation" in Line 408. Can you please check on this?
soundness: 1
strengths: - The paper addresses an important problem of efficient and privacy-preserving machine learning and provides a practical solution.
- The evaluation covers two datasets, two models, and multiple baseline machine unlearning algorithms.
summary: This paper proposes an efficient machine unlearning solution, Privacy-Preserving Unlearning (PPU), that aims to minimize privacy leakage while maintaining model performance. The proposed algorithm is evaluated on two datasets and two deep neural network models, demonstrating its effectiveness in reducing the forget error on forgotten data. The paper provides a comprehensive evaluation of the algorithm and compares it with multiple baseline unlearning methods.
weaknesses: - The proposed PPU algorithm seems to only work for deep neural networks and classification tasks and may not be applicable to other types of models or tasks.
- The optimization goal of the PPU algorithm could be wrong. The algorithm aims to maximize the forget error on forgotten data instead of minimizing the discrepancy between the original and unlearned models.
- In the evaluation section, the retain error and forget error metrics could be further explained to provide more insights into the algorithm's behavior.
- There are many editing issues throughout the paper, such as typos, missing citations, and missing figures.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. Should $\lambda_k$ in Section 4.2.2 be $\alpha_k$?
2. Should "retrain error" on line 485 be "retain error"?
3. What is $w_k$ in Equation 6?
4. The goals in Section 5.4 and Section 5.5 are different. Are the two goals contradictory? Can PPU achieve both of them simultaneously?
soundness: 2
strengths: 1. The idea of modifying the final-layer output probabilities of the neural network to pseudo-probabilities for machine unlearning is novel.
2. The paper is overall well-structured and generally easy to follow.
summary: The paper proposes Pseodo-Probability Unlearning (PPU), a novel method that enables models to forget data efficiently and in a privacy-preserving manner. PPU replaces the final-layer output probabilities of the neural network with pseudo-probabilities for the data to be forgotten. The pseudo-probabilities are initialized from some distributions (e.g., a uniform distribution) and are further refined to maintain performance on the remaining data. Extensive experiments demonstrate the efficiency of PPU while preventing privacy leakage.
weaknesses: 1. Adding an independent paragraph for contributions in the Introduction Section would be better.
2. The method SISA is considered to be exact unlearning.
3. Some typos. "Figure ??" on line 080. $\mathcal D_r$ and $D_{fog}$ on line 139. "The dual variables $\lambda_k$" on line 269. Missing space characters after $\lambda$s on line 478 and line 480.
4. Miss descriptions of Table 3 in the main text.
5. The font size of the text in the figures is too small.
6. Reuse of the notation $f$ for both the model and the forget set.
7. Experiments on larger datasets and networks (e.g., ImageNet) would be better.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: The motivation for the proposed method in the introduction was the privacy violation in unlearning through membership inference. However, in the experiment, only test, retain and forget errors were evaluated. There was no experimental evaluation of privacy violations through membership inference. It is necessary to experimentally evaluate whether the proposed method is more robust against privacy violations through membership inference than other methods.

The proposed method claims that if the probability output of the final layer is uniform or random, it can avoid membership inference. Is this true? It is unlikely that the probability output of the final layer is uniform by chance. Could it be evidence that the probability output of the final layer was the target of unlearning?

The same applies if the probability output of the final layer is random. If such randomness does not appear in any other test data, it is possible to infer that it is artificial randomness. To show that the data to be forgotten is not identified by membership inference, it may be necessary to show, for example, using statistical testing, that the probability output of the final layer for the data contained in the test data is statistically indistinguishable from the probability output of the data to be forgotten.
soundness: 2
strengths: The perspective on privacy violations of unlearning through membership inference is important, and this paper introduces this perspective as a new contribution.
summary: This research studies methods for achieving unlearning, which involves forgetting information about specific data from a trained model. In particular, it points out that with existing unlearning methods, it is possible to identify whether or not a piece of data has been unlearned by using a membership inference attack and that this can lead to privacy violations. This research proposes a method that enables unlearning while preventing such privacy violations. Specifically, the authors propose a method that not only makes it impossible to classify the data to be forgotten but also makes the output probability of the final layer when classifying the data to be forgotten to match a uniform distribution or a distribution with random probabilities for each class. They argue that this prevents privacy violations associated with unlearning. They also consider optimization methods for implementing such a method.
weaknesses: It is not sufficiently discussed whether the proposed method can indeed prevent privacy violations of unlearning through membership inference. In addition, there is no experimental comparison with other methods from this perspective.

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 1
questions: No additional questions.
soundness: 2
strengths: 1. The experiments and evaluation are sufficient.
summary: The paper tries to solve the efficiency and privacy leakage of machine unlearning. The problem and topic is interesting and hot. I have some comments as follows.

Strengths: 1. The experiments and evaluation are sufficient.

Weaknesses:
1. The problem statement is not clear. In the introduction and abstract, the authors claimed that they aim to solve the efficiency and privacy leakage of machine unlearning. However, in the section 3, the problem definition section, it has not mentioned the definition related to the efficiency and privacy leakage problems in machine unlearning.

2. Regarding the privacy leakage in machine unlearning, the authors ignored the common attacks that compare the model difference before and after unlearning to implement inference attacks. To the reviewer's understanding, the proposed method is infeasible for these attacks in machine unlearning because the original model performs well on erased samples but now randomly predicts them, which is a huge difference.

3. The paper needs heavy proofreading. There are many typos, for example "Figure ??" in page 2.
weaknesses: 1. The problem statement is not clear. In the introduction and abstract, the authors claimed that they aim to solve the efficiency and privacy leakage of machine unlearning. However, in the section 3, the problem definition section, it has not mentioned the definition related to the efficiency and privacy leakage problems in machine unlearning.

2. Regarding the privacy leakage in machine unlearning, the authors ignored the common attacks that compare the model difference before and after unlearning to implement inference attacks. To the reviewer's understanding, the proposed method is infeasible for these attacks in machine unlearning because the original model performs well on erased samples but now randomly predicts them, which is a huge difference.

3. The paper needs heavy proofreading. There are many typos, for example "Figure ??" in page 2.