PyramidDrop: Accelerating Your Large Vision-Language Models via Pyramid Visual Redundancy Reduction

## Abstract

Abstract In large vision-language models (LVLMs), images serve as inputs that carry a wealth of information. As the idiom “A picture is worth a thousand words” implies, representing a single image in current LVLMs can require hundreds or even thousands of tokens. This results in significant computational costs, which grow quadratically as input image resolution increases, thereby severely impacting the efficiency of both training and inference. Previous approaches have attempted to reduce the number of image tokens either before or within the early layers of LVLMs. However, these strategies inevitably result in the loss of crucial image information, ultimately diminishing model performance. To address this challenge, we conduct an empirical study revealing that all visual tokens are necessary for LVLMs in the shallow layers, and token redundancy progressively increases in the deeper layers of the model.
To this end, we propose PyramidDrop, a visual redundancy reduction strategy for LVLMs to boost their efficiency in both training and inference with neglectable performance loss. Specifically, we partition the LVLM into several stages and drop part of the image tokens at the end of each stage with a pre-defined ratio, creating pyramid-like visual tokens across model layers. The dropping is based on a lightweight similarity calculation with a negligible time overhead. Extensive experiments demonstrate that PyramidDrop can achieve a 40% training time and 55% inference FLOPs acceleration of LLaVA-NeXT with comparable performance. Besides, the PyramidDrop could also serve as a plug-and-play strategy for inference acceleration without training, with better performance and lower inference cost than counterparts. We hope that the insights and approach introduced by PyramidDrop will inspire future research to further investigate the role of image tokens in LVLMs and explore additional methods to enhance their efficiency. Our code is available at https://github.com/Cooperx521/PyramidDrop .

## 1 Introduction

In recent years, Large Vision-Language Models (LVLMs) have emerged as a central focus in deep learning research(Liu et al., ; Dai et al., ; Bai et al., ; Zhang et al., ; Chen et al., ; Huang et al., ). We have witnessed remarkable progress across various application domains, including image and video understanding(OpenAI, ; Gemini Team, ). The rapid development of MLLMs is gradually paving the way for artificial intelligence to integrate into daily life(Li et al., ; Zhu et al., ; Zhang et al., ; Liu et al., ; Chen et al., ).

However, despite the advancements in large vision-language models (LVLMs), a significant challenge lies in the escalating computational costs. Images, as continuous and information-rich signals, exhibit substantial spatial redundancy but are difficult to compress losslessly. It results in excessive image tokens and a steep increase in training and inference costs, which becomes particularly pronounced with higher image resolutions (Zhang et al., ; Wang et al., ; Hu et al., ). The number of image tokens increases quadratically with the resolution, driving the sequence length into the tens of thousands(Li et al., ). Given that the computational complexity of transformers scales with sequence length, the associated computational costs become prohibitively high(Liu et al., ; Xu et al., ). Consequently, there is a pressing need to reduce the redundancy in visual information for more efficient LVLMs.

Previous exploration of image token compression could be roughly categorized into two ideas: compressing the token number before fed into the LVLM(Shang et al., ; Arif et al., ; Li et al., ; Yao et al., ) or dropping part of the tokens at the very shallow layer of the LVLM(Chen et al., ). However, both ideas inevitably hurt the performance of LVLMs: the former suffers from the information loss introduced by their compression, and the latter drops part of the information before the LVLMs fully understand them.

To break through the limitations of the aforementioned ideas, we explore the nature of LVLMs in understanding images from an intuitive question: are all image tokens necessary for all LVLM layers? We conduct an empirical study by removing different ratios of image tokens at different layers of the LVLM at inference time and observing the benchmark performance change.
As shown in Figure 1, the LVLMs are sensitive toward token dropping on shallow layers, regardless of the dropping ratio. However, in deeper layers, image tokens gradually become less critical to the final results. The results indicate that the LVLMs understand the image layer-by-layer and the redundancy within image tokens increases correspondingly. We further visualize the attention between the instructions and the image tokens, and we observed a consistent phenomenon that in shallow layers, the LVLMs pay attention to most image tokens to understand the image globally. With the layer increasing, it tends to focus on the few tokens that are related to the instruction and the rest are unnecessary.

Based on the observation, we introduce PyramidDrop, a simple yet effective image token reduction strategy for LVLMs to accelerate both training and inference without performance loss.
PyramidDrop divides the LVLM into several stages, dropping a portion of the image tokens at the end of each stage according to a predefined ratio. We employ a lightweight attention module to rank the image tokens, which incurs negligible overhead. With this design, we retain all image tokens in the shallow layers to avoid information loss, while progressively reducing the number of tokens as the layers deepen to maximize training and inference efficiency.

