acceptodds
Under review as a conference paper at ICLR 2027

Prune Less, Pay More: Imperceptible Budget Inflation Attacks on Token Pruning in Vision-Language Models

Abstract

The growing number of visual tokens processed by Vision-Language Models (VLMs) increases inference costs, motivating token pruning and compression techniques that reduce computational demand. Increasingly, these techniques adapt the number of retained tokens to the complexity of each input. The count is determined by statistical thresholds, learned importance predictors, or image-complexity estimators. In this work, we show that this flexibility introduces a hidden opportunity for adversarial cost amplification: an imperceptibly perturbed image can cause a VLM to retain substantially more visual tokens than its clean counterpart while preserving task performance. Consequently, users may incur greater resource consumption without noticing changes in either the image’s appearance or the quality of the model's response. Unlike existing attacks that manipulate token selection within a fixed budget to degrade accuracy, our attack targets the adaptive token budget itself. We propose the Budget Inflation Attack (BIA), which optimizes imperceptible image perturbations to induce content-adaptive compressors to retain more tokens, undermining their intended efficiency benefits. Across multiple adaptive pruning mechanisms and datasets, BIA increases retained visual token counts by significantly while leaving task accuracy essentially unchanged. This token inflation can increase inference computation, latency, and energy consumption. More importantly, it may translate into higher user charges when billing reflects the additional processing. Our findings reveal that adaptive visual token pruning creates an overlooked attack surface: adversaries can erode efficiency and consume resource budgets while preserving the apparent utility of the system. Our code is available at https://anonymous.4open.science/r/PLPM/README.md.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Visual Token Pruning, Energy-Latency Attacks, Vision-Language Models, Inference Efficiency

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_DUigOpenReview ↗
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
  1. 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
  1. 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?

  2. 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?

  3. 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

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:

  • AgilePruner variants: The two variants will be named AgilePrune-S (scaled) and AgilePrune-E (effective-rank) everywhere. This fixes the mismatch where the table rows read AgilePrune patch (Tables 3 and 7) while the columns read "AgilePrune-S"/"AgilePrune-E".
  • Metric name: The quantity the attack inflates will be called retained visual tokens throughout, with the column header Token Count used uniformly. This removes the current mix of "Token Count" (Tables 1, 2, 4), "Tokens" (Tables 3, 6), and "retained visual token counts" in the text.

