acceptodds
Under review as a conference paper at ICLR 2027

AliasGuard: Surrogate-Based Defense Against Passive Inference in Split Language Model Fine-Tuning

Abstract

Split learning (SL) is often treated as a privacy-preserving way to fine-tune language models (LMs) without exposing clients' private training tokens. In split-based LM fine-tuning (SL-FT), however, an honest-but-curious (passive) server can leverage smashed data in the forward pass and gradients in the backward pass to infer these private tokens in training sequences. Under the passive inference, current defenses face a trade-off: they cannot protect these private tokens while retaining training utility. To mitigate this trade-off, we present AliasGuard, a surrogate-based defense. Specifically, AliasGuard generates surrogates from the unprotected context of a sequence and uses these surrogates to construct the training sequences and one-hot vectors for computing smashed data and gradients. We prove that AliasGuard's smashed data and gradients provide no additional information about private tokens beyond the unprotected context. We also bound changes in smashed data at unprotected-token positions. We evaluate AliasGuard under three corpora and three models. Under adaptive inference attacks, AliasGuard reduces private-token recovery by 67.4-99.6% relative to the lowest baseline rate, while retaining much of No Defense baseline's task utility.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
split learning, language models, privacy-preserving fine-tuning, passive inference attacks, privacy-preserving machine learning, LLM fine-tuning

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_H3X3OpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

Existing defenses face a dilemma: they cannot protect private tokens while retaining training utility. To address this, the authors propose ALIASGUARD, a surrogate-based defense. The client first identifies the private tokens in each training sequence and removes them, leaving the unprotected context C. An external language model then generates surrogate replacements for the private tokens using only C. The client runs each selected surrogate sequence through the head and averages the resulting smashed data; it likewise averages the surrogates’ one-hot labels to compute the gradients. Empirically, BF recovery of private tokens drops from about 83–100% for the baselines to 0.35–30.7% (Table 1a), while task utility is largely retained.

Critical strengths

The problem is real. Passive inference in split-learning fine-tuning is a real threat. The paper clearly explains why existing perturbation defenses fail: each one leaves either the forward or the backward channel exploitable.

Good empirical privacy results on the evaluated datasets. Across three datasets and three models, BF recovery of private tokens drops from about 83–100% for the baselines to 0.35–30.7% (Table 1a).

Formal privacy guarantees. The authors provide theoretical and empirical proofs of their method.

Critical weaknesses

My main concerns are novelty, experiments, and scope.

Specifically, the work lacks novelty. Replacing the critical token is a well-known method, even in the unlearning domain.

Second, the experiments are small-scale. The largest model is Qwen2.5-3B, and each run trains on only 169 sequences.

Finally, the scope is limited. The method requires accurate private-token detection beforehand and cannot be extended to coding, math, or other domains.

Questions for authors

Can you report utility with larger models, larger training sets, and more seeds? Can you justify your novelty?

3 comments
AuthorsOpenReview ↗

The methodological novelty of AliasGuard

We thank the reviewer for raising this important question. Although surrogate replacement (SR) has been explored in machine unlearning and text anonymization, AliasGuard uses it differently in split learning (SL). We explain four crucial differences: the purpose of SR, the computation path, the training objective, and the resulting task utility and computational cost. The four differences give the benefits: AliasGuard provides an efficient training path, while maintaining the training utility and data privacy.

The purpose of SR

  • As for unlearning, the trained model knows the confidential fact stated in SS = “Alice was born in the USA”, where SS is a sequence. The goal of unlearning is to let the model forget that Alice was born in the USA, while the model must still recognize Alice and the USA.
  • As for text anonymization, the text contains the sequence SS. Its goal is to anonymize SS to generate S′S'. Thus, attackers who see S′S' are less likely to identify Alice.
  • As for AliasGuard in SL, the training sequences contain SS. Its goal is that, after observing all smashed data, gradients, and server states during training, attackers cannot learn additional information about the private tokens in SS beyond the permitted context CC, where CC is “was born in the USA” in this context.

