acceptodds
Under review as a conference paper at ICLR 2027

UNACT: GRADIENT-FREE UNLEARNING VIA TARGETED ACTIVATION INTERVENTION

Abstract

Machine unlearning seeks to remove the influence of designated training data from a trained model without retraining from scratch. Retrain-free methods such as Selective Synaptic Dampening (SSD) and its label-free variant LFSSD avoid full retraining but still require backpropagation and parameter importance computed over the entire dataset. We ask: what happens when a deletion request arrives with only a few images of the class to be forgotten? To answer this question, we introduce UnAct, a gradient-free class-unlearning method that needs only forward passes over the forget images. UnAct scores late-layer units by their responses, attenuates the most responsive connections, and repeats this for up to 20 rounds using no gradients, no labels, and no retained data. On ResNet-18 trained with CIFAR-10, CIFAR-20, and CIFAR-100, UnAct is competitive with SSD and LFSSD when forgetting entire classes and, unlike them, never collapses the network when forget data is scarce. On ResNet-18, across all tested sizes, UnAct’s retain accuracy stays within 2.5 points of retraining, while SSD and LFSSD, at their full-class operating points, lose up to 86 points on some classes. With five forget images on CIFAR-10, UnAct’s distance to retraining is 0.21 points, against 67 for LFSSD and 90 for SSD, and re-selecting SSD’s threshold at each size with an oracle does not close the gap. In preliminary transfer to ViT-B/16, UnAct’s distance to retraining is 11.5 against 33.7 for SSD, and a request is 19× faster than SSD when SSD computes its importance at request time. The code is available at https://anonymous.4open.science/r/UnAct-D688/.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Machine Unlearning, AI Safety, GDPR, Gradient-Free

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_FUjVOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This work presents UnAct that is a gradient-free class-unlearning method by an iterative attenuating the most responsive connections in response to the forget samples. As presented and claimed by the authors, it needs no gradients, no labels or retain data samples.

Critical strengths

The draft is well-organized and easy to read. The proposed method is well presented, also some limitations are discussed.

Critical weaknesses
  • There is no experiment regarding multi-class unlearning
  • The related works do not include the most recent works. There are several recent works that are not discussed. So the list of baselines is very limited. It is not clear how the model performs compared to the SOTA.
  • In Section 3.1, the authors mentioned that a model retrained from scratch on the retain set is ideal unlearning. What is ideal unlearning? In ideal class unlearning, we want the model performs random on forget classes. However, in retraining from scratch, due to the generalization ability of the model, it may not perform randomly on forget classes. That is exactly why forgetting most of the time, degrades the model's ability on the retain set.
  • It is mentioned that just one training seed is used. My question is why is that so? At least in classifier unlearning it is very common to use several seeds and report averaged results. So several conclusions claimed in the paper are based on just 1 seed's results so they are not robust evidence.
  • In section D in the appendix, it is mentioned that the hyperparameters are selected on test. So the results regarding that are biased!
  • The authors mentioned that their method suppresses the forgot class and does not erase it. It means it is admitted that the information regarding the forget classes is still there in the model's parameters even after unlearning. Then they discussed the results of the membership inference attack. We know that the information is there, so even if some MIA methods fail, it still says nothing about the privacy! So having such experiments and showing that some MIAs failed so the model is secure is superficial.
Questions for authors

Please see critical weaknesses.

4 comments

Response to Reviewer FUjV (1/2)

Thank you for the detailed comments. Two of them identified real gaps, which we have closed with new experiments; three concern points that the submission already addresses, and we give the locations.

Single training seed. We agree this was a limitation, and we stated it in Section 5. We trained two further ResNet-18 models per dataset with different seeds and applied every method at its submitted configuration, with no re-tuning. The new models have no retrained references yet, so we report a gold-free gap (|retain-accuracy change from the original model| + forget accuracy), which differs from Δ\Delta by at most 0.82 on the 15 classes where both exist (0.35 on average).

Gold-free gap, mean ±\pm std over three trained modelsUnActSSDLFSSD
CIFAR-100.48±0.090.48 \pm 0.0917.89±22.0617.89 \pm 22.060.45±0.060.45 \pm 0.06
CIFAR-200.26±0.040.26 \pm 0.040.98±1.120.98 \pm 1.120.26±0.040.26 \pm 0.04
CIFAR-1001.01±0.421.01 \pm 0.420.15±0.080.15 \pm 0.080.08±0.020.08 \pm 0.02

UnAct's results carry over: across all 45 class-model pairs its worst forget accuracy is 3.0% and its worst retain-accuracy loss 1.1 points. LFSSD's also carry over. SSD's selected threshold fails on 5 of the 30 new pairs; on one new CIFAR-10 model re-tuning recovers it, on the other no single threshold in its range works for all five classes. We also redrew the forget images for the few-image experiments (four draws): with five images UnAct's Δ\Delta is 0.17±0.050.17 \pm 0.05, 0.89±0.100.89 \pm 0.10 and 1.33±0.061.33 \pm 0.06. We will add Δ\Delta against retrained references for the new models in the final version.

Hyperparameters selected on the test split. This is a fair criticism, which we had stated in Section 5 and Appendix D. We now select every method's configuration on a held-out half of the test set (fixed seed, saved before any run, never used in any reported evaluation) and report on the other half: UnAct 0.34 / 0.69 / 1.06, SSD 0.47 / 0.15 / 0.39, LFSSD 0.28 / 0.21 / 0.24. No conclusion changes. All methods stay within about one point of retraining, with the same ordering as Table 2. Six of the nine selected configurations are identical to the submitted ones; for the other three, Δ\Delta on the held-out half moves by at most 0.1. Swapping the halves, or using the retrain-free rule of Appendix D on the validation half, gives the same picture (all Δ\Delta between 0.15 and 1.23).

