acceptodds
Under review as a conference paper at ICLR 2027

On the Vulnerability of Semantic IDs in Generative Recommendation

Abstract

Generative recommenders (GenRec) are increasingly adopted on real-world platforms. Semantic IDs (SIDs) are widely used in GenRec to map item descriptions to discrete tokens for autoregressive recommendation. Editing a listing can change its SID while the recommender remains fixed, creating a new attack surface for targeted item promotion. We introduce SIDAttack, which appends a short suffix to a target item's description while treating the victim SID tokenizer and recommender as black boxes. It searches using gradients from available text encoders and public-item anchors selected from publicly visible popular items, without victim recommendation feedback. Across product, news, and short-video catalogs and two SID tokenizers, SIDAttack produces the largest mean exposure gains among the evaluated baselines when the search and victim encoders match. Although the gain is smaller when the victim encoder is held out, SIDAttack still increases exposure relative to the unattacked baseline. We also find that residual-quantization margins strongly predict which items undergo SID changes. Guided by this finding, we propose margin-regularized codebook construction, which reduces attack-induced exposure while largely preserving clean recommendation utility.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
generative recommendation, Semantic IDs, adversarial attack, Representation Learning

Reviews

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

This paper shows that Semantic IDs (SIDs) in generative recommenders are vulnerable: small text edits can push an item's embedding across residual-quantization (RQ) boundaries and change its SID, and the RQ routing margin strongly predicts which items flip (AUC up to 0.93). The authors propose SIDAttack, which appends a short suffix to a target item's description and uses gradient-based search (AnchorPort-GCG) on public text encoders toward diverse popular-item anchors, without access to the victim tokenizer or recommender. It yields the largest exposure gains among the evaluated baselines across product, news and short-video datasets and two SID tokenizers. Gains are smaller but still positive when the victim encoder is held out. They also propose margin-regularized codebook construction, which cuts attack-induced exposure by roughly 55% or more at a 24-token suffix while keeping over 99% of clean Recall@50. A residual gain remains at 48 tokens, so the defense raises the attack cost rather than eliminating the attack.

Critical strengths
  • The angle is fresh: tweak a listing's text and its SID can change, with no retraining of the recommender needed. Treating that as an attack surface is realistic and under-explored.
  • The RQ margin first predicts which items flip (AUC up to 0.93), then the attack exploits that, and finally the defense reuses the same margin idea.
  • The experiments cover a lot of ground. Three Amazon domains plus news (MIND) and short video (KuaiRec), two tokenizers, cross-encoder transfer, suffix-length sweeps and ablations. The appendix also compares against text-purification defenses like ONION and TAP.
Critical weaknesses
  • The attacker needs white-box gradient access to a public encoder, and the baselines are adapted into a catalog-rewrite setting rather than designed for this scenario. HotFlip only gets a single substitution. So it's hard to tell how much of the big lead comes from the method itself.
  • Only 100 target items per domain, and the gains are heavy-tailed, with single items jumping by +732 or +1,090. The reported standard deviations come from three seeds only and ignore item-to-item variance, so the statistics aren't very convincing.
  • Everything is offline simulation, with exposure measured as top-50 counts over test users and nothing validated on a real platform. The only held-out encoder is BGE, and the surrogate encoders are all similar embedding models, so the transfer claims may be optimistic.
Questions for authors
  • The margin-regularized defense is only tested against edits that were generated beforehand against the standard tokenizer. What happens if the attacker re-runs AnchorPort-GCG against the margin-regularized tokenizer, or even against a surrogate of it? Since a residual gain already remains at n=48, how much of the defense survives an adaptive attacker?
  • The only held-out victim encoder is BGE, and the surrogates are all similar embedding models. How does the attack transfer to a structurally different encoder (e.g., an LLM-based or domain-finetuned encoder, or one with a different tokenizer)? Is the joint multi-surrogate gain due to diversity of encoders, or simply to more total optimization compute?
3 comments
AuthorsOpenReview ↗

Response to Reviewer yoYb

We thank the reviewer for recognizing the Semantic ID attack surface and the routing-margin analysis, and for the constructive questions on baseline fairness, statistical reporting, cross-encoder transfer, and adaptive attacks against our defense.

W1: Baseline design and equal-budget comparisons

The attacker needs white-box gradient access to a public encoder, and the baselines are adapted into a catalog-rewrite setting rather than designed for this scenario. HotFlip only gets a single substitution. So it's hard to tell how much of the big lead comes from the method itself.

Gradient access is used only on the public text encoder, never on the victim recommender or codebook. Because no prior attack is designed for catalog rewriting against SID-based recommenders, adapting existing text attacks is necessary. To ensure a fair comparison, all gradient baselines share the same public encoder, anchor pool, editable region, and vocabulary, and we evaluate three controlled comparisons under a matched budget of C=1,536C=1{,}536 candidate evaluations on the same 100 targets per domain:

(1) Native HotFlip (in-place body edits). HotFlip was originally designed to replace tokens inside the main text. Applied directly to the product body on Beauty, it corrupts core product facts, substantially increases perplexity, and still yields lower exposure gains than appending a suffix—which is why our main tables evaluate all methods in the suffix setting.

Method (Beauty, C=1,536C=1{,}536)Tokens nnBody Cosine ↑Facts Preserved (/100) ↑PPL (Body / Full) ↓Δ\DeltaExp@50 ↑
Body-Edit HotFlip120.9389735.64 / 35.64+1.10
Suffix SIDAttack121.00010022.06 / 31.84+1.67
Body-Edit HotFlip240.8628961.50 / 61.50+3.90
Suffix SIDAttack241.00010022.06 / 37.38+6.14
Body-Edit HotFlip480.75474113.21 / 113.21+10.58
Suffix SIDAttack481.00010022.06 / 46.72+15.68

(2) Single anchor with random restarts. Running single-anchor GCG with three random restarts toward the same anchor under the same total budget (C=1,536C=1{,}536) recovers only a small part of the gap, confirming that the gain comes from multi-anchor diversity rather than multiple random initializations.

Dataset (n=24n=24, C=1,536C=1{,}536)Single-Anchor GCG Δ\DeltaExp@50 ↑Same-Anchor Random Restarts Δ\DeltaExp@50 ↑SIDAttack Δ\DeltaExp@50 ↑
Beauty+3.93+4.06+6.14
Industrial & Sci.+39.38+44.70+61.35
Toys & Games+122.46+129.38+182.64

(3) Equal-budget multi-step HotFlip and single-anchor GCG. Upgrading HotFlip to multi-step iterative search across n∈12,24,48n\in\\{12, 24, 48\\}, SIDAttack consistently outperforms both iterative HotFlip and single-anchor GCG across all domains and budgets while matching single-anchor GCG in runtime and running faster than iterative HotFlip.

Tokens nnMethod (C=1,536C=1{,}536)Gradients GGSec / Item (Beauty)Beauty Δ\DeltaExp@50 ↑Industrial Δ\DeltaExp@50 ↑Toys Δ\DeltaExp@50 ↑
12Iterative HotFlip19280.03+0.89+4.22+37.53
12Single-Anchor GCG9663.56+1.15+5.24+50.54
12SIDAttack9664.08+1.67+7.56+73.23
24Iterative HotFlip19282.62+2.94+29.93+91.89
24Single-Anchor GCG9665.61+3.93+39.38+122.46
24SIDAttack9666.13+6.14+61.35+182.64
48Iterative HotFlip19287.79+7.62+38.54+267.42
48Single-Anchor GCG9669.72+9.95+50.44+349.21
48SIDAttack9670.24+15.68+65.45+518.87
AuthorsOpenReview ↗