Extensive experiments verify the effectiveness and efficiency of our PyramidDrop. For example, LLaVA-NeXT-7B (Liu et al., ) trained with PyramidDrop could reduce training time by 40% without sacrificing performance across 15 Vision-Language tasks. Moreover, PyramidDrop enables the LLaVA-NeXT model to be trained with doubled input resolution with only 269 GPU hours, which is 70% of the vanilla LLaVA-NeXT, and reaches a better performance on high-resolution benchmarks like DocVQA (Mathew et al., ) and InfoVQA (Mathew et al., ). Furthermore, PyramidDrop can function as a plug-and-play strategy for inference acceleration, offering enhanced model performance and fewer FLOPs than FastV (Chen et al., ).

## 2 Related Work

#### Token Reduction

The large language model (LLM) realm has made several efforts in applying token reduction for inference acceleration and KV cache compression(Han et al., ). StreamLLM(Xiao et al., ) only keeps attention sinks and the most recent tokens to reduce the size of the KV cache. FastGen(Ge et al., ) introduces an adaptive KV cache management approach that optimizes memory usage by adjusting retention strategies according to the specific properties of attention heads. Heavy-Hitter Oracle (H2O)(Zhang et al., ) employs a strategy that selectively prunes key-value pairs (KVs) during generation, utilizing a scoring mechanism driven by cumulative attention to inform the removal process. ScissorHands(Liu et al., ) concentrates on identifying and retaining important tokens that show a consistent pattern of attention weight across previous token windows during generation. These works attempt to address the redundancy of text tokens during the inference process in LLMs. As for visual tokens, existing works (Liang et al., ; Kong et al., ; Ding et al., ; Cao et al., ; Shi et al., ; Xiong et al., ) make explorations on Vision Language Models (VLMs) before the era of large vision-language models, focusing on token reduction for vision transformers (ViTs). A recent work, FastV (Chen et al., ), makes an early attempt at visual token reduction in LVLMs, which drops visual tokens at the second layer of LVLMs during inference. In contrast, our work makes a more comprehensive study of the visual redundancy in LVLMs and proposes a pyramid visual token reduction solution for both training and inference of LVLMs.

#### Large Vision Language Models

Enabled by the open-sourcing of large language models like LLaMA(Touvron et al., ) and Vicuna(Chiang et al., ), LVLMs(Tong et al., ; Chen et al., ; Yao et al., ; Huang et al., ; Liu et al., ; Ding et al., ) have advanced the ability to understand and generate diverse content by seamlessly integrating information across multiple modalities, such as text, images, and audio. Models like LLaVA(Liu et al., ), InstructBLIP(Dai et al., ), and MiniGPT-4(Zhu et al., ) have pushed the boundaries of this field, enabling users to interact with these intelligent systems through multimodal prompts(Ma et al., ; Qiao et al., ), including images and text(Ye et al., ; Chen et al., ; Huang et al., ; Zhang et al., ). Recent advances (Zhang et al., ; Wang et al., ; Hu et al., ) have significantly increased the number of image tokens for high-resolution image understanding, resulting in substantial costs for training and inference in LVLMs. This underscores the critical importance of developing more efficient training and inference methods for LVLMs.

## 3 Method

Figure: Figure 1: Observatioins about visual redundancy acoross layers. Left: TextVQA performance of LLaVA-1.5 with varying ratio of retained image tokens at different layer. The preserved image tokens are those that receive the highest attention from the text tokens. Right: Visualization of attention map in shallow and deep layers.
Refer to caption: x1.png

### 3.1 Study of Visual Token Redundancy in LVLMs

The fundamental design of PyramidDrop stems from an intuitive question: are all image tokens necessary for all LVLM layers?
To explore it and reveal the nature of LVLMs, we conduct a two-variable experiment by removing different ratios of image tokens at different layers of the LVLM at inference time and observing the benchmark performance change.

In detail, we select LLaVA-v1.5-7B (Liu et al., ) as the base model, and employ a popular LVLM benchmark, TextVQA (Singh et al., ), as the evaluation data.
TextVQA consists of a substantial number of images that contain fine-grained information like text.
The questions in TextVQA focus on the textual elements within images, requiring LVLMs to capture the global image information while mining the great detailed visual clues.
This characteristic increases the model’s sensitivity to image token compression, enabling a more precise evaluation of redundancy.

Considering LLaVA-v1.5-7B consists of 32 layers, we drop varying proportions of image tokens during inference at layer 2, 8, 16, and 24 to assess redundancy at different layers.
The ranking of tokens is based on the attention values of text tokens towards image tokens, with the retained image tokens corresponding to those with the highest attention values. As illustrated in Figure 1(a), at layer 2, the LVLMs are sensitive toward token dropping on shallow layers, regardless of the dropping ratio. This indicates most of the image tokens in shallow layers play a important role in providing information for answering the instruction. With the layer increases, the redundancy of image tokens increases rapidly. At layer 16, even preserving only 10% of image tokens will not cause an obvious performance decline. Notably, at layer 24, the model performance is nearly irrelevant to the image tokens, indicating that the model has already captured the necessary image information and the image tokens are redundant for the model now.