(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.

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 Q3+1.5⋅IQRQ_3 + 1.5\cdot\mathrm{IQR} (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, ϵ\epsilon = 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, ϵ\epsilon = 2/255. Ratio = Verbose-image input token count / Clean input token count

MethodClean Input Token CountVerbose-image Input Token CountRatio
PruMerge31.433.11.05$\times$
TRIM115.3115.21.00$\times$
AgilePrune-S98.099.71.02$\times$
AgilePrune-E109.3112.21.03$\times$
GlimpsePrune193.5191.80.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.

MethodClean KV-cache (MiB)Attack KV-cache (MiB)Clean Concurrent RequestsAttack Concurrent Requests
PruMerge58.2103.3338151
TRIM102.1109.9177161
GlimpsePrune239.7325.86052

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.

MethodClean output TokenAttacked output Token
PruMerge3.152.94
TRIM3.143.01
AgilePrune-S3.123.02
AgilePrune-E3.133.01
GlimpsePrune3.092.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.

MethodTokens/req cleanTokens/req attackExtra input tokens per 1,000 requests
PruMerge4113190,000
TRIM12914415,000
AgilePrune-S9410612,000
AgilePrune-E100351251,000
GlimpsePrune75576501,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.

Reviewer_degwOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes BIA, an attack that increases the number of visual tokens retained by adaptive VLM pruning. It measures token counts, task accuracy, and serving costs across four pruning mechanisms. The attack is interesting, but the claims about imperceptibility, utility preservation, and black-box generality are too strong. I do not recommend acceptance in the current form.

Critical strengths
  • It identifies an important resource-exhaustion surface in adaptive token pruning.
  • The objectives are adapted to threshold, gate, and effective-rank pruning rules.
  • The paper reports token counts, TTFT, latency, KV-cache size, and accuracy.
  • Transfer and universal-patch experiments broaden the analysis.
Critical weaknesses
  • The black-box patch is not imperceptible. The 64×64 universal patch is unconstrained, while bounded attacks reach 16/255. No human perceptual evaluation or clear stealth criterion is provided.

  • Task accuracy often drops substantially. In the TextVQA sweep, GlimpsePrune rises from about 76 to 576 tokens while accuracy drops from 58.27% to 51.88%; the PruMerge universal patch changes accuracy from 54.5% to 47.3%.

  • Transfer is narrow and inconsistent. All four mechanisms share the LLaVA/CLIP backbone, and Table 2 shows that some source attacks transfer weakly or even reduce the target count. There is no held-out encoder or unrelated pruning architecture.

  • The white-box setting assumes implementation access. The attack uses half-precision thresholds, straight-through rounding, PNG reloads, and the highest-count intermediate image. Results should also be tested without knowing the victim’s exact arithmetic and export path.

Questions for authors

See Weakness.

4 comments

We sincerely thank the reviewer for a thoughtful, expert review, and for recognising the importance of the attack surface, our rule-specific objectives and the breadth of our cost measurements. We agree that our claims of imperceptibility, utility preservation and black-box generality were stated too strongly. Below we narrow each claim to what our results support and present new robustness experiments.

W1 :(The universal patch). We agree: the 64×64 patch is unconstrained and visible, and it should not be described as imperceptible. It belongs to the visible adversarial-patch threat model (Brown et al., 2017), in which a single reusable pattern is pasted onto many images. We include it to test whether one pattern can inflate the budget across unseen images, not as a stealthy attack. We will label it "visible universal patch" throughout and remove it from any imperceptibility claim.

Stealth criterion for the bounded attacks. We will state the criterion explicitly. The imperceptibility claim applies only to per-image attacks at ε ≤ 2/255 (SSIM ≥ 0.98, PSNR ≥ 43.8 dB for every mechanism, Table 6). Larger budgets (8/255 and 16/255) are reported as a stress test of how far inflation can go, and are not presented as imperceptible. At ε = 2/255 the attack still inflates every mechanism (TextVQA, Table 6):

MethodClean tokensBIA tokens (ϵ\epsilon = 2/255)InflationSSIMPSNR (dB)
PruMerge41.3054.921.33×0.982044.97
TRIM128.42143.661.12×0.982443.85
AgilePrune-S94.70106.001.12×0.981844.27
AgilePrune-E100.83250.302.48×0.982443.78
GlimpsePrune75.97573.127.54×0.982643.89

For comparison, the patch and the 8/255 ensemble attack:

InputSSIMPSNR (dB)
Ensemble universal patch0.960421.61
Ensemble per-image attack (ϵ\epsilon = 8/255)0.832631.95

The patch's high SSIM comes from leaving most of the image untouched. Its low PSNR reflects a large, localised change, so SSIM alone does not establish that it is hard to see.


W2 : Accuracy. We agree that the accuracy cost is often substantial, and we will remove the claim that accuracy is "essentially unchanged". In our threat model (Sec. 3) token inflation is the primary goal and answer quality is a secondary goal that we measure jointly. The revised paper will report the trade-off per mechanism and per ϵ\epsilon.

The accuracy cost depends on ϵ\epsilon and on the mechanism.

At ϵ\epsilon = 2/255 (Table 6, TextVQA):

MethodInflationAccuracy change (pts)
PruMerge1.33×−2.22
TRIM1.12×−2.09
AgilePrune-S1.12×+0.25
AgilePrune-E2.48×−3.39
GlimpsePrune7.54×−4.90

The trade-off is therefore not all-or-nothing. At the stealth budget GlimpsePrune is inflated 7.5x for a 4.9-point drop, and PruMerge, TRIM and AgilePrune-S lose at most about 2 points. Accuracy loss grows with ϵ\epsilon, and we will state this plainly.

On the PruMerge universal-patch figure. In Table 3 the PruMerge universal patch changes PruMerge accuracy from 54.5% to 51.6% (−2.9 points). The 47.3% value belongs to the per-image ensemble attack row at ϵ\epsilon = 8/255. We will make the two rows easier to tell apart.

W3: Transferability. We agree with both points and will scope the claim accordingly. Our black-box setting means that the attacker does not know which pruning rule is deployed. It does not mean the attacker does not know the backbone. All four pruning methods were released for, and are evaluated on, LLaVA-1.5 with CLIP ViT-L/14-336, which is the standard testbed in this literature.

Single-source transfer (Table 2) is inconsistent, and in some cases it lowers the target count. Each objective is designed for one budget rule: an outlier threshold, a question-conditioned score, a learned gate or an effective rank. Inflation achieved under one rule therefore need not carry over to another. This result is what motivated the ensemble attack.

Leave-one-out ensemble: the unseen-rule result. For each target we remove it from both gradient sampling and candidate selection, regenerate the images with the remaining three mechanisms, and evaluate them on all five configurations. The bold cells are the held-out (unseen-rule) results.

InputimagePruMergeTRIMAgilePrune-SAgilePrune-EGlimpsePrune
Clean40.8/54.5128.7/53.594.5/56.8100.6/57.075.8/58.1
Fullensemble119.2/47.3136.4/47.9103.0/48.6115.7/48.6457.2/48.4
w/oPruMerge62.4/47.2138.6/46.6103.9/48.4116.8/48.5531.8/48.4
w/oTRIM138.8/47.0129.7/47.0105.2/47.8119.7/47.9566.9/47.3
w/oAgilePrune121.0/47.6138.8/47.3100.8/48.4112.3/48.2483.8/48.2
w/oGlimpsePrune125.4/48.2137.5/48.1103.4/49.4115.0/49.579.4/50.3

(TextVQA, ε = 8/255, tokens / accuracy %.)

On an unseen rule, inflation is 1.53× on PruMerge, 1.12× on AgilePrune-E, 1.07× on AgilePrune-S, 1.05× on GlimpsePrune and 1.01× on TRIM. We take from this that black-box inflation is real but strongly rule-dependent. Rules that threshold scores computed before the LLM (PruMerge) are exposed even to an attacker who does not know the rule. Question-conditioned (TRIM) and learned-gate (GlimpsePrune) rules mostly require knowing the rule. We will state this clearly in Sec. 5.4.

Held-out model. Appendix A.1 replays the 7B adversarial images through LLaVA-1.5-13B without re-optimization. This changes the language model and, for GlimpsePrune, the learned gate, which is retrained at each scale. PruMerge and TRIM transfer unchanged (40.9 →\rightarrow 131.1 and 119.1 →\rightarrow 144.2), because they decide inside the shared CLIP tower. GlimpsePrune's retrained gate is still inflated, from 94.4 to 172.9 (1.83x), though far below the 576 reached at 7B. Inflation therefore survives a change of LLM and gate, but this is not a held-out encoder.


W4: White box attack.

a)Half-precision thresholds: We use FP16 because it is the precision used by LLaVA-1.5 and GlimpsePrune in our evaluated setup, so generating and evaluating attacks in FP16 follows the victim's actual inference setting. For PruMerge, FP16 has a large effect on pruning: about 92% of the CLS-to-patch attention values underflow to zero in half precision, which collapses the Tukey fence and sets how many tokens PruMerge retains.

To directly address the reviewer's request, we ran a precision-mismatch evaluation: we re-score the same FP16-optimized adversarial images under BF16 and FP32 deployment on 300 TextVQA images (Due to short time in rebuttal. We will replace this result with full dataset results in the revised paper). We report the realized inflation RK=(attacked token count)/(clean token count)R_K = (attacked\ token\ count)/ (clean\ token\ count) under each deployment precision. Table A shows this result.

Table A: Token inflation ratio (RKR_K) of FP16-optimized adversarial images under (FP16, BF16, and FP32) on 300 TextVQA images.

MechanismFP16BF16FP32
PruMerge3.67$\times$1.19$\times$1.19$\times$
TRIM1.11$\times$1.09$\times$1.11$\times$
AgilePrune-S1.12$\times$1.11$\times$1.12$\times$
GlimpsePrune7.18$\times$7.31$\times$notapplicable

For PruMerge the effect is precision-specific. Under BF16/FP32, whose wider exponent has no underflow floor, it is the clean baseline that moves, not the attacked count. We present this result on Table B.

Table B: Average retained visual token counts under different numerical precisions in PruMerge, evaluated on 300 TextVQA images.

PruMergeCleanAttacked
FP1639.50144.89
BF16117.63139.95
FP32117.84140.35

In FP16 the clean count is floored to about 40, and the attack lifts it to about 145 under BF16/FP32. So this is the official implementation of Prumerge. They use the FP16 to reduce the token count for any image.

For TRIM, AgilePrune-S, and GlimpsePrune the inflation is precision robust as it survives the FP16 to BF16 to FP32 switch essentially unchanged. In summary, the attack's effect is precision-specific for PruMerge (official implementation uses FP16) and measured precision-robust for TRIM, AgilePrune-S, and GlimpsePrune.

b) Straight-through rounding : Straight-through estimation (STE) is used to calculate gradients through the non-differentiable pixel-rounding operation. Our attack operates on integer pixel values, but rounding prevents gradients from passing through the operation directly. STE provides an approximate gradient that allows us to optimize the perturbation. Importantly, STE is used only during attack generation. It does not change the victim model or the image provided to it. The final adversarial input is a regular image containing integer pixel values.