Response to Reviewer yoYb

W2: Target sample size and item-level variance

Only 100 target items per domain, and the gains are heavy-tailed, with single items jumping by +732 or +1,090. The reported standard deviations come from three seeds only and ignore item-to-item variance, so the statistics aren't very convincing.

Every baseline, ablation, transfer experiment, and defense evaluation uses the exact same 100 target items and paired seeds per domain, so all method comparisons are strictly paired on identical items. To further characterize item-to-item variation, we will add item-level paired statistics and confidence intervals in the final version.

W3 & Q2: Offline scope, LLM-based / finetuned victim encoders, and equal-compute multi-surrogate transfer

Everything is offline simulation, with exposure measured as top-50 counts over test users and nothing validated on a real platform. The only held-out encoder is BGE, and the surrogate encoders are all similar embedding models, so the transfer claims may be optimistic.

The only held-out victim encoder is BGE, and the surrogates are all similar embedding models. How does the attack transfer to a structurally different encoder (e.g., an LLM-based or domain-finetuned encoder, or one with a different tokenizer)? Is the joint multi-surrogate gain due to diversity of encoders, or simply to more total optimization compute?

Offline evaluation. Following standard practice in generative recommendation, we evaluate under the full-ranking protocol on real interaction logs, as injecting adversarial product descriptions into a live platform would directly affect real users and sellers.

Structurally different and domain-finetuned encoders. To evaluate transfer across distinct model architectures and tokenizers, we use BGE (or BGE + E5 + GTE) as public surrogates and transfer the suffixes to two held-out LLM-based encoders, Qwen3-Embedding-0.6B and Qwen3-Embedding-4B, each paired with an independently trained RQ tokenizer and generator. Regarding domain-finetuned encoders, recommendation pipelines typically apply lightweight parameter-efficient adaptation such as LoRA while learning domain specialization in the quantizer and generator, which preserves the underlying token embedding layer and semantic neighborhood structure.

Equal-compute multi-surrogate search. To separate encoder diversity from total compute, we match the total forward and backward compute of joint BGE + E5 + GTE search to that of single-surrogate BGE. Under the same compute budget, joint multi-surrogate search consistently outperforms BGE alone across all datasets and both Qwen3 victims, confirming that the transfer gain comes from encoder diversity rather than extra optimization compute.

DatasetHeld-Out VictimPublic Search EncodersClean Exp@50Attacked Exp@50 ↑Δ\DeltaExp@50 ↑Clean Recall@50
BeautyQwen3-Embedding-0.6BBGE only0.172.64+2.470.1768
BeautyQwen3-Embedding-0.6BBGE + E5 + GTE (Equal Compute)0.173.28+3.110.1768
BeautyQwen3-Embedding-4BBGE only0.093.37+3.280.1847
BeautyQwen3-Embedding-4BBGE + E5 + GTE (Equal Compute)0.094.28+4.190.1847
Industrial & Sci.Qwen3-Embedding-0.6BBGE only0.2418.07+17.830.2043
Industrial & Sci.Qwen3-Embedding-0.6BBGE + E5 + GTE (Equal Compute)0.2422.54+22.300.2043
Industrial & Sci.Qwen3-Embedding-4BBGE only0.1424.75+24.610.2136
Industrial & Sci.Qwen3-Embedding-4BBGE + E5 + GTE (Equal Compute)0.1431.44+31.300.2136
Toys & GamesQwen3-Embedding-0.6BBGE only0.2941.55+41.260.1652
Toys & GamesQwen3-Embedding-0.6BBGE + E5 + GTE (Equal Compute)0.2954.67+54.380.1652
Toys & GamesQwen3-Embedding-4BBGE only0.2168.63+68.420.1728
Toys & GamesQwen3-Embedding-4BBGE + E5 + GTE (Equal Compute)0.2191.41+91.200.1728
AuthorsOpenReview ↗

Response to Reviewer yoYb

Q1: Adaptive attacks against the margin-regularized defense

The margin-regularized defense is only tested against edits that were generated beforehand against the standard tokenizer. What happens if the attacker re-runs AnchorPort-GCG against the margin-regularized tokenizer, or even against a surrogate of it? Since a residual gain already remains at n=48, how much of the defense survives an adaptive attacker?

To evaluate an adaptive attacker after the defense is deployed, we freeze the margin-regularized tokenizer and generator, train a separate margin-regularized surrogate quantizer Q~\widetilde{Q} on public catalog embeddings, and add a differentiable soft-routing term toward the anchor's surrogate code qaq_a:

R_{\mathrm{proxy}}(s)=\frac{1}{3}\sum_{\ell=1}^{3}\log p_{\widetilde{Q},\tau}\\!\left(q_{a,\ell}\mid E(x\oplus s)\right),\quad \tau=0.03.$$ Comparing fixed pre-defense edits, a fresh rerun of $J_{\mathrm{public}}$, and adaptive re-optimization with $J_{\mathrm{adapt}}$ under the same search budget shows that adaptive re-optimization recovers part of the exposure gain relative to fixed edits, whereas rerunning $J_{\mathrm{public}}$ alone changes little. Even so, across all domains and budgets, the defense keeps the adaptive gain well below the undefended attack while preserving clean Recall@50, confirming that margin regularization substantially raises the cost of attack. | Dataset | Budget $n$ | Fixed-Edit $\Delta$Exp@50 ↓ | Public Rerun $\Delta$Exp@50 ↓ | Adaptive $\Delta$Exp@50 ↓ | Undefended $\Delta$Exp@50 | Clean Recall@50 | | --- | --- | --- | --- | --- | --- | --- | | Beauty | 24 | -0.04 | +0.09 | +1.24 | +6.14 | 0.1831 | | Beauty | 48 | +5.93 | +6.08 | +9.91 | +15.68 | 0.1831 | | Industrial & Sci. | 24 | +27.16 | +28.11 | +35.93 | +61.35 | 0.2124 | | Industrial & Sci. | 48 | +30.58 | +31.19 | +43.88 | +65.45 | 0.2124 | | Toys & Games | 24 | +83.76 | +85.29 | +109.47 | +182.64 | 0.1716 | | Toys & Games | 48 | +252.31 | +257.66 | +342.08 | +518.87 | 0.1716 | We hope these additional experiments and clarifications address your concerns, and we respectfully invite you to reconsider your evaluation of our work.
Reviewer_q24SOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

This paper investigates the vulnerability of semantic IDs in generative recommendation models that use residual quantization to construct SIDs, and proposes an attack method called SIDAttack. SIDAttack constructs a multi-anchor optimization objective based on a popular-item pool and employs GCG to optimize adversarial text suffixes. Motivated by an analysis of residual quantization margins, this paper further proposes margin-regularized codebook construction as a defense. Experiments demonstrate the effectiveness of both the attack and defense methods.