We further validate our hypothesis with an attention map comparison between different layers. As shown in Figure 1(b), the LVLM pays attention to most of the image tokens at shallow layers and the attention to different tokens shows a uniform pattern. On the contrary, at the middle of the LVLMs, the attention shows a sparse pattern and mainly focuses on the question related image local parts.

Figure: Figure 2: Overview of PyramidDrop. We divide the forward pass of the LLM into multiple stages, and drop part of the image tokens at the end of each stage with a pre-defined ratio. The dropping is based on a lightweight attention calculation with a negligible time overhead, and according to this criterion, the LLM accurately selects important image tokens related to instruction. Due to the efficient redundancy reduction strategy, the average sequence length decreases rapidly.
Refer to caption: x2.png

### 3.2 PyramidDrop

Previous research on image token compression typically drops image tokens before passing them to the language model or uses a fixed compression ratio across all language model layers. However, as we analyzed in Sec 3.1, redundancy is not consistent across different layers. Redundancy of image tokens is relatively minimal in the shallow layers and becomes progressively larger in deeper layers. Thus, uniformly compressing image tokens across layers may lead to the loss of valuable information in the shallow layers while retaining unnecessary redundancy in the deeper layers.

Inspired by this observation, we propose PyramidDrop, which fully leverages layer-wise redundancy to compress image tokens. The pipeline of the proposed PyramidDrop is illustrated in Figure 2. To maximize training efficiency while preserving the essential information of the image tokens, we choose to divide the forward pass of the LLM into multiple stages. In the shallow layers, we retain a higher proportion of image tokens to preserve the entire vision information. At the end of each stage, we partially drop the image tokens, until nearly all the image tokens being eliminated in the deeper layers. This approach allows us to optimize training efficiency while maintaining critical information.

#### LVLM Pre-fill Formulation.

We denote the vision encoder as $\mathcal{V}$, the vision-language projector as $\mathcal{P}$, the language model as $\mathcal{L}$, a pretrained LVLM as $\mathcal{M}=(\mathcal{L},\mathcal{V},\mathcal{P}$), where $\mathcal{L}=(\mathcal{L}_{0},\mathcal{F})$. The language model consists of tokenizer $\mathcal{L}_{0}$ and $J$-layer transformer decoder $\mathcal{F}$. We formulate an image-text pair as $(\mathcal{V},\mathcal{T})$, where the text is composed with an instruction and an answer $\mathcal{T}=\{T_{i};T_{a}\}$(^1^11Here we omit the system prompt and chat format for illustrative purposes).
The input of the transformer $\mathcal{F}$ contains both the image tokens $v_{0}=\mathcal{P}(\mathcal{V}(v))$ and the text tokens $t_{0}=\mathcal{L}_{0}(T)$.

During the forward pass of tokens, we can obtain the hidden states $v_{j}$, $t_{j}$ of vision tokens and text tokens in layer $j$, formally:

$$ $v_{j},t_{j}=\mathcal{F}_{j}(v_{j-1},t_{j-1})$ (1) $$

#### Pyramid Visual Redundancy Reduction.

We partition the language into $\mathcal{S}=\{s_{n}\}_{n=0}^{S}$ stages, and remove the image tokens $v$ with a pre-defined ratio $\lambda$ at the end of each stage. Formally, with the image tokens $v_{s_{n}}$ as the input of stage $s_{n}$, we remove $\lceil(1-\lambda)\cdot|v_{s_{n}}|\rceil$ tokens from the $v_{s_{n}}$ and treat the rest image tokens as the next stage input $v_{s_{n+1}}$.

Following our observation in Sec 3.1, the attention value between image and text tokens could reflect the image token importance properly, so we based on it to realize the drop operation. With the concern of calculation efficiency and training-inference consistency, we calculate the attention between all the image tokens and the last token of the instruction (we denote it as $t_{j}^{I}$, the last-instruction token in the following).

Formally, we denote the last layer of stage $s_{n}$ as $F_{j}$, we obtain key states of the image tokens as $k_{j}^{v}$ and the query state of last instruction token $q_{j}^{t_{I}}$ with the following operation:

$$ $k_{j}^{v}=\mathcal{K}_{j}(v_{j}),\quad q_{j}^{t_{I}}=\mathcal{Q}_{j}(t_{j}^{I}).$ (2) $$

where $\mathcal{Q}_{j}$, $\mathcal{K}_{j}$ are the query matrix and the key matrix reused from the self-attention block of $F_{j}$.

We calculate the similarity with $q_{j}^{t_{I}}\times(k_{j}^{v})^{T}$ and drop part of the image tokens based on the drop ratio $\lambda$. The image token number decreases exponentially stage by stage, and close to zero in the deeper layers. We denote the image token number of $v_{0}$ as $V=|v_{0}|$, and the image token number at each stage $V_{s}$ could be calculated as:

$$ $V_{s}=V_{0}\cdot\lambda^{s-1},\quad s=1,2,\dots,S$ $$

#### Efficiency Analysis of PyramidDrop

Here we analyze the efficiency from two parts: the computation overhead introduced by PyramidDrop, and the input sequence computation cost economized by PyramidDrop.

The extra computation cost introduced by PyramidDrop mainly lay in the similarity computing for image token ranking. Benefiting from our design, the calculation is only between a query toke and $V_{s}$ image tokens, so its computation complexity is $O(n)$ and only $S-1$ times in the forward process.
Further, we notice the importance of FalshAttention in practice, so we keep using it during training and extract the query and key token from the original forward to calculate our lightweight similarity matrix.

When it comes to the computation cost economized by PyramidDrop. With the consideration of FlashAttn (Dao et al., ), we roughly define the forward inference cost of a layer with $N$ image tokens as a linear function with a constant factor $c$ that $c\cdot L$, so the overall computation cost of an LVLM with $L$ layers is $c\cdot N\cdot L$. When using PyramidDrop with S stages and the ratio $\lambda$, the overall computation cost is:

$$ $\frac{1-\lambda^{S}}{S\cdot(1-\lambda)}\cdot c\cdot N\cdot L$ (3) $$

For example, if $\lambda=0.5$ and we reduce the redundancy with 4 stages, it could save nearly $53.2\%$ computation cost theoretically, and we find this setting has a neglectable performance influence for models in practice.

## 4 Experiment

### 4.1 Setup

#### Models

We verify the effectiveness and generalize of the proposed PyramidDorp by experiment on LVLMs with different architectures and input resolution. In detail, we study LLaVA-1.5-Vicuna-7B (Liu et al., ), LLaVA-NeXT-Vicuna-7B (Liu et al., ). LLaVA-1.5 is the most widely used open-source LVLM backbone for research, which is designed with a simple yet effective architecture that maps the 576 image features from the CLIP encoder as the LLM input with a projector. LLaVA-Next is the high-resolution extension of LLaVA-1.5, which supports at most 2880 image tokens and has better high-resolution capability.

#### Benchmarks

To thoroughly evaluate our image token compression strategy, we conduct experiments across 14 benchmarks.
The MME Benchmark (Fu et al., ) assesses the perception and cognitive abilities of LMMs. MMBench and MMBench-CN (Liu et al., ) are benchmarks that manually craft questions to evaluate vision-related reasoning and perception in both English and Chinese, respectively. SEED (Li et al., ), generated with the aid of GPT-4, comprises a dataset of approximately 19,000 questions pertaining to images and videos. MM-Vet (Yu et al., ) leverages GPT-4 for a six-dimensional evaluation of LMM capabilities. In the realm of traditional VQA benchmarks, such as VQA-v2 (Goyal et al., ) and VizWiz (Gurari et al., ), are also utilized. Additionally, several benchmarks featuring higher-resolution visual content, including DocVQA (Mathew et al., ), ChartQA (Masry et al., ), InfographicVQA (Mathew et al., ), and TextVQA (Singh et al., ). Finally, MMStar (Chen et al., ) presents tasks with strong visual dependency, minimal data leakage, and requires sophisticated multimodal capabilities.

#### Efficientness Evaluation

We consider both the training time efficiency evaluation and inference time throughout. For training efficiency, we report the real training GPU hours with the same devices. For inference throughout, we follow the FastV(Chen et al., ) and report the FLOPs of the image token part. In detail, we consider the FLOPs of the multi-head attention and the feed-forward network modules as $4nd^{2}+2n^{2}d+2ndm$, where $n$ is the number of tokens, $d$ is the hidden state size, and $m$ is the intermediate size of the FFN. Considering there are three linear layers in FFN of LLaMA, the FLOPs is modified as $4nd^{2}+2n^{2}d+3ndm$. Our PyramidDrop has different image token numbers at different stages and the FLOPS could be calculated by:

$$ $\sum_{s=0}^{S-1}K_{s}\times\left(4n_{s}d^{2}+2n_{s}^{2}d+3n_{s}dm\right)\quad \text{s.t.}\quad n_{s}=\lambda^{s}\times n,\quad s=0,1,2,\dots,S-1$ (4) $$

#### Implementation details

Given that the LLM within the LVLM used in our experiments consists of 32 layers, we employ a straightforward approach by fixing $S$ to 4, effectively dividing the LLM into four equal parts. This segmentation allows the forward pass to be divided into four stages, with the number of image tokens decreasing exponentially at each stage. During accelerated training, we can adjust the value of $\lambda$ to control the proportion of image tokens that are pruned, and by default, $\lambda=0.5$. We conduct all the experiments on 8 NVIDIA A100 80GB GPUs. The partial evaluation like MMStar is done on the OpenCompass VLMEvalKit(Duan et al., ) for convenience.

It is important to note that, since the LLaVA-NeXT model’s data and training code are not open-source, we conduct training based on the open-source project Open-LLaVA-NeXT (Lin & Long, ). Due to differences in a portion of the training data, the benchmark performance may vary compared to that of LLaVA-NeXT (Liu et al., ) blog.

### 4.2 Efficient of PyramidDrop in Training

#### PyramidDrop is effective for diverse architectures.

We first study the PyramidDrop on both LLaVA-1.5 and LLaVA-Next. As shown in Table 1, PyramidDrop reduces the training time (including both pretraining and fine-tuning stages) of the LLaVA-Next from 366 to 218 GPU hours, resulting in an impressive 40% reduction in overall time. Besides the promising efficiency improvement, the model’s performance remains comparable to the original on 14 different benchmarks. Notably, for fine-grained benchmarks like TextVQA, DocVQA, and OCRVQA, images contain a large amount of text and even documents, which request a dense and fine-grained understanding of the image. Even in this case, our approach still maintain performance at the original level. This indicates that our method successfully compresses redundant information while preserving the most critical image content.

In the case of LLaVA-1.5, which processes fewer image tokens per sample, the acceleration is not as pronounced as with LLaVA-NeXT. However, it still offers a nearly 20% improvement in speed with comparable performance. This underscores the potential of our method to enhance training efficiency across different model configurations.

#### PyramidDrop enables larger resolution with constrained cost.

The PyramidDrop is proposed to reduce the redundancy within image tokens, and as we observed above, it enjoys higher speedup with the increase of the image/text token ratio. In this part, we explore its performance with higher image/text token ratio.
In detail, LLaVA-NeXT is designed with a flexible image processing strategy in which an image is divided into a maximum of four local patches and a global patch, leading to at most 2880 image tokens. We denote it as LLaVA-NeXT-p5 and experiment on the LLaVA-NeXT-p9 by increasing the maximum local patches into 8 patches.

As shown in Table 2, with the increased image/text ratio, PyramidDrop reaches a higher speedup that only 269 GPU hours is used for training, which is only 55% of the vanilla LLaVA-Next-p9.
Besides the superb speedup, the model trained with PyramidDrop achieves a slightly higher average performance across the 14 benchmarks. We argue too many image tokens with redundant information may confuse the LVLMs and hinder their performance, while our PyramidDrop efficiently reduce the image tokens number and helps the LVLM to focus on the critical information.
Furthermore, it is worth noting that the training time is even 70% of the original LLaVA-Next-p5 but achieves better performance on diverse tasks, showcasing the superb efficiency and effectiveness of PyramidDrop.

Table: Table 1: LVLM w and w/o our method on 6 benchmarks. Benchmark names are abbreviated due to space limits. MMB: MMBenchmark (Liu et al., ); MMB^CN: MMBench-Chinese (Liu et al., ); SEED^I: SEED-Bench (Image) (Li et al., ). We denote PyramidDrop as PDrop.

**Table 2: LLaVA -NeXT-7B on other 8 benchmarks. We report more benchmarks which contain lots of fine-grained content to examine the performance.**
| Model | Train & Infer | GPU<br>hours | #patches | Doc<br>VQA | Info<br>VQA | Text<br>VQA | Chart<br>QA | OCR<br>VQA | VQA<br>V2 | Viz<br>Wiz | GQA | Avg |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLaVA<br>-NeXT-7B | vanilla | 366 | 5 | 70.0 | 33.3 | 67.2 | 64.0 | 63.7 | 81.7 | 59.6 | 64.2 | 63.0 |
| PDrop | 218 | 5 | 69.0 | 31.7 | 67.7 | 63.0 | 63.1 | 81.5 | 61.0 | 63.9 | 62.6 |  |
| vanilla | 483 | 9 | 74.3 | 36.2 | 67.6 | 63.0 | 63.8 | 81.6 | 58.0 | 63.5 | 63.5 |  |
| PDrop | 269 | 9 | 75.0 | 37.4 | 68.4 | 64.3 | 63.5 | 81.7 | 60.6 | 64.1 | 64.4 |  |

#### PyramidDrop training encourages LVLMs to understand images compactly.

Then we dive into the properties of the model trained with PyramidDrop and conduct experiments to investigate the changes in image token redundancy. Two models are employed for this exploration: the vanilla LLaVA-1.5 and the LLaVA-1.5 trained with our approach. As illustrated in Figure 3, we plot the TextVQA scores against the retained image tokens at layers 2, 8, 16, and 24, maintaining the same experimental settings as Sec 3.1. We find that the curve of models trained with PyramidDrop keeps higher than the vanilla one.
The phenomenon suggests that, for a given proportion of retained image tokens, model trained with PtramimdDrop preserves more image information and achieves better performance. Alternatively, at equivalent performance levels, our method allows for a higher ratio of image tokens to compress. This improvement can primarily be attributed to the multi-stage training strategy, which progressively prunes image tokens, encouraging the model to consolidate essential information into a smaller set of tokens, resulting in more densely informative representations.

We further validate our hypothesis by replacing the inference strategy with FastV.
As demonstrated in Table 3, directly applying efficient inference strategies like FastV to models trained with PyramidDrop yields substantial improvements. Notably, there is a 1.3% increase in POPE and a 0.5% increase in MME, with even more pronounced gains observed on high-resolution benchmarks: ChartQA shows an increase of 4%, while DocVQA improves by 1.8%. These results provide compelling evidence for our hypothesis that training with PyramidDrop encourages the LVLMs to understand images compactly, which is a generalized result, rather than an overfit to the training strategy.

Figure: Figure 3: We compare the performance of the original LLaVA-1.5 and LLaVA-1.5 trained using PDrop, where we preserve different ratios of image tokens at layer 2, 8, 16, and 24, respectively. The horizontal axis represents the proportion of retained image tokens according to attention score.
Refer to caption: x3.png

Table: Table 3: Performance gain with models trained with PyramidDrop. Directly applying efficient inference strategies like FastV to models trained with PyramidDrop yields substantial improvement.

Table: Table 4: Ablation studies results. We adjust $\lambda$ form 0.4 to 0.6 for investigating the influence on performance and training time.

#### Balancing PyramidDrop performance and efficiency with λ 𝜆 \lambda italic_λ .

$\lambda$ balances the performance and efficiency of PyramidDrop, a larger $\lambda$ preserves more image information but slows down the training, and a smaller $\lambda$ has higher speedup while may influence the model performance. In this part, we study the influence of $\lambda$ on both LLaVA-1.5 and LLaVA-NeXT.

Table: Table 5: Inference acceleration performance. We compare PDrop, FastV and vanilla model, and find PDrop outperforms FastV on almost all benchmarks. PDrop here is as an inference-only strategy.

As shown in Table 4, we vary the $\lambda$ from 0.4 to 0.6 and report the model performance on both general and high-resolution benchmarks.
For the general benchmarks, we observe a relative robust performance among different lambda, this indicates that for most questions, the information within images is somewhat redundant. When it comes to the DocVQA, which requires a fine-grained understanding on high-resolution images, the model performance shows a clear decline when the $\lambda$ decreases to 0.4. It is reasonable as the loss of critical image information and we could anticipate a more pronounced performance decline with the $\lambda$ keeps decreasing.
Therefore, we opt for $\lambda=0.5$, which maintains comparable performance to the baseline while also yielding a significant reduction in processing time.

### 4.3 Efficient of PyramidDrop in Inference

#### PyramidDrop outperforms SOTA methods as a inference-only strategy
.

As illustrated in Table 5, we directly apply the multi-stage compression strategy during the inference phase of the vanilla model, comparing it with the inference acceleration approach, FastV. The results on LLaVA-Next demonstrate that our method significantly outperforms FastV across various critical benchmarks. Specifically, we achieve an impressive score of 1533.0 on MME, surpassing Fastv by 2.5%, while also exceeding it by 0.9% on both POPE and GQA. Notably, the advantages of our method become even more pronounced in high-resolution benchmarks. For instance, on the relatively challenging DocVQA, our approach outperforms FastV by 3.5%, and on ChartQA and TextVQA, we achieve improvements of 3.2% and 1% respectively.

Results from LLaVA-1.5 reveal similar trends across multiple benchmarks, including MME, ScienceQA, and MMBenchCN, where our method not only demonstrates superior performance but also achieves a greater reduction in FLOPs. When compared to the baseline, our approach consistently reaches comparable performance levels across most benchmarks, while effectively mitigating information loss in high-resolution benchmarks.
These findings indicate that FastV’s premature compression of image tokens leads to inevitably image information loss and significant performance declines in many benchmarks, whereas our multi-stage compression strategy preserves critical information from image tokens while maximizing the elimination of redundancy.
The observation is also consistent with our finding in Sec 3.1 that in shallow layers, most image tokens are critical for LVLMs to understand the image properly, while in the deep layers, most of them are redundant for the LVLMs.

#### PyramidDrop enjoys a better trade-off between performance and inference cost.

We further compare PyramidDrop and FastV under a precise FLOPs-constrained setting with LLaVA-NeXT-7B. In practice, we adjust the drop rate of FastV and the $\lambda$ of our PyramidDrop to control the model inference FLOPs and evaluate the model benchmark performance. As the FLOPs-performance curve shown in Figure 4, our PyramidDrop consistently outperforms FastV under different settings and across diverse benchmarks. For example, under a constraint of 12 TFLOPs, PyramidDrop outperforms FastV with 3.0% on DocVQA and 2.6% on ChartQA. When we reduce the inference cost to only 8 TFLOPs, the performance gap increases, with PyramidDrop surpassing FastV by 6% on DocVQA, and 5.9% on ChartQA.
The results further prove that our multi-stage redundant reduction strategy matches the nature of LVLMs and enables the model to understand the image better under constrained inference cost.

#### LVLM with PyramidDrop effectively preserves image tokens related to instruction.

As shown in Figure 5, we visualize the image tokens retained by LLaVA-1.5 with PyramidDrop in different stages. It is evident that when the user asks about a small object in the image, the LLM accurately identifies the region containing the relevant information based on the instructions and provides the correct answer. This demonstrates that our method effectively leverages the LLM’s nature to understand images. The token dropping in PyramidDrop applied during inference does not result in the loss of valuable information.

Figure: Figure 4: The performance of LLaVA-NeXT-7B with different inference acceleration strategies. PDrop (without training) outperforms FastV on DocVQA, ChartQA, and GQA with across various inference cost budgets.
Refer to caption: x4.png

Figure: Figure 5: Visualization of token dropping in LLM of LLaVA -1.5. We compute the attention score of image tokens received from the last instruction token as the ranking criterion, and find LLM accurately retain image tokens according to instruction.
Refer to caption: x5.png

## 5 CONCLUSION

We have introduced PyramidDrop, a simple yet effective strategy for reducing visual token redundancy in large vision-language models (LVLMs) to enhance efficiency with negligible performance loss. Our empirical study reveals that while all visual tokens are necessary in the shallow layers of LVLMs, token redundancy progressively increases in deeper layers. Extensive experiments demonstrate that PyramidDrop can achieve significant acceleration in both training and inference.

## Peer Reviews

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: See weakness for details.
soundness: 2
strengths: 1. The proposed method improve LVLM efficiency through progressive token reduction based on layer-wise redundancy analysis. Different from compressing tokens uniformly or only in early layers, PyramidDrop's stage-wise reduction aligns with the redundency distribution of visual tokens in LVLMs.

2. Experiments show the proposed method effectively reduce LLaVA-NeXT training time by 40% while maintaining performance across 14 benchmarks. It also enables training with doubled input resolution using only 70% of the original computational cost, demonstrating better efficiency-performance trade-off than existing methods like FastV.

3. The proposed method could be deployed as a plug-and-play module without requiring architectural modifications or additional training. 

4. The method's design is simple yet effective, using only lightweight attention calculations for measuring token importance.
summary: This paper introduces PyramidDrop, a method to improve the efficiency of Large Vision-Language Models by progressively reducing visual tokens across model layers. Specifically, PyramidDrop addresses computational efficiency in two ways: 1) it divides the LVLM into several stages and preserves all visual tokens in shallow layers, 2) it then progressively drops tokens at the end of each stage based on a lightweight attention-based similarity calculation. The authors demonstrate that visual token redundancy increases in deeper layers of LVLMs, making this staged approach more effective. Experiments on LLaVA-NeXT show that PyramidDrop reduces training time by 40% while maintaining comparable performance across 14 different benchmarks. The method is also shown to be effective for inference acceleration, reducing FLOPs by 55% and enabling training with doubled input resolution while using only 70% of the original training time, with better performance on high-resolution tasks.
weaknesses: 1. The technical novelty is very limited. The core idea of progressive token pruning has been previously explored in both LTP (Learned Token Pruning) [1] and Magic Pyramid[2] papers. LTP introduced learnable thresholds for token pruning across different layers, while Magic Pyramid combined progressive token pruning with early exiting. PyramidDrop's approach of stage-wise token reduction follows a similar progressive pruning strategy, making its technical contribution incremental.

2. Another critical limitation of the proposed method is its incompatibility with FlashAttention, as it relies on explicit attention score for token dropping. Without analyzing this limitation or providing comparisons against FlashAttention-powered baselines, the paper leaves open questions about the method's true efficiency gains in terms of memory usage and inference latency.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 2
questions: See above.
soundness: 3
strengths: 1. The idea is simple and straightforward
2. The writing is easy to follow. The writing logic is clear.
3. This paper beats FastV at the inference stage.
summary: This paper introduces PyramidDrop to adaptively drop image tokens in multimodal models. They partition the layers into fixed groups and use a hyperparameter to indicate the ratio of tokens to keep during training and inference. 

This paper is a natural extension of FastV with more fine-grained operations to prune the image tokens progressively.

This paper achieves better performance than FastV on all benchmarks. At the same time, this method is compatible with FastV.
weaknesses: 1. The overhead of token pruning operation. Though this operation does not cost much computation,  more analysis on this is important since we want global speedup.

2. Speedup metric. Previous token pruning methods[1, 2] provide both GFLOPs and global latency. This work provides only GFLOPs which does not convince me of the actual speedup on hardware. 

3. The effect of group size. As the main contribution of this paper, it does not include the discussion of the choice of group number and how will that influence performance and efficiency.

4. As shown in Table 5, the performance improvement is limited(<1.0) compared with FastV while FastV does not require multiply-time token pruning. 

Overall this work is simple, but I am concerned that it may not meet the bar of ICLR.

Minor:  

line 255: FalshAttention

line 253: toke

line 377: PtramimdDrop

[1] Bolya, Daniel, et al. "Token merging: Your vit but faster." arXiv preprint arXiv:2210.09461 (2022).

[2] Kong Z, Dong P, Ma X, et al. Spvit: Enabling faster vision transformers via latency-aware soft token pruning[C]//European conference on computer vision. Cham: Springer Nature Switzerland, 2022: 620-640.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. Experiments are insufficient. In the training stage, this paper only compared the baseline with LVLM without rank and drop, lack of comparison with other efficiency training methods, such as VoCo-LLaMA, LLaMA-Vid or LLaVa-PruMerge, etc.
2. In the ablation studies, there is also no analysis of the impact of the number of layers chosen for token dropping. In addition, have you tried different pruning ratios in different stages instead of using the same ratio in all stages?
3. I think PyramidDrop is a hierarchical token-pruning version of FastV. Can you describe more about the difference between your method and FastV? 
4. Could you add the visualization of layer 2 in Figure 5?
soundness: 3
strengths: 1. The paper discusses the problem of computational efficiency in large vison-language models, which is a hot issue that urgently requires effective methods to accelerate speed.
2. The proposed method is easy to follow and replicate.
summary: The paper discusses the significant computational costs of processing images in large vision-language models (LVLMs) and proposes a new method called PyramidDrop, which reduces visual tokens across different layers to improve training and inference efficiency with minimal performance loss. PyramidDrop prunes image tokens progressively across model stages using a lightweight similarity calculation. Experiments show that it speeds up training and inference with results comparable to those of the original model.
weaknesses: 1. The contributions of this paper are not enough. The method is common, as it only uses rank and drop operations, like FastV, but with a hierarchical version. Additionally, the experimental results do not show particularly impressive outcomes, compared to other efficient methods that have been proven to work, such as VoCo-LLaMA[1], LLaMA-VID[2], or LLaVA-PruMerge[3].
2. Experiments are insufficient. In the training stage, this paper only compared the baseline with LVLM without rank and drop, with a lack of comparison with other efficient methods as point 1 demonstrated. In the ablation study, there is also no analysis of the impact of the number of layers chosen for token dropping.
3. There are some small typos, such as play a important in line 159, FalshAttention in line 256, and PtramimdDrop in line 377.

[1] Ye, Xubing, et al. "VoCo-LLaMA: Towards Vision Compression with Large Language Models." arXiv preprint arXiv:2406.12275 (2024).

[2] Li, Yanwei, Chengyao Wang, and Jiaya Jia. "Llama-vid: An image is worth 2 tokens in large language models." European Conference on Computer Vision. Springer, Cham, 2025.

[3] Shang, Yuzhang, et al. "Llava-prumerge: Adaptive token reduction for efficient large multimodal models." arXiv preprint arXiv:2403.15388 (2024).

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. How were the experimental results for the 0.0 ratio in Figure 1(a) obtained? Was the attention output of that layer directly used as the input for the LLM?
2. Since only the last instruction token is used to compute attention with all visual tokens, shouldn’t the visualization in Figure 5 tend to focus visual tokens on the last instruction token? Why does the attention highlight information such as "1856" and "green dress"?
3. Could you provide the practical speed comparison of the baseline and proposed method?
soundness: 3
strengths: 1. This paper is coherent and logical, effectively demonstrating that visual redundancy varies across different layers.  Based on this observation, the authors propose a hierarchical sparsification strategy.
2. The experiments are comprehensive, with the proposed algorithm being validated across multiple benchmarks, demonstrating its feasibility.
summary: Current approaches focus on reducing the number of visual tokens either before or within the early layers of LVLMs (Large Vision-Language Models). This paper considers the inconsistency in visual redundancy across different layers and proposes the PyramidDrop, which effectively reduces redundant visual tokens in LVLMs. Extensive evaluations on multiple benchmarks demonstrate that this method enhances efficiency with negligible performance loss.
weaknesses: 1. The `method` section lacks clarity, particularly in explaining the rationale behind using the last instruction token and all visual tokens to calculate attention. Was there any attempt to use other indexes of the instruction tokens for attention calculation?
2. The approach introduces additional overhead, as the attention between the instruction token and visual tokens can be directly derived from the transformer's attention without the need for additional key and value computations.
3. The comparative experiments are incomplete, as only inference-only algorithms are compared, lacking a comparison with similar train-inference token reduction approaches, like LLaMA-VID [1] and VoCo-LLaMA [2].

[1] Li, Yanwei, Chengyao Wang, and Jiaya Jia. "Llama-vid: An image is worth 2 tokens in large language models." In *European Conference on Computer Vision*, pp. 323-340. 

[2] Ye X, Gan Y, Huang X, Ge Y, Shan Y, Tang Y. VoCo-LLaMA: Towards Vision Compression with Large Language Models. arXiv preprint arXiv:2406.12275. 2024 Jun 18.