Computation path

  • In unlearning, it needs to generate NN surrogate versions of SS. For example, the three surrogate sequences are “Bob was born in the USA”, “Carol was born in the USA”, and “David was born in the USA”. With the original model fixed, it performs three forward passes using the three sequences, obtaining the probabilities of “USA” as 10%, 20%, and 30%, respectively. It then averages the three probability distributions and uses SS as input to a trainable copy of the model, which initially predicts “USA” with a probability of 95%. It performs one backward pass to move this probability 95% toward (10+20+30)%/3=20%, while matching the other next-word probabilities. Thus, it needs NN+1 forward passes.

  • In text anonymization, it uses a privacy evaluator, a utility evaluator, and an optimizer to repeatedly change SS into S′S'. Thus, it computational path is not related to model training.

  • In AliasGuard, users execute NN forward passes through the Head, obtaining NN Head outputs, i.e., NN smashed data. They average the NN outputs into one Head output, together with the corresponding training labels. The server uses this output to compute one forward pass through the Trunk, obtaining a Trunk output, whereas the user uses the Trunk output to compute one forward pass through the Tail.

Objectives

  • In unlearning, the original model predicts “USA” with probabilities of 10%, 20%, and 30% after “Bob/Carol/David was born in”, respectively. Their average is 20%. Another model, initially predicting “USA” with 95% probability after “Alice was born in”, is trained to move its prediction toward 20% while matching the other averaged word probabilities.

  • In text anonymization, the objective is to change SS into S′S' so that Alice is difficult to identify.

  • In standard multi-surrogate SL that is directly deduced from the unlearning paradigm, the model computes a loss for each of the NN surrogate sequences and averages these losses:

\mathrm{CE}(h(g(f(X_k))),Y_k).$$ - AliasGuard instead averages the $N$ Head outputs and their labels before computing one loss: $$L_{\mathrm{AG}}= \mathrm{CE}\left( h\left(g\left(\frac1N\sum_{k=1}^{N}f(X_k)\right)\right), \frac1N\sum_{k=1}^{N}Y_k \right).$$ Here, $f$, $g$, and $h$ are the Head, Trunk, and Tail; $X_k$ and $Y_k$ are each surrogate sequence and its training labels. Averaging before the Trunk and loss calculation is generally different from averaging $N$ complete losses. **Therefore, AliasGuard changes the training objective, raising the question of whether it can preserve task utility while reducing computation.** **Task utility and computational cost** On DialogSum, we compared AliasGuard with standard surrogate replacement using identical sets of three surrogates and three paired random seeds. - AliasGuard achieved higher ROUGE-L in all three seeds, averaging 39.931 versus 39.358 on standard surrogate replacement. Thus, changing the training objective did not reduce AliasGuard’s task utility in these experiments. - Meanwhile, update time decreased from 796.12 to 341.88 ms (2.33× faster), and communication decreased from 7.310 to 2.437 MiB (66.7% less). These results demonstrate that AliasGuard can reduce SL training costs while maintaining comparable task utility, despite using an more efficient training objective.
AuthorsOpenReview ↗

Adding experiments with larger models, longer training, and more seeds

We have completed GSM8K experiments with larger models, longer training, and more seeds.

First, we extend the evaluation from Qwen2.5-3B to Qwen3.5-9B. Each run performs 2,048 updates on 2,048 distinct training sequences, 12.1 times the original 169 sequences. We compare AliasGuard and NoDef across five paired random seeds, giving ten completed runs.

Second, we test whether attackers can recover private tokens. F uses smashed data (the Head’s output) and the Trunk’s output; B uses gradients from the backward pass; BF uses both. Recovery is the percentage of private-token positions guessed correctly. We evaluate 546 positions in 128 training sequences. Averaged across five seeds, recovery falls from 43.63% with NoDef to 1.87% with AliasGuard for F, from 18.94% to 1.03% for B, and from 47.95% to 1.87% for BF.