"No experiment regarding multi-class unlearning." We thank the reviewer for raising this. The paper includes multi-class experiments in two forms, which we summarize here as the pointer from the main text may not have been prominent enough.

  • Sequential removal (Appendix I, Figure 6, Table 12). Five one-class requests are applied one after another to the same model, over five random class orders per dataset. UnAct keeps every requested class forgotten on CIFAR-10 and CIFAR-20 (forget accuracy never exceeds 2.7% across all orders and requests), while SSD's forget accuracy on previously requested classes reaches 76.1% and 62.1% by the fifth request on CIFAR-10 and CIFAR-20 respectively. On CIFAR-100, SSD is the better choice for sequential requests, and we report this openly in Section 4.2 and Appendix I.
  • Simultaneous removal (Table 13). We test removing up to five classes in a single request, measured against models retrained without all those classes. Both methods degrade for q>1q > 1 without re-tuning. UnAct is less affected than SSD (Δ\Delta of 84.76, 60.51 and 43.66 against 94.54, 89.97 and 81.29 at q=5q = 5), but neither method handles this task well without re-tuning, and we report this as an explicit limitation.

Why UnAct is designed for one class per request. This is a principled design choice, not an oversight. UnAct's scoring assumes the forget images come from a single class: this is what allows it to identify class-specific units without retained data, labels, or gradients. Extending the scoring to multiple simultaneous classes in a principled way is a direction we identify for future work. We will make the pointer to these experiments more prominent in the main text of the revised paper.

(continued in 2/2)

Response to Reviewer FUjV (2/2)

Membership inference. We agree that a failed attack says nothing about privacy, and the paper draws no privacy conclusion from it. We report the attack because the SSD and LFSSD protocols do, and then set it aside: "every method drives it to at most 0.9% on ResNet-18, below the retrained models' rates, so we do not use it to rank them" (Section 4.2). Our evidence about what remains in the model comes from the tests you would favour, a linear probe (Table 9) and relearning (Appendix M), and on that basis we state that UnAct suppresses the class rather than erasing it. The revision states explicitly that the attack supports no privacy claim.

"What is ideal unlearning?" We use the standard oracle: the model retrained from scratch without the forget data (Section 3.1), following Cao & Yang (2015), Ginart et al. (2019), and the protocols of SSD, LFSSD, SalUn, and the gap-to-retraining metric we adopt (Jia et al., 2023; Fan et al., 2024). This represents the model that would exist had the data never been included, which is precisely what a deletion request asks for.

The reviewer raises a valid philosophical point: due to generalization, a retrained model may still have non-trivial performance on the forgotten class. This is correct and the community has discussed it. However, for class removal on our tasks, the retrained model achieves exactly 0.00% forget accuracy on every dataset (Table 2): it never predicts the forgotten class, because it was never trained to do so. This is not chance performance: it is the model routing those images to other classes, which is the correct behavior after a class deletion.

The reviewer's deeper point, that the retrained model oracle is imperfect as a philosophical definition of ideal forgetting, is an active discussion in the unlearning community and we agree it is worth acknowledging. The LFSSD authors make the same point about over-forgetting: a model pushed too far from the retrained reference is detectable precisely because it differs. We use the retrained model as oracle in that spirit, as the consensus standard, and supplement it with the diagnostics in Table 9 (where each method sends forgotten images) and Appendix M (relearning speed), which go beyond Δ\Delta to characterize what the edit actually does to the model.

Recent related work and baselines. We agree Section 2 should cover more recent work and will extend it, including the closest training-free method we are aware of, Kodge et al. (Deep Unlearning, TMLR 2024), which also avoids gradients but uses retain samples that UnAct does not. Our comparison is restricted to methods that operate under the same access conditions (no retained data, no fine-tuning), which is why SSD and LFSSD are the baselines; both receive strictly more information than UnAct. Optimisation-based methods such as SCRUB and SalUn use labels, retained data or both. We will extend Section 2 to cover these and any further recent works in the revision. We are committed to ensuring the related work is current and the baselines are as strong as possible within our stated setting. If the reviewer has specific additional methods in mind that require neither retained data nor gradient steps at request time, we will continue to survey the recent literature and add any that fit our setting to the comparison in the revision.

A correction on our side. Prompted by Reviewer HrVt, we found that LFSSD's few-image collapse in our submission came from how its reference implementation batches importance: a uniform batch size on both the forget and training sides at the whole class, but only one small batch on the forget side at small nn. With per-image importance, as LFSSD's own paper defines it, LFSSD is safe from five images and within one point of UnAct on ResNet-18. We withdraw the claim that LFSSD collapses with few images and replace its results throughout.

SSD's few-image failure is confirmed as genuine under every batching and every threshold from 2 to 2000. No UnAct result changes. Full details are in the general response and the reply to Reviewer HrVt.

I thank the authors for their responses.

  • Regarding the new expriment presented for different seed, the SSD results for CIFAR-10 and CIFAR-20 have large sd. Can author clarify why is that so?
  • Also can authors comment why the experimental results do not include the common datasets such as TinyImageNet and backbones such as ResNet-50 and Swin-T?
  • In addition, several recent works are not discussed. As example I can mention the following (there are more...):
  1. Zhai W et al. Nullify: Null-Space Activation Steering for Training-Free LLM Unlearning. InProceedings of the 2026 Conference on Empirical Methods in Natural Language Processing 2026 Oct (pp. 20213-20225).
  2. Dehghani Z et al. A universal source-free class unlearning framework via synthetic embeddings. Transactions on Machine Learning Research. 2026;2026.
  3. Qian C et al. pH-Strips for Selective Forgetting: A Blunt but Fast Diagnostic Baseline for Machine Unlearning. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition 2026 (pp. 3306-3315).