c) PNG reloads : We agree that the image export and preprocessing pipeline can affect adversarial perturbations. In our experiments, the perturbations are optimized on the integer pixel grid. The resulting images are saved as PNG files and reloaded before evaluation.

Since PNG uses lossless compression, this process preserves the integer pixel values under the same image representation. Moreover, the reported token counts are obtained from the saved and reloaded images rather than directly from the optimization variables. We verified this directly by reloading each saved adversarial PNG from disk and recomputing the deployed token count reproduces on all 300 images for all four mechanisms.

Table C: Comparison of retained visual token counts before and after PNG save-and-reload, evaluated on 300 TextVQA images at ϵ=8/255\epsilon = 8/255.

MethodIn-attack countReloaded-from-PNG countExact matchMax token difference
PruMerge144.89144.89100%0
TRIM143.78143.78100%0
AgilePrune-S105.94105.94100%0
GlimpsePrune576.00576.00100%0

The reloaded counts match the in-attack counts with zero token difference across all 300 images. We note that this covers the 8-bit PNG round-trip at the model's input resolution.

d) Highest-count intermediate image (keep-best). Our attack selects the intermediate image with the highest token count rather than always using the final iteration. To understand how much this selection affects our results, we conducted an ablation study comparing the final iteration with the best intermediate iteration. We evaluated 300 TextVQA images with a perturbation budget of ϵ\epsilon = 8/255.