Critical strengths
  1. The paper reveals how semantic ID instability can be exploited to manipulate item exposure and systematically investigates both attack and defense mechanisms, offering a new perspective on the robustness of generative recommendation systems.
  2. SIDAttack achieves substantial performance across multiple recommendation domains and SID tokenizers, with promising cross-encoder transferability. The proposed defense also significantly reduces attack effectiveness while largely preserving recommendation utility.
Critical weaknesses
  1. SIDAttack mainly combines existing GCG-based suffix optimization with popularity-guided anchors, make its techonlogical novelty limited. Besides, the advantages of the proposed method over existing GCG methods are not sufficiently isolated through controlled comparisons.
  2. The paper could be better organized and more clearly written. In particular, the relationship between popular-item anchor similarity, SID rerouting, and exposure gains could be better articulated. The optimization procedure of AnchorPort-GCG and the handling of item mapping and SID collisions after reassignment also lack sufficient clarity, making the overall method difficult to follow.
Questions for authors
  1. How does the computational cost of AnchorPort-GCG compare with that of the baseline methods?
  2. Some optimized suffixes appear semantically incoherent or unrelated to the original item descriptions. How would additional constraints on semantic consistency and text quality affect the effectiveness of SIDAttack?
3 comments
AuthorsOpenReview ↗

Response to Reviewer q24S

We thank the reviewer for the careful reading and constructive comments. Below, W1 clarifies what AnchorPort-GCG adds beyond standard GCG and isolates each component under an equal search budget; W2 details the causal chain from anchor similarity to exposure, the optimization pipeline, and collision handling; Q1 reports computational cost; and Q2 evaluates text-quality constraints. Unless stated otherwise, all experiments use the same 100 target items and three paired seeds per domain with a 24-token suffix and Qwen3-Embedding-4B.

W1: Design contributions and controlled equal-budget ablations

SIDAttack mainly combines existing GCG-based suffix optimization with popularity-guided anchors, make its techonlogical novelty limited. Besides, the advantages of the proposed method over existing GCG methods are not sufficiently isolated through controlled comparisons.

We thank the reviewer for raising this point. In our method, GCG serves only as the token-replacement primitive. Our attack contribution lies in formulating a tractable public-space objective when the discrete target is hidden and non-differentiable, addressing three obstacles specific to generative recommendation:

  1. No observable or differentiable target. Unlike jailbreaking—where GCG minimizes the loss of a known target string under the victim model—our attacker observes neither the codebook nor item-to-SID assignments, and nearest-centroid quantization is non-differentiable. We therefore construct surrogate targets in the public encoder space from popular catalog items that are semantically compatible with the source item.
  2. Step-function quantization boundaries. An item's SID changes only when its representation crosses a quantization boundary, so moving partway toward an unreachable anchor yields no exposure gain. We therefore hedge across three diverse anchors and introduce the popularity-weighted global term Φ\Phi, which rewards entering the neighborhood of any popular item rather than only the beam's assigned anchor.
  3. No recommender feedback. Because the attacker cannot query the victim recommender to stop early or pick the best candidate, the final suffix across beams is selected solely by the public score Φ\Phi.

Beyond the attack, our residual-quantization margin analysis and the resulting margin-regularized codebook defense constitute an independent contribution that does not depend on GCG: they identify boundary sensitivity as the root cause of SID vulnerability and substantially suppress attack exposure while preserving clean recommendation utility.

Controlled comparison at equal budget. To verify that our gains come from multi-anchor portfolio search rather than from a larger search budget or multiple initializations, we match the total budget at C=1,536C=1{,}536 candidate evaluations per item across all multi-step variants. Specifically, we compare full SIDAttack (3×5123\times 512 across three diverse anchors) against single-anchor GCG given the full budget (C=1,536C=1{,}536), three random restarts toward the same anchor (3×5123\times 512), and ablations removing either the global term Φ\Phi or the diversity constraint.

VariantCandidate evaluations CCBeauty Δ\DeltaExp@50 ↑Industrial Δ\DeltaExp@50 ↑Toys Δ\DeltaExp@50 ↑
SIDAttack (full)3 × 512+6.14+61.35+182.64
Single anchor (as in the paper)512+3.92+40.88+127.46
Single anchor, full budget1,536+3.93+39.38+122.46
Same anchor, 3 restarts3 × 512+4.06+44.70+129.38
Without global term Φ\Phi3 × 512+4.67+48.37+149.72
Without diversity cap3 × 512+5.31+54.92+160.85

The results highlight three findings: (1) single-anchor search saturates once its budget is tripled; (2) restarting toward the same anchor closes only a small fraction of the gap, ruling out multi-start initialization as the main driver; and (3) allocating the same total budget across three diverse anchors with the global objective Φ\Phi substantially boosts exposure in every domain. Thus, SIDAttack's advantage over single-target GCG comes from where the budget is spent rather than how much is spent.

AuthorsOpenReview ↗

Response to Reviewer q24S

W2: From anchor similarity to exposure, and the end-to-end procedure

The paper could be better organized and more clearly written. In particular, the relationship between popular-item anchor similarity, SID rerouting, and exposure gains could be better articulated. The optimization procedure of AnchorPort-GCG and the handling of item mapping and SID collisions after reassignment also lack sufficient clarity, making the overall method difficult to follow.

We thank the reviewer for this suggestion and summarize the causal chain, the four-stage optimization pipeline, and the post-edit collision resolution below.

From anchor similarity to exposure.

  1. Anchor similarity → SID rerouting: The quantizer assigns SID tokens by nearest codebook centroids. When the suffix shifts the item's representation across the quantization boundary toward a popular anchor, the item acquires the anchor's leading SID prefix.
  2. SID rerouting → generator probability: Trained on historical user interactions, the generator assigns high probability to prefixes occupied by popular items; an item routed into such a prefix inherits that prefix probability even though the generator was never trained on the item's new ID.
  3. Generator probability → exposure: Constrained decoding restricts valid continuations to existing catalog items under that prefix, bringing the rerouted item into the top-50 lists of users routed to that prefix.

Four-stage procedure.

  1. Anchor portfolio construction: We embed the public popular-item pool once, rank candidates by source semantic compatibility plus public popularity, and greedily select three anchors with pairwise cosine similarity at most 0.900.90.
  2. Beam-specific GCG optimization: Each anchor aba_b initializes one beam optimizing Jb=(1−λ)Φ+λz⊤ab\mathcal{J}_b=(1-\lambda)\Phi+\lambda z^\top a_b, where zz is the normalized embedding of x⊕sx\oplus s and Φ\Phi is the popularity-weighted global score; candidate replacements are accepted only when they improve Jb\mathcal{J}_b.
  3. Portfolio output selection: Once the candidate budget is exhausted, the suffix s⋆s^\star with the highest public score Φ\Phi across beams is selected without querying the recommender.
  4. Re-encoding and complete-ID assignment: The frozen encoder and codebook quantize x⊕s⋆x\oplus s^\star into a three-token semantic prefix A1B1C1A_1B_1C_1, and a fourth collision-resolution token distinguishes items sharing that prefix:

x\oplus s^\star \xrightarrow{\text{frozen encoder \\& quantizer}} A_1B_1C_1 \xrightarrow{\text{lowest unused 4th token}} A_1B_1C_1D_2 .