We thank the reviewer for the follow-up and the references.

Large SSD standard deviation. The standard deviation is over three independently trained models (the paper's and two new ones), using the gold-free gap defined in Appendix O.4. SSD works on the paper's model, but its selected threshold fails on 5 of the 30 new class–model pairs: on CIFAR-10, one class collapses (retain accuracy 24%) and three are left largely unforgotten (forget accuracy 47.5%, 49.3% and 91.1%); on CIFAR-20, one class keeps 10% forget accuracy. Sweeping α from 2 to 50 (λ = 1) on both new CIFAR-10 models shows why: SSD works only in a narrow α window that moves between trained models; re-tuning recovers one model, while on the other no single α works for all five classes. SSD therefore needs re-tuning for every trained model. UnAct's percentile and attenuation factor transfer without re-tuning (std 0.09 / 0.04 / 0.42; no failure). Per-model results are in Appendix O.4 (Table 22) of the revised PDF; we will add the per-α sweep in the final version.

Datasets and backbones. We used CIFAR-10/20/100 with ResNet-18 and ViT-B/16 to match the setting in which SSD, our main baseline, was evaluated. We agree that TinyImageNet, ResNet-50 and Swin-T would strengthen the paper and will state their absence as a limitation. UnAct's ResNet score applies unchanged to ResNet-50 (its classifier also reads globally pooled channels; the incoming parameters become the last bottleneck's final convolution and BatchNorm). Swin-T pools tokens instead of using a class token, so the transformer score needs an adaptation we have not yet tested. We will add TinyImageNet with ResNet-50 in the final version.

Related work. Thank you for these references. The revised PDF now discusses all three in Section 2 (and adds pH-Strips to Table 1), together with Kodge et al. (TMLR 2024), a gradient-free class-forgetting method.

pH-Strips (Qian et al., CVPR 2026): it is training-free, needs no retain set in its base form, works from a few forget samples, and edits the model's weights. It differs in how: it removes the forget concept's feature subspace from linear-layer weights in one closed-form step, whereas UnAct ranks units by the forget signal they send to the classifier and attenuates them over several re-scored rounds, with an edit size fixed by rank. Its authors present it as a diagnostic baseline, in line with our evaluation point in Section 4.2. Its code is public, and we will add a quantitative comparison in the final version. Dehghani et al. (TMLR 2026) make existing gradient-based class-unlearning methods source-free by running them on synthetic embeddings pseudo-labelled by the model. It needs no forget data but requires the label of the forget class and runs optimisation; UnAct uses a few unlabelled forget images and no optimisation. The two are complementary. Nullify (Zhai et al., EMNLP 2026; arXiv October 2026, after our submission) unlearns in LLMs by steering hidden states at inference time under a null-space constraint built from retained data, without changing the weights; UnAct edits the weights and reads no retained data.

Reviewer_YN1wOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes UnAct, a post hoc, gradient-free class-unlearning method that operates exclusively via forward passes on a small set of forget images. Unlike existing retrain-free methods, which require backpropagation, full training-set statistics, or labels, UnAct scores late-layer units using activation/logit attribution, softly attenuates their parameters, and iterates over multiple rounds.

Critical strengths

Extreme Data Scarcity Robustness: UnAct's primary conceptual breakthrough is solving the collapse failure mode of traditional importance-ratio dampening methods when deletion requests arrive with only a few samples.

Operational Efficiency: By eliminating backpropagation, gradient tracking, and caching of global training-set importance, UnAct provides a practical, low-latency solution for frequent or dynamic privacy requests.

Critical weaknesses

Suppression vs. Erasure: UnAct effectively suppresses the target class in the output logits, but the internal features remain linearly recoverable to some degree.

Hyperparameter & Scope Adaptation: The scoring metric requires domain-aware alignment, such as activation means for standard conv layers versus token-level logit attributions for residual transformers.

The retrain-free selection rule uses the test split. A held-out validation protocol is missing.

Questions for authors

Can you select operating points on a held-out validation split (not the test set) for all methods and report results?

How sensitive is UnAct to out-of-distribution or unseen classes when transferring hyperparameters without dataset-specific tuning?

Remaining weaknesses

3 comments

Response to Reviewer YN1w (1/2)

We thank the reviewer for the careful reading and two concrete questions. We ran both experiments directly. We address each point in turn.

Q1 / W3. Operating points selected on a held-out validation split. We ran this experiment directly. We split the test set 50/50 within each class (fixed seed, saved before any run), selected every method's configuration on one half and report results on the other half. The selection half was never used in any evaluation reported in the submitted paper.

Δ\Delta on the held-out halfUnActSSDLFSSD
CIFAR-100.340.470.28
CIFAR-200.690.150.21
CIFAR-1001.060.390.24

No conclusion changes: all methods stay within about one point of retraining, with the same ordering as Table 2. Six of the nine selected configurations are identical to the submitted ones; for the other three, Δ\Delta on the held-out half moves by at most 0.1. Swapping the halves, or using the retrain-free rule of Appendix D on the validation half, gives the same picture (all Δ\Delta between 0.15 and 1.23).