Table D: Effect of best-iterate selection on token inflation (RKR_K), comparing the final and best intermediate iterations on 300 TextVQA images at ϵ=8/255\epsilon = 8/255.

MethodFinal-iterate RKR_KBest-iterate RKR_KDifference
PruMerge3.51×3.51\times3.67×3.67\times4.5%
TRIM1.09×1.09\times1.11×1.11\times1.7%
AgilePrune-S1.12×1.12\times1.12×1.12\times0.0%
GlimpsePrune7.18×7.18\times7.18×7.18\times0.0%

For PruMerge, token inflation increases from 3.51$\times$ to 3.67$\times$, an improvement of approximately 4.5%. For TRIM, the improvement is about 1.7%. These results show that our attack remains effective even when we use the final iteration without selecting the best intermediate image. However, we got the best result using the best iterate version.

Dear Reviewer degw,

We sincerely appreciate your time and feedback. We wanted to follow up to see if our responses have sufficiently addressed your concerns. If so, we would be grateful if you could consider updating your overall assessment accordingly.

Thank you again for your consideration.

Best regards,

Authors

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

This paper studies image perturbations that make adaptive VLM pruning methods retain more visual tokens. BIA optimizes a loss for each pruning rule and also explores transfer attacks, universal patches, and ensembles. Experiments on LLaVA-1.5 show large token-count increases in several settings and smaller increases in inference time, although accuracy often drops.