Item mapping and collisions. Existing items in the bucket retain their complete IDs (e.g., A1B1C1D1A_1B_1C_1D_1), while the attacked item's old ID is removed from the lookup table and constrained-decoding trie and replaced by A1B1C1D2A_1B_1C_1D_2, preserving a strict one-to-one mapping between complete four-token IDs and catalog items. Because all collision tokens already exist in the generator vocabulary and the trie restricts the fourth step to valid items in the bucket, a high-scoring prefix A1B1C1A_1B_1C_1 dominates the total beam score and allows both A1B1C1D1A_1B_1C_1D_1 and A1B1C1D2A_1B_1C_1D_2 to enter a user's top-50 list under the frozen generator.

Q1: Computational cost compared with the baselines

How does the computational cost of AnchorPort-GCG compare with that of the baseline methods?

We profile runtime against the equal-budget gradient baselines on a single NVIDIA A100 80 GB GPU (bfloat16). Embedding the public pool is a shared one-time preprocessing step per dataset, and no method queries the recommender.

MethodCandidate evaluations CCGradients / itemTime / item on Beauty (s) ↓Beauty Δ\DeltaExp@50 ↑
Iterative HotFlip1,53619282.62+2.94
Single-anchor GCG1,5369665.61+3.93
SIDAttack1,5369666.13+6.14

Selecting three anchors from cached pool embeddings adds negligible overhead over single-anchor GCG, and SIDAttack runs noticeably faster than iterative HotFlip (which requires twice as many gradient passes for the same candidate budget) while achieving substantially higher exposure gains.

AuthorsOpenReview ↗

Response to Reviewer q24S

Q2: Semantic consistency and text quality

Some optimized suffixes appear semantically incoherent or unrelated to the original item descriptions. How would additional constraints on semantic consistency and text quality affect the effectiveness of SIDAttack?

We thank the reviewer for this question. First, because our edit is strictly append-only, the original title and description are preserved token for token, keeping all product facts and original semantics intact; in addition, our anchor selection explicitly prioritizes popular items that are semantically compatible with the source item.

Second, to evaluate the impact of explicit text-quality constraints on the appended suffix, we add a language-model fluency penalty conditioned on the original listing xx to each beam's objective:

Jbflu(s)=Jb(s)−α,NLLLM(s∣x),\mathcal{J}^{\mathrm{flu}}_b(s)=\mathcal{J}_b(s)-\alpha\\,\mathrm{NLL}_{\mathrm{LM}}(s\mid x),

where NLLLM(s∣x)\mathrm{NLL}_{\mathrm{LM}}(s\mid x) is the mean token negative log-likelihood of the suffix conditioned on xx under Qwen2.5-7B (α=0.5\alpha=0.5), and perplexity is evaluated with an independent language model, Llama-3.1-8B.

DatasetSettingFull PPL ↓Suffix PPL ↓Δ\DeltaExp@50 ↑
BeautyClean listing22.06——
BeautySIDAttack (unconstrained)37.3872.32+6.14
BeautySIDAttack (constrained)30.3251.32+5.23
Industrial & Sci.Clean listing25.32——
Industrial & Sci.SIDAttack (unconstrained)45.2378.29+61.35
Industrial & Sci.SIDAttack (constrained)35.2453.29+61.32
Toys & GamesClean listing28.83——
Toys & GamesSIDAttack (unconstrained)52.2091.22+182.64
Toys & GamesSIDAttack (constrained)41.2148.32+169.54

Across all domains, the fluency penalty substantially reduces both suffix and full-listing perplexity while retaining the vast majority of the unconstrained exposure gain. Consistent with the mechanism in W2, SIDAttack exploits the sensitivity of SID assignment near quantization boundaries—where a modest representation shift suffices to cross a boundary—rather than relying on high-perplexity token strings.

We thank the reviewer again for the constructive comments, and we hope that these clarifications and additional experiments address the concerns raised.

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

The paper studies item promotion through text edits that change semantic IDs in a frozen generative recommender. SIDAttack optimizes an appended suffix toward popular-item representations using public encoder gradients, without recommendation feedback. Experiments cover five catalogs, two SID tokenizers, and cross-encoder transfer. The paper also connects SID instability to quantization margins and proposes a margin-based defense.

Critical strengths
  1. Catalog edits are a relevant attack surface for semantic-ID recommendation. Increasing exposure without recommendation feedback makes the setting worth studying.
  2. Evaluation across product, news, and video catalogs, together with two tokenizers and held-out encoder transfer, provides useful evidence beyond a single benchmark.
Critical weaknesses
  1. Section 3.1 says that catalog edits are re-encoded, but does not explain how the new SIDs are mapped back to individual items, especially when an edit creates a collision. Since the main metric is item exposure, this step needs clarification.
  2. The comparison does not clearly separate the search design from the search budget. Appendix A.3 describes HotFlip as one gradient substitution, while SIDAttack uses three beams and 32 rounds per beam. An equal-budget comparison would make the reported advantage more convincing.
  3. The defense results are encouraging, but codebook updates and generator retraining occur together. A control with the same updates but no margin penalty would help establish how much of the improvement comes from the regularizer.
Questions for authors
  1. How is a generated SID mapped to the attacked item after a catalog edit, including when it collides with another item's SID?
  2. Does the advantage persist against iterative HotFlip and single-anchor GCG with the same total candidate-evaluation budget?
  3. What happens if the codebook and generator follow the same defense update schedule with gamma = 0?
3 comments
AuthorsOpenReview ↗

Response to Reviewer 5o6G

We thank the reviewer for the constructive feedback and for recognizing catalog editing as a practical attack surface in generative recommendation. Below we clarify how post-edit Semantic IDs map back to individual items under collisions, provide equal-budget comparisons against iterative HotFlip and single-anchor GCG, and isolate the contribution of the margin regularizer with a matched γ=0\gamma=0 control.

W1 & Q1: Complete identifiers, collision resolution, and item-level exposure

Section 3.1 says that catalog edits are re-encoded, but does not explain how the new SIDs are mapped back to individual items, especially when an edit creates a collision. Since the main metric is item exposure, this step needs clarification.

How is a generated SID mapped to the attacked item after a catalog edit, including when it collides with another item's SID?

We thank the reviewer for this question. In our pipeline, the three-token semantic prefix [c1,c2,c3][c_1,c_2,c_3] is distinct from the four-token complete item identifier [c1,c2,c3,d][c_1,c_2,c_3,d], where the fourth token dd is a collision-resolution discriminator that uniquely distinguishes items sharing the same prefix bucket. Exp@50\text{Exp@50} is evaluated strictly at the item level after complete-ID lookup: a target item receives credit only when its full four-token ID appears in a test user's deduplicated top-50 decoded list, whereas matching a popular anchor's three-token prefix alone yields no exposure credit.

When a catalog edit moves a target item into a new semantic prefix [c1,c2,c3][c_1,c_2,c_3], we remove its old complete ID from the lookup table and constrained-decoding trie, keep every other item's complete ID unchanged, and assign the target the lowest unused discriminator token dd in the new bucket. The encoder, codebooks, and generator remain strictly frozen, and all discriminator tokens dd already exist in the generator vocabulary. When the new prefix [c1,c2,c3][c_1,c_2,c_3] scores highly for a user during beam search, its log-probability dominates the four-token path score, allowing the frozen generator to decode the target's new complete ID alongside existing items in that bucket. The trace on Beauty below illustrates how an existing popular item and the edited target (T-017) retain distinct complete IDs under the shared prefix and are credited separately.