Q2. Unseen classes, without re-tuning. We froze each method's validation-selected configuration and applied it to 37 classes never used for selection: the other 5 CIFAR-10 classes, the other 15 CIFAR-20 classes and 17 CIFAR-100 classes (15 drawn at random, plus the two hard classes of Appendix E). Retrained references for 37 classes could not be trained in the discussion period, so we report a gold-free gap: |retain-accuracy change from the original model| + forget accuracy. On the 15 classes where retrained models exist it differs from Δ\Delta by at most 0.82 (0.35 on average) and ranks configurations almost identically (rank correlation 0.995).

Gold-free gap, mean / worst classUnActSSDLFSSD
CIFAR-10 (5 classes)0.18 / 0.270.52 / 1.620.16 / 0.27
CIFAR-20 (15)0.46 / 1.312.69 / 26.440.30 / 0.69
CIFAR-100 (17)0.81 / 1.250.23 / 1.150.10 / 0.34

UnAct's frozen configuration holds on all 37 classes: retain accuracy never drops by more than 1.25 points and forget accuracy never exceeds 1.2%. LFSSD transfers equally well within a dataset. SSD fails on 2 of the 15 unseen CIFAR-20 classes (one left 26.4% unforgotten, one losing 6.1 points of retain accuracy).

Two harder versions of the same question separate the methods further:

  • Across datasets (configuration chosen on the other two datasets, validation half): UnAct's Δ\Delta is 1.65 / 0.69 / 4.23. SSD's is 31.35 / 0.30 / 32.32 and LFSSD's 93.91 / 0.29 / 20.88 (reference implementation), because an importance-ratio threshold does not mean the same thing on different models, whereas a percentile does.
  • Across independently trained models (two further ResNet-18s per dataset, submitted configurations, no re-tuning): UnAct and LFSSD carry over with no failure in 30 new class-model pairs. SSD's selected threshold fails on 5 of them; on one new CIFAR-10 model re-tuning the threshold recovers it, on the other no single threshold in its range works for all five classes.

We read "out-of-distribution" as classes and models outside those used for tuning; removing a class the model was never trained on is not defined in our setting.

(continued in 2/2)

Response to Reviewer YN1w (1/2)

We thank the reviewer for the careful reading and two concrete questions. We ran both experiments directly. We address each point in turn.

Q1 / W3. Operating points selected on a held-out validation split. We ran this experiment directly. We split the test set 50/50 within each class (fixed seed, saved before any run), selected every method's configuration on one half and report results on the other half. The selection half was never used in any evaluation reported in the submitted paper.

Δ\Delta on the held-out halfUnActSSDLFSSD
CIFAR-100.340.470.28
CIFAR-200.690.150.21
CIFAR-1001.060.390.24

No conclusion changes: all methods stay within about one point of retraining, with the same ordering as Table 2. Six of the nine selected configurations are identical to the submitted ones; for the other three, Δ\Delta on the held-out half moves by at most 0.1. Swapping the halves, or using the retrain-free rule of Appendix D on the validation half, gives the same picture (all Δ\Delta between 0.15 and 1.23).

Q2. Unseen classes, without re-tuning. We froze each method's validation-selected configuration and applied it to 37 classes never used for selection: the other 5 CIFAR-10 classes, the other 15 CIFAR-20 classes and 17 CIFAR-100 classes (15 drawn at random, plus the two hard classes of Appendix E). Retrained references for 37 classes could not be trained in the discussion period, so we report a gold-free gap: |retain-accuracy change from the original model| + forget accuracy. On the 15 classes where retrained models exist it differs from Δ\Delta by at most 0.82 (0.35 on average) and ranks configurations almost identically (rank correlation 0.995).

Gold-free gap, mean / worst classUnActSSDLFSSD
CIFAR-10 (5 classes)0.18 / 0.270.52 / 1.620.16 / 0.27
CIFAR-20 (15)0.46 / 1.312.69 / 26.440.30 / 0.69
CIFAR-100 (17)0.81 / 1.250.23 / 1.150.10 / 0.34

UnAct's frozen configuration holds on all 37 classes: retain accuracy never drops by more than 1.25 points and forget accuracy never exceeds 1.2%. LFSSD transfers equally well within a dataset. SSD fails on 2 of the 15 unseen CIFAR-20 classes (one left 26.4% unforgotten, one losing 6.1 points of retain accuracy).

Two harder versions of the same question separate the methods further:

  • Across datasets (configuration chosen on the other two datasets, validation half): UnAct's Δ\Delta is 1.65 / 0.69 / 4.23. SSD's is 31.35 / 0.30 / 32.32 and LFSSD's 93.91 / 0.29 / 20.88 (reference implementation), because an importance-ratio threshold does not mean the same thing on different models, whereas a percentile does.
  • Across independently trained models (two further ResNet-18s per dataset, submitted configurations, no re-tuning): UnAct and LFSSD carry over with no failure in 30 new class-model pairs. SSD's selected threshold fails on 5 of them; on one new CIFAR-10 model re-tuning the threshold recovers it, on the other no single threshold in its range works for all five classes.

We read "out-of-distribution" as classes and models outside those used for tuning; removing a class the model was never trained on is not defined in our setting.

(continued in 2/2)

Response to Reviewer YN1w (2/2)

W1. Suppression versus erasure. We agree, and the paper states this explicitly in Section 4.2, Section 5, and Appendices G and M. Two calibration points from Table 9 are important for interpreting this limitation correctly. This is true of every method compared: a linear probe recovers the class at AUROC 0.979 or higher after SSD and LFSSD as well. And the model retrained from scratch, which never saw the class, also gives 0.956 to 0.977, because features learned from the other classes already separate it. The relearning experiment (Appendix M) is a sharper test. Both UnAct and SSD recover the class faster than a retrained model learns it from the same images, confirming that neither method erases strongly. We report this openly and scope our claims accordingly throughout: UnAct suppresses the class at the output, as do SSD and LFSSD, and we use Δ\Delta only in that sense.

