Pith. sign in

REVIEW 3 major objections 4 minor 23 references

MergeOver: Post-Training Token Merging for Recursive Vision Transformers

T0 review · 3 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read MergeOver shows that token merging can be added after training to a recursively weight-shared vision transformer, cutting GPU peak activation memory by about 38% on ImageNet-1K with a 1.47-point top-1 accuracy drop.

desk verdict A competent engineering paper that makes a post-training ToMe/SReT integration work and reports internally consistent numbers, but the missing unmerge isolation ablation and selection details keep it from a clean yes. read the letter →

arxiv 2608.13141 v1 pith:I6KETHKH submitted 2026-08-13 cs.CV cs.LG

Junseo Kim , Uraz Odyurt , Amirreza Yousefzadeh This is my paper · ORCID
classification cs.CVcs.LG
keywords visiontransformerstokenmergingrecursiveweight-sharingpost-trainingcompressionhierarchicaltransformerImageNet-1KpeakactivationmemoryedgeAI
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to show that token merging, a post-training compression trick that fuses similar image patches, can be grafted onto a recursively weight-shared vision transformer without retraining. It does this for the Sliced Recursive Transformer (SReT), whose repeated passes through shared blocks make it cheap in parameters but expensive in attention and activation memory. MergeOver restores the 2D grid before each hierarchical pooling layer, respects group-divisibility constraints inside grouped attention, and keeps token-mass bookkeeping aligned through spatial permutations. On ImageNet-1K the chosen single-shot configuration drops top-1 accuracy by 1.47 percentage points while cutting GPU peak activation memory by 37.3% at batch size 1 and 38.4% at batch size 16, and raising batch-16 GPU throughput by 21.7%. A sympathetic reader would take this as evidence that recursive and token-reduced transformers can be combined post hoc, opening an axis of compression for edge deployment.

What carries the argument

The load-bearing object is the Unmerge tracking stack: every ToMe merge pushes a stored inverse operation that later duplicates the merged features back to their original spatial coordinates, restoring the exact sequence length the next convolutional pooling layer expects. Around it sit two bookkeeping devices: a constraint-safe merge-rate adjustment that selects the largest reduction satisfying $(N-r)mod g=0$, $N-r\ge g$ with $g=\mathrm{LCM}(g_1,g_2)$, and $r\le \lfloor N/2\rfloor$; and a synchronized token-mass tensor that runs through the same permutation and inverse-permutation as the features so proportional attention stays correct. The stage-wise single-shot schedule applies reduction only at the first block of each stage, holding sequence length fixed through the remaining recursive iterations.

What would settle it

Run an ablation that substitutes exact token reinsertion for ToMe's duplication-based unmerge at the same merge rate and compare ImageNet top-1 accuracy and the cosine similarity of pooled activations; a material accuracy gain or a large divergence in pooled activations would show that the duplication approximation, and not merging itself, is what the frozen pooling layers must absorb.

Watch

Extended reading notes

Core claim

The central claim is that recursive weight sharing and dynamic token merging are compatible without retraining, provided three structural frictions are removed: merged sequences must be rebuilt to a square 2D layout before convolutional pooling, the number of merged tokens must keep sequence length divisible by the least common multiple of the grouped-attention group sizes, and the per-token mass vector that ToMe uses for proportional attention must be permuted in lockstep with the features. MergeOver resolves these with an Unmerge stack, a constraint-safe merge-rate adjustment, and synchronized mass tracking, then applies reduction once per stage at the first block. On SReT-Tiny-Distill this yields a 1.47-point top-1 accuracy decrease on ImageNet-1K, a 37.3% and 38.4% GPU peak-activation-memory reduction at batch sizes 1 and 16, and a 21.7% GPU throughput increase at batch size 16, with latency reductions on x86 and ARM CPUs at batch size 16.

Load-bearing premise

The load-bearing premise is that ToMe's unmerge operation, which restores the sequence length by duplicating merged features back into their original spatial positions, gives SReT's frozen convolutional pooling layers a spatial layout they can consume without retraining; if those duplicated features distort local geometry beyond what the frozen weights tolerate, the accuracy result collapses.

Editorial extensions

If this is right

  • Token merging no longer requires retraining or architectural redesign to enter a recursive hierarchical transformer; the post-hoc route is enough for a meaningful memory saving.
  • Peak activation memory is determined mainly by the initial reduction fraction of each stage, because the largest activations sit near the start of the stage.
  • On the GPU the method crosses from overhead to speedup as batch size grows: 21.7% slower at batch size 1, 21.7% faster at batch size 16.
  • FLOPs do not predict hardware throughput for this method, because matching, mass tracking, and unmerge operations fall outside the arithmetic estimate.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper, the unmerge step is the natural pressure point: since it duplicates merged features instead of restoring originals, replacing it with exact token reinsertion would separate reconstruction error from merging error and likely raise accuracy at a small memory cost.
  • Because MergeOver is post hoc and leaves weights untouched, it should stack with post-training quantization and kernel-level attention tiling, so the reported memory and latency gains are a lower bound for a full edge pipeline.
  • The same grid-restoration and divisibility machinery should transfer to non-recursive pyramid transformers whose inter-stage pooling imposes the same square-grid constraint, even though the paper only demonstrates the recursive case.
  • A testable consequence of the batch-size crossover is that larger sequence lengths amortize the matching and unmerge overhead better, so larger recursive models or higher-resolution inputs should show larger net speedups than the tiny model measured here.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes MergeOver, a post-training method that integrates Token Merging (ToMe) into the recursively weight-shared Sliced Recursive Transformer (SReT). To overcome architectural incompatibilities, the method introduces an Unmerge tracking stack that restores the 2D spatial grid before inter-stage convolutional pooling, a constraint-safe merge-rate adjustment that respects the group-divisibility bounds of Sliced Group Self-Attention (Equation 3), and parallel token-mass tracking through SReT's spatial permutations. The authors benchmark several token-reduction schedules on ImageNet-1K and select a stage-wise single-shot configuration (rho_shot = 0.25) that loses 1.47 percentage points of top-1 accuracy while reducing GPU peak activation memory by 37.3% and 38.4% at batch sizes 1 and 16, with GPU throughput increasing by 21.7% at batch size 16. On x86 and ARM CPUs, latency reductions are reported at batch size 16, with only modest or negative effects at batch size 1. The paper includes detailed tables across batch sizes and platforms and makes the source code publicly available.

Significance. If the results hold, MergeOver is a useful demonstration that token merging can be applied post-training to a hierarchical recursive transformer, recovering part of the throughput and memory costs introduced by recursive weight sharing. The core constraint derivation (Equation 3) is simple and correct, and the hardware evaluation is reported transparently across three platforms with an honest discussion of measurement limitations (e.g., FLOPs are not predictive, CPU RSS is not equivalent to activation memory). The authors also explicitly acknowledge that the evaluation is limited to one model and that the schedule comparisons are not matched in total reduction budget. The public release of the source code is a clear strength. The main outstanding risks are the lack of validation of the Unmerge reconstruction and the absence of variance information for the hardware metrics.

major comments (3)
  1. [Section 3.1, Figures 1 and 3] The Unmerge stack restores the exact token count by duplicating merged features back onto their original spatial coordinates, but the paper does not validate that SReT's frozen convolutional pooling layers can safely consume this reconstructed signal. Because multiple positions within a pooling receptive field can carry identical vectors, the input distribution to the pretrained convolutions is shifted relative to the spatially distinct activations seen during training. The paper reports only end-to-end accuracy, so the 1.47 percentage-point drop in Table 1 conflates the inherent information loss of token merging with any distortion introduced by the duplication. Please add an ablation that compares the Unmerge reconstruction against alternative length-restoration schemes (e.g., interpolation, nearest-neighbor fill, zero-fill, or truncation to a compatible length), and ideally measure the distribution shift at the pooling input. Without such an analysis, the claimed solution to the spatial-layout constraint is validated only at the shape level, not at the signal level.
  2. [Section 4.2 and Tables 2-7] All hardware metrics (latency, throughput, PAM, and DeltaRSS) are reported as single median values with no measure of run-to-run variability, such as standard deviation, confidence interval, or range over repeated runs. Several reported effects are small, for example the 2.4% ARM latency reduction at batch size 1 in Table 4, and without error bars it is impossible to judge whether such differences are meaningful or within measurement noise. Given that hardware efficiency is a central claim of the paper, please report variance across repeated trials for at least the headline configurations and batch sizes.
  3. [Section 5.1 and Figure 5] The comparison between global and stage-wise schedules is confounded because the schedules differ not only in shape but also in parameterization, depth indexing, and total token-reduction budget. The paper acknowledges this in Section 6, but since 'an analysis of token reduction scheduling strategies' is listed as a contribution, the conclusion that the stage-wise single-shot schedule is preferable would be much stronger with a matched-budget comparison. Please either tune the global schedules so that the total number of removed tokens matches the stage-wise configurations or explicitly restrict the scheduling claim to the particular formulations evaluated, rather than suggesting a general advantage of stage-wise single-shot reduction.
minor comments (4)
  1. [Figure 1] The figure is visually ambiguous: the stage-map sequence lengths (N=584, N=144, N=37) appear to show the post-merge lengths, while the text and Figure 3 emphasize that the original length is restored before pooling. Labeling both the post-merge and post-unmerge lengths at each stage boundary would improve clarity.
  2. [Table 1] The table contains formatting artifacts, such as '70.95-6.44"' and '40.97-36.42"'; these should be typeset consistently as '70.95 (-6.44)' and '40.97 (-36.42)'.
  3. [Section 5.1] The 'accuracy-preserving criterion' of a maximum 2-percentage-point top-1 accuracy loss is introduced without any justification. A brief rationale for the threshold, or a sensitivity analysis around it, would help the reader interpret the selection of rho_shot = 0.25 as the headline configuration.
  4. [Section 6] The limitations paragraph correctly notes that the evaluation is restricted to SReT-Tiny-Distill and that generality cannot be assumed. Given the title's reference to 'Recursive Vision Transformers', it would be helpful to state more explicitly that the empirical demonstration is a single case study, with generality left as future work.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: all reported efficiency and accuracy figures are direct measurements against an external baseline, with no fitted parameter renamed as a prediction.

full rationale

MergeOver makes no first-principles derivation that reduces to its inputs. The central claim, that ToMe token merging can be integrated post-training into the recursively weight-shared SReT, is supported by direct ImageNet-1K measurements (Tables 1 and 2) against an external baseline (SReT-Tiny-Distill, reference [7]). No constants are fitted to the reported outcomes and then re-presented as predictions; the schedule equations (4)-(7) are definitions, not derived results. The Unmerge mechanism is adopted from ToMe [10], an external cited method, and the mass-tracking procedure is a straightforward parallel bookkeeping operation, not a predicted outcome. The choice of the stage-wise single-shot rho_shot=0.25 configuration is made by applying an explicit accuracy-preserving criterion (maximum 2pp top-1 loss) to measured results; this is model selection on observed data, not circularity. The paper also candidly acknowledges its limitation to SReT-Tiny-Distill and states that schedule comparisons do not isolate schedule shape alone, which further distances the claims from any hidden circular argument. No self-citation chain is load-bearing, and no uniqueness theorem is imported from the authors' own prior work. The derivation is therefore self-contained and externally falsifiable.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The central claim is an engineering benchmark rather than a derivation. It depends on the untested assumption that unmerge duplication and mass synchronization preserve enough fidelity for frozen SReT weights, on hand-chosen schedule hyperparameters (rho_shot=0.25), and on an arbitrary 2-percentage-point accuracy selection threshold. No new physical entities are introduced; the Unmerge stack is a deterministic data structure derived from ToMe's existing unmerge operation.

free parameters (4)
  • rho_shot (stage-initial reduction fraction) = 0.25 for the selected configuration; 0.40 also evaluated
    This scalar controls how many tokens are removed at the first block of each stage. It is a hand-chosen hyperparameter, not derived from first principles, and the paper selects rho_shot=0.25 after observing validation accuracy under a 2pp tolerance criterion. All headline accuracy and efficiency numbers depend on this choice.
  • rho_exp and alpha for the exponential schedule = rho_exp in {0.25, 0.40}, alpha=0.3
    Used for alternative schedule comparison; alpha is fixed by hand. These configurations are not the headline result but are part of the paper's trade-off analysis.
  • r_const and r_lin for the global schedules = 10 and 20
    Canonical ToMe schedule hyperparameters chosen to represent light and heavy reductions; the reported results for those schedules depend on these values.
  • Accuracy-preserving criterion = 2 percentage points maximum top-1 loss
    Imposed in Section 5.1 as the selection rule for the headline configuration. It is chosen by hand and determines that rho_shot=0.25 rather than 0.40 is reported.
assumptions (4)
  • domain assumption ToMe's unmerge operation restores the original sequence length by duplicating merged features into their original spatial coordinates, and this restored tensor is valid input for SReT's pretrained convolutional pooling layers.
    Section 3.1 and Figure 3. If this duplication corrupts spatial structure, the method's accuracy and even functional validity fail.
  • domain assumption SReT's pretrained Tiny-Distill weights remain applicable to the modified forward pass that inserts merging and unmerging operations.
    Section 4.4, baseline SReT weights obtained from the authors' repository; MergeOver does not update any weights.
  • domain assumption Routing the token-mass vector through SReT's permutation and inverse-permutation functions preserves ToMe's proportional attention.
    Section 3.3. If the mass vector misaligns with tokens, attention weighting would be corrupted.
  • standard math The feasible merge rate is fully described by group-divisibility and bipartite-matching constraints: (N-r) mod g = 0, N-r >= g, r <= floor(N/2).
    Section 3.2, Equation (3). This is a combinatorial constraint, not a fitted relation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MergeOver: Post-Training Token Merging for Recursive Vision Transformers." pith.science (2026). https://pith.science/paper/I6KETHKH

@misc{pith2026260813141,
  author       = {Pith},
  title        = {Pith review of: MergeOver: Post-Training Token Merging for Recursive Vision Transformers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/I6KETHKH}},
  note         = {Machine review of arXiv:2608.13141}
}
read the original abstract

Vision Transformers (ViTs) demonstrate exceptional performance in computer vision but suffer from large parameter counts and quadratic computational complexity, severely limiting their deployment on resource-constrained edge hardware. While recursive weight-sharing reduces parameter counts and token merging mitigates computational and memory bottlenecks, integrating these two paradigms without costly retraining is non-trivial, leaving this intersection largely unexplored. We propose MergeOver, a post-training approach that integrates Token Merging (ToMe) into the recursively weight-shared Sliced Recursive Transformer (SReT). Through an Unmerge tracking stack, constraint-safe merge-rate adjustment, and synchronised token-mass tracking across spatial permutations, MergeOver resolves the spatial and merging constraints of this integration. We further employ a stage-wise single-shot schedule that performs token reduction at the first block of each stage and maintains a fixed sequence length throughout its subsequent recursive iterations. Benchmarked on ImageNet-1K, our selected configuration reduces top-1 accuracy by 1.47 percentage points. On the GPU, it reduces peak activation memory by 37.3% and 38.4% at batch sizes 1 and 16, while throughput decreases by 21.7% at batch size 1 but increases by 21.7% at batch size 16. On a Raspberry Pi 5 (ARM CPU), it reduces latency by 2.4% and 17.6% at batch sizes 1 and 16. These results show that MergeOver can recover a meaningful part of the throughput and memory cost that recursive weight-sharing introduces, without retraining, and provides a baseline for combining token merging with hierarchical recursive transformers.

Figures

Figures reproduced from arXiv: 2608.13141 by the authors.

Figure 1
Figure 1. An overview of the proposed MergeOver approach, integrating the recursive weight-sharing of SReT with the token merging of ToMe. The initial token sequence of length 𝑁 = 784 is reduced using a stage-wise single-shot schedule. Crucially, the spatial layout is reconstructed prior to each inter-stage convolutional pooling layer through the Unmerge block. length while increasing channel depth. After the final stage, glo… view at source ↗
Figure 2
Figure 2. The hierarchical spatial pyramid architecture of [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The Unmerge stack mechanism for token sequence length restoration. By applying Unmerge operations, the orig￾inal length (𝑁 = 784) is restored to satisfy the spatial grid requirements of the convolutional pooling layer. This mechanism allows the attention and Multilayer Perceptron (MLP) blocks to reap the computational benefits of processing a compressed token sequence, while ensuring that the convolutional pooling l… view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: The MergeOver Transformer block (SReT+ToMe), with the token merging module inserted between the Sliced Group Attention (SGA) and the Multilayer Perceptron (MLP) layers. Detailed expansions illustrate the spatial permuta￾tions and grouped attention within SGA, alongside…
Figure 5
Figure 5. Figure 5: Normalised token reduction trajectories per sched [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: GPU performance results compared to the SReT [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: x86 CPU performance results compared to the SReT [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: ARM CPU performance results compared to the [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

23 extracted references · 6 canonical work pages

  1. [1]

    Gomez, Łukasz Kaiser, and Illia Polosukhin

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention Is All You Need. InProceedings of the 31st International Conference on Neural Information Processing Systems(NIPS’17). Curran Associates Inc., Long Beach, California, USA, 6000–6010.isbn: 9781510860964. doi:10.5555/...

    arXiv 2017

  2. [2]

    Alexey Dosovitskiy et al. 2021. An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. InInternational Conference on Learning Repre- sentations. OpenReview.net. https://openreview.net/forum?id=YicbFdNTTy

    work page 2021

  3. [3]

    Sachin Mehta and Mohammad Rastegari. 2022. MobileViT: Light-weight, General- purpose, and Mobile-friendly Vision Transformer. (2022). arXiv: 2110.02178 [cs.CV]. doi:10.48550/arXiv.2110.02178

    arXiv doi:10.48550/arxiv.2110.02178 2022

  4. [5]

    Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Łukasz Kaiser. 2019. Universal Transformers. (2019). arXiv: 1807.03819 [cs.CL]. doi:1 0.48550/arXiv.1807.03819

    arXiv doi:10.48550/arxiv.1807.03819 2019

  5. [6]

    Jinnian Zhang, Houwen Peng, Kan Wu, Mengchen Liu, Bin Xiao, Jianlong Fu, and Lu Yuan. 2022. MiniViT: Compressing Vision Transformers with Weight Multiplexing. In2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 12135–12144. doi:10.1109/CVPR52688.2022.01183

    arXiv 2022

  6. [7]

    Zhiqiang Shen, Zechun Liu, and Eric Xing. 2022. Sliced Recursive Transformer. InComputer Vision – ECCV 2022. Shai Avidan, Gabriel Brostow, Moustapha Cissé, Giovanni Maria Farinella, and Tal Hassner, (Eds.) Springer Nature Switzer- land, Cham, 727–744.isbn: 978-3-031-20053-3. doi:10.1007/978-3-031-20053-3 _42

    doi:10.1007/978-3-031-20053-3 2022

  7. [8]

    Yongming Rao, Wenliang Zhao, Benlin Liu, Jiwen Lu, Jie Zhou, and Cho-Jui Hsieh. 2021. DynamicViT: Efficient Vision Transformers with Dynamic Token Sparsification. InAdvances in Neural Information Processing Systems. Vol. 34. Curran Associates, Inc., 1393–1405. https://proceedings.neurips.cc/paper_files /paper/2021/file/747d3443e319a22747fbb873e8b2f9f2-Paper.pdf

    work page 2021

  8. [9]

    Youwei Liang, Chongjian Ge, Zhan Tong, Yibing Song, Jue Wang, and Pengtao Xie. 2022. Not All Patches are What You Need: Expediting Vision Transformers via Token Reorganizations. (2022). arXiv: 2202.07800 [cs.CV]. doi:10.48550/ar Xiv.2202.07800

    arXiv doi:10.48550/arxiv.2202.07800 2022

Show all 23 references
  1. [10]

    Daniel Bolya, Cheng-Yang Fu, Xiaoliang Dai, Peizhao Zhang, Christoph Feicht- enhofer, and Judy Hoffman. 2023. Token Merging: Your ViT But Faster. (2023). arXiv: 2210.09461[cs.CV]. doi:10.48550/arXiv.2210.09461

    2023 doi arXiv

  2. [11]

    Hoai-Chau Tran et al. 2024. Accelerating Transformers with Spectrum-Preserving Token Merging. InAdvances in Neural Information Processing Systems. A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang, (Eds.) Vol. 37. Curran Associates, Inc., 30772–...

    2024 doi

  3. [12]

    Minchul Kim, Shangqian Gao, Yen-Chang Hsu, Yilin Shen, and Hongxia Jin

  4. [13]

    Pavan Kumar Anasosalu Vasu, James Gabriel, Jeff Zhu, Oncel Tuzel, and Anurag Ranjan. 2023. FastViT: A Fast Hybrid Vision Transformer using Structural Reparameterization. In2023 IEEE/CVF International Conference on Computer Vision (ICCV), 5762–5772. doi:10.1109/ICCV51070.2023.00532

    2023

  5. [14]

    Ao Wang, Hui Chen, Zijia Lin, Jungong Han, and Guiguang Ding. 2024. Rep ViT: Revisiting Mobile CNN From ViT Perspective. In2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 15909–15920. doi:10.1109 /CVPR52733.2024.01506

    2024

  6. [15]

    Jianjian Cao, Chong Yu, Peng Ye, and Tao Chen. 2026. MADTP++: Bridge the Gap Between Token and Weight Pruning for Accelerating VLTs.IEEE Transactions on Pattern Analysis and Machine Intelligence, 48, 5, 5180–5194. doi:10.1109/TPAMI.2025.3650545

    2026

  7. [16]

    [SW] Junseo Kim, MergeOver Code version v1.0.0, Aug. 2026. doi:10.5281/zen odo.21888951

    2026 doi

  8. [17]

    Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. 2009. ImageNet: A large-scale hierarchical image database. In2009 IEEE Conference on Computer Vision and Pattern Recognition, 248–255. doi:10.1109/CVPR.2009.5 206848

    2009 doi

  9. [20]

    Byeongho Heo, Sangdoo Yun, Dongyoon Han, Sanghyuk Chun, Junsuk Choe, and Seong Joon Oh. 2021. Rethinking Spatial Dimensions of Vision Trans- formers. In2021 IEEE/CVF International Conference on Computer Vision (ICCV), 11916–11925. doi:10.1109/iccv48922.2021.01172

    2021

  10. [21]

    Lu Yu and Wei Xiang. 2023. X-pruner: explainable pruning for vision transform- ers. In2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 24355–24363. doi:10.1109/cvpr52729.2023.02333

    2023

  11. [22]

    Tri Dao, Dan Fu, Stefano Ermon, Atri Rudra, and Christopher Ré. 2022. FlashAt- tention: Fast and Memory-Efficient Exact Attention with IO-Awareness. In Advances in Neural Information Processing Systems. S. Koyejo, S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh, (Eds.) ...

    2022 doi

  12. [23]

    Yang Lin, Tianyu Zhang, Peiqin Sun, Zheng Li, and Shuchang Zhou. 2022. FQ-ViT: Post-Training Quantization for Fully Quantized Vision Transformer. InProceedings of the Thirty-First International Joint Conference on Artificial Intelligence, IJCAI-22. Lud De Raedt, (Ed.) Internat...

    2022 doi

  13. [24]

    Xinqing Li, Xin He, Xindong Zhang, Ming-Ming Cheng, Lei Zhang, and Yun Liu. 2026. Towards Joint Quantization and Token Pruning of Vision-Language Models. (2026). arXiv: 2604.17320[cs.CV]. doi:10.48550/arXiv.2604.17320

    2026 doi arXiv

  14. [25]

    Zhiqiang Shen. 2022. Sliced Recursive Transformer (SReT). https://github.com /szq0214/SReT. GitHub repository, accessed 2026-04-28. (2022). A Extended results This appendix reports the complete batch-dependent measurements underlying the hardware-efficiency analysis. For each ...

    2022

  15. [2024]

    In2024 IEEE/CVF Winter Conference on Applications of Computer Vision (W ACV), 1372–1381

    Token Fusion: Bridging the Gap between Token Pruning and Token Merging. In2024 IEEE/CVF Winter Conference on Applications of Computer Vision (W ACV), 1372–1381. doi:10.1109/WACV57701.2024.00141

    2024

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.