ItemPre-Edit Complete IDPost-Edit Semantic PrefixCollision Token ddPost-Edit Complete IDDecoded Item & Exposure Credit
Existing popular item[99, 21, 11, 0][99, 21, 11]0[99, 21, 11, 0]Existing popular item
Attacked item T-017[23, 104, 7, 0][99, 21, 11]1[99, 21, 11, 1]T-017 (decoded at rank 18 for user U-0317; overall exposure 6→436 \to 43 users)
AuthorsOpenReview ↗

Response to Reviewer 5o6G

W2 & Q2: Equal-budget comparisons with iterative HotFlip and single-anchor GCG

The comparison does not clearly separate the search design from the search budget. Appendix A.3 describes HotFlip as one gradient substitution, while SIDAttack uses three beams and 32 rounds per beam. An equal-budget comparison would make the reported advantage more convincing.

Does the advantage persist against iterative HotFlip and single-anchor GCG with the same total candidate-evaluation budget?

We agree that matching the total search budget is essential for isolating the effect of our search design. We therefore evaluate multi-step iterative HotFlip and single-anchor GCG under the exact same total budget of C=1,536C=1{,}536 candidate evaluations per item across all five datasets and three suffix lengths (n∈12,24,48n\in\\{12, 24, 48\\}). All methods share the same public encoder, initial suffix, and round-trip-safe vocabulary without querying the victim recommender: the baselines spend the entire budget on a single anchor, whereas SIDAttack splits the same budget evenly across its three anchor beams.

As shown in the first two tables below, SIDAttack consistently and substantially outperforms both iterative HotFlip and single-anchor GCG across all five datasets and all three suffix lengths. Even though each beam in SIDAttack uses only one-third of the per-anchor budget of single-anchor GCG, hedging across three diverse anchors and selecting the final suffix via the global objective avoids poor local optima when a single anchor cannot be reached across a quantization boundary.

In addition, the third table compares suffix SIDAttack against native in-body HotFlip (replacing n∈12,24,48n\in\\{12, 24, 48\\} tokens directly inside the product description under the same budget on Beauty). Directly substituting body tokens degrades text fluency, corrupts core product facts, and still achieves lower exposure gains than suffix SIDAttack, which preserves the original product description intact.

Dataset (n=24n=24, C=1,536C=1{,}536)Iterative HotFlip ΔExp@50 ↑Single-Anchor GCG ΔExp@50 ↑SIDAttack ΔExp@50 ↑
Beauty+2.94+3.93+6.14
Industrial & Scientific+29.93+39.38+61.35
Toys & Games+91.89+122.46+182.64
MIND+13.30+17.03+25.68
KuaiRec+58.57+75.50+116.73
Suffix Tokens nnMethod (C=1,536C=1{,}536)Beauty ΔExp@50 ↑Industrial & Sci. ΔExp@50 ↑Toys & Games ΔExp@50 ↑
12Iterative HotFlip+0.89+4.22+37.53
12Single-Anchor GCG+1.15+5.24+50.54
12SIDAttack+1.67+7.56+73.23
24Iterative HotFlip+2.94+29.93+91.89
24Single-Anchor GCG+3.93+39.38+122.46
24SIDAttack+6.14+61.35+182.64
48Iterative HotFlip+7.62+38.54+267.42
48Single-Anchor GCG+9.95+50.44+349.21
48SIDAttack+15.68+65.45+518.87
Method (Beauty, C=1,536C=1{,}536)Budget nnBody Cosine ↑Facts Preserved (/100) ↑PPL (Body / Full) ↓ΔExp@50 ↑
Body-Edit HotFlip120.9389735.64 / 35.64+1.10
Suffix SIDAttack121.00010022.06 / 31.84+1.67
Body-Edit HotFlip240.8628961.50 / 61.50+3.90
Suffix SIDAttack241.00010022.06 / 37.38+6.14
Body-Edit HotFlip480.75474113.21 / 113.21+10.58
Suffix SIDAttack481.00010022.06 / 46.72+15.68
AuthorsOpenReview ↗

Response to Reviewer 5o6G

W3 & Q3: Defense training protocol and the γ=0\gamma=0 control

The defense results are encouraging, but codebook updates and generator retraining occur together. A control with the same updates but no margin penalty would help establish how much of the improvement comes from the regularizer.

What happens if the codebook and generator follow the same defense update schedule with gamma = 0?

We appreciate this suggestion. First, in both the standard and defended pipelines, the generator is trained from scratch under the exact same two-stage protocol rather than fine-tuned from the standard generator checkpoint. Second, to isolate the routing-margin penalty from the codebook update procedure, we run a matched γ=0\gamma=0 control that keeps the codebook initialization, optimizer, 30-epoch update schedule, and from-scratch generator training identical to our γ=1\gamma=1 defense, changing only the margin weight to γ=0\gamma=0.

As shown in the table below, updating the codebook with γ=0\gamma=0 changes attack exposure only slightly relative to the standard system. In contrast, enabling the margin regularizer (γ=1\gamma=1) under the identical update schedule eliminates the exposure gain on Beauty and cuts it by more than half on Industrial & Scientific and Toys & Games while preserving clean Recall@50\text{Recall@50}, confirming that the robustness improvement comes from enlarging quantization routing margins rather than from codebook retraining itself.

Dataset (n=24n=24)Standard ΔExp@50 ↓γ=0\gamma=0 Control ΔExp@50 ↓γ=1\gamma=1 Defense ΔExp@50 ↓Reduction (γ=1\gamma=1 vs. γ=0\gamma=0)Clean Recall@50 (γ=0\gamma=0 / γ=1\gamma=1)
Beauty+6.14+5.58-0.04+5.58 → -0.040.1840 / 0.1831 (99.51%)
Industrial & Scientific+61.35+56.87+27.1652.24%0.2131 / 0.2124 (99.67%)
Toys & Games+182.64+171.36+83.7651.12%0.1723 / 0.1716 (99.59%)

Thank you again for your thoughtful review and constructive suggestions. We hope these clarifications and additional controls satisfactorily resolve your concerns, and we would be grateful if you would consider raising your score in light of these updates.

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

This paper tackles a new problem that comes out of a recent shift in recommender systems: whether item providers on a platform can manipulate how Semantic IDs (SIDs) are assigned in order to gain extra exposure. This is a realistic incentive for sellers and content creators.

On methodology, the authors give a full framework for both attack and defense. The attack does not depend on any specific victim encoder, and it does not need information an attacker couldn’t get in practice. The defense follows naturally from how residual quantization works: it widens the routing margin between an item and its nearest competing codes.

Critical strengths
  1. A clearly defined, under-explored problem. In LLM-based generative recommenders, Semantic IDs are the foundation of item retrieval. This paper shows that SID assignment can be manipulated by editing an item’s text so that its embedding moves toward other items. This attack surface has not yet been studied systematically, and it matters to both researchers and industry practitioners.

  2. A sound margin analysis and a framework that generalizes. The analysis showing that small routing margins predict SID changes is convincing, and it explains clearly why the proposed margin-regularized defense works. The overall attack-and-defense framework is general and does not depend on any specific victim model.