W2. The score depends on the architecture. Yes, and we list this as a limitation in Section 5. The underlying principle is identical in both cases: score a unit by the forget signal it sends to the classifier (Section 3.3). The implementation differs because the path from units to classifier differs:

  • ResNet-18. The classifier reads units directly through global average pooling. The unit's mean post-ReLU activation is therefore the right measure: it is exactly the feature the classifier receives.
  • ViT-B/16. Units reach the classifier only through the shared residual stream and a final LayerNorm rescaling. The activation alone does not capture a unit's contribution to the class logit. The class-token logit attribution is needed instead. It is computed entirely in the forward pass from the outgoing weights and the classifier direction, with no backward pass required (Section 3.3, Appendix L).

Within each architecture nothing is adapted across datasets: the same score and scope are used across all three ResNet-18 datasets and all five ViT-B/16 forget classes. The adaptation is a one-time architectural decision guided by a single principle, not a per-dataset tuning step.

Compared to the baselines, the adaptation burden is lighter. SSD and LFSSD also require architecture-specific adaptation: backward passes, labels or squared output norms, and full-dataset importance passes must all be tailored to each architecture's loss and output structure. UnAct's adaptation amounts to one conceptual decision about the scoring formula, described once in Section 3.3. We identify a unified cross-architecture scoring strategy as future work.

A correction relevant to the first strength you listed. Prompted by Reviewer HrVt, we found that LFSSD's few-image collapse in our submission came from how its reference implementation batches importance. With per-image importance, as LFSSD's own paper defines it, LFSSD is safe from five images and within one point of UnAct on ResNet-18. We withdraw the claim that LFSSD collapses with few images and replace its results throughout.

This correction is relevant to the first strength you identified. SSD's few-image failure is confirmed as genuine under every batching and every threshold. UnAct's distinguishing property is therefore its information requirement (forward passes on the forget images only, no training-set gradients), together with its robustness across trained models and datasets shown above. Full details are in the general response and the reply to Reviewer HrVt.

Reviewer_HrVtOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

UnAct scores late units through forward passes, attenuates their incoming and outgoing weights, and iteratively reranks them; ViT uses pseudo-labels and direct logit attribution. Experiments on ResNet-18 across three CIFAR tasks and ViT-B/16 on CIFAR-10 examine few-image class suppression, retained accuracy, sequential requests, runtime, and relearning.

Critical strengths
  1. At request time, no gradients, retained data, or ground-truth labels are needed. With five images, Table 10 reports Δ=0.21/0.77/1.37 across the three ResNet tasks, supporting class suppression with limited data access.

  2. Appendices G, M, and N distinguish output suppression from feature recoverability and show that iteration expands edit coverage. These diagnostics clarify what accuracy results establish.

Critical weaknesses
  1. Internal editing's benefit over simple masking remains unclear: Table 9 (p.18) reports CIFAR-20/100 Δ=0.25/0.33 for logit masking versus 0.79/1.14 for UnAct, and CIFAR-10 prediction agreement with retraining is 62.4% versus 31.4%. Although masking requires a class index and the paper acknowledges Δ's limited meaning, ViT already infers that index (§3.3). The added complexity therefore needs stronger justification.

  2. Batch-size effects remain unresolved: Appendix B (p.13) takes the absolute batch-mean gradient for LFSSD, rather than averaging per-sample absolute gradients. At small n, unequal effective batch sizes could change importance scales; Table 11 retunes SSD's α while fixing batch size and λ. This limits attribution of the gap, without establishing an implementation error.

Questions for authors
  1. With identical few-image inputs, what existing evidence or applicability distinction favors UnAct over logit masking using the pseudo-label from §3.3?

  2. What batching and normalization formulas are used for SSD/LFSSD at n=5 and with the full class, and which existing controls address scale differences caused by effective batch sizes?

3 comments

Response to Reviewer HrVt (1/3)

Thank you for a precise review. Both concerns were fair. We ran the control you described, and your hypothesis is correct for LFSSD. We address each point in turn.

1. Batch-size effects (W2, Q2)

Formulas used in the submission (your Q2). We followed the authors' reference code. A loader splits a set of images into MM batches B1,…,BMB_1, \dots, B_M of size bb (the last may be smaller). For each parameter θi\theta_i:

SSD: [D]i=1M∑m=1M(∂∂θi1∣Bm∣∑x∈BmℓCE(x,y))2\text{SSD: } [D]_i = \frac{1}{M} \sum_{m=1}^{M} \left( \frac{\partial}{\partial \theta_i} \frac{1}{\lvert B_m \rvert} \sum_{x \in B_m} \ell_{\text{CE}}(x, y) \right)^2

LFSSD: [D]i=1M∑m=1M∣∂∂θi1∣Bm∣∑x∈Bm∥f(x)∥22∣\text{LFSSD: } [D]_i = \frac{1}{M} \sum_{m=1}^{M} \left\lvert \frac{\partial}{\partial \theta_i} \frac{1}{\lvert B_m \rvert} \sum_{x \in B_m} \lVert f(x) \rVert_2^2 \right\rvert

The same estimator gives [Df]i[D_f]_i on the forget images. Both methods then dampen:

θi←min⁡(λ[D]i[Df]i,1)θiif [Df]i>α[D]i\theta_i \leftarrow \min\left( \lambda \frac{[D]_i}{[D_f]_i}, 1 \right) \theta_i \quad \text{if } [D_f]_i > \alpha [D]_i

