Paper deep dive
Rethinking Video Token Compression with a Global Codebook: Learning Once, Compressing Everywhere
Jiayang He, Tianling Xu, Diancheng Kang, Huaide Jiang, Junyan Bai, Shaoming Zheng, Xuan Song
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Video large language models (Video-LLMs) represent videos as dense sequences of visual tokens, whose length grows with the temporal and spatial extent of the input. These tokens often contain substantial redundancy arising from repeated visual patterns, leading to unnecessary computation in the subsequent language-model processing. Existing token compression methods, including pruning and merging, perform compression online during inference, repeatedly incurring additional computation for each input video and often relying on model-specific designs that limit their generality, we instead rethink this paradigm by shifting the costly compression process offline. We propose \textbf{ONCE}, a plug-in video token compression framework that introduces an offline-to-online paradigm: a frequency-aware global codebook is learned once in the visual feature space and reused for lightweight online compression through codebook lookup and aggregation, reducing repeated per-video computation and the need for model-specific compression designs. Extensive experiments across multiple video understanding benchmarks and against diverse compression baselines demonstrate that our approach achieves a strong accuracy-efficiency trade-off, maintaining competitive performance while achieving the lowest inference latency among compared methods.
Tags
Links
- Source: https://arxiv.org/abs/2608.01271v1
- Canonical: https://arxiv.org/abs/2608.01271v1
Trouble viewing inline? Open PDF directly →
Full Text
70,964 characters extracted from source content.
Expand or collapse full text
Rethinking Video Token Compression with a Global Codebook: Learning Once, Compressing Everywhere Jiayang He 1, Tianling Xu 1, Diancheng Kang1, Huaide Jiang1, Junyan Bai1, Shaoming Zheng2 , Xuan Song3 Abstract Video large language models (Video-LLMs) represent videos as dense sequences of visual tokens, whose length grows with the temporal and spatial extent of the input. These tokens often contain substantial redundancy arising from repeated visual patterns, leading to unnecessary computation in the subsequent language-model processing. Existing token compression methods, including pruning and merging, perform compression online during inference, repeatedly incurring additional computation for each input video and often relying on model-specific designs that limit their generality, we instead rethink this paradigm by shifting the costly compression process offline. We propose ONCE, a plug-in video token compression framework that introduces an offline-to-online paradigm: a frequency-aware global codebook is learned once in the visual feature space and reused for lightweight online compression through codebook lookup and aggregation, reducing repeated per-video computation and the need for model-specific compression designs. Extensive experiments across multiple video understanding benchmarks and against diverse compression baselines demonstrate that our approach achieves a strong accuracy-efficiency trade-off, maintaining competitive performance while achieving the lowest inference latency among compared methods. Introduction Video understanding with large multimodal models requires processing thousands of visual tokens extracted from video inputs. As video duration increases, the resulting sequences place growing pressure on the context window and prefill computation of the language model (Lin et al. 2024; Li et al. 2025a; Yang et al. 2025). Meanwhile, neighboring frames and patches often contain repeated visual information (Tao et al. 2025; Fu et al. 2025b), making efficient token compression an important problem. Existing methods mainly compress visual tokens through selection (Chen et al. 2024a; Yang et al. 2025; Shang et al. 2025; Ju et al. 2026), aggregation (Bolya et al. 2023; Tao et al. 2025; Fu et al. 2025b; Li et al. 2026), or compact representation learning (Li et al. 2024b; Zhang and Fu 2025). Despite their different designs, most follow an inference-time workflow: dense visual features are first generated and then compressed independently for each input video. Despite their differences, existing methods perform compression only after dense visual tokens have already been generated. As a result, a substantial portion of the visual encoding cost has already been incurred before compression takes place, making token compression itself an additional inference-stage computation rather than an intrinsic part of visual representation learning. Moreover, compression decisions are computed independently for every input video. Although videos often share recurring objects, scenes, and visual structures, existing approaches repeatedly estimate token importance or similarity from scratch (Shen et al. 2025; Ju et al. 2026; Du et al. 2026; Li et al. 2026), preventing compression knowledge from being shared or reused across different videos. Finally, many existing approaches rely on model-dependent compression mechanisms, such as attention-based importance estimation or architecture-specific similarity metrics (Chen et al. 2024a; Shang et al. 2025; Huang et al. 2025). Such designs often couple the compression process with the underlying Video-LLM architecture, requiring additional adaptation when deployed across different models and limiting their flexibility in practical scenarios. Figure 1: ONCE learns a reusable global codebook from an offline video corpus. For each test video, fixed-codebook assignment and continuous mean pooling replace N projected visual tokens with at most B pooled tokens before language-model processing. The plotted LLaVA-OneVision-7B operating point uses B=256B=256 and compares task accuracy with the corresponding Full model. In this work, we propose ONCE, an offline-to-online video token compression framework (Figure 1) that learns a reusable grouping prior in a frozen visual feature space. Offline, ONCE fits a balanced global codebook to temporally stratified sketches weighted by source-token count. During inference, it retains the codewords best supported by the current video, reassigns all source tokens to them, and mean-pools their original continuous embeddings. The codebook guides grouping while all Video-LLM parameters remain frozen. Our main contributions are summarized as follows: • We introduce an novel offline-to-online framework that learns a corpus-level grouping prior and reuses it for unseen videos in the same frozen feature space. • We learn a global codebook from source-count-weighted sketches, with budget-aware selection and source-token mean pooling. • We evaluate ONCE across four video understanding benchmarks and two model backbones against input-adaptive compression baselines. ONCE achieves a favorable accuracy–efficiency trade-off, with its strongest accuracy gains under tight token budgets and consistent reductions in inference cost. Related Work Video Large Language Models Recent advances in multimodal large language models have enabled Video-LLMs to perform complex video understanding tasks by integrating pretrained visual encoders with large language models. Early Video-LLMs, such as Video-ChatGPT and Video-LLaVA, establish a modular architecture that connects pretrained vision encoders with LLMs through lightweight projection modules (Maaz et al. 2024; Lin et al. 2024; Zhang et al. 2023; Li et al. 2025b). Recent works, including LongVILA, LongLLaVA, and LLaVA-OneVision, further scale Video-LLMs toward long-video understanding by extending visual contexts, improving temporal reasoning, and leveraging large-scale video instruction data (Chen et al. 2025; Wang et al. 2025c; Li et al. 2025a; An et al. 2025). Meanwhile, general-purpose vision-language models such as InternVL and Qwen3-VL provide stronger multimodal representations and flexible visual token processing, serving as powerful backbones for video understanding tasks (Chen et al. 2024b; Wang et al. 2025b; Bai et al. 2025). However, these advances rely on increasingly dense visual-token sequences, where the growing number of visual tokens becomes a major bottleneck for long-video inference. Video Token Compression Existing video token compression methods reduce redundant visual tokens through different compression operations, mainly including token pruning and token aggregation. Token pruning methods remove less informative tokens by estimating token importance or redundancy, reducing the number of visual tokens while preserving essential information (Shen et al. 2025; Ju et al. 2026; Guo et al. 2026; Huang et al. 2025; Wang et al. 2025a). In contrast, token aggregation methods merge redundant tokens into compact representations by exploiting feature similarity, temporal redundancy, or token correspondence (Kim et al. 2024; Tao et al. 2025; Fu et al. 2025b; Shao et al. 2025). These compression operations typically rely on different token decision proxies to estimate token importance or redundancy. Existing approaches leverage various signals, including spatio-temporal structures (Ju et al. 2026; Guo et al. 2026), temporal and visual redundancy (Shen et al. 2025; Tao et al. 2025), feature similarity (Kim et al. 2024; Fu et al. 2025b), language-query relevance (Huang et al. 2025), and information-aware criteria (Liu et al. 2026). Despite using different compression operations and decision proxies, existing methods generally follow an instance-specific compression paradigm, where compression decisions are determined independently for each input video after dense visual tokens have been generated. As a result, compression patterns need to be repeatedly estimated for each video, limiting the reuse of compression knowledge across different inputs and motivating the exploration of reusable compression priors. Codebook-based Representation Learning Codebook-based representation learning learns a finite set of representative prototypes to discretize continuous visual features into compact latent spaces. Early approaches such as VQ-VAE and VQGAN introduce vector quantization to construct discrete visual representations for image reconstruction and generation (van den Oord et al. 2017; Esser et al. 2021). Recent works extend this idea to multimodal models by learning discrete visual vocabularies, where continuous visual features are mapped to compact token representations for efficient visual understanding and generation (Zhang and Fu 2025; Zhang et al. 2025a). Inspired by these discrete representation learning approaches, we explore a different perspective of codebook utilization for video token compression. Such discrete vocabularies provide a shared representation space by assigning visual features to a finite set of prototypes. Rather than using the codebook as a discrete tokenizer for replacing continuous visual features, our method treats the learned prototypes as a reusable assignment prior for grouping visual tokens across videos. The compressed tokens remain continuous aggregations of the original visual features, enabling offline-learned grouping structures to be efficiently reused through lightweight online assignment. Method Figure 2: Overview of ONCE. (a) Offline, ONCE fits a global codebook from temporally stratified, source-count-weighted corpus sketches. (b) At inference, the fixed codebook selects groups supported by the current video, all projected visual tokens are reassigned, and each group is represented by the mean of its source embeddings. ONCE Framework Overview ONCE is an offline-to-online visual token compression framework that learns a reusable global grouping prior once and applies it to arbitrary videos through efficient token assignment and aggregation. Given a video V, the frozen visual encoder EvisE_vis and visual projection/merger PvisP_vis produce dense visual tokens: X=Pvis(Evis(V))∈ℝN×D.X=P_vis(E_vis(V)) ^N× D. (1) Instead of performing video-specific compression at inference time, ONCE first learns a global visual codebook C=[c1,…,cK]C=[c_1,…,c_K] T offline from large-scale video data. During inference, the fixed codebook is used as a grouping prior to assign dense tokens and aggregate them into a compact sequence: Z=ONCE(X,C,B)∈ℝM×D,M≤min(N,B).Z=ONCE(X,C,B) ^M× D, M≤ (N,B). (2) Here, B bounds the number of pooled visual-content tokens, excluding model-specific special and layout tokens, and M is the input-dependent pooled output length. We write ν(v)=v/max(∥v∥2,δ)ν(v)=v/ ( v _2,δ), with δ>0δ>0, for ℓ2 _2 normalization in the cosine assignments below. Importantly, the compressed tokens remain continuous aggregations of the original visual embeddings rather than discrete code indices. Therefore, ONCE requires no optimization for each input video and can efficiently compress videos within the same frozen visual feature space. Global Codebook Learning ONCE learns a global codebook from large-scale video data through two stages: temporally aware corpus sketching and balanced prototype fitting. Temporally Stratified Corpus Sketch To learn a corpus-level codebook efficiently, we first construct a compact yet representative sketch from the training corpus. Instead of uniform sampling, we preserve temporal diversity by stratifying each video along its timeline. We divide each video’s normalized timeline into L equal bins, assigning τ=1τ=1 to the final bin. For N tokens, the sketch size is m=minN,clip(⌈N/R⌉,mmin,mmax)m= \N,clip( N/R ,m_ ,m_ )\, where R is the target number of source tokens per sketch token. We distribute the m representatives across nonempty bins as evenly as capacity permits, with at least one per bin whenever m is large enough. Within each bin, spherical Lloyd (Dhillon and Modha 2001) updates partition the normalized tokens into local groups AjA_j. Each group stores a representative and the number of source tokens it summarizes: rj=ν(∑i∈Ajν(xi)),wj=|Aj|,∑jwj=N.r_j=ν\! ( _i∈ A_jν(x_i) ), w_j=|A_j|, _jw_j=N. (3) Distinct seeds avoid empty local groups. Aggregating all videos produces a corpus-level set of weighted sketches: =(ru,wu,gu)u=1U,D=\(r_u,w_u,g_u)\_u=1^U, where gug_u denotes the dataset category of the source video. Each sketch token rur_u preserves its summarized visual content, while wuw_u records the amount of source-token mass it represents. Balanced Global Codebook Fitting Since naive clustering tends to allocate multiple prototypes to dominant visual patterns, we introduce balanced assignment to promote more even codeword utilization across the corpus. For each representative rur_u, we first define an effective weight ωu=wupgu−α, _u=w_up_g_u^-α, (4) where wuw_u preserves the number of source tokens summarized by the representative, pgup_g_u denotes the frequency of its source category, and α controls the strength of long-tail correction. When category labels are unavailable, we set α=0α=0. This weighting scheme preserves the contribution of high-mass representatives while preventing dominant categories from overwhelming the learned codebook. Given a mini-batch of representatives ℬB, we normalize the representative weights as row marginals and assign uniform mass to all codewords: au=ωu∑v∈ℬωv,bk=1K.a_u= _u _v _v, b_k= 1K. (5) The similarity between representative rur_u and codeword ckc_k is measured by cosine similarity: Suk=ν(ru)ν(ck).S_uk=ν(r_u) Tν(c_k). (6) We formulate the codebook assignment as an entropy-regularized optimal transport problem: Γ⋆= = argmaxΓ≥0⟨Γ,S⟩+εH(Γ), _ ≥ 0 ,S + H( ), (7) s.t.Γ=a,Γ=b, .t. 1=a, T1=b, where H(Γ)=−∑u,kΓuklogΓukH( )=- _u,k _uk _uk. The row marginal preserves representative importance, while the uniform column marginal encourages balanced utilization of codewords. We solve Eq. 7 using log-domain Sinkhorn iterations (Cuturi 2013). During optimization, straight-through Gumbel–Softmax assignments (Jang et al. 2017) enable differentiable codebook updates with weighted reconstruction and code-usage objectives. After offline training, the learned codebook C is fixed and reused during inference. Inference-Time Token Compression Given the offline-learned global codebook, ONCE performs inference-time compression by using it as a reusable grouping prior. Dense visual tokens are matched to codewords, while the current video determines which part of that global geometry is active. Active Codeword Selection For a new video, ONCE first performs codebook lookup by assigning each visual token to its nearest codeword in the frozen global codebook: k^i=argmaxk∈[K]ν(xi)ν(ck),nk=∑i[k^i=k]. k_i= *arg\,max_k∈[K]ν(x_i) Tν(c_k), n_k= _i1[ k_i=k]. (8) The initial assignment compares each input token against the reusable global codebook and identifies the codewords activated by the current video. The frequency nkn_k records how many visual tokens are associated with codeword k, reflecting how frequently the codeword represents visual tokens in the input sequence. Based on these frequencies, ONCE selects the active codeword set BK_B by retaining the codewords with the largest nonzero frequencies, where |B|≤min(B,K)|K_B|≤ (B,K). This frequency-based selection adapts the corpus-level codebook to each individual video by removing inactive codewords before compression. The selected active codewords form a compact grouping set for the subsequent reassignment and token pooling stage. Reassignment and Token Pooling After selecting the active codewords, ONCE performs a second assignment over the retained set BK_B to construct the final grouping structure. Specifically, each source token is reassigned to its nearest active codeword: ki k_i =argmaxk∈Bν(xi)ν(ck), = *arg\,max_k _Bν(x_i) Tν(c_k), (9) zk z_k =1|k|∑i∈kxi. = 1|G_k| _i _kx_i. where kG_k denotes the set of source tokens assigned to active codeword k. The reassignment step updates token-to-codeword associations after removing inactive codewords, ensuring that every source token is assigned to one of the retained groups. Each group kG_k is then compressed into a single visual token zkz_k through mean pooling over its original continuous embeddings. Although the codebook determines the grouping structure, the pooled representation is computed from the input video features rather than the codeword itself. The output tokens are ordered according to the frequency ranking of their corresponding active codewords. Since the groups form a partition of all source tokens, no visual token is discarded during pooling, and the output sequence length satisfies M≤min(N,B)M≤ (N,B). Inference complexity. The initial codebook lookup costs O(NKD)O(NKD), while reassignment over the selected codewords costs O(N|B|D)O(N|K_B|D). Frequency counting, partial top-B selection, and pooling cost O(N+KlogB+ND)O(N+K B+ND). Since |B|≤B|K_B|≤ B, these additional terms are lower order when K≫BK B and ND≫logBND B. In particular, reassignment uses at most a fraction B/KB/K of the similarity computations required by the initial lookup. Under these conditions, the total online compression overhead simplifies to O(NKD)O(NKD). Experiments Token budget Method MVBench EgoSchema Video-MME LongVideoBench 23329 LLaVA-OV-7B 55.78 67.00 57.37 55.72 32 ForestPrune 44.85 47.80 45.93 46.15 FastVID 40.67 39.60 43.85 43.08 ONCE (Ours) 47.93 55.20 48.44 47.49 64 ForestPrune 47.67 52.80 47.96 46.45 FastVID 45.06 49.20 46.41 44.95 ONCE (Ours) 50.58 57.00 50.30 47.64 128 ForestPrune 49.33 54.40 50.33 47.94 FastVID 49.32 54.80 49.44 47.42 ONCE (Ours) 52.20 60.40 51.07 49.89 256 ForestPrune 52.80 57.20 52.22 50.26 FastVID 53.78 60.40 53.67 52.36 ONCE (Ours) 54.13 62.80 52.30 51.61 512 ForestPrune 55.75 61.20 53.56 53.55 FastVID 56.45 59.80 56.56 54.75 ONCE (Ours) 54.50 62.40 53.26 52.95 1024 ForestPrune 57.83 62.40 56.15 56.62 FastVID 57.65 59.40 57.26 56.17 ONCE (Ours) 54.28 62.60 53.85 54.00 Table 1: LLaVA-OneVision-7B accuracy (%) across visual-token budgets. ONCE selects codewords jointly across all sampled frames of each video. Bold marks the best compressed result within each budget. Experimental Setup Models, data, and baselines. We evaluate ONCE with the frozen LLaVA-OneVision-7B backbone (Li et al. 2025a) on MVBench (Li et al. 2024a), EgoSchema (Mangalam et al. 2023), Video-MME (Fu et al. 2025a), and LongVideoBench (Wu et al. 2024), which collectively span short-form temporal reasoning, long-video comprehension, and broad multimodal video evaluation. We also instantiate ONCE with Qwen3.5-9B (Qwen Team 2026) on MVBench and LongVideoBench to evaluate its generalization across video-language model architectures. For each backbone, we learn a global codebook once in its frozen visual feature space using the 0–30 s subset of LLaVA-Video-178K (Zhang et al. 2025b). The learned codebook is fixed and reused for all downstream videos processed by the same backbone. Since different backbones produce visual features in different representation spaces, each codebook is dimension-matched to its corresponding backbone while retaining the same ONCE design. For LLaVA-OneVision-7B, we compare ONCE with two representative recent training-free video token compression methods, ForestPrune (Ju et al. 2026) and FastVID (Shen et al. 2025), under the same backbone across different token budgets. ForestPrune performs high-ratio visual token pruning via spatio-temporal token modeling, while FastVID adopts dynamic density-based pruning to reduce redundant visual tokens. These methods provide strong baselines for efficient video understanding by reducing redundant visual tokens. Supplementary experiments with LLaVA-OneVision-0.5B further evaluate the scalability of ONCE across different model sizes. Protocols and metrics. We evaluate video understanding performance under different token budgets B by varying the number of pooled visual tokens retained by ONCE. Accuracy comparisons are conducted on MVBench (Li et al. 2024a), EgoSchema (Mangalam et al. 2023), Video-MME (Fu et al. 2025a), and LongVideoBench (Wu et al. 2024), following the corresponding evaluation protocols. For efficiency evaluation, we profile inference cost under a fixed operating point (B=512B=512). All profiling experiments are conducted on a single NVIDIA GeForce RTX 4090. We report four deployment-oriented metrics, including visual token count, FLOPs, end-to-end latency, and peak GPU memory. Implementation details. For each backbone, we learn a global codebook once in its frozen visual feature space using the 0–30 s subset of LLaVA-Video-178K (Zhang et al. 2025b). The learned codebook is fixed and reused for all downstream videos processed by the same backbone. Since different backbones produce visual features in different representation spaces, we construct separate codebooks for different backbones while preserving the same ONCE framework. Unless otherwise specified, we use a codebook size of K=8192K=8192 and perform online assignment with cosine similarity between visual tokens and codewords. Additional details on dataset splits, video sampling, decoding, and profiling settings are provided in the supplementary material. Main Results LLaVA-OneVision-7B. At B∈32,64,128B∈\32,64,128\, ONCE attains the highest accuracy among compressed methods on all four benchmarks (Table 1), indicating that the reusable grouping prior is most valuable when token capacity is scarce. As B grows, pruning baselines close or reverse the gap; the result is therefore low-budget robustness rather than uniform dominance. Token budget Method MV LVB Standard Qwen3.5-9B 70.18 65.37 128 ONCE 56.23 51.46 256 ONCE 58.90 53.78 512 ONCE 63.25 56.40 1024 ONCE 61.95 54.43 Table 2: Qwen3.5-9B accuracy (%) across visual-token budgets. Videos are sampled at 2 frames per second (FPS), with at most 256 frames. Qwen3.5-9B. ONCE transfers to Qwen3.5-9B, with B=512B=512 best on both benchmarks (Table 2). The trend suggests that downstream performance under codebook compression need not improve linearly with the retained-token budget. Thus, B should be selected empirically rather than treated as a direct proxy for representation quality. Unlike LLaVA’s tight-budget advantage and mixed higher-budget rankings, Qwen provides a complementary budget trend. All Qwen rows reuse one codebook without retraining. Efficiency. ONCE removes most visual-token prefill work on both backbones, yet end-to-end speedup is smaller and varies by workload (Table 3). Compression occurs after visual encoding, leaving encoder and decoding costs unchanged; the remaining runtime therefore limits realized acceleration. The larger LLaVA speedups indicate that deployment gains depend on the backbone’s prefill share rather than token reduction alone. Memory falls more modestly because model weights and non-visual state remain resident. Model Data Vis. Tok.↓ FLOPs↓ E2E↑ Mem.↓ (avg.) (%) (%) (×) (%) LLaVA MV 467.70 98.00 98.29 4.49 16.36 LLaVA LVB 503.64 97.84 97.95 3.35 16.69 Qwen MV 340.77 93.48 91.22 1.79 15.58 Qwen LVB 701.31 98.82 98.04 2.22 14.39 Table 3: Efficiency at B=512B=512; arrowed columns are relative to matched uncompressed inference. Ablation Study Table 4 separates the roles of temporal partitioning, reassignment, grouping, and output representation. All inference-side variants reuse Full’s codebook. Variant Changed component MV LVB Full (Table 1) – 54.50 52.95 Single-bin Partition 39.03 41.96 w/o complete reassignment Reassignment 53.83 53.48 Random grouping Grouping 45.33 46.00 Codeword output Representation 38.38 41.74 Table 4: LLaVA-OneVision-7B ablations at B=512B=512; Random grouping preserves Full’s group sizes and randomizes membership. Single-bin training and codeword output produce the largest losses even though they alter different stages of ONCE. The two failures are complementary. Single-bin training removes temporal stratification from the offline corpus sketch, whereas codeword output substitutes fixed prototypes for current-video source means. Their similar degradation supports a division of labor: offline learning organizes the feature space, while online pooling retains instance-specific evidence. The codebook should therefore guide group membership rather than serve as the compressed representation. Random grouping keeps Full’s group-size profile and source-mean output rule while breaking feature-based membership. Its lower accuracy on both benchmarks indicates that group size alone does not account for Full’s result; codebook membership carries task-relevant structure. Removing complete reassignment changes accuracy much less, although the supplementary coverage diagnostic shows that some source tokens stop contributing. Reassignment therefore guarantees complete representation, while grouping and output construction determine what the compressed sequence retains. Codebook Analysis Beyond downstream accuracy, we analyze whether the offline-learned codebook captures reusable visual grouping structures in the feature space, rather than merely storing training examples. We analyze the selected Full codebook in two stages: utilization on the training corpus and coverage of public-video features. The training diagnostics in Table 5 describe three complementary properties. Active codes measure occupancy, entropy-effective capacity discounts highly uneven assignment mass, and mean cosine error measures how closely cached features match their nearest codewords. Together, they distinguish a codebook that is merely nonempty from one whose capacity is distributed across the corpus. Training-corpus diagnostic Estimate 95% CI Active codes (%) 99.93 – Entropy-effective capacity (%) 53.39 [53.25, 53.42] Mean cosine error (×10−3× 10^-3) 4.763 [4.750, 4.775] Table 5: Full-codebook utilization on the Stage-A cache (K=8192K=8192). The 95% confidence intervals (CIs) use video-level bootstrap resampling. The table establishes broad occupancy but less uniform effective use. To localize this imbalance, Figure 3 orders codewords by assigned source-token mass and aggregates them into equal-count deciles. Bar height represents each decile’s share of the assignments; the emphasized bars isolate the highest-ranked fifth, and the dashed line provides the uniform reference. Figure 3: Training-corpus codebook utilization. Nearly all codewords are active, although assignment mass remains concentrated. Figure 3 shows that assignment mass is concentrated in the leading deciles and then tapers across the remaining codebook. Thus, near-complete activation does not imply balanced use: common visual structures carry much of the workload, while lower-frequency regions still retain dedicated codewords. Corpus utilization does not show how a fixed token budget redistributes accuracy across video capabilities. We therefore expand the B=512B=512 MVBench comparison in Figure 4. Every spoke uses the same raw scale, so an outward separation directly indicates higher accuracy on that task. Figure 4: MVBench subtask performance. ONCE remains competitive across diverse video-reasoning tasks, with its clearest gains in event counting and change recognition. Figure 4 shows a selective rather than uniform retention pattern. ONCE is higher on seven tasks, with the clearest outward shifts in moving count, action antonym, state change, and object shuffle. The larger inward shifts occur in action localization, fine-grained pose, action prediction, character order, and counterfactual inference. Grouped by capability, the pattern suggests that global grouping retains event-level counts and state transitions more reliably than precise temporal alignment or subtle pose cues. A supplementary public-video stress test finds lower mean and tail cosine residuals for Full than for equally sized random-exemplar codebooks. This result suggests that the fitted geometry remains useful beyond the training cache. Together with the ablation, these diagnostics suggest a two-part mechanism. The global codebook supplies reusable partition geometry, while the current video determines which regions are active and provides the content of the compressed tokens. This division explains how ONCE can reuse an offline structure without making every video share the same compressed representation, and it connects the codebook analysis to the accuracy and efficiency gains reported above. Conclusion Efficient long-video inference requires compressing dense visual-token sequences without optimizing a new compression strategy for every input. ONCE learns offline a global visual codebook that captures corpus-level statistics in the frozen feature space of the target Video-LLM. At inference, the fixed codebook is reused for codebook lookup, complete reassignment, and token aggregation. The codebook determines the grouping structure, while online mean pooling preserves task-relevant continuous representations from the current video. Across the tested token budgets and Video-LLM backbones, ONCE maintains competitive task performance. Under extreme token budgets (B∈32,64,128B∈\32,64,128\), ONCE achieves the highest accuracy among the compared compression baselines on all four benchmarks. Across the four backbone–dataset profiling configurations at B=512B=512, visual-token prefill FLOPs fall by 96.38±3.4496.38± 3.44 percentage points, and end-to-end inference is (2.96±1.21)×(2.96± 1.21)× faster (mean ± standard deviation). Under our design and configuration, 99.93%99.93\% of the codewords are active, although source-token assignment mass remains concentrated among the leading codewords. This pattern indicates a feature-space partition aligned with the corpus statistics: frequent visual patterns receive more assignments, while dedicated codewords still cover lower-frequency regions. Lower mean and tail cosine residuals than random-exemplar codebooks on the public-video stress set further support the use of this statistical structure beyond the training cache. The ablation indicates that combining reusable global structure with video-specific representation aggregation is an effective design for ONCE. Limitations and future work. ONCE still requires a separate codebook for each target feature space. The fixed codebook is learned from a finite offline sample of the frozen visual feature space. Broader coverage of that space could improve the fitted grouping prior, but constructing a sufficiently diverse sample is currently limited by data and computational resources. Compression occurs after visual encoding and therefore does not reduce vision-encoder computation. The task profile also suggests weaker retention of precise temporal localization, event ordering, and fine-grained pose cues than of event counts and state changes. Future work could share or transfer codebooks across related backbones and move compression earlier into visual encoding. Although the current evaluations focus on video question answering, adaptations to the target data, representation space, and downstream objective may extend this compression approach to other tasks and application domains. References X. An, Y. Xie, K. Yang, W. Zhang, X. Zhao, Z. Cheng, Y. Wang, S. Xu, C. Chen, D. Zhu, et al. (2025) LLaVA-OneVision-1.5: fully open framework for democratized multimodal training. External Links: 2509.23661 Cited by: Video Large Language Models. S. Bai, Y. Cai, R. Chen, K. Chen, X. Chen, Z. Cheng, L. Deng, W. Ding, C. Gao, C. Ge, et al. (2025) Qwen3-VL technical report. External Links: 2511.21631, Link Cited by: Video Large Language Models. D. Bolya, C. Fu, X. Dai, P. Zhang, C. Feichtenhofer, and J. Hoffman (2023) Token Merging: Your ViT but Faster. In The Eleventh International Conference on Learning Representations, Cited by: Introduction. L. Chen, H. Zhao, T. Liu, S. Bai, J. Lin, C. Zhou, and B. Chang (2024a) An image is worth 1/2 tokens after layer 2: plug-and-play inference acceleration for large vision-language models. In Computer Vision – ECCV 2024, Lecture Notes in Computer Science, Vol. 15139, p. 19–35. External Links: Document Cited by: Introduction. Y. Chen, F. Xue, D. Li, Q. Hu, L. Zhu, X. Li, Y. Fang, H. Tang, S. Yang, Z. Liu, et al. (2025) LongVILA: scaling long-context visual language models for long videos. In International Conference on Learning Representations, Vol. 2025, p. 18227–18246. External Links: Link Cited by: Video Large Language Models. Z. Chen, J. Wu, W. Wang, W. Su, G. Chen, S. Xing, M. Zhong, Q. Zhang, X. Zhu, L. Lu, et al. (2024b) InternVL: scaling up vision foundation models and aligning for generic visual-linguistic tasks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 24185–24198. Cited by: Video Large Language Models. M. Cuturi (2013) Sinkhorn distances: lightspeed computation of optimal transport. Advances in neural information processing systems 26. Cited by: Balanced Global Codebook Fitting. I. S. Dhillon and D. S. Modha (2001) Concept decompositions for large sparse text data using clustering. Machine learning 42 (1), p. 143–175. Cited by: Temporally Stratified Corpus Sketch. J. Du, J. Xue, A. Li, J. Dai, and G. Lu (2026) Unified Spatiotemporal Token Compression for Video-LLMs at Ultra-Low Retention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 17661–17671. Cited by: Introduction. P. Esser, R. Rombach, and B. Ommer (2021) Taming Transformers for High-Resolution Image Synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 12873–12883. Cited by: Codebook-based Representation Learning. C. Fu, Y. Dai, Y. Luo, L. Li, S. Ren, R. Zhang, Z. Wang, C. Zhou, Y. Shen, M. Zhang, et al. (2025a) Video-MME: the first-ever comprehensive evaluation benchmark of multi-modal LLMs in video analysis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 24108–24118. Cited by: Models, data, and baselines., Protocols and metrics.. T. Fu, T. Liu, Q. Han, G. Dai, S. Yan, H. Yang, X. Ning, and Y. Wang (2025b) FrameFusion: combining similarity and importance for video token reduction on large vision language models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 22654–22663. Cited by: Introduction, Video Token Compression, Video Token Compression. Y. Guo, C. Zhu, J. Ji, J. Lin, and L. Cao (2026) HieraVid: hierarchical token pruning for fast video large language models. External Links: 2604.01881 Cited by: Video Token Compression, Video Token Compression. X. Huang, H. Zhou, and K. Han (2025) PruneVid: visual token pruning for efficient video large language models. In Findings of the Association for Computational Linguistics: ACL 2025, Vienna, Austria, p. 19959–19973. External Links: Document Cited by: Introduction, Video Token Compression, Video Token Compression. E. Jang, S. Gu, and B. Poole (2017) Categorical reparameterization with gumbel-softmax. In International conference on learning representations, Cited by: Balanced Global Codebook Fitting. S. Ju, B. Song, T. Chen, J. Zhang, Q. Wu, C. Chang, H. Wang, Y. Zhou, and R. Ji (2026) ForestPrune: high-ratio visual token compression for video multimodal large language models via spatial-temporal forest modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Findings, p. 8326–8336. Cited by: Introduction, Video Token Compression, Video Token Compression, Models, data, and baselines.. M. Kim, S. Gao, Y. Hsu, Y. Shen, and H. Jin (2024) Token fusion: bridging the gap between token pruning and token merging. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, p. 1383–1392. Cited by: Video Token Compression, Video Token Compression. B. Li, Y. Zhang, D. Guo, R. Zhang, F. Li, H. Zhang, K. Zhang, P. Zhang, Y. Li, Z. Liu, et al. (2025a) LLaVA-OneVision: easy visual task transfer. Transactions on Machine Learning Research. External Links: Link Cited by: Introduction, Video Large Language Models, Models, data, and baselines.. J. Li, L. Jiang, H. Zhang, and N. Sebe (2026) Token Reduction via Local and Global Contexts Optimization for Efficient Video Large Language Models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 10451–10461. Cited by: Introduction. K. Li, Y. He, Y. Wang, Y. Li, W. Wang, P. Luo, Y. Wang, L. Wang, and Y. Qiao (2025b) VideoChat: chat-centric video understanding. Science China Information Sciences 68 (10), p. 200102. Cited by: Video Large Language Models. K. Li, Y. Wang, Y. He, Y. Li, Y. Wang, Y. Liu, Z. Wang, J. Xu, G. Chen, P. Luo, et al. (2024a) MVBench: a comprehensive multi-modal video understanding benchmark. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 22195–22206. Cited by: Models, data, and baselines., Protocols and metrics.. Y. Li, C. Wang, and J. Jia (2024b) LLaMA-VID: an image is worth 2 tokens in large language models. In Computer Vision – ECCV 2024, Lecture Notes in Computer Science, Vol. 15104, p. 323–340. External Links: Document Cited by: Introduction. B. Lin, Y. Ye, B. Zhu, J. Cui, M. Ning, P. Jin, and L. Yuan (2024) Video-LLaVA: learning united visual representation by alignment before projection. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, p. 5971–5984. Cited by: Introduction, Video Large Language Models. X. Liu, S. Gan, X. Liu, Y. Yin, L. Xie, and S. Lu (2026) InfoMerge: information-aware token compression for efficient video large language models. arXiv preprint arXiv:2606.02161. Cited by: Video Token Compression. M. Maaz, H. Rasheed, S. Khan, and F. Khan (2024) Video-ChatGPT: towards detailed video understanding via large vision and language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Bangkok, Thailand, p. 12585–12602. External Links: Document, Link Cited by: Video Large Language Models. K. Mangalam, R. Akshulakov, and J. Malik (2023) EgoSchema: a diagnostic benchmark for very long-form video language understanding. Advances in Neural Information Processing Systems 36, p. 46212–46244. Cited by: Models, data, and baselines., Protocols and metrics.. Qwen Team (2026) Qwen3.5-9B. Note: Hugging Face model cardAvailable at https://huggingface.co/Qwen/Qwen3.5-9B (accessed July 29, 2026) Cited by: Models, data, and baselines.. Y. Shang, M. Cai, B. Xu, Y. J. Lee, and Y. Yan (2025) LLaVA-PruMerge: adaptive token reduction for efficient large multimodal models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 22857–22867. Cited by: Introduction. K. Shao, K. Tao, C. Qin, H. You, Y. Sui, and H. Wang (2025) HoliTom: holistic token merging for fast video large language models. External Links: 2505.21334 Cited by: Video Token Compression. L. Shen, G. Gong, T. He, Y. Zhang, P. Liu, S. Zhao, and G. Ding (2025) FastVID: dynamic density pruning for fast video large language models. In Advances in Neural Information Processing Systems, Vol. 38, p. 123553–123581. Cited by: Introduction, Video Token Compression, Video Token Compression, Models, data, and baselines.. K. Tao, C. Qin, H. You, Y. Sui, and H. Wang (2025) DyCoke: dynamic compression of tokens for fast video large language models. In Proceedings of the Computer Vision and Pattern Recognition Conference, p. 18992–19001. Cited by: Introduction, Video Token Compression, Video Token Compression. A. van den Oord, O. Vinyals, and K. Kavukcuoglu (2017) Neural discrete representation learning. In Advances in Neural Information Processing Systems, Vol. 30, p. 6306–6315. Cited by: Codebook-based Representation Learning. M. Wang, S. Chen, K. Kersting, V. Tresp, and Y. Ma (2025a) METok: multi-stage event-based token compression for efficient long video understanding. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, p. 18870–18884. Cited by: Video Token Compression. W. Wang, Z. Gao, L. Gu, H. Pu, L. Cui, X. Wei, Z. Liu, L. Jing, S. Ye, J. Shao, et al. (2025b) InternVL3.5: advancing open-source multimodal models in versatility, reasoning, and efficiency. External Links: 2508.18265, Link Cited by: Video Large Language Models. X. Wang, D. Song, S. Chen, J. Chen, Z. Cai, C. Zhang, L. Sun, and B. Wang (2025c) LongLLaVA: scaling multi-modal LLMs to 1000 images efficiently via a hybrid architecture. In Findings of the Association for Computational Linguistics: EMNLP 2025, Suzhou, China, p. 21419–21436. External Links: Document, Link Cited by: Video Large Language Models. H. Wu, D. Li, B. Chen, and J. Li (2024) LongVideoBench: a benchmark for long-context interleaved video-language understanding. Advances in Neural Information Processing Systems 37, p. 28828–28857. Cited by: Models, data, and baselines., Protocols and metrics.. S. Yang, Y. Chen, Z. Tian, C. Wang, J. Li, B. Yu, and J. Jia (2025) VisionZip: longer is better but not necessary in vision language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 19792–19802. Cited by: Introduction. H. Zhang and Y. Fu (2025) VQToken: neural discrete token representation learning for extreme token reduction in video large language models. In Advances in Neural Information Processing Systems, Vol. 38, p. 32851–32869. Cited by: Introduction, Codebook-based Representation Learning. H. Zhang, X. Li, and L. Bing (2023) Video-llama: an instruction-tuned audio-visual language model for video understanding. In Proceedings of the 2023 conference on empirical methods in natural language processing: system demonstrations, p. 543–553. Cited by: Video Large Language Models. W. Zhang, Y. Feng, H. Luo, Y. Li, Z. Yue, S. Zheng, and Z. Lu (2025a) Unified Multimodal Understanding via Byte-Pair Visual Encoding. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 12976–12986. Cited by: Codebook-based Representation Learning. Y. Zhang, J. Wu, W. Li, B. Li, Z. Ma, Z. Liu, and C. Li (2025b) LLaVA-Video: video instruction tuning with synthetic data. Transactions on Machine Learning Research. External Links: Link Cited by: Models, data, and baselines., Implementation details.. Additional Experiments Evaluation Details Models and accuracy evaluation. We learn a separate ONCE codebook from LLaVA-Video-178K for each frozen visual feature space. The main LLaVA-OneVision-7B evaluation uses MVBench, EgoSchema, Video-MME, and LongVideoBench; the Qwen3.5-9B evaluation uses MVBench and the visual-only validation split of LongVideoBench. All ONCE accuracy results use whole-video codeword selection. The Qwen3.5-9B budget sweep uses BF16, non-thinking greedy decoding, 2-FPS sampling, and at most 256 frames, with 4,000 MVBench and 1,337 LongVideoBench samples. The LLaVA-OneVision-0.5B results below provide an additional model-scale comparison. Codebook reuse across token budgets. For a fixed backbone and frozen visual feature space, every sweep over the inference budget B reuses the same learned K=8192K=8192 codebook; changing B only changes how many active codewords are retained online and does not trigger codebook retraining. Only an experiment that changes the offline codebook-learning procedure or the backbone’s visual feature space requires a newly trained codebook. Downstream reuse and corpus audit. ONCE learns a grouping prior from frozen visual features without using downstream questions, answers, task labels, or evaluation predictions. We also compared Stage-A source identities with the downstream records available to the evaluation pipeline. The source annotations contain 94,583 unique media paths, of which 94,581 were successfully encoded. MVBench has no source-qualified logical-path match with these records. Its 41 shared generic basenames arise from the naming conventions of PerceptionTest and CLEVRER rather than a shared source. None of the 753 unique LongVideoBench validation identifiers matches a normalized training identifier. These results find no direct identity reuse in the audited records. More generally, cross-video reuse in ONCE means that one corpus-level codebook is applied without task-specific or per-video fitting; the mechanism does not rely on downstream supervision. Qwen evaluation alignment. The Standard and Full B=512B=512 Qwen3.5-9B results use the same benchmark splits, sample sets, BF16 non-thinking greedy decoding, 2-FPS input, and at-most-256-frame cap. These are the settings reported in main Table 2. Checkpoint size and indirect verification. The full-precision LLaVA-OneVision-7B checkpoint is 117,442,176 bytes (112.0 MiB), and the Qwen3.5-9B checkpoint is 134,272,832 bytes (128.1 MiB). Lossless ZIP compression reduces them only to 108,806,213 bytes (103.8 MiB) and 124,634,011 bytes (118.9 MiB), respectively. Thus, either checkpoint alone exceeds the 50 MB code-and-data upload limit, and the binary weights are omitted from the submitted archive. For indirect verification, the archive records each artifact and codebook-tensor SHA-256, the expected 8192×35848192× 3584 and 8192×40968192× 4096 shapes, and the pre-packaging results of strict loading, finite-value checks, nearest-code assignment, and the model-specific temporal-compression paths. It also contains the fixed configurations and scripts needed to retrain and locally validate either checkpoint. Together, these records define an indirect verification path for artifact identity and the tested inference interfaces under the submission size limit. Random seeds and reproducibility. The reported codebook-training, accuracy, control, and profiling jobs use the fixed seed 42. The training-cache video-level bootstrap uses seed 20260729, and deterministic public-video stress-set construction uses seed 20260731. The five public-video random-exemplar codebooks use seeds 20260801–20260805. The public-video coverage and cross-view analyses each use 5,000 resamples with bootstrap seed 20260811. All seeds are explicit configuration values reused across matched comparisons. Matched efficiency evaluation. All matched profiling runs were conducted locally on one NVIDIA GeForce RTX 4090 in a 48-GiB memory configuration (49,140 MiB reported device memory), with batch size 1. Each ONCE run is paired with standard inference without visual-token compression using the same backbone, benchmark, sample set, and input settings. LLaVA-OneVision videos are decoded at 1 FPS and uniformly sampled to 32 frames. Qwen3.5 uses 2-FPS sampling with 4–256 frames. The main efficiency comparison uses B=512B=512. The reported visual-token count includes pooled content tokens and model-specific special or layout tokens, while B is an upper bound on pooled content tokens. We report prefill FLOPs because ONCE directly changes the sequence entering the language model; the estimate uses its actual input length and isolates the targeted computation. End-to-end latency covers the complete path, including visual encoding, the O(NKD)O(NKD) lookup, pooling, and autoregressive decoding. The two metrics separate the direct prefill saving from the realized system effect. Table 15 reports the absolute PyTorch peak reserved memory rather than peak allocated memory or nvidia-smi process usage. One-time offline cost and storage. Table 6 reports completed wall-clock measurements for one recorded single-RTX 4090 run per backbone. Stage A extracts the frozen representatives and writes the fitting cache; Stage B fits the K=8192K=8192 codebook from that cache. Backbone Stage A Stage B Cache Reps. Codebook LLaVA-7B 15.62 h 4.67 min 32.93 GiB 4.918 M 112 MiB Qwen-9B 1.39 h 3.76 min 15.15 GiB 1.980 M 128 MiB Table 6: One-time codebook-construction cost and storage. Times are completed single-run wall-clock measurements. Cache is fitting-time storage; Codebook is the deployment checkpoint footprint. Stage A dominates the measured one-time cost, while Stage B takes minutes; neither is charged per evaluation video. The cache can be discarded after validation and deployment retains only the codebook. For N downstream inferences, the amortized one-time cost is (TA+TB)/N(T_A+T_B)/N. Relative to Dense inference, a configuration-specific break-even count is N⋆=TA+TBℓDense−ℓONCE.N = T_A+T_B _Dense- _ONCE. For the LLaVA MVBench B=512B=512 measurements in Table 11, 56,508.54 seconds of offline work and a 2,634.43-ms per-video latency difference give N⋆≈21,450N ≈ 21,450. This calculation expresses the one-time construction cost at a concrete deployment scale; the same equation gives the corresponding crossover for any backbone, benchmark, and inference configuration. Inference controls. The inference controls below use the frozen B=512B=512 operating point from main Table 1. Fixed-random selection and codeword output use the same codebook, sample sets, and frozen inference runtime as the Full reference. Fixed-random selection uses one shared subset of 512 codewords, followed by complete reassignment. Codeword output retains the Full assignments but emits the selected prototypes instead of source-embedding means. Nearest-source output, referred to internally as medoid output, also retains the Full assignments and emits the assigned source token with maximum cosine similarity to each pooled mean. Full codebook configuration. Table 7 gives the single Full configuration used for each backbone. These are the reference settings for all reported budget sweeps. An inference-budget experiment changes only B. Setting LLaVA-OneVision-7B Full Qwen3.5-9B Full Codebook shape 8192×35848192× 3584 8192×40968192× 4096 Feature source Projected patch-grid features Visual-merger output Training videos 94,581 LLaVA-Video-178K videos 94,581 LLaVA-Video-178K videos Stage-A video sampling 1 FPS; 32 uniformly sampled frames 2 FPS; 4–2,048 frames Accuracy evaluation FP16; 1 FPS; 32 uniformly sampled frames BF16; non-thinking greedy; 2 FPS; at most 256 frames Adaptive sketch R=256,mmin=16,mmax=52R=256,\ m_ =16,\ m_ =52 (128 requested) R=256,mmin=16,mmax=128R=256,\ m_ =16,\ m_ =128 Temporal sketch bins 4 4 Cached representatives 4,918,212 BF16 vectors 1,980,488 BF16 vectors Source tokens covered 2,206,385,568 436,884,976 Representative weighting Source count with long-tail exponent α=0.5α=0.5 Source count Initialization 65,536 candidates and 3 weighted spherical-Lloyd refinements 8,192 sampled candidates without post-refinement Sinkhorn FP32; ε=0.05 =0.05; 5 normalization steps FP32; ε=0.05 =0.05; 5 normalization steps Optimization AdamW; batch 65,536; LR 10−310^-3; WD 10−210^-2; cosine schedule; gradient clip 1 AdamW; batch 65,536; LR 10−310^-3; WD 10−210^-2; cosine schedule; gradient clip 1 Regularization Commitment 0.25; usage 0.01; temperature 1.0→0.011.0\!→\!0.01, decay 0.999 Commitment 0.25; usage 0.01; temperature 1.0→0.011.0\!→\!0.01, decay 0.999 Checkpoint selection At most 5 epochs; patience 2; refined initializer (epoch 0) selected 5 epochs; patience 2; epoch 5 selected Inference rule Whole-video selection, complete reassignment, source-mean output Whole-video selection, complete reassignment, source-mean output Selection rounds Q 4 4 Main operating point B=512B=512 B=512B=512 Random seed 42 42 Table 7: Full codebook-training and inference configuration. The 5,000,000 representative cap resolves the LLaVA per-video sketch maximum from the requested 128 to 52. All token-budget experiments for a fixed backbone reuse the corresponding Full codebook. Checkpoint selection treats the refined initializer as epoch 0 and subsequent Sinkhorn epochs as additional candidates. It retained the refined initializer for LLaVA and epoch 5 for Qwen. This backbone-specific selection is deliberate: it retains the initialized geometry when adequate and later balanced updates when they improve the selection criterion, while leaving the shared online rule unchanged. Across the two backbones, Full keeps K, Q, the main operating point, and the online rule fixed, while the feature source and dimension follow the visual encoder. This separates the shared ONCE design—whole-video selection, complete reassignment, and source-mean output—from the codebook fitted in each feature space. The cross-backbone results therefore test the same compression mechanism with a backbone-matched grouping prior. LLaVA ablation evaluation. The inference-policy, codebook-training, and output-representation controls reported in the ablation tables use the frozen LLaVA-OneVision-7B model with FP16 inference and 32 uniformly sampled frames. We evaluate all 4,000 MVBench and 1,337 LongVideoBench samples. Unless the variant name changes one of these steps, inference uses whole-video codeword selection, complete reassignment, and source-embedding mean pooling at the displayed budget. Public-video stress diagnostic. The coverage and support-origin diagnostics use the Full codebook; the coverage control additionally uses matched Hard-Lloyd. The diagnostic contains 1000 unique Wikimedia Commons video file pages, selected deterministically from the API video index. Eligible pages have a free-license record, a 3–180 s duration, and an official WebM derivative with at least 360 pixels on the short side. We cap each normalized creator and uploader at 30 retained pages; the realized set contains 367 normalized creator clusters and 282 uploaders. File-page ids, downloaded hashes, and five-frame perceptual signatures are all unique. The manifest records the file page, source and derivative URLs, source-page SHA-1, downloaded-derivative SHA-256, license, credit, upload timestamp, creator, uploader, and decoded metadata. The downloaded media remain outside the manuscript repository. Comparing file size and then SHA-256 against all 94,699 files in the audited local Stage-A tree found no byte-identical derivative. We designed this set as a public-video stress diagnostic rather than as a formal OOD claim. Its role is to test feature coverage across independently indexed public file pages under creator and uploader caps. Re-encodes, related events, semantic overlap, and model-pretraining exposure are outside the definition of this diagnostic. Each video is uniformly sampled to 32 frames and encoded by the frozen LLaVA-OneVision-7B vision tower and projector without spatial pooling, yielding 32×72932× 729 BF16 vectors of dimension 3,584. Feature identity is checked against the Stage-A cache and every codebook checkpoint. Figure 6 compares Full and matched Hard-Lloyd with five K=8192K=8192 random-exemplar codebooks. Assignment follows the production BF16 order (cast, normalize, matrix multiply). The primary metric is each video’s 95th percentile FP32 cosine residual, R95: it targets the least-covered 5% of tokens while retaining about 1,166 tail tokens per video. Mean residual and R50/R90/R99 are sealed as sensitivity measures; they do not replace R95 in this diagnostic. For the supplementary support-origin diagnostic, even and odd frames form two interleaved views. One view selects up to B supported Full-codebook ids; the other is fully reassigned to that support and pooled using only its own BF16 source means, after which the direction is reversed and averaged. Videos are partitioned into 500 disjoint reciprocal pairs by projected-feature-centroid similarity, requiring different creators and uploaders whenever an eligible partner remains. This makes the other-video control visually conservative rather than trivially cross-domain. The realized support is min(B,number of supported ids) (B,number of supported ids), so B is an upper bound. No realized pair shares a normalized creator or uploader, and the median projected-centroid cosine is 0.998. We use 5,000 nonparametric resamples. Videos and the five random-codebook seeds are resampled for Figures 5 and 6; disjoint pairs are resampled for Figure 7. For legibility, the small symbols in Figure 6 are 30 observed order statistics selected at evenly spaced empirical percentiles from 2.5 to 97.5; they are not a 30-video subsample. All displayed means and intervals use the full 1000 videos. Figure 6 reports pointwise percentile 95% intervals. Because all four budgets reuse the same pairs, the support-origin figure instead reports a non-studentized max-deviation 95% simultaneous band across the prespecified budgets; its right labels count positive effects among all 500 pairs. The resampling treats videos or pairs as units; creator and uploader concentration is handled by the construction caps rather than a second hierarchical model. Figure 5 summarizes the paired random-minus-Full effects for per-video mean residual and R95. Positive values favor Full. Figure 5: Cross-video feature coverage. Full improves both typical- and tail-token coverage over random exemplars. Both estimates and their confidence intervals lie to the right of zero. The larger tail reduction indicates that learned geometry is especially helpful for poorly covered tokens, while the positive mean effect shows that the improvement is not confined to the tail. Full lowers nearest-codeword R95 by 1.70×10−31.70× 10^-3 (95% CI [1.58,1.85]×10−3[1.58,1.85]× 10^-3), or 3.4% of the random R95; both learned codebooks are lower on all 1000 videos. Hard-Lloyd-minus-Full is −0.61×10−3-0.61× 10^-3 (95% CI [−0.66,−0.57]×10−3[-0.66,-0.57]× 10^-3). Full and Hard-Lloyd therefore both improve coverage over random exemplars; optimizer-specific ordering is separate from the learned-versus-random question measured here. Figure 6: Public-video tail-coverage gains over random exemplars. Small markers are observed order statistics; enlarged markers and whiskers show full-sample means and pointwise 95% CIs. Positive favors learned codebooks. The learned-versus-random coverage gain remains positive for mean residual and R50/R90/R99, so the result is not specific to R95. Figure 7: Effect of support origin on pooled R95. Markers show donor-minus-current means, whiskers show simultaneous 95% CIs, and labels count positive pairs. Positive favors current-video support. The simultaneous-CI lower bounds in Figure 7 are positive at all four budgets. At B=128B=128, donor support increases pooled R95 by 3.67×10−33.67× 10^-3 (simultaneous 95% CI [3.37,3.97]×10−3[3.37,3.97]× 10^-3); the effect is positive for 480 of 500 pairs. Donor support also increases mean residual by 1.44×10−31.44× 10^-3 (pointwise 95% CI [1.34,1.55]×10−3[1.34,1.55]× 10^-3), while current-video support covers 14.3 percentage points more of the target view’s initial Full-code assignments (pointwise 95% CI [13.4,15.2] points). These sensitivity measures agree with the R95 diagnostic, but this secondary comparison is not used as the main evidence for codebook quality. Table 8 separates adaptive selection, complete reassignment, and temporal selection scope. Full exceeds fixed-random selection at both budgets on both benchmarks, which supports selecting a video-conditioned subset rather than retaining one global subset for every input. Complete reassignment restores full source-token coverage, while its accuracy change is small and has opposite signs on MVBench and LongVideoBench. Its primary role is therefore to ensure that every source token contributes; selection determines which supported regions compete for the output budget. Frame-wise selection remains close to Full, suggesting that whole-video selection is a consistent default rather than the sole source of the downstream result. Accuracy (%) Coverage (%) Inference policy B MV LVB MV LVB Full 256 54.13 51.61 100.0 100.0 Fixed-random selection 256 52.33 50.79 100.0 100.0 Full 512 54.50 52.95 100.0 100.0 Fixed-random selection 512 53.85 51.68 100.0 100.0 w/o complete reassignment 512 53.83 53.48 85.8 69.9 Frame-wise selection 512 54.08 52.80 100.0 100.0 Table 8: Selection and inference-policy ablations. Coverage is the fraction of source tokens represented by the output groups. Fixed-random selection uses the same codeword permutation at both budgets. Stage-B variant MV LVB Weighted + long-tail + Sinkhorn 51.45 47.87 Uniform weights 52.35 49.07 w/o long-tail 51.78 48.99 Hard-Lloyd 51.90 48.17 Table 9: Stage-B fitting sensitivity (%) at B=512B=512. The rows share one Stage-A cache, backbone, codebook size, and evaluation sample sets while varying the indicated fitting component. Table 9 is read within its sweep: the first row anchors the Stage-B variants, while the main table reports the selected end-to-end operating point, so cross-table subtraction is not a component effect. The variants remain within 1.20 points on each benchmark, indicating that ONCE does not require a uniquely tuned learner. We retain source-count weighting, long-tail correction, and balanced fitting because they preserve summarized token mass, limit domination by the largest source categories, and encourage broad codeword use. These choices shape the corpus prior; reusable grouping and input-specific source-mean aggregation remain the common mechanism. Additional ablation results. Nearest-source output gives 54.03% on MVBench and 53.78% on LongVideoBench, compared with 54.50% and 52.95% for the Full reference. The changes have opposite signs and provide no consistent benchmark-wide preference, so we treat nearest-source output as a representation-sensitivity control. Its mean cosine similarity to the pooled source representation is 0.944 and 0.924, compared with 0.864 and 0.887 for the corresponding global codeword prototypes. These diagnostics are accumulated over 2,047,100 occupied MVBench groups and 684,187 occupied LongVideoBench groups. Variant Diagnostic MV LVB Full Coverage (%) 100.0 100.0 w/o complete reassignment Coverage (%) 85.8 69.9 Source-mean output Cosine to mean 1.000 1.000 Medoid output Cosine to mean 0.944 0.924 Codeword output Cosine to mean 0.864 0.887 Table 10: Mechanism diagnostics for the LLaVA-OneVision-7B ablations. Coverage is the percentage of source tokens represented by output groups; cosine is similarity to the Full pooled source representation. Medoid outputs stay closer to pooled source means than global codeword prototypes on both benchmarks, and their accuracies remain near Full. This joint fidelity and accuracy pattern supports the mechanism used in the main paper: codewords define group membership, whereas current-video source features provide the compressed content. The coverage rows answer a separate question. Complete reassignment guarantees source-token participation, but the mixed accuracy response shows that coverage alone is not a proxy for task quality. Inference efficiency. Tables 11 and 14 report the complete measurements for the 7B and 0.5B LLaVA-OneVision models, respectively. Figure 8: Accuracy and reported inference efficiency on LLaVA-OneVision-7B across visual-token budgets. Panel (a) reports MVBench accuracy; the dashed line marks the uncompressed result of 55.78%. Panel (b) reports end-to-end speedup relative to the Dense latency of 3653.79 ms; the dashed line marks 1×. All speedups follow the inference setup in Table 11. Method # Tokens Lat. (ms) E2E Prefill Dense 23,329 3653.79 1.00× 1.00× ForestPrune 32 2747.38 1.33× 4.31× 64 2791.53 1.31× 4.16× 128 2836.98 1.29× 3.72× 256 2937.61 1.24× 3.39× 512 2962.96 1.23× 2.78× 1024 2915.80 1.25× 2.25× FastVID 32 1102.72 3.31× 69.58× 64 1012.68 3.61× 65.18× 128 1117.70 3.27× 52.15× 256 1032.48 3.54× 45.59× 512 1051.65 3.47× 33.57× 1024 1092.14 3.35× 22.73× Ours 32 998.91 3.66× 69.34× 64 1014.50 3.60× 64.26× 128 1001.12 3.65× 60.71× 256 1010.02 3.62× 50.15× 512 1019.36 3.58× 36.46× 1024 1056.44 3.46× 23.92× Table 11: Inference efficiency under different visual token budgets on LLaVA-OneVision-7B. #\# Tokens denotes the number of visual tokens. Lat. is measured in milliseconds, while E2E and Prefill report speedups relative to Dense. Prefill speedup decreases as more pooled tokens are retained, whereas end-to-end speedup varies over a much narrower range. This gap supports the runtime interpretation in the main paper: compression removes language-model prefill work, but visual encoding, compression overhead, and autoregressive decoding limit the realized wall-clock gain. ONCE preserves this end-to-end advantage over Dense across the tested budgets, while all ONCE accuracy rows use the same compression pipeline. Qwen3.5-9B ablations. Table 12 reports component and codebook-size controls on all 4,000 MVBench examples at B=512B=512. Each row changes the named choice from the Full K=8192K=8192 configuration. Variant Accuracy (%) Δ Full (K=8192K=8192) 63.25 0.00 w/o complete reassignment 64.63 +1.38+1.38 Codeword output 41.33 −21.93-21.93 Uniform fitting weights 61.55 −1.70-1.70 K=2048K=2048 63.53 +0.28+0.28 K=4096K=4096 63.60 +0.35+0.35 Table 12: Qwen3.5-9B ablations on MVBench at B=512B=512. All rows use 2-FPS sampling with at most 256 frames and 4,000 examples. Full uses Q=4Q=4, K=8192K=8192, source-count weighting, complete reassignment, and source-mean output. Δ is the accuracy change relative to Full. Replacing source means with codeword prototypes lowers accuracy by 21.93 points. The same direction as the LLaVA output control supports a shared design interpretation across backbones: the learned codebook organizes groups, while source means retain input-specific content. Uniform fitting weights have a smaller effect, and changing K from 8192 to 2048 or 4096 changes accuracy by at most 0.35 points. Codebook capacity therefore need not translate linearly into downstream quality at a fixed output budget. Removing complete reassignment raises accuracy by 1.38 points in this control, again separating its coverage guarantee from benchmark accuracy. Budget trade-off. Figure 8 aligns task accuracy and reported end-to-end efficiency for the same methods and token budgets on LLaVA-OneVision-7B. The global codebook gives the highest MVBench accuracy at B=32B=32, 64, 128, and 256, while the input-adaptive baselines lead at B=512B=512 and 1024. The global codebook has the highest reported end-to-end speedup at five of the six budgets, with FastVID leading at B=64B=64. At B=64B=64, FastVID and ONCE differ by only 1.82 ms, or 0.18% of the approximately 1.01-s latency, which we treat as practical parity. ONCE is lower at the other five budgets, so the sweep supports a consistently low-latency regime without relying on the ordering of one near-tied point. Smaller model. The LLaVA-OneVision-0.5B comparison tests whether the same compression behavior holds across model scales (Table 13). Budget Method MV V-MME LVB 23329 LLaVA-OV-0.5B 43.08 42.59 43.01 32 VQToken 38.10 37.93 38.82 Global Codebook (Ours) 37.90 35.74 40.84 64 VQToken 38.25 37.48 38.67 Global Codebook (Ours) 39.50 36.81 42.71 Table 13: Accuracy (%) under different visual-token budgets on LLaVA-OneVision-0.5B. MV, V-MME, and LVB denote MVBench, Video-MME, and LongVideoBench. Bold marks the best compressed result within each budget. At B=32B=32, the two compressed methods divide the benchmark leads, whereas ONCE leads on MVBench and LongVideoBench at B=64B=64. Its LongVideoBench advantage at both budgets is consistent with global grouping retaining evidence distributed across longer videos, but the Video-MME rows rule out uniform dominance. Together with the 7B results, the table supports applicability across model scales while keeping the accuracy conclusion benchmark dependent. Method # Tokens Lat. (ms) E2E Prefill Dense 23,329 1362.54 1.00× 1.00× VQToken 32 1108.76 1.23× 14.40× 64 1263.03 1.08× 14.10× Ours 32 985.26 1.38× 14.00× 64 984.72 1.38× 14.14× Table 14: Inference efficiency on a uniform 400-example MVBench subset with LLaVA-OneVision-0.5B. E2E and Prefill are speedups over Dense. ONCE has the higher end-to-end speedup at both budgets even though the two methods have similar prefill speedups. This separation points to costs outside language-model prefill and reinforces the main-paper distinction between token-level computation and measured latency. ONCE’s nearly unchanged latency between B=32B=32 and B=64B=64 further suggests that fixed inference stages dominate this small budget change on the 0.5B backbone. Peak reserved (GiB) Reduction Model Data Dense ONCE (%) LLaVA-OV-7B MV 23.89 19.99 16.36 LLaVA-OV-7B LVB 24.01 20.00 16.69 Qwen3.5-9B MV 37.73 31.85 15.58 Qwen3.5-9B LVB 41.42 35.46 14.39 Table 15: Absolute peak GPU memory for the matched Dense and ONCE runs at B=512B=512. MV and LVB denote MVBench and LongVideoBench. Values are PyTorch peak reserved memory; all runs use batch size 1 on the same local 48-GiB RTX 4090. ONCE lowers peak reserved memory in all four matched pairs, despite the different absolute footprints of the two backbones and benchmarks. The 14.39–16.69% memory reductions are much smaller than the corresponding visual-token reductions in the main paper, which is consistent with model weights and non-visual state remaining resident. The table therefore supports memory savings as a practical consequence of compression without equating token reduction with total device-memory reduction.