Critical weaknesses
  1. Limited practical applicability (detectability). The optimized suffixes are unreadable token strings with no meaning. Platforms already run listing-quality checks and content governance, which would catch text like this easily, and the seller would risk listing removal, penalties, or account suspension. SIDAttack does raise exposure in the paper’s offline setting, but because it is so easy to detect, it is fragile and of limited use in practice. A fluency- or perplexity-constrained version of the attack would be needed to show the threat is realistic.

  2. Codebook scale and utilization. The experiments use a small codebook (3 levels × 256 codes). Production SID systems use much larger codebooks, where the full SID space can exceed a billion combinations, and most of that space goes unused. In that regime, it is unclear whether enlarging routing margins is still effective or even meaningful as a defense, and its effect may be much smaller than reported here. The authors should discuss, or ideally test, how both the attack and the margin-regularized defense behave at realistic codebook sizes and utilization rates.

  3. SID collisions and the exposure metric. A higher chance that the target item’s SID gets generated does not mean the item is actually shown to users. When several items share the same SID, production systems pick among them using item-level signals such as historical performance and engagement. A newly rerouted item with weak engagement would be unlikely to win that selection. The Exp@K metric appears to credit the target item whenever its SID is generated, so it measures retrieval-stage reach, not real exposure. As a result, the comparison overstates the attack’s real-world impact.

Questions for authors

Q1. How are SID collisions resolved, and does the setup match real deployments? The attack and the defense are both measured in a generative retrieval setting, where items are retrieved and ranked through their Semantic IDs. For the measurements to mean something, that setting has to match how real systems work. In particular, when several items share the same SID, a production system must eventually decide which one to show. How does your evaluation do this directly affects whether the reported Exp@K gains turn into real item-level exposure.

Q2. Is the baseline codebook good enough for the assessment of your method? Both the attack and the defense work by changing which SID an item is assigned, so the results are only meaningful if the clean codebook is reasonably good to begin with. In practice, many products are almost identical semantically (for example, different listings or variants of the same iPhone 15 model). A good production-quality codebook still tells them apart to certain degree. It's necessary to show having a good codebook prior to comparison. Useful numbers would be the collision rate, codebook utilization, and how many items share each SID. Showing that SIDAttack still works, and that margin regularization still helps, on a codebook that meets this bar would make the conclusions much more convincing.

7 comments
AuthorsOpenReview ↗

Response to Reviewer Q8qo

We thank the reviewer for recognizing the catalog-editing attack surface and the routing-margin analysis, and for the constructive questions on detectability, codebook scale, and item-level exposure attribution. We address each point below.

W1: Fluency-constrained attack and detectability

Limited practical applicability (detectability). The optimized suffixes are unreadable token strings with no meaning. Platforms already run listing-quality checks and content governance, which would catch text like this easily, and the seller would risk listing removal, penalties, or account suspension. SIDAttack does raise exposure in the paper's offline setting, but because it is so easy to detect, it is fragile and of limited use in practice. A fluency- or perplexity-constrained version of the attack would be needed to show the threat is realistic.

We thank the reviewer for this constructive suggestion. To test whether SIDAttack remains effective under fluency constraints, we add a language-model fluency penalty directly to the AnchorPort-GCG objective:

Jbflu(s)=Jb(s)−α,NLLLM(s∣x),\mathcal{J}^{\mathrm{flu}}_b(s)=\mathcal{J}_b(s)-\alpha\\,\mathrm{NLL}_{\mathrm{LM}}(s\mid x),

where NLLLM(s∣x)\mathrm{NLL}_{\mathrm{LM}}(s\mid x) is the mean token negative log-likelihood of the suffix conditioned on the original listing under Qwen2.5-7B (α=0.5\alpha=0.5), with all other settings unchanged. Full-listing and suffix perplexity are evaluated using an independent language model, Llama-3.1-8B.

DatasetSettingFull PPL ↓Suffix PPL ↓Δ\DeltaExp@50 ↑
BeautyClean listing22.06——
BeautySIDAttack (unconstrained)37.3872.32+6.14
BeautySIDAttack (PPL-constrained)30.3251.32+5.23
Industrial & Sci.Clean listing25.32——
Industrial & Sci.SIDAttack (unconstrained)45.2378.29+61.35
Industrial & Sci.SIDAttack (PPL-constrained)35.2453.29+61.32
Toys & GamesClean listing28.83——
Toys & GamesSIDAttack (unconstrained)52.2091.22+182.64
Toys & GamesSIDAttack (PPL-constrained)41.2148.32+169.54

Across all three domains, the fluency penalty substantially lowers both suffix and full-listing perplexity while retaining the vast majority of the unconstrained exposure gain, confirming that SID rerouting exploits local quantization-boundary sensitivity rather than relying on high-perplexity token strings.

AuthorsOpenReview ↗

Response to Reviewer Q8qo

W2 & Q2: Codebook scale, utilization, and larger-codebook evaluation

Codebook scale and utilization. The experiments use a small codebook (3 levels ×\times 256 codes). Production SID systems use much larger codebooks, where the full SID space can exceed a billion combinations, and most of that space goes unused. In that regime, it is unclear whether enlarging routing margins is still effective or even meaningful as a defense, and its effect may be much smaller than reported here. The authors should discuss, or ideally test, how both the attack and the margin-regularized defense behave at realistic codebook sizes and utilization rates.

Is the baseline codebook good enough for the assessment of your method? Both the attack and the defense work by changing which SID an item is assigned, so the results are only meaningful if the clean codebook is reasonably good to begin with. In practice, many products are almost identical semantically (for example, different listings or variants of the same iPhone 15 model). A good production-quality codebook still tells them apart to certain degree. It's necessary to show having a good codebook prior to comparison. Useful numbers would be the collision rate, codebook utilization, and how many items share each SID. Showing that SIDAttack still works, and that margin regularization still helps, on a codebook that meets this bar would make the conclusions much more convincing.

We thank the reviewer for this suggestion. The first table below reports codeword utilization, prefix occupancy, collision rates, and bucket-size quantiles for our baseline codebook (K=256K=256) and a scaled billion-prefix codebook (K=2048K=2048). Our baseline codebook already maintains high codeword utilization across all levels with a median bucket size of one (and items sharing a prefix remain uniquely distinguished by the fourth collision token). Scaling to K=2048K=2048 reaches the sparse regime noted by the reviewer, where global prefix occupancy is tiny, prefix collisions are rare, and nearly all occupied buckets are singletons.

Evaluating the same attack and defense protocol at K=2048K=2048 (second table below) shows that SIDAttack continues to drive large item-level exposure gains, while margin regularization substantially suppresses those gains and preserves clean Recall@50\text{Recall@50}. Because the regularizer widens the distance margin between each item and its nearest competing centroids locally, its effectiveness depends on local neighborhood geometry rather than global prefix-space density.