The only normalisation is the batch mean inside the derivative and the 1/M1/M average over batches; there is no per-image normalisation and no rescaling between the two sides.

Training-set side, [D][D]Forget side, [Df][D_f]
Whole classall 50,000 images, batch bbthe whole class (5,000 / 2,500 / 500 images), batch bb
n=5n = 5unchanged: all 50,000 images, batch bbone batch of 5 (M=1M = 1)

with b=64b = 64 for LFSSD and b=256/512/64b = 256 / 512 / 64 for SSD on C10 / C20 / C100. So at the whole class both sides use batch bb, while at n=5n = 5 they do not. Writing the per-image gradient as mean μi\mu_i plus noise of variance σi2\sigma_i^2, the batch-mean estimator has E[(gˉB)2]≈μi2+σi2/b\mathbb{E}[(\bar{g}_B)^2] \approx \mu_i^2 + \sigma_i^2 / b. At n=5n = 5 the forget side therefore carries a noise term about b/5b/5 times larger than the training-set side, which is exactly the effect you describe. LFSSD's own paper (its Eq. 3) defines the per-image average 1N∑k∣∂∥f(xk)∥22/∂θi∣\frac{1}{N} \sum_k \left\lvert \partial \lVert f(x_k) \rVert_2^2 / \partial \theta_i \right\rvert, which does not depend on batch size; the SSD paper defines a Fisher diagonal without fixing its batching. Following the reference code is standard practice, and the submitted implementation matches what the authors published and validated. The batch-size dependence of both reference implementations is now reported as a finding of the paper.

Existing controls (your Q2, second part). None in the submission addressed this directly. Table 11 re-selects α\alpha at each nn with the retrained model as an oracle, which would absorb a uniform rescaling of the forget-side importance, but not this one: the noise term inflates the noisiest parameters most, so it changes their ranking, not only the scale. We therefore ran the control below.

Control. Same models, classes and forget images. One batch size bb on both sides, b∈{1,5,64,128}b \in \lbrace 1, 5, 64, 128 \rbrace; α∈[2,2000]\alpha \in [2, 2000]; n∈{1,5,10,25,whole class}n \in \lbrace 1, 5, 10, 25, \text{whole class} \rbrace; 4,500 configurations per method. λ\lambda stays at each method's selected value (as in Table 11); the batch size, which Table 11 held fixed, is now varied. b=1b = 1 is LFSSD's Eq. 3. As in the paper, α\alpha is chosen once at the whole class and reused at every nn.

Δ\DeltaMethodn=5n = 5n=10n = 10n=25n = 25whole class
C10UnAct0.210.190.100.08
LFSSD, per image0.450.280.290.16
LFSSD, submitted67.0739.400.740.11
SSD, best bb and α\alpha at each nn52.355.136.60.29
C20UnAct0.770.730.790.79
LFSSD, per image0.300.300.250.25
LFSSD, submitted7.552.560.350.24
SSD, best bb and α\alpha at each nn40.540.721.00.27
C100UnAct1.371.241.221.14
LFSSD, per image0.400.390.370.40
LFSSD, submitted0.440.390.390.38
SSD, best bb and α\alpha at each nn15.714.41.10.50