For task utility, we measure the percentage of correct answers on all 1,319 GSM8K test questions. Averaged across five seeds, AliasGuard answers 23.11% correctly, versus 22.71% for NoDef.

The above results demonstrate that the conclusion of original manuscript still holds under larger models, longger training and more seeds.

The reviewer first raises the limitation of accurate private-token detection. However, many data owners can identify sensitive information before training. For example, hospitals, banks, and enterprises can mark patient names, account numbers, and confidential identifiers. Clients in split learning and federated learning can likewise identify private tokens in their own sequences. Thus, accurate private-token identification is a practical requirement that can be met across multiple application domains. Investigating how to use this information for privacy protection is valuable, and this work provides an example under SL.

We then address the reviewer's concern that the method cannot be extended to coding, math, or other domains. In these domains, models need to learn general knowledge and task-specific rules. During SL fine-tuning, our goal is to allow models to learn these rules while protecting private information in the training sequences. For example, companies' source code may contain confidential identifiers that are not necessary for learning how functions work. The reviewer's unlearning and other domains also need the trained models to forget the confidential identifiers without forgetting the general knowledge. SL fine-tuning does this at the training duration.

Coding: We tested AliasGuard on CodeAlpaca-H4. Our goal is to protect private identifiers without preventing models from learning the logic of functions in code. We evaluate generated code using lexical F1 (word overlap), together with Python grammar and compilation checks (Appendix G.3). The results in Table 1 demonstrate AliasGuard's ability to support code generation while protecting designated private identifiers.

Math: GSM8K evaluates mathematical reasoning while protecting person names and preserving numerical quantities. In our new 9B experiment, attackers using smashed data and gradients correctly recovered 47.95% of private-token positions with NoDef, compared with 1.87% with AliasGuard, averaged across five paired seeds. Together with Table 1, these results demonstrate that AliasGuard can protect person names during mathematical fine-tuning.

Other domains: We also tested dialogue summarization on DialogSum. Our goal is to train the model to summarize conversations while protecting person names. AliasGuard replaces these names and preserves the other words. With Qwen2.5-1.5B, AliasGuard achieves a ROUGE-L score of 41.57, compared with 41.19 for NoDef (Table 1). ROUGE-L measures word-sequence overlap between generated and reference summaries. These results demonstrate that AliasGuard can also support dialogue summarization.

In summary, our objective is to protect designated private tokens, not to prevent models from learning general mathematical, scientific, or programming knowledge.

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

AliasGuard addresses the problem of attackers reconstructing private tokens from activations and gradients during split language model fine-tuning. It uses the unprotected context and protected-span metadata to generate length-matched "surrogates." These surrogates replace private content in both the input sequences and next-token labels. Before the trunk/tail computation, the head outputs of the selected surrogate sequences are averaged, and their label distributions are also averaged for computing the training loss. Experiments on three corpora and three models show substantial reductions in private-token recovery under the evaluated attacks, although some task-dependent utility losses remain.

Critical strengths
  1. AliasGuard addresses privacy leakage in both communication directions by replacing private inputs and their corresponding next-token labels. This design is logically coherent and supported by useful evidence about the role of each component.
  2. Theorem 3 extends the conditional privacy argument across training updates, imposing explicit constraints on the initial state, randomness, and subsequent computations. Furthermore, distinguishing between additional information leakage and correct context-based guesses makes the privacy guarantee easier to interpret.
