- Rating
- 1
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 1
- Soundness
- 1
Read review
Paper summary
This paper investigates resource-consumption attacks against adaptive visual token pruning in Vision-Language Models (VLMs). The authors propose the Budget Inflation Attack (BIA), which introduces adversarial image perturbations to increase the number of retained visual tokens, thereby increasing inference costs. The method is evaluated across multiple pruning mechanisms under both white-box and black-box settings, with experiments measuring token inflation, task accuracy, and inference overhead.
Critical strengths
- The paper reveals a potential security risk in adaptive visual token pruning mechanisms, showing that adversarial image perturbations can increase resource consumption in VLMs.
Critical weaknesses
1. Poor Presentation and Unclear Experimental Reporting.
The paper suffers from several presentation issues that significantly affect readability. Some figures contain excessive whitespace and small, difficult-to-read text, particularly Figure 1 on Page 2. The terminology and metric names are not consistently presented across sections and tables, and the Appendix is poorly organized. Moreover, some experimental descriptions appear inconsistent, such as the different training sample counts reported for universal patches. These issues make the paper unnecessarily difficult to follow and reproduce.
2. Lack of Competitive Baselines and Limited Practical Significance.
The evaluation only compares the proposed attack against clean inputs and random perturbations, without considering existing VLM resource-consumption attacks, such as DeSparsify and Verbose-image. More importantly, the attack relies on specific adaptive visual token pruning mechanisms, significantly restricting its applicability. Its effectiveness also varies considerably across pruning methods. Although the retained visual token count can increase substantially, the maximum reported end-to-end latency increase is only 1.15×. The paper does not sufficiently analyze output token lengths or demonstrate corresponding billing increases. Therefore, it remains unclear whether this specialized attack offers meaningful practical advantages over existing, more broadly applicable VLM DoS attacks.
3. Insufficient Validation of Attack Stealthiness and Task Utility.
The paper emphasizes imperceptible perturbations and preserved task performance, but the experimental results do not consistently support these claims. For example, the accuracy of AgilePrune-S on POPE drops from 85.50% to 65.79%. Moreover, some adversarial images exhibit visually noticeable modifications, particularly the universal patches, raising concerns about their perceptual quality and the claimed imperceptibility. Although SSIM and PSNR are reported, these metrics alone may not adequately reflect human perception. A human evaluation study with perceptual quality ratings would help validate the stealthiness of the proposed attacks.
Questions for authors
-
Given the limited applicability of BIA to specific adaptive token pruning mechanisms and the relatively small end-to-end latency increase (up to 1.15×), what practical advantages does BIA offer over existing VLM DoS attacks?
-
How does the increase in retained visual tokens translate into actual inference costs? Were output token counts and decoding overhead controlled or analyzed when measuring latency?
-
How do the authors justify the claims of preserved task performance and imperceptibility, given the substantial accuracy degradation in some experiments and the visually noticeable modifications in certain adversarial images? Would human perceptual evaluations be necessary to validate the latter claim?
6 comments
W2 / Q1 / Q2: Baselines and practical significance
(i) Baselines.
DeSparsify[1] and BIA share the same high-level goal: perturb the input so that a token-reduction mechanism keeps more tokens and inference costs more. They differ in where the attack happens, what it costs the victim, and which objectives work.
a) Different setting and different cost. DeSparsify attacks token sparsification inside a vision transformer (ATS, AdaViT, A-ViT) used for image classification, so extra tokens only add vision-encoder compute. BIA attacks visual-token pruning between the vision encoder and the language model of a VLM. Every token that survives pruning goes into the LLM. Each one adds prefill computation and a KV-cache entry that is held for the whole generation. That is the main cost of serving a VLM, and services that bill by input tokens would charge more for it. This is why the attack raises KV-cache memory by up to 2.42× (Figure 3).
b) Different pruning rules need different objectives. DeSparsify's losses raise the score each token needs in order to be kept. This simple strategy does not work for most of the VLM pruning rules we study:
- PruMerge and TRIM keep only the tokens whose scores are statistical outliers, i.e. above the threshold (the standard box-plot outlier rule). Because this threshold is computed from the scores themselves, raising all scores also raises the threshold, so the count barely changes. Our loss (Eq. 4) instead reshapes the score distribution: it keeps the lower three quarters of the scores low and tightly grouped, pushes the top quarter well above them, and penalizes overshooting the 144-token limit.
- TRIM sets its budget from the question as well as the image, so the same image gets a different budget for each question.
- GlimpsePrune makes its keep/drop decision at layer 21 of the 32-layer language decoder. Gradients must pass through 22 half-precision LLM layers, which requires dynamic loss rescaling to avoid overflow.
- AgilePrune sets its budget from the effective rank of the visual features. We raise that rank by optimizing the eigenvalue spectrum in double precision, because in float32 much of the spectrum collapses and passes no gradient.
In short, DeSparsify shows that sparsification inside a ViT can be attacked. BIA shows that the pruning stage of a VLM is also an attack surface. DeSparsify’s losses target ViT-internal sparsifiers (ATS, AdaViT, A-ViT), so applying them to VLM pruners would require re-engineering the attack rather than a direct comparison. We didn't any official code in their github repository. So we can't directly compare their attack in pruning scenario. We have requested for the code to the author.
Verbose-image[2] attacks a different axis of VLM inference than ours. It is a decode-side sponge: it perturbs the input image so that the language model lowers the probability of the end-of-sequence (EOS) token, which delays termination and forces the model to generate a much longer output sequence. Our attack works on the opposite side. We leave the generated output untouched and instead inflate the number of input (visual) tokens that the adaptive compressor retains and feeds to the language model. Because one attack targets the output and the other targets the input, a direct head-to-head comparison is not possible.
We evaluated Verbose-image by generating its adversarial images with the official code (BLIP-2, = 2/255, 100 MS-COCO images) and fed them to each pruning mechanism on LLaVA-1.5-7B. The result is shown in Table A.
Table A: Retained visual tokens on images attacked by Verbose-image , 100 MS-COCO images, = 2/255. Ratio = Verbose-image input token count / Clean input token count
| Method | Clean Input Token Count | Verbose-image Input Token Count | Ratio |
|---|---|---|---|
| PruMerge | 31.4 | 33.1 | 1.05$\times$ |
| TRIM | 115.3 | 115.2 | 1.00$\times$ |
| AgilePrune-S | 98.0 | 99.7 | 1.02$\times$ |
| AgilePrune-E | 109.3 | 112.2 | 1.03$\times$ |
| GlimpsePrune | 193.5 | 191.8 | 0.99$\times$ |
Verbose-image changes the number of retained visual tokens by at most 0.05. At the same budget, BIA increases it by 1.12$\times$ to 7.54$\times$ (Table 6 in the submitted paper). Verbose-image lengthens the generated output, while BIA inflates the visual input kept for the language model. The two are complementary attack surfaces, and an existing output-length attack does not achieve what BIA does. Besides, BIA leaves output length unchanged, monitoring for abnormally long responses does not detect it. In short, we can say BIA inflates prefill, Verbose images inflates decoding.
[1] DeSparsify: Adversarial Attack Against Token Sparsification Mechanisms in Vision Transformers, NeurIPS 2024 [2] Inducing High Energy-Latency of Large Vision-Language Models with Verbose Images, ICLR 2024
(ii) Applicability. We agree that BIA applies only to adaptive pruning. That is its intended scope: it shows that an input-dependent token budget is itself an attack surface. Within that scope, the four mechanisms span the main ways a budget is set: outlier thresholds (PruMerge, TRIM), a learned gate (GlimpsePrune) and feature rank (AgilePrune). BIA inflates all four, and on GlimpsePrune it removes the pruning savings entirely. We will also state the practical lesson for defenders: any adaptive budget should have a hard cap. Effectiveness varies across mechanisms mainly because of those caps. TRIM and AgilePrune-S are bounded at 144 and 106 tokens, so their inflation is limited by design, not by the attack.
(iii) Practical impact beyond end-to-end latency
We agree that the maximum end-to-end latency increase of 1.15$\times$ may appear relatively small. However, end-to-end latency for a single request does not fully capture the resource impact of our attack. In our evaluation, the generated responses are short, so increasing the number of visual tokens mainly affects input processing rather than output generation.
An additional concern is GPU memory usage. When more visual tokens are retained, the language model needs additional KV-cache memory to process and store their representations. This can reduce the number of requests that can be served concurrently. To investigate this effect, we additionally measured KV-cache usage and concurrent serving capacity on a 48 GB GPU. Table B shows the results of concurrent serving capacity.
Table B. KV-cache usage and concurrent serving capacity for clean and adversarial inputs.
| Method | Clean KV-cache (MiB) | Attack KV-cache (MiB) | Clean Concurrent Requests | Attack Concurrent Requests |
|---|---|---|---|---|
| PruMerge | 58.2 | 103.3 | 338 | 151 |
| TRIM | 102.1 | 109.9 | 177 | 161 |
| GlimpsePrune | 239.7 | 325.8 | 60 | 52 |
The results show that token inflation can reduce concurrent serving capacity even when the increase in single-request latency is relatively small. For example, PruMerge's KV-cache usage increases from 58.2 MiB to 103.3 MiB per request. At the same time, the measured concurrent serving capacity decreases from 338 to 151 requests, a 2.24$\times$ reduction in the number of requests that can be served concurrently.
We will include this analysis to provide a clearer picture of the resource overhead caused by the attack.
(iv)Output-token length and billing.
Output-token length. Across all five mechanisms the generated output length stays the same under attack (it does not increase), because our attack targets input visual tokens, not generation. Table C shows the average number of output tokens generated by the VLM for clean and adversarial images.
Table C: Average generated output token length for clean and adversarial images across different pruning mechanisms.
| Method | Clean output Token | Attacked output Token |
|---|---|---|
| PruMerge | 3.15 | 2.94 |
| TRIM | 3.14 | 3.01 |
| AgilePrune-S | 3.12 | 3.02 |
| AgilePrune-E | 3.13 | 3.01 |
| GlimpsePrune | 3.09 | 2.93 |
Since the output length is unchanged, the attack is not visible to the user in the response, and the added cost comes entirely from the inflated input (prefill) tokens.
Billing. Usage-based APIs charge per input token, and retained visual tokens are input tokens. This cost therefore scales with the token ratio rather than wall-clock latency, and it also covers the ensemble attack. Table D shows the average number of visual tokens retained for clean and adversarial images
Table D: Additional retained visual tokens per 1,000 requests under BIA.
| Method | Tokens/req clean | Tokens/req attack | Extra input tokens per 1,000 requests |
|---|---|---|---|
| PruMerge | 41 | 131 | 90,000 |
| TRIM | 129 | 144 | 15,000 |
| AgilePrune-S | 94 | 106 | 12,000 |
| AgilePrune-E | 100 | 351 | 251,000 |
| GlimpsePrune | 75 | 576 | 501,000 |
The per-request difference is small in isolation, but it aggregates linearly: at scale the attack adds up to half a million extra billed input tokens per 1,000 requests on the uncapped mechanisms.
We thank the reviewer for the careful review. We accept the presentation criticisms in full. We also agree that our claims of imperceptibility and preserved utility were stated too strongly. Below we (1) list the concrete presentation fixes, (2) add the baselines and cost analyses requested in W2/Q1/Q2, and (3) narrow the stealth and utility claims to what our results support.
W1: Presentation and Unclear Experimental Reporting. We agree that our current figure and presentation has some flaws. Thanks for pointing this out and we will update that accordingly.
(i) Figures: We will redraw Figure 1 to remove the surrounding whitespace and enlarge all in-figure text, panel titles, pipeline labels, and the metric boxes to the body font size so it is legible at print scale. We will apply the same readability pass to Figures 2-4.
(ii) Consistent terminology and metric names: We have audited every name across the text, tables, and figures and will standardize them:
(iii) Appendix organization. We will reorganize the appendix into clearly labeled subsections - a) attack hyperparameters per solver, b) per-mechanism deployed-count definitions, c) dataset and split details, and d) supplementary tables - with a short pointer list at the top.
(iv) Universal-patch training sample counts. Thanks to the reviewer for pointing this out. The paper currently states "200 image-question pairs" in the Implementation settings (Section 5.1, p. 7) and "500 images" in the Universal Patches description (Section 5.4, p. 8). The correct value is 200: each 64×64 patch is trained on 200 image-question pairs that are disjoint from the evaluation set, and evaluated on 2,666 held-out images (4,224 questions). We will correct the "500 images" statement to "200 training images" and state the disjoint train/eval split (200 training vs 2,666 held-out images) consistently in both Section 5.1 and Section 5.4.