Critical strengths
  1. BIA substantially increases retained tokens on PruMerge and GlimpsePrune, with only a 0.95-point accuracy drop for PruMerge on POPE.

  2. The TTFT and latency measurements in Figure 3 show that token inflation can increase inference cost.

Critical weaknesses
  1. The claim that accuracy is essentially unchanged is too strong. In Table 1, GlimpsePrune loses 6.19 to 7.50 percentage points across tasks, and AgilePrune-S loses 19.71 points on POPE. The AgilePrune-S TextVQA results are also hard to reconcile: at 4/255, accuracy drops by 8.23 points in Table 1 but only 0.76 in Table 6, while both retain 106 tokens. Different data or settings might explain this, but the paper does not say. It is therefore unclear how often the attack increases cost while keeping the answer correct.

  2. Several important method and evaluation details are missing. AgilePrune-E gives the largest cache increase in Figure 3, but Section 4.2.4 only defines K_S. The PruMerge count term in Eq. (4) simplifies to n_esc/72 - 2, which does not match the claimed two-sided penalty; this could be missing hinge notation, but the implemented loss needs checking. Table 3 also does not say whether each target was excluded from both ensemble optimization and candidate selection, as required by the black-box setting. These details matter when judging what BIA adds beyond the attack framework already studied in DeSparsify.

Questions for authors
  1. Why do Tables 1 and 6 give such different accuracy drops for AgilePrune-S on TextVQA at 4/255? Please clarify the data, decoding settings, and attack configurations. For the requests used in Figure 3, how often does the answer stay correct while token count or TTFT increases, and how do output lengths change?

  2. What exactly is AgilePrune-E, and how does its budget and token-selection rule differ from the published AgilePruner extension? Which rule produced the 2.42× cache increase? Also, why does Table 2 report 106.2 tokens for AgilePrune-S when Eq. (7) caps the count at 106?

  3. Are positive-part or hinge terms missing from Eq. (4)? As written, minimizing its first term lowers the soft count rather than pushing it toward 144. Please provide the loss actually used in the experiments so that this can be checked.

  4. For each target in Table 3, which mechanisms were used for gradients and candidate scoring? Was that target excluded from both, with a separate image generated for it? If the row uses all targets during optimization, please clarify which results support the additional black-box ensemble claim.

6 comments

We sincerely thank the reviewer for a careful and detailed review, and for recognising that BIA substantially inflates retained tokens and that this translates into measurable inference cost. The reviewer's concrete catches (the Eq. (4) hinge terms, the AgilePrune-E definition, the Table 1/ Table 6 inconsistency and the black-box ensemble question) have each led to a correction or a new experiment, which we address below.

W1 and Q1:

i) Accuracy : We agree it is too strong, and we will tune down the accuracy claim. Our threat model already treats token inflation as the primary goal and answer preservation as a secondary goal that we measure jointly. The abstract did not reflect that. The revised abstract will say that BIA increases retained tokens at a modest, epsilon-controllable accuracy cost.

Smaller budgets. Table A reports ϵ\epsilon = 2/255 (all values regenerated with the final pipeline).

Table A: Retained visual token counts and task accuracy of clean and BIA-attacked images across four benchmarks at ϵ=2/255\epsilon = 2/255.

MethodImagePOPEMMEMMBenchTextVQA
TokensAcc.TokensAcc.TokensAcc.TokensAcc.
PruMergeClean36.3274.26%40.155.70%37.966.58%40.954.96%
BIA44.7872.41%52.7553.65%48.3265.20%55.1652.69%
TRIMClean118.3389.40%127.2961.04%126.5772.28%128.7655.50%
BIA137.4286.90%141.0459.62%144.5272.01%143.7553.81%
AgilePrune-SClean98.885.50%91.4161.54%84.9671.24%94.4358.31%
BIA10678.79%10649.93%105.8462.97%10658.20%
AgilePrune-EClean105.8086.18%94.8561.51%84.3371.53%100.558.12%
BIA246.0379.81%314.6453.01%228.4564.66%249.3754.43%
GlimpsePruneClean108.4188.50%201.1866.48%65.8573.82%75.9257.96%
BIA575.9580.00%575.8861.08%574.667.56%573.1653.01%