Critical weaknesses
  1. Regarding the contribution of the method, a question that remains not fully clarified is: how much incremental value does this approach provide compared to a simple substitution method? Constructing a "baseline trained under matched conditions"—employing a simple substitution scheme that maintains structural validity and matched protected-span token lengths—would allow for a more direct quantification of the specific contribution of "context-compatible generation" to the final utility.
  2. Conclusions regarding utility require more robust support across various training conditions. In the experiments, GPT-2 underwent 154 updates, while Qwen underwent 169. As shown in Table 1(a), for the Qwen2.5-1.5B model, the accuracy on the GSM8K task is 36.62% for "NoDef" and 31.31% for "AliasGuard"; for the Qwen2.5-3B model, the figures are 51.33% and 40.56%, respectively. While the matched three-seed studies are valuable, conducting longer-duration, matched experiments would help further verify the stability and limits of utility preservation.
  3. Certain empirical results should be interpreted with caution. The "ineffective refinement steps" mentioned in Appendices E.6 and E.8 limit the conclusions that can be drawn from unchanged reconstruction predictions under "HIGH". Other variations, such as differences in information access, computational budget, and baseline configurations—require further clarification.
Questions for authors
  1. Beyond the existing K′=1,3,5K'=1, 3, 5 comparisons, could you train one simple replacement baseline under matched conditions, using structurally valid replacements with matched protected-span token lengths? This would isolate the utility gained from context-compatible surrogate generation without presuming that averaging is necessary for privacy.

  2. Could one representative Qwen setting receive a longer matched NoDef–AliasGuard training experiment? Please report generated-task utility and reconstruction results. If this is infeasible, please explicitly scope the utility conclusions to the reported training budgets and clarify the sources of study-to-study variation noted in Appendix B. 4.

  3. Under the same target sequences and information access, how does a capable context-only (C-only) reconstruction baseline compare with inference using both context and the communication transcript? Please distinguish effective candidate-search results from unchanged refinement iterations, and clarify whether a limited comparison with matched hyperparameter-tuning budgets changes the ordering of the evaluated methods.

  4. Could the main text more prominently summarize the full-context conditioning and protected-span metadata assumed by the privacy guarantee? Please also clarify which test sequences are covered by the unprotected-token metrics and how their private-token positions are identified.

5 comments
AuthorsOpenReview ↗

Answer the first question, namely comparing one simple replacement baseline with our context-based replacement

We compared context-based replacement with random replacement. The random replacement uses the surrogates with the same token length and semantic meaning of private data. Other settings of the both replacement methods are the same. In one DialogSum [7] dialogue, the speaker mentions working as a “waitress”, and the summary uses “she”. Context-based replacement chose Beth, Laura, and Maria. Random replacement chose Edward, Ben, and Justin.

The model predicted each next summary token from the dialogue and the preceding reference tokens. We measured loss on tokens outside the names. Averaged over each method’s three names, the loss fell from 0.783 with random replacement to 0.287 with context-based replacement (63.4%). The names chosen from context fit the pronoun and role, while random replacement cannot achieve it due to missing contextual information. The results indicate that context matters when task utility needs the surrogates to match the meaning provided by context. Apparently, random replacement cannot provide this benefit for improving task utility.

Reference

[7]Chen et al. DialogSum: A Real-Life Scenario Dialogue Summarization Dataset. Findings of ACL-IJCNLP, 2021.

AuthorsOpenReview ↗

Responses for the second question, i.e., more training steps

We extend the GSM8K [8] evaluation from Qwen2.5-3B [12] to Qwen3.5-9B [13]. Each run performs 2,048 updates on 2,048 distinct training sequences, 12.1 times the original 169 sequences. We compare AliasGuard and NoDef across five paired seeds using the same sequences and order within each pair, giving ten runs.

F uses smashed data (the Head’s output) and the Trunk’s output. B uses backward observations including gradients, and BF uses both. Recovery is the percentage of private-token positions guessed correctly. We score 546 positions across 128 training sequences using observations from their recorded training updates. For task utility, we score the numerical answers generated for all 1,319 GSM8K test questions. The table reports means across five seeds.

MethodF recovery (%)B recovery (%)BF recovery (%)Test accuracy (%)
NoDef43.6318.9447.9522.71
AliasGuard1.871.031.8723.11