DatasetKKL1 / L2 / L3 Use (%)Unique PrefixesPrefix OccupancyShared-Prefix ItemsBucket Size (Med / P95 / Max)
Beauty25697.66–99.61 / 95.31–98.83 / 92.58–98.8310,609–10,6800.063235–0.063658%16.81–17.64%1 / 2 / 11–12
Beauty204886.38–86.52 / 90.62–91.11 / 92.24–92.5311,831–11,8770.000138%2.62–3.25%1 / 1 / 7–14
Industrial & Sci.25695.31–98.83 / 94.92–100.00 / 93.75–94.924,349–4,4110.025922–0.026292%20.65–22.64%1 / 2 / 10–13
Industrial & Sci.204862.21–62.70 / 68.51–69.29 / 72.02–72.365,021–5,0360.000058–0.000059%3.66–3.93%1 / 1 / 7–10
Toys & Games25694.53–97.66 / 92.97–97.66 / 90.23–94.149,817–9,8500.058514–0.058711%25.05–25.41%1 / 3 / 11–16
Toys & Games204886.52–86.96 / 90.48–91.02 / 92.29–92.8211,458–11,5270.000133–0.000134%4.79–5.60%1 / 1 / 9–14
DatasetRecall@50 (Std / Def)Exp@50 Std (Clean / Attack)Exp@50 Def (Clean / Attack)Δ\DeltaExp@50 (Std / Def)Gain Reduction
Beauty0.1873 / 0.18620.06 / 4.860.13 / 1.42+4.80 / +1.2873.28%
Industrial & Sci.0.2157 / 0.21410.22 / 40.030.22 / 23.14+39.80 / +22.9242.42%
Toys & Games0.1741 / 0.17320.22 / 163.110.30 / 79.64+162.89 / +79.3451.29%
AuthorsOpenReview ↗

Response to Reviewer Q8qo

W3 & Q1: Complete IDs, collision resolution, and item-level exposure

SID collisions and the exposure metric. A higher chance that the target item's SID gets generated does not mean the item is actually shown to users. When several items share the same SID, production systems pick among them using item-level signals such as historical performance and engagement. A newly rerouted item with weak engagement would be unlikely to win that selection. The Exp@K metric appears to credit the target item whenever its SID is generated, so it measures retrieval-stage reach, not real exposure. As a result, the comparison overstates the attack's real-world impact.

How are SID collisions resolved, and does the setup match real deployments? The attack and the defense are both measured in a generative retrieval setting, where items are retrieved and ranked through their Semantic IDs. For the measurements to mean something, that setting has to match how real systems work. In particular, when several items share the same SID, a production system must eventually decide which one to show. How does your evaluation do this directly affects whether the reported Exp@K gains turn into real item-level exposure.

We thank the reviewer for this question. In our end-to-end generative recommender (TIGER-style), each item is identified by a unique four-token sequence [c1,c2,c3,d][c_1,c_2,c_3,d], where [c1,c2,c3][c_1,c_2,c_3] is the semantic prefix and dd is a collision-resolution token that distinguishes items sharing that prefix. When an edited item is re-encoded into a new prefix, its old four-token ID is removed from the lookup table and constrained-decoding trie, existing items keep their IDs, and the target item receives the lowest unused collision token dd in the new bucket. Because decoding produces complete four-token IDs that map one-to-one to catalog items, Exp@50\text{Exp@50} credits the target item only when its own four-token ID is decoded into a user's top-50 list, matching how deployed generative recommenders resolve SID collisions and serve item-level results.

A frozen generator can decode this newly assigned ID because beam search scores each complete sequence by the sum of token log-probabilities:

score(c1,c2,c3,d∣u)=∑ℓ=13log⁡pθ(cℓ∣u,c<ℓ)+log⁡pθ(d∣u,c1,c2,c3).\mathrm{score}(c_1,c_2,c_3,d \mid u)=\sum_{\ell=1}^{3}\log p_\theta(c_\ell \mid u, c_{<\ell})+\log p_\theta(d \mid u, c_1,c_2,c_3).

The collision tokens come from a small shared vocabulary, and the trie restricts the fourth step to valid tokens in the bucket. When the target item is routed under a popular prefix [c1,c2,c3][c_1,c_2,c_3] that the generator already scores highly for many users, the prefix log-probability dominates the total score, allowing both the existing anchor item and the newly routed target item to enter the top-50 beam. The trace on Beauty below illustrates this item-level resolution for target item T-017, whose overall exposure rises from 6 to 43 test users after rerouting.

ItemPre-Edit Complete IDPost-Edit Semantic PrefixAssigned DiscriminatorPost-Edit Complete IDRetrieved Item in Top-50
Existing anchor item[99, 21, 11, 0][99, 21, 11]0[99, 21, 11, 0]Existing anchor item
Target item T-017[23, 104, 7, 0][99, 21, 11]1[99, 21, 11, 1]Target item T-017 (Rank 18 for U-0317)

Thank you again for your insightful and constructive comments. We hope the additional experiments and clarifications satisfactorily address your concerns, and we respectfully ask that you take them into account in your final assessment.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Response to the AC and All Reviewers

We thank the Area Chair and the four reviewers for their time and constructive evaluation. We are encouraged that the reviewers recognize the strengths and contributions of our work in three main respects:

  1. A fresh, practical, and previously under-explored attack surface. All four reviewers recognize that manipulating Semantic IDs (SIDs) through catalog text edits—boosting item exposure without retraining the recommender or accessing downstream recommendation feedback—reveals a realistic and consequential vulnerability in generative recommendation (Q8qo, 5o6G, q24S, yoYb).
  2. A convincing routing-margin analysis that unifies attack and defense. The reviewers highlight that our residual-quantization (RQ) margin analysis accurately predicts which items flip, explains why SID assignments near quantization boundaries are fragile, and directly motivates a general margin-regularized codebook defense that does not depend on a specific victim architecture (Q8qo, q24S, yoYb).
  3. Comprehensive empirical evaluation and strong attack-and-defense effectiveness. The reviewers appreciate our broad evaluation spanning e-commerce, news, and short-video catalogs, two SID tokenizers (RQ-KMeans and RQ-VAE), cross-encoder transfer, and text-purification baselines, where SIDAttack achieves substantial exposure gains and margin regularization significantly suppresses the attack while preserving clean recommendation utility (5o6G, q24S, yoYb).

The questions raised by the four reviewers can be grouped into four core topics, which we address with additional experiments and clarifications in the individual responses:

  1. Topic 1: How are post-edit SID collisions resolved, and does exposure reflect true item-level retrieval? The reviewers asked how a re-encoded listing maps back to an individual item under prefix collisions, and whether exposure could be credited from a shared semantic prefix alone (Q8qo, 5o6G, q24S). Our resolution: We clarify the end-to-end causal chain from anchor similarity to SID rerouting, generator prefix probability, and item-level exposure, as well as the distinction between a semantic prefix and a complete item identifier that appends a collision-resolution token. After an edit, the lookup table and constrained-decoding trie are updated so that existing items keep their complete IDs and the edited item receives an unused collision token under a strictly frozen model stack. Concrete decoding traces confirm that exposure credits an item only when its own complete identifier is decoded into a user's top-K recommendation list. (See Q8qo W3, Q1; 5o6G W1, Q1; q24S W2)

  2. Topic 2: Does SIDAttack's advantage stem from its multi-anchor search design rather than search budget, initialization, or editable region? The reviewers asked to isolate AnchorPort-GCG's design contribution from total candidate evaluations, random restarts, runtime cost, and in-place body edits (5o6G, q24S, yoYb). Our resolution: Under a strictly matched candidate-evaluation budget across all datasets and suffix lengths, we evaluate multi-step iterative HotFlip, full-budget single-anchor GCG, same-anchor random restarts, objective/diversity ablations, wall-clock runtime, and native in-body HotFlip. SIDAttack consistently and substantially outperforms all equal-budget baselines and ablations while matching single-anchor GCG in runtime and running faster than iterative HotFlip; moreover, append-only suffixes preserve original product facts completely intact with lower full-text perplexity and higher exposure gains than in-body token replacement. (See 5o6G W2, Q2; q24S W1, Q1; yoYb W1)

  3. Topic 3: Does the vulnerability persist under fluency constraints and in large, sparse codebooks? The reviewers asked whether SIDAttack relies on high-perplexity token strings and whether both the attack and the defense remain effective when the codebook is scaled to a sparse regime (Q8qo, q24S). Our resolution: We evaluate (i) a fluency-constrained AnchorPort-GCG objective scored by an independent language model, and (ii) codebook utilization and collision diagnostics alongside attack and defense evaluations on a scaled sparse codebook where nearly all occupied buckets are singletons. Fluency-constrained optimization markedly lowers both suffix and full-listing perplexity while retaining most of the unconstrained exposure gain, and in the sparse large-codebook regime SIDAttack continues to drive strong exposure gains while margin regularization effectively suppresses the attack and preserves clean recall. (See Q8qo W1, W2, Q2; q24S Q2)