PruMerge and TRIM: accuracy stays within 0.3–2.5 points of clean on all four benchmarks, while tokens rise by up to 1.35× (PruMerge, TextVQA).

Count-saturating mechanisms (AgilePrune-S/E, GlimpsePrune): these give the largest inflation (GlimpsePrune 108 →\rightarrow 576 on POPE; AgilePrune-E 106 →\rightarrow 246 on POPE and 95 →\rightarrow 315 on MME), but their accuracy cost is larger. For example, AgilePrune-S loses 6.7 points on POPE and 11.6 on MME.

(ii) Table 1 and Table 6. Thank you for catching this. Both tables use the same TextVQA split, but Table 1 was generated with an earlier version of our evaluation pipeline that differed in loss function iteration. Table 6 uses the final pipeline. Decoding is greedy, with max_new_tokens = 128, in both cases. The discrepancy affects all TextVQA entries of Table 1, most visibly the AgilePrune-S BIA accuracy (48.13%, versus 57.51% with the final pipeline). We regenerated Table B with the final pipeline. We will revised the table in the manuscript. The corrected TextVQA column at ϵ\epsilon = 4/255 is:

Table B: White-box attacks on POPE, MME, MMBench, and TextVQA with ε = 4/255. We report mean retained visual tokens and accuracy (%).

MechanismImagePOPEMMEMMBenchTextVQA
Token CountAccuracyToken CountAccuracyToken CountAccuracyToken CountAccuracy
PruMergeClean36.374.26%40.155.77%37.966.58%41.3055.10%
Random36.8474.18%39.3455.69%38.6266.49%41.2255.58%
BIA88.473.31%9653.24%84.863.83%90.1051.26%
TRIMClean118.3389.4%127.2961.04%126.5772.28%128.4255.79%
Random119.6389.31%127.5460.98%126.7072.34%128.5654.76%
BIA140.1287.4%140.2661.11%140.9272.69%144.0853.38%
AgilePrune-SClean98.885.5%91.4161.54%84.9671.24%94.7058.27%
Random98.9085.42%91.5961.47%84.7971.31%94.8458.05%
BIA10665.79%10647.62%105.9456.98%106.0057.51%
AgilePrune-EClean105.885.37%94.8561.51%84.3371.53%100.8358.24%
Random105.9185.29%95.2361.62%84.5871.41%100.9858.77%
BIA356.2977.79%353.8849.45%280.1759.72%306.1050.10%
GlimpsePruneClean108.4188.5%201.1866.48%65.8573.82%75.9758.27%
Random108.1988.37%199.7766.31%64.4073.68%74.9558.43%
BIA575.9981%575.9959.82%575.9867.63%575.9651.88%

W2, Q3 and Q4: Experimental Details

(i) AgilePrune-S and AgilePrune-E. The main AgilePruner[1] configuration uses a fixed token budget and adapts which tokens are selected. Appendix B.5 of the official paper also describes an adaptive-count extension. It uses a reference budget of 88 tokens, reduces the count by up to 20% for low-effective-rank images, and increases it proportionally for high-effective-rank images.

Both configurations use effective rank to measure the diversity of projected visual-token features.

AgilePrune-S (scaled). This configuration scales the reference budget of 88 using the effective rank relative to the reference value of 90. We clamp the scaling factor to [0.8, 1.2]:

\operatorname{round}\left[88\cdot\operatorname{clip}_{[0.8,1.2]}\left(\frac{r(X)}{90}\right)\right]\right).$$ The upper clamp limits the retained count to $\operatorname{round}(88\times1.2)=106$ tokens. **AgilePrune-E (effective-rank).** This is an additional experimental configuration in our study. It directly uses the rounded effective rank as the token budget: $$K_E(X) = \operatorname{clip}_{[1,576]}\left(\operatorname{round}[r(X)]\right).$$ Unlike AgilePrune-S, it does not scale the reference budget or apply the [0.8, 1.2] multiplier clamp. It is also different from simply removing the upper clamp from AgilePrune-S, since that rule would still scale the rank by 88/90. [1] AgilePruner: An Empirical Study of Attention and Diversity for Adaptive Visual Token Pruning in Large Vision-Language Models, ICLR 2026 **ii) Prumerge Loss and Equation:** Thank you for catching this. The Equation (4) from the submitted paper is missing the positive-part (hinge) brackets. Without them, the count term reduces to a single linear expression, and minimizing it would lower the number of retained tokens rather than push it toward 144. This is a typesetting error in the paper but not in our implementation. Our code uses the intended two-sided hinge, and we will correct the equation in the revision. **(iii) Ensemble attack and leave-one-out evaluation.** The original "Ensemble Attack" row in Table 3 uses all four source mechanisms for optimization and candidate selection. Therefore, this row alone does not demonstrate transfer to a target that was excluded from the attack. We agree that this distinction should have been stated clearly. To evaluate an excluded target, we performed the leave-one-out experiment shown in Table C. Each row removes one pruning mechanism from the ensemble, generates a separate adversarial image set using the remaining three mechanisms, and then evaluates the saved images on all five configurations. The removed mechanism is excluded from both gradient computation and candidate selection. **Table C: Leave one out ablation of the ensemble attack on TextVQA.** (Tokens are per-image means; the per-image ensemble attack uses $\epsilon = 8/255$.) | | PruMerge | | TRIM | | AgilePrune-S | | AgilePrune-E | | GlimpsePrune | | |---|---|---|---|---|---|---|---|---|---|---| | Input Image | Tokens | Acc. | Tokens | Acc. | Tokens | Acc. | Tokens | Acc. | Tokens | Acc. | | Ensemble Attack | 119.2 | 47.3 | 136.4 | 47.9 | 103.0 | 48.6 | 115.7 | 48.6 | 457.2 | 48.4 | | Ensemble w/o PruMerge | 62.4 | 47.2 | 138.6 | 46.6 | 103.9 | 48.4 | 116.8 | 48.5 | 531.8 | 48.4 | | Ensemble w/o TRIM | 138.8 | 47.0 | 129.7 | 47.0 | 105.2 | 47.8 | 119.7 | 47.9 | 566.9 | 47.3 | | Ensemble w/o AgilePrune | 121.0 | 47.6 | 138.8 | 47.3 | 100.8 | 48.4 | 112.3 | 48.2 | 483.8 | 48.2 | | Ensemble w/o GlimpsePrune | 125.4 | 48.2 | 137.5 | 48.1 | 103.4 | 49.4 | 115.0 | 49.5 | 79.4 | 50.3 |

(iv) Relation to DeSparsify. DeSparsify 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 Q3+1.5⋅IQRQ_3 + 1.5\cdot\mathrm{IQR} (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. 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.

To test whether an existing efficiency attack on VLMs already inflates visual tokens, we evaluated Verbose-image[1]. Verbose-image perturbs images so that a VLM generates longer outputs. We generated its adversarial images with the official code (BLIP-2, ϵ\epsilon = 2/255, 100 MS-COCO images) and fed them to each pruning mechanism on LLaVA-1.5-7B.

Table D: Retained visual tokens on images attacked by Verbose-image , 100 MS-COCO images, ϵ\epsilon = 2/255. Ratio = Verbose-image input token count / Clean input token count

MethodClean Input Token CountVerbose-image Input Token CountRatio
PruMerge31.433.11.05$\times$
TRIM115.3115.21.00$\times$
AgilePrune-S98.099.71.02$\times$
AgilePrune-E109.3112.21.03$\times$
GlimpsePrune193.5191.80.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.

[1] Inducing High Energy-Latency of Large Vision-Language Models with Verbose Images, ICLR 2024


Q1: 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 E shows the average number of output tokens generated by the VLM for clean and adversarial images.

Table E: Average generated output token length for clean and adversarial images across different pruning mechanisms.

MethodClean output TokenAttacked output Token
PruMerge3.152.94
TRIM3.143.01
AgilePrune-S3.123.02
AgilePrune-E3.133.01
GlimpsePrune3.092.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.


Q2: 106.2-token entry. The 106.2-token value in Table 2 is a typo. The correct value is 106. Since AgilePrune-S has a maximum retained count of 106 for each image, its average cannot exceed 106. Thanks to the reviewer for pointing this out. We will correct the value in the revised manuscript.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.