(SSD's whole-class column is its submitted configuration, as in Table 2. Its other columns are an oracle: the best over all four batch sizes with α\alpha tuned separately at each nn against the retrained model.)

(continued in 2/3)

Response to Reviewer HrVt (2/3)

LFSSD: you are right. With per-image importance LFSSD no longer collapses from n=5n = 5 and is within one point of UnAct on every dataset: on par on C10, and closer on C20 and C100 by the margin it already had at the whole class (Table 2). The collapse in Figure 2 and Table 10 is a property of the reference implementation's batching. We withdraw the statement that LFSSD collapses with few images and replace its results with the per-image version.

SSD: the failure is not a batching effect. SSD fails at n≤10n \le 10 at every bb, even with the oracle threshold above. Per-image SSD also fails at the whole class on C10 and C20 (Δ\Delta = 38.21 and 13.12), so no single batching serves both regimes.

UnAct's results are unchanged, and stable across draws. We redrew the forget images (same images for every method within a draw):

Δ\Delta, mean ±\pm std over drawsn=1n = 1, UnActn=1n = 1, LFSSD per imagen=5n = 5, UnActn=5n = 5, LFSSD per image
C103.87±2.793.87 \pm 2.798.71±8.808.71 \pm 8.800.17±0.050.17 \pm 0.050.23±0.190.23 \pm 0.19
C205.76±2.285.76 \pm 2.2815.77±10.2415.77 \pm 10.240.89±0.100.89 \pm 0.101.56±1.221.56 \pm 1.22
C10010.31±2.3410.31 \pm 2.342.65±1.752.65 \pm 1.751.33±0.061.33 \pm 0.060.42±0.020.42 \pm 0.02

(UnAct 4 draws, LFSSD 3. SSD at n=5n = 5 averages 87.6 / 69.6 / 40.5 over 4 draws and is never below 19 on any draw.)

What we now claim at n=1n = 1 versus n=5n = 5. Our submitted value of 1.72 for UnAct on CIFAR-10 at n=1n = 1 was a favorable draw (mean 3.87±2.793.87 \pm 2.79). We withdraw this as a point claim and will report n=1n = 1 as a mean over draws in the revised paper. We do not stake our central claims on n=1n = 1: a single image is noisy for every method, and we say so explicitly. Our central few-image claim rests on n=5n = 5, where UnAct's Δ\Delta is 0.17±0.050.17 \pm 0.05 / 0.89±0.100.89 \pm 0.10 / 1.33±0.061.33 \pm 0.06 across draws, stable and consistent across all three datasets. From five images the two methods are comparable, with UnAct more consistent on CIFAR-10 and CIFAR-20 and per-image LFSSD closer on CIFAR-100.

The failure modes at n=1n = 1 differ in character. UnAct's retain accuracy is never more than 3.03 points below retraining in any of 263 runs: when it misses, it leaves part of a class unforgotten rather than damaging the retained classes. Per-image LFSSD lost 61, 26 and 12 points of retain accuracy on individual classes at n=1n = 1.

LFSSD on ViT-B/16 (missing in the submission). We ran it with batch 5 on both sides, chose one setting at the whole class by mean Δ\Delta over the five classes (α=5,λ=0.1\alpha = 5, \lambda = 0.1), and applied it unchanged at each nn, as for the other methods.

Δ\Delta, ViT-B/16n=5n = 5n=10n = 10n=25n = 25whole class
UnAct12.6312.7011.3711.47
LFSSD, matched batches31.6624.1825.0223.29
SSD96.1298.20110.6433.74

LFSSD keeps retain accuracy here (98.1 to 98.5%) but leaves the class recognised on 23 to 31% of its test images on average; UnAct's forget accuracy is 4.9 to 7.1% at a cost of about 5.5 to 6.5 points of retain accuracy. Four caveats. (i) LFSSD's grid was small (α∈{2,5,10,25,50}\alpha \in \lbrace 2, 5, 10, 25, 50 \rbrace, λ∈{0.1,1}\lambda \in \lbrace 0.1, 1 \rbrace) and its best region lies between α=2\alpha = 2 and 5, so a finer grid may improve it. (ii) With a separate setting per class, which needs a retrained model per class, LFSSD would be about level with UnAct at the whole class (11.9 against 11.5). (iii) At n=1n = 1 (UnAct 22.38, LFSSD 65.69) the forget side is a single image against batches of 5, so that point is not matched and we draw no conclusion from it. (iv) SSD's ViT few-image runs use a fixed batch of 128; we repeated the SSD batch-size control on ResNet-18 only, where it changed nothing. Table 2 reports UnAct's whole-class value as 11.49 from a separate run.

What the paper now claims. From five forget images UnAct matches a correctly batched LFSSD on ResNet-18 and is far closer to retraining than SSD, using forward passes on those images alone. LFSSD needs, for each model, a backward pass over the whole training set (computed once and stored, as its paper describes) and backward passes at request time; UnAct needs neither. That pass is small on a CIFAR-scale ResNet (about 11 to 12 minutes with per-image batches on a shared GPU, under a minute at batch 64) and not small beyond it: on our ViT-B/16 the equivalent pass for SSD takes 1,248 s at batch 128 (Section 4.1), and matched batches take several times longer, against 73 s for a complete UnAct request. We will report the batch-size dependence of both reference implementations as a finding of the paper.

(continued in 3/3)

Response to Reviewer HrVt (3/3)

2. Logit masking versus UnAct (W1, Q1)

Your figures are right, and we agree with more of this point than we dispute.

Direct answer to Q1. With identical few-image inputs, no existing evidence shows UnAct closer to retraining than a pseudo-label mask on the accuracy metrics, and we do not claim it is. The pseudo-label is as easy to obtain from five images as from the whole class, and our mask measurements (Table 9) are at the whole class; we have not measured the mask at n=5n = 5. What favours UnAct is applicability, plus one existing measurement of where the edit lives, both set out below: the mask leaves the model unchanged, while UnAct edits it.

What we concede. On Δ\Delta the mask matches or beats UnAct (0.09 / 0.25 / 0.33 against 0.08 / 0.79 / 1.14). It agrees with the retrained model on forget images more often (62.4 / 46.0 / 45.0% against 31.4 / 28.4 / 27.8%). The class index is not a real barrier: one forward pass on the forget images gives it, as in §3.3. If the only requirement is that a served model never outputs the class, a mask is sufficient, and the revision states this explicitly.

Why the row is in the paper. The mask sets forget accuracy to zero and can only raise retain accuracy, so its Δ\Delta is near-optimal by construction. It is as close to retraining as the published baselines (SSD 0.29 / 0.26 / 0.51, LFSSD 0.11 / 0.24 / 0.38). We included it to show that Δ\Delta, the standard metric here, cannot distinguish an output filter from a genuine edit of the model. That holds for every method in Table 9: the finding is a calibration of the metric, not a claim about UnAct specifically.

The distinction, with existing evidence.

Logit maskUnAct
What is changedone classifier row and bias (0.005% of parameters)last residual block and classifier columns (4.80 / 4.95 / 2.18%)
Penultimate featuresidentical to the original modeledited
Forget accuracy with the original classifier put back93.3 / 89.0 / 81.0% (the original model, by construction)51.7 / 21.2 / 20.6% (Table 9, "In only" row)
To undo, given the weightsremove the maskidentify the edited units and factor, or fine-tune on labelled forget images

The third row is already in Table 9: the "In only" model is UnAct's edited feature extractor with the original classifier. So UnAct's edit is in the representation the classifier reads, whereas the masked model is the original model with one output hidden. This matters when the model itself is released, copied or built upon, which is the setting SSD, LFSSD and our paper address. Our requirements claim is accordingly made among methods that edit the model; an output filter needs less, and we name it as the lower bound.

What we do not claim. UnAct does not erase the class. A refitted linear probe recovers it as well as from the masked model (0.991 / 0.989 / 0.985 against 0.992 / 0.991 / 0.981), and fine-tuning restores much of it within 10 to 20 steps (Appendix M). The mask was not part of our relearning experiment, so we make no relearning comparison with it. UnAct's lower agreement with retraining arises because it scales classifier columns shared with neighbouring classes (the "Out only" row reproduces it with the features untouched); it counts against UnAct, as Appendix G states.

Changes. The mask is presented in Table 9 as a reference alongside the original and retrained models, with the classifier-restoration row added; §4.2 and the Limitations state that an output filter suffices when only served predictions matter; "AUROC of at least 0.98" is corrected to "0.979 or higher".

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response: new experiments, one correction, and what the paper claims

We thank the reviewers for careful and constructive reviews. We ran seven new experiments in response. They lead to one correction and otherwise strengthen the paper. A revised PDF with changes marked will follow.

What the paper claims after revision UnAct removes a class from a trained classifier using forward passes on as few as five unlabelled forget images, with an edit whose size is fixed in advance. It matches the best gradient-based dampening method where that method works, stays safe where SSD does not, and its single configuration keeps working when the forget images, the classes, the trained model or the selection split change. It needs none of the training-set gradient computation that SSD and LFSSD depend on. Like those methods, it suppresses the class at the output and does not erase it.

One correction (raised by Reviewer HrVt) Our submission reported that LFSSD collapses with few forget images. A full batch-size control (4,500 configurations per baseline) shows that this came from how LFSSD's reference implementation batches its importance. Following reference implementations is standard practice, and the submitted code matches what the LFSSD authors published and validated. The batch-size dependence of both reference implementations is now reported as a finding of the paper rather than as correct behavior. Computed per image, as the LFSSD paper's own equation defines it, LFSSD is safe from five images and within one point of UnAct. We withdraw the claim that LFSSD collapses with few images and replace its few-image results throughout. The same control confirms that SSD's failure is genuine: it persists under every batching and every threshold from 2 to 2000. No UnAct result changes.

Suppression, erasure and the logit mask (all three reviewers). All three reviews note that UnAct suppresses the class without erasing it. We agree, and the submission says so (Limitations; Appendices G and M). Appendix G shows the same for every method we tested: a linear probe recovers the class at AUROC 0.979 or higher after SSD, LFSSD and UnAct, and at 0.956 to 0.977 even from a model retrained without the class, while a trivial logit mask is as close to retraining on the standard accuracy metric as any method. We report these as a calibration of how class unlearning is evaluated. Our claims are limited to output-level forgetting by an edit of the model, and we make no privacy or erasure claim.

New experiments

ExperimentAsked byResult
Batch-size control for SSD and LFSSDHrVtLFSSD repaired by per-image importance; SSD not repaired by anything
LFSSD on ViT-B/16 (missing in the submission), matched batchesHrVtUnAct closer to retraining from five images upward
Selection on a held-out validation halfYN1w, FUjVNo conclusion changes
37 unseen classes, frozen configurationsYN1wUnAct: no failure, worst gap 1.31
Two further trained models per datasetFUjVUnAct's configuration carries over with no failure; SSD's does not
Redraws of the forget images at n=1,5,10n = 1, 5, 10FUjV, HrVtUnAct stable from five images; a single image is noisy for every method

Summary table (ResNet-18 unless stated; C10 / C20 / C100 = CIFAR-10 / CIFAR-20 / CIFAR-100; Δ\Delta = distance to the retrained model in points, lower is better; means over the paper's five forget classes).

UnActSSDLFSSD
Needs training set and gradientsnoyesyes
Five forget images, Δ\Delta0.21 / 0.77 / 1.3789.85 / 72.95 / 46.14; best case over all batchings and thresholds 52.3 / 40.5 / 15.7per image 0.45 / 0.30 / 0.40; reference implementation 67.07 / 7.55 / 0.44
Five images, mean ±\pm std over draws0.17±0.050.17 \pm 0.05 / 0.89±0.100.89 \pm 0.10 / 1.33±0.061.33 \pm 0.0687.6 / 69.6 / 40.5 (lowest single draw 19.3)per image 0.23±0.190.23 \pm 0.19 / 1.56±1.221.56 \pm 1.22 / 0.42±0.020.42 \pm 0.02
Validation-selected, Δ\Delta on the held-out half0.34 / 0.69 / 1.060.47 / 0.15 / 0.390.28 / 0.21 / 0.24
37 unseen classes: failures; worst gap0; 1.312; 26.440; 0.69
New trained models (30 class-model pairs): failures050
Configuration from the other two datasets, Δ\Delta1.65 / 0.69 / 4.2331.35 / 0.30 / 32.3293.91 / 0.29 / 20.88 (reference implementation)
ViT-B/16, five images / whole class, Δ\Delta12.63 / 11.4996.12 / 33.7431.66 / 23.29

Notes. Draws: 4 for UnAct and SSD, 3 for per-image LFSSD, same images within a draw. Unseen classes and new trained models have no retrained references, so they use a gold-free gap,

gap=∣RetainAccunlearned−RetainAccoriginal∣+ForgetAccunlearned\text{gap} = \left| \text{RetainAcc}^{\text{unlearned}} - \text{RetainAcc}^{\text{original}} \right| + \text{ForgetAcc}^{\text{unlearned}}

On the 15 classes where both exist, it differs from Δ\Delta by at most 0.82 (0.35 on average). "Failure" means gap>5\text{gap} > 5. ViT-B/16 details and caveats are in the reply to Reviewer HrVt; the ViT results remain preliminary.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.