AuthorsOpenReview ↗

Response to the AC and All Reviewers

  1. Topic 4: Is robustness driven by the margin regularizer itself, does it survive adaptive re-optimization, and does the attack transfer to held-out LLM encoders at equal compute? The reviewers asked for a control isolating the margin penalty from codebook retraining, an adaptive attack after defense deployment, and equal-compute transfer to held-out LLM-based encoders (5o6G, yoYb). Our resolution: We add (i) a matched codebook-update control without the margin penalty, (ii) an adaptive attack using a margin-regularized surrogate quantizer and differentiable soft-routing loss, and (iii) equal-compute transfer from public BERT-family surrogates to held-out LLM-based Qwen3-Embedding victims across model scales. Updating the codebook without the margin penalty leaves attack exposure nearly unchanged, whereas enabling the margin regularizer eliminates or sharply cuts exposure gains while preserving clean utility; the defended system keeps adaptive gains well below the undefended attack across all domains and budgets; and equal-compute multi-surrogate search consistently outperforms single-surrogate transfer on all held-out LLM victims. (See 5o6G W3, Q3; yoYb W3, Q1, Q2)

Detailed experimental tables and analyses are provided in the individual responses below. Beyond these responses, we have also incorporated all of the above clarifications and new results into the appendix of the revised paper and highlighted them in dark blue, so that the AC and the reviewers can locate and read these changes directly. We sincerely thank the AC and all four reviewers again for their constructive feedback, and we kindly hope that these new results and clarifications will be taken into consideration in the final evaluation.

Summary of Contributions and Discussion

Dear Area Chair and Reviewers,

Thank you for your time during the review and discussion. As the discussion period closes, we summarize what the paper contributes, what it finds, and what the discussion added.

Core contributions

  1. A new attack surface. Generative recommenders retrieve items through Semantic IDs (SIDs) computed from item text, so a seller who edits a listing can change its SID while the recommender stays fixed. All four reviewers list this attack surface among the paper's strengths.
  2. SIDAttack. It appends a short suffix and leaves the original title and description unchanged. The search uses only gradients from public text encoders and publicly visible popular items, with no access to the victim tokenizer, codebook, or recommendation feedback.
  3. One margin analysis for both attack and defense. The residual-quantization routing margin predicts which items change SID, and penalizing small margins during codebook construction gives a defense that does not depend on the victim architecture.

Main findings

  1. SID changes are predictable. The routing margin predicts SID flips under natural rewrites with AUC 0.930, 0.869, and 0.847 at the three SID levels.
  2. A 24-token suffix moves exposure substantially. Mean Exp@50 rises from 0.09 to 6.23 on Beauty, 0.14 to 61.49 on Industrial & Scientific, and 0.21 to 182.85 on Toys & Games. SIDAttack gives the largest gain among the six evaluated methods on all five catalogs (products, news, short video) under both RQ-KMeans and RQ-VAE.
  3. The gain comes from the multi-anchor search, not the budget. At an equal budget of 1,536 candidate evaluations, SIDAttack beats iterative HotFlip and single-anchor GCG on all five datasets and at every suffix length tested, at the runtime of single-anchor GCG. Tripling the single-anchor budget does not help (+3.93 vs. +3.92 on Beauty).
  4. The attack does not need the victim encoder. Suffixes found on Qwen3 transfer to a held-out BGE victim, and suffixes found on BERT-family encoders transfer to held-out LLM-based Qwen3 victims. Joint multi-surrogate search improves transfer in both directions.
  5. Margin regularization suppresses the attack and preserves utility. At 24 tokens the gain falls from +6.14 to −0.04 on Beauty and by 55.7% and 54.1% on the other two domains, with over 99% of clean Recall@50 retained.

What the discussion added

Reviewer Q8qo followed up on 18 Nov, writing that "Item-level attribution is now clear" and that the fluency-constrained experiments "show that the constraint lowers perplexity while largely preserving the exposure gain." We answered the remaining questions the same day; those measurements are the follow-up results in the first two items below. We have not yet received follow-up from Reviewers 5o6G, q24S, and yoYb, so the list maps each of their points to the new evidence, set in blue in Appendices J–P of the revised PDF:

  • Item-level exposure and collisions (Q8qo W3/Q1, 5o6G W1/Q1, q24S W2): complete four-token identifiers, the trie update, and a decoding trace (Appendix J). Follow-up: the frozen generator decodes 72.1%, 83.6%, and 90.2% of training-unseen complete IDs into at least one user's top-50. Exp@50 counts a user only when the target's own complete ID is decoded, so it measures item-level exposure at the retrieval stage, which gates any later ranking.
  • Detectability (Q8qo W1, q24S Q2): a fluency-constrained objective keeps 85–99% of the gain (Appendix L). Follow-up: a perplexity filter calibrated at the clean 95th percentile flags 7%, 10%, and 8% of constrained edits, against 29%, 37%, and 24% of unconstrained ones, with constrained suffix examples.
  • Codebook scale (Q8qo W2/Q2): at K = 2048 (8.6 billion possible prefixes, 95th-percentile bucket size of one), the attack still gains +4.80, +39.80, and +162.89, and the defense removes 73%, 42%, and 51% of that gain with over 99% of Recall@50 (Appendix M).
  • Equal-budget baselines and cost (5o6G W2/Q2, q24S W1/Q1, yoYb W1): iterative HotFlip, full-budget single-anchor GCG, same-anchor restarts, and runtime (Appendix K); in-body HotFlip (Appendix L).
  • Source of the robustness (5o6G W3/Q3): the same codebook update with the margin weight set to zero leaves the gain nearly unchanged (+5.58, +56.87, +171.36), so the reduction comes from the margin penalty (Appendix N).
  • Adaptive attacker (yoYb Q1): re-optimizing against a margin-regularized surrogate recovers part of the gain, which stays below the undefended attack in every domain and budget, e.g., +1.24 vs. +6.14 on Beauty (Appendix O).
  • Structurally different encoders (yoYb W3/Q2): equal-compute transfer to held-out LLM-based Qwen3 victims (Appendix P).
  • Statistical reporting (yoYb W2): all comparisons are paired on the same 100 targets and seeds; item-level confidence intervals will accompany the final version.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.