AliasGuard’s mean test accuracy is 0.39 percentage points higher (paired 95% CI [−2.41,3.20][-2.41, 3.20]). The results therefore show that the conclusion of our original manuscript still holds under larger models and more training steps.

References

[8] Cobbe et al. Training Verifiers to Solve Math Word Problems. arXiv:2110.14168, 2021.

[12] Yang et al. Qwen2.5 Technical Report. arXiv:2412.15115, 2024.

[13] Qwen Team. Qwen3.5-9B. Official model card.

AuthorsOpenReview ↗

Why HIGH leaves AliasGuard’s reconstruction predictions unchanged

The reason is due to our design illustrated in the following. Consider two versions “Alice was born in the USA” and “Bob was born in the USA”. If the two private names have the same token length, the sequences have the same unprotected context CC. It contains “was born in the USA” and the position and token length of the name.

AliasGuard generates and selects surrogates using only CC and random choices independent of the private tokens given CC. Suppose the same random choices select surrogates including Carol, David, and Emma. Both versions then produce “Carol was born in the USA”, “David was born in the USA”, and “Emma was born in the USA”. The Head processes these sequences to produce Z1Z_1, Z2Z_2, and Z3Z_3. The client sends their average Z′=Z1+Z2+Z33Z'=\frac{Z_1+Z_2+Z_3}{3} to the server and averages the corresponding one-hot labels for training. In summary, although both versions private tokens are different, they generate the same surrogates, and smashed data. Their same smashed data and training labels lead to the same trunk outputs, tail outputs, and gradients, yielding the same transcript. Thus, both versions with different private tokens have the same transcript.

The same transcript can therefore represent different private tokens, so the mapping is non-injective. Theorem 3 shows that, given the full training context, the transcript adds no information about the private tokens beyond context CC. In the tested BF/HIGH evaluator, changing the guess leaves the loss unchanged. Extra HIGH iterations therefore keep the decoder’s initial prediction (Appendices E.6 and E.8).

Reviewer_DN1zOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates inference attacks against split-learning-based fine-tuning of LMs, where a server attempts to reconstruct private tokens from smashed data and gradients. The authors propose AliasGuard, which removes designated private tokens (e.g., person names and code identifiers), generates surrogate tokens based on the remaining context using an external language model, and trains on the resulting surrogate sequences by averaging their smashed data and replacing labels at private positions with averaged one-hot vectors of the surrogates. Experiments across multiple datasets and models demonstrate that AliasGuard substantially reduces private-token recovery under adaptive attacks while preserving task utility.

Critical strengths
  1. The paper clearly explains how both the forward and backward signals leak private tokens in split fine-tuning, and the problem is well motivated.
  2. The method is simple, easy to implement, and adds little training overhead.
  3. The evaluation considers adaptive attacks that combine both signals, and the fixed-context test provides a clear sanity check of the privacy claim.
Critical weaknesses
  1. AliasGuard replaces private tokens with surrogates generated solely from the unprotected context, so the original private tokens are no longer used to compute training signals. The privacy guarantee largely follows from this construction rather than a new protection mechanism. Moreover, the ablation suggests that using a single surrogate is sufficient, making the method similar to standard fine-tuning on pseudonymized data. The paper does not clearly distinguish its contribution from existing de-identification and sensitive-token redaction techniques [1, 2].

  2. The paper assumes that private tokens are identified in advance and removes them before training, whereas the evaluated baselines generally attempt to protect information that remains in the training signals. The reported improvements therefore do not establish whether AliasGuard offers meaningful advantages over simple data sanitization. Comparisons with straightforward alternatives, such as replacing private tokens with placeholders or randomly selected surrogates before standard fine-tuning, are needed to demonstrate the value of the proposed design.

  3. The experiments involve relatively few fine-tuning updates, and the performance of the original pre-trained models is not reported, making it difficult to assess the actual benefits of fine-tuning. AliasGuard also shows noticeable utility losses relative to No Defense in some settings, including GSM8K, where the protected person names appear less relevant to the task. These losses are not sufficiently explained, raising questions about how reliably the method preserves downstream task performance.

[1] Carrell et al. Hiding in Plain Sight: Use of Realistic Surrogates to Reduce Exposure of Protected Health Information in Clinical Text. JAMIA, 2013.

[2] Shi et al. Just Fine-tune Twice: Selective Differential Privacy for Large Language Models. EMNLP, 2022.

Questions for authors

Q1. What does AliasGuard provide beyond fine-tuning on pseudonymized data, and how does it compare with that baseline?

Q2. What causes the utility drop relative to No Defense on GSM8K, where only person names are replaced?

3 comments
AuthorsOpenReview ↗

Responses for the second questions of Reviewer DN1z

We compared context-based replacement with random replacement. The random replacement uses the surrogates with the same token length and semantic meaning of private data. Other settings of the both replacement methods are the same. In one DialogSum [7] dialogue, the speaker mentions working as a “waitress”, and the summary uses “she”. Context-based replacement chose Beth, Laura, and Maria. Random replacement chose Edward, Ben, and Justin.

The model predicted each next summary token from the dialogue and the preceding reference tokens. We measured loss on tokens outside the names. Averaged over each method’s three names, the loss fell from 0.783 with random replacement to 0.287 with context-based replacement (63.4%). The names chosen from context fit the pronoun and role, while random replacement cannot achieve it due to missing contextual information. The results indicate that context matters when task utility needs the surrogates to match the meaning provided by context. Apparently, random replacement cannot provide this benefit for improving task utility.

Reference

[7] Chen et al. DialogSum: A Real-Life Scenario Dialogue Summarization Dataset. Findings of ACL-IJCNLP, 2021.

AuthorsOpenReview ↗

Resonses for the third question of Reviewer DN1z

The third question asks for more training steps, pre-trained models’ task utility, and the reasons of the task utility losses of AliasGuard compared to No defense baseline.

For the first two issues, we ran Qwen3.5-9B [13] for 2,048 updates across five paired seeds. The original Qwen runs used 169 updates. Before our fine-tuning, accuracy on the 1,319 GSM8K [8] test questions was 1.74% for GPT-2-small [11], 43.37% for Qwen2.5-1.5B, 44.28% for Qwen2.5-3B [12], and 88.48% for Qwen3.5-9B.

For the final issue, at 2,048 updates, AliasGuard achieved 23.11% and NoDef achieved 22.71%. Both scores were below that of the initial 9B model. To examine this decline, we compared three fine-tuning methods at 256 updates, using the same starting model, training examples, prompts, and scoring. The table gives mean accuracy (%) on the same 128 development questions across three paired seeds.

Fine-tuning methodNoDefAliasGuard
Original fine-tuning11.7215.89
LoRA [5]89.8489.58
OPLoRA [6]90.1088.80

With LoRA, both NoDef and AliasGuard retained an average of 108.7 of the 112 initially correct answers. With the original fine-tuning method, they retained 13.3 and 18.7, respectively. The fine-tuning method substantially affected utility in both systems, and AliasGuard and NoDef achieved similar accuracy with LoRA under larger training steps, removing the loss observed by the reviewer. We will include the initial scores, training curves, and fine-tuning comparisons in the revision.

References

[5] Hu et al. LoRA: Low-Rank Adaptation of Large Language Models. ICLR, 2022.

[6] Xiong and Xie. OPLoRA: Orthogonal Projection LoRA Prevents Catastrophic Forgetting during Parameter-Efficient Fine-Tuning. arXiv:2510.13003, 2025.

[8] Cobbe et al. Training Verifiers to Solve Math Word Problems. arXiv:2110.14168, 2021.

[11] Radford et al. Language Models are Unsupervised Multitask Learners. OpenAI, 2019.

AuthorsOpenReview ↗

Responses for the first question of Reviewer DN1z

Why we may need multiple surrogates beyond one surrogate? Our evaluation results show that with more surrogates, the task utility of AliasGuard can become better. For example, on GSM8K, Qwen2.5-1.5B reached 32.68%, 35.56%, and 36.32% test accuracy with 1, 3, and 5 surrogates. When we use one surrogate, there is only one sequence, such as Alice say 1 adding 1 equals to 2. During model training, 1+1=2 may relate to Alice. With more surrogates, such as Bob (or Carol, David) says 1 adding 1 equals to 2. During model training, it may find that the names are noises, so they focus on learning 1+1=2. Thus, more surrogates may improve the generalization capability during training. We will investigate it in our future work.

Why pseudonymized fine-tuning is not enough in SL fine-tuning? HIPS [1] uses features of private tokens to generate surrogates. These surrogates can therefore retain information about the private tokens. An adaptive attacker who knows the rules can use that information to narrow down the possible private tokens. AliasGuard generates surrogates using only unprotected context CC and independent randomness. Changing private tokens while keeping CC fixed leaves the surrogate distribution unchanged. Theorem 3 proves that smashed data, gradients, and server states reveal no additional information about private tokens beyond CC. This is one of the key designs for AliasGuard to defend against adaptive attacks. JFT [2] uses the original sequences in its second stage to learn from the private tokens removed in the first stage. In split learning, the Head would compute smashed data from those original sequences, so the smashed data can reveal information about private tokens. In contrast, AliasGuard avoid this. Theorem 1 proves that AliasGuard’s smashed data reveal no additional information about private tokens beyond CC.

References

[1] Carrell et al. Hiding in Plain Sight: Use of Realistic Surrogates to Reduce Exposure of Protected Health Information in Clinical Text. JAMIA, 2013.

[2] Shi et al. Just Fine-tune Twice: Selective Differential Privacy for Large Language Models. EMNLP, 2022.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of manuscript revisions

1. Novelty (Section 2.3)

We added a paragraph on surrogate replacement in unlearning, text anonymization, and prompt privacy. This paragraph is to illustrate why existing surrogate replacement methods are not enough in split learning fine-tuning. Methods that choose surrogates based on private tokens can still pass information about those tokens through smashed data, so existing attacks can leverage this to infer. Methods that use random replacement can influence task utility, which has been attested by our experiments. Methods that use in unlearning can introduce heavy computation overhead. Thus, existing methods face troubles to achieve this manuscript’s goal - resolving the privacy-utility trade-off with minor added computational time. Our context-based surrogate replacement with a new computation path achieves our goal. This demonstrates both methodological novelty and its significance.

2. Privacy guarantee and experimental setup

  • Section 3. We have already defined context in Section 3, but it is too abstract to understand. We thus show an example to help readers to understand what is context in this manuscript.

  • Section 4.1. We clarify the number of updates in the main comparison.

  • Section 4.4 and Appendix G.1. We explain which test answers count in the unprotected-token scores and how we use recorded positions to skip private tokens when scoring.

3. Additional GSM8K experiments

  1. Larger model, more updates, and more seeds (Appendix D.4, Tables 17–18). We train Qwen3.5-9B for 2,048 updates on 2,048 distinct sequences, with five paired seeds. The added evaluations show that our conclusion in the original manuscript still holds.

  2. GSM8K scores before and after fine-tuning (Appendix D.5, Table 19). We report the pre-trained models’ task score (task utility).

  3. Effect of the fine-tuning method (Appendix D.5, Table 20). We add experiments to illustrate why AliasGuard’s task scores are sometimes lower than that of No defense baseline. With more training steps, the gap is filled, and sometimes AliasGuard has better task scores than No defense. The results demonstrate the effectiveness of AliasGuard’s capability on preserving task utility.

Other questions from reviewers are due to misunderstanding. Thus, we revise the manuscript to make these points clearer.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.