Towards Scalable Exact Machine Unlearning Using Parameter-Efficient Fine-Tuning

TL;DR

Exact unlearning in production faces high retraining costs and downtime. S3T combines parameter-efficient fine-tuning (LoRA-based PEFT) with sequence-aware, shard-level sliced training to isolate parameters by data slices, training multiple slice sequences offline to enable fast, exact unlearning by deactivating affected layers. Theoretical results show deletion rate benefits: $\\delta({S^{3}T}) \\sim O(mL\\log(mB'))$ versus $\\delta(\\mathrm{SISA}) \\sim O(mL\\log m)$, alongside sequence-selection strategies (cyclic rotation and bipartite matching) and empirical evidence across vision, NLP, and instruction-tuning tasks that S3T achieves near- or better-than full-training performance while significantly reducing deletion cost. This work offers a scalable, production-ready approach to exact unlearning with practical gains in availability and efficiency for large-scale deployments.

Abstract

Machine unlearning is the process of efficiently removing the influence of a training data instance from a trained machine learning model without retraining it from scratch. A popular subclass of unlearning approaches is exact machine unlearning, which focuses on techniques that explicitly guarantee the removal of the influence of a data instance from a model. Exact unlearning approaches use a machine learning model in which individual components are trained on disjoint subsets of the data. During deletion, exact unlearning approaches only retrain the affected components rather than the entire model. While existing approaches reduce retraining costs, it can still be expensive for an organization to retrain a model component as it requires halting a system in production, which leads to service failure and adversely impacts customers. To address these challenges, we introduce an exact unlearning framework -- Sequence-aware Sharded Sliced Training (S3T), which is designed to enhance the deletion capabilities of an exact unlearning system while minimizing the impact on model's performance. At the core of S3T, we utilize a lightweight parameter-efficient fine-tuning approach that enables parameter isolation by sequentially training layers with disjoint data slices. This enables efficient unlearning by simply deactivating the layers affected by data deletion. Furthermore, to reduce the retraining cost and improve model performance, we train the model on multiple data sequences, which allows S3T to handle an increased number of deletion requests. Both theoretically and empirically, we demonstrate that S3T attains superior deletion capabilities and enhanced performance compared to baselines across a wide range of settings.

Figures (16)

• Figure 1: Schematic diagram of the Sharded, Isolated, Sliced, and Aggregated training (SISA) bourtoule2021machine framework. An ensemble of models is individually trained on disjoint shards ($\mathcal{D}_i$'s). (Left) Each shard is further divided into slices. (Right) Each model is sequentially trained on the slices and checkpoints are stored. After deletion, retraining resumes from the best available checkpoint.
• Figure 2: (Left) We show the schematic diagram of the slice-wise training strategy in S3T. We incrementally train the model -- $i$th layer (from the top) using slices $S_{1:i}$ while keeping the other layers fixed. (Right) We show the impact of deletion on models trained on different permutations of slices.
• Figure 3: Illustration of the slice sequence selection problem with uniform deletion prior under a budget constraint, $B$. (Left) An example of a permutation tree with $L=3$ and a diverse set of sequences for budget $B=3$ is shown in green. (Center) We show the functioning of the cyclic rotation algorithm, where we generate cyclic permutations of the original sequence. (Right) We iteratively extend the algorithm when budget $B > L$ by generating cyclic rotations of the subsequences.
• Figure 4: Illustration of the BMS algorithm. BMS selects one element for each permutation at a time. This is done by constructing a bipartite graph with all feasible edges to the next node, where edge weights are the current sequence scores. We compute the maximum weight matching on this graph. The dark gray arrows ($\rightarrow$) indicate the selected edges and dotted arrows ($\mathrel{ {$$} {$$} {$$} \@whiledim<{ } \mathrel{} \mathrel{ \mathop{\dabar@\dabar@}\limits } \mathrel{\mathchar"0\hexnumber@\symAMSa 4B }{} }$) the feasible ones.
• Figure 5: Comparison of the performance between slice-wise training and full training on vision datasets and GLUE & SuperGLUE benchmarks. We report the overall Matthew’s correlation for CoLA, Pearson correlation for STS-B, and accuracy for other tasks. We observe that slice-wise training achieves similar performance to full training across all datasets.

Theorems & Definitions (7)

• Definition 1: Deletion Rate
• Lemma 1
• Lemma 2: Performance Retention
• proof
• proof
• proof
• Lemma 3