Pith. sign in

REVIEW 4 major objections 5 minor 18 references

LGQ: Learnable Geometric Quantization for Image Tokenization

T0 review · 4 major / 5 minor · reviewed 2026-08-02 · deepseek-v4-flash

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

Pith's one-line read A tokenizer that learns its discretization geometry claims better ImageNet reconstruction than fixed-grid quantizers while using about half the codebook.

desk verdict The body's rFID result at K=16,384 is worth a look, but the abstract overclaims 100% utilization, MaskGIT generation, and 256x256—each contradicted by the paper's own sections 4.1 and 6—so the preprint needs revision before it should be trusted. read the letter →

arxiv 2602.16086 v3 pith:YDVHK5ID submitted 2026-02-17 cs.CV cs.LG

Idil Bilge Altun , Mert Onur Cakiroglu , Elham Buxton , Mehmet Dalkilic , Hasan Kurban This is my paper
classification cs.CVcs.LG
keywords imagetokenizationvectorquantizationcodebookcollapsediscreterepresentationlearningtemperatureannealingsoft-to-hardassignmentrate-distortiontrade-offNet
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

LGQ tries to dissolve the trade-off in discrete image tokenization between learnable codebooks that collapse and fixed scalar grids that are stable but rigid. It replaces hard nearest-neighbor lookup with temperature-controlled soft assignments over a learnable codebook, then anneals temperature to recover hard discretization at inference. Two cheap regularizers — one per-token peakedness term, one global usage term — are meant to prevent codebook collapse without EMA, resets, or reparameterization. On a controlled VQGAN-style backbone, the paper reports the lowest reconstruction FID among compared quantizers at K=16,384 as well as at K=65,536, and argues this comes from allocating capacity selectively rather than saturating the codebook. The paper frames quantization as geometry learning, with theoretical support that assignments are posterior responsibilities of a Gaussian mixture and converge to hard nearest-neighbor in the zero-temperature limit.

What carries the argument

The load-bearing object is the temperature-controlled Gibbs assignment $p_{t,k} \propto \exp\left(-\frac{\|z_{e,t} - c_k\|_2}{\tau}\right)$ over a shared learnable codebook. This soft assignment is the unique minimizer of a free-energy functional $F = \sum p_k \|z - c_k\| + \tau \sum p_k \log p_k$, which trades distortion against entropy. It lets gradients reach every codebook entry while annealing $\tau$ to 0.1 makes assignments collapse to hard nearest-neighbor selection; a straight-through estimator carries the hard index forward while preserving soft gradients. Two regularizers with $\lambda = 0.005$ each — $L_{\text{peak}} = \mathbb{E}[\max(0, 1 - \sum p^2)]$ and $L_{\text{bins}} = \sum \bar{p}_k^2$ — are proven to push token assignments toward one-hot and marginal usage toward un

What would settle it

Re-run the evaluation at ImageNet 256×256 for the full 61 epochs with the MaskGIT generation protocol named in the abstract (which the body does not report). If LGQ does not beat FSQ and SimVQ on reconstruction rFID and class-conditional FID under that protocol, the headline claims fail. A cheaper check: after training at K=16,384, count active codes — the abstract promises 100% utilization, while Table 1 shows 8,199 of 16,384 active (50.0%); the two cannot both hold.

Watch

Extended reading notes

Core claim

The central claim is that discretization geometry can be learned end-to-end: LGQ maintains a shared codebook and assigns each latent token to all codes with probabilities proportional to $e^{-\text{distance}/\tau}$, which are the posterior responsibilities of an isotropic Gaussian mixture and minimize a free-energy objective. During training these soft assignments make every codebook entry receive gradient signal, eliminating the disjoint updates of standard VQ; at inference a straight-through estimator selects the $\arg\max$, and the temperature is annealed to make assignments converge to hard nearest-neighbor quantization. Two regularizers — peakedness (driving each token's assignment toward one-hot) a

Load-bearing premise

The load-bearing premise is the fairness and completeness of the benchmark protocol: that a fixed VQGAN backbone, with only the discretization mechanism varied and all baselines at comparable training stages, makes the reported rFID differences attributable to the quantizer — and that the evaluation setting is the one described in the body (128×128 reconstruction) rather than the abstract's 256×256 plus MaskGIT protocol, which does not appear in the body.

Editorial extensions

If this is right

  • If LGQ's central claim holds, discrete tokenizers can scale to very large codebooks (65k+) without per-K hyperparameter tuning or collapse-reset machinery.
  • A lower effective representation rate at equal or better reconstruction suggests downstream autoregressive or masked generative models could be trained more cheaply on shorter or lower-entropy token sequences.
  • The provable convergence to hard nearest-neighbor in the low-temperature limit means the method is a drop-in replacement for standard VQ: at inference it produces ordinary discrete tokens.
  • The free-energy framing gives a principled objective for future quantizer design, potentially extending to video, audio, or multimodal tokenization.
  • The paper's reported trade-off argues that matching codebook coverage to the latent density, not saturating the codebook, is the operative goal — utilization alone is not a sufficient measure of discretization quality.

Reading between the lines

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

  • Editorial: The abstract's headline claims (ImageNet 256×256, 100% utilization, MaskGIT generation results) are not reproduced in the body: Table 1 shows LGQ at 50.0% utilization (8,199 active of 16,384) and the experiments are at 128×128 with no MaskGIT. A sympathetic reader would need those experiments to be run or the abstract revised; if the body numbers are the actual results, the paper's stat
  • Editorial: If the rate-distortion advantage is real, it suggests a testable extension: measuring the entropy of LGQ tokens as a plug-in prior for a fixed transformer should show faster convergence or better FID per bit than tokens from a saturated codebook, since the effective rate is lower.
  • Editorial: The sensitivity to temperature schedule shown in Appendix A.1 (slow annealing collapses to 1 active code) implies the method's stability hinges on annealing being fast enough; this is a practical constraint the paper acknowledges, and a robustness check across random seeds would clarify how brittle the reported operating point is.
  • Editorial: The claim that 'learned geometry' rather than codebook size drives performance could be probed by initializing the codebook with FSQ's lattice and fine-tuning with LGQ's objective; if LGQ still outperforms FSQ, the benefit comes from the learning rule, not just the geometry.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper introduces Learnable Geometric Quantization (LGQ), a discrete image tokenizer that replaces hard nearest-neighbor lookup with temperature-annealed soft assignments over a learnable codebook, augmented by a peakedness regularizer and a global usage regularizer. The authors claim that LGQ bridges the flexibility of VQ and the stability of structured quantizers such as FSQ, prevents codebook collapse without EMA or reset heuristics, and scales to very large vocabularies without per-K tuning. The experimental section compares LGQ against FSQ, LFQ, SimVQ, and VQ under a fixed VQGAN-style backbone and reports reconstruction FID, PSNR, SSIM, LPIPS, and codebook utilization. The abstract makes stronger claims: ImageNet 256×256, 100% codebook utilization at K=16,384 and unchanged at K=65,536, and best MaskGIT class-conditional generation. The body, however, states that all experiments are at 128×128, reports LGQ utilization of 50.0% at K=16,384 and 22.5% at K=65,536, and explicitly defers MaskGIT evaluation to future work.

Significance. If the claims in the abstract were true, LGQ would be a significant contribution: a drop-in tokenizer that removes standard VQ heuristics, scales to large codebooks without per-K tuning, and improves both reconstruction and downstream generation. The paper also includes formal propositions on peakedness, balanced usage, soft-to-hard convergence, and Lipschitz stability, as well as ablation studies. However, the central claims as stated are internally contradicted by the paper's own reported numbers and scope. The body does show that LGQ achieves the best rFID at K=16,384 (110.64 vs. 117.77–125.56), which is a meaningful result if the baseline tuning is fair, but this result is presented in a way that contradicts the abstract's characterization of the method. The paper's actual contribution, as evidenced by the body, is more modest: a soft-to-hard quantizer that obtains good reconstruction at deliberately lower codebook utilization. This discrepancy is load-bearing, not a presentation issue.

major comments (4)
  1. [Abstract; §4.1; Table 1; §6] The abstract's three headline claims are contradicted by the body. (i) '100% codebook utilization' is contradicted by Table 1, which reports LGQ utilization as 50.0% (8,199 active codes) at K=16,384 and 22.5% (14,716 active) at K=65,536. (ii) 'Training MaskGIT ... LGQ further attains the best class-conditional generation' is contradicted by §6, which states that 'our evaluation focuses on reconstruction and representation analysis rather than end-to-end generative modeling with a learned prior (e.g., MaskGIT)' and lists MaskGIT as future work. (iii) 'ImageNet 256x256' is contradicted by §4.1: 'All experiments are conducted on the ImageNet dataset resized to 128×128.' Additionally, the claim that LGQ 'continues to improve as the codebook grows to K=65,536 with utilization unchanged' is not supported: Table 1 shows rFID worsens from 110.64 to 111.08 and utilization drops from 50.0% to 22.5
  2. [§3.1, Eq. (1), Eq. (2)] The text identifies the soft assignments in Eq. (1) as 'posterior responsibilities in an isotropic Gaussian mixture,' but Eq. (1) uses exp(-d_{t,k}/τ) with d_{t,k} = ||z_{e,t} - c_k||_2, i.e., a Laplace/Gibbs kernel, not a Gaussian posterior (which would be exp(-||z-c||²/(2σ²))). The free-energy functional in Eq. (2) uses ||z-c_k||_2, whose minimizer is indeed the normalized exp(-||z-c||/τ), so Eq. (1) is consistent with Eq. (2) but not with the 'isotropic Gaussian mixture' description. The Introduction even writes exp(-||z-c||²/τ). This inconsistency affects the claimed principled derivation: the variational story is presented as Gaussian, but the implemented assignment is not. The authors should either correct the kernel to squared distance (and adjust Eq. (2) accordingly) or remove the Gaussian-mixture language.
  3. [§3.3, Theorem 3.1] Theorem 3.1 is false as stated. The assumption that the codewords c_1,...,c_K are pairwise distinct does not imply that each z has a unique nearest codeword. If z is equidistant to two codewords, then as τ→0 the limiting distribution splits mass between the two nearest codes, so it is not one-hot. The proof itself assumes 'k*(z) is the unique minimizer.' The theorem should be restated with the condition 'for every z with a unique nearest codeword' or 'for almost every z' (with respect to Lebesgue measure). This is a mathematical correctness issue in the main theoretical guarantee, though it is local and fixable.
  4. [§4.2, Table 1 (large-vocabulary scaling)] The large-vocabulary scaling evidence does not support the claims made for it. The K=65,536 row is explicitly described as an 'early training stage (epoch 9)' snapshot, whereas the K=16,384 main result is at epoch 61. The abstract's claim that LGQ 'continues to improve as the codebook grows to K=65,536 with utilization unchanged' is contradicted by the table: utilization drops from 50.0% to 22.5% and rFID goes from 110.64 to 111.08 (higher is worse). The paper frames lower utilization as a feature, but this is not the claim advertised in the abstract. A matched-epoch comparison or a full training run at K=65,536 is needed before any scalability conclusion can be drawn.
minor comments (5)
  1. [§3.4 vs. Appendix A.1, Table 2] The main text says τ is annealed from τ_start=1.0 to τ_end=0.1, but Table 2's 'fast annealing' schedule is 1.0→0.05 and reports rFID 118.36, not the 110.64 in Table 1. Please clarify the exact temperature schedule used for the main comparison.
  2. [§4.3, Figure references] The text in §4.3 refers to 'latent space visualizations in Figure 6' and 'Figure 6 illustrates the resulting utilization-distortion behavior,' but Figure 4 is the UMAP visualization and Figure 6 is the rate-distortion plot. Please fix the cross-references.
  3. [Throughout] The method is referred to inconsistently as 'SIM-VQ' and 'SimVQ'; please standardize. Also, 'effective representation rate' is defined first via active code count and later via entropy; the distinction should be made explicit.
  4. [§4.1, Experimental setup] The description of baselines is thin: it is not stated how many training epochs each baseline ran, whether hyperparameters were tuned per baseline, or how rFID is computed (e.g., number of samples, feature statistics). Given the paper's emphasis on a controlled comparison, these details are necessary for reproducibility.
  5. [Appendix A.1, Table 4] The ablation table is reported at epoch 2, whereas the main results are at epoch 61. This makes it difficult to interpret the effect of the regularizers relative to the final performance. Please either report final-epoch ablations or justify the early stopping.

Circularity Check

1 steps flagged · score 2.0 of 10

Mild self-referential utilization metric; central rFID and theory are externally grounded.

  1. self definitional [Section 3.2 (Eq. 6) and Section 4.1/4.2 (utilization metrics, Table 1)]
    "L_bins is defined as the squared L2 norm of the marginal code usage distribution: L_bins = sum_k \bar{p}_k^2 ... This is minimized when code usage is uniform (\bar{p}_k = 1/K for all k) and increases as usage becomes concentrated on fewer codes. ... For codebook utilization, we report two metrics: active codes ... and effective codebook size K_eff, defined as the perplexity of the empirical code usage distribution."

    The 'balanced utilization' / collapse-resistance evidence is a direct target of the training loss, not an independent prediction: L_bins is a function of the same empirical marginal \bar{p} from which the utilization metrics are computed, so observing non-collapse partly restates the objective. However, LGQ's reported utilization (50.0%) is far from the regularizer's uniform optimum and the main rFID comparison is external to the loss, so this is a minor, non-load-bearing circularity.

full rationale

The paper's central reconstruction claim is benchmarked externally: under a fixed VQGAN backbone, rFID/PSNR/SSIM are measured on ImageNet reconstructions and LGQ's 110.64 rFID is compared with baseline numbers from the same protocol; this quantity is not fitted from the loss (aside from normal training). The free-energy derivation, soft-to-hard convergence (Thm 3.1), and Lipschitz bound (Prop 3.2) are standard self-contained math with proofs in the text. There are no self-citations; references [17], [9], etc. are external prior work. The only mild circularity is the usage-regularizer/utilization-metric alignment described above. Separately, the abstract's MaskGIT generation claim, 256x256 setting, and '100% utilization' are internally contradicted by §4.1 ('ImageNet dataset resized to 128×128'), Table 1 (50.0% and 22.5% utilization), and §6 (MaskGIT deferred to future work); these are reporting/consistency failures, not circular derivations, and therefore do not increase the circularity score.

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

No new physical or mathematical entities are introduced. The central empirical claims rest on a small number of hand-set hyperparameters (regularizer weights, temperature schedule, training budget) and on assumptions about fair baseline tuning and the theoretical identification of the soft assignment distribution.

free parameters (4)
  • lambda_peak = 0.005
    Set by hand and fixed across all experiments; the paper's ablation (Table 4) shows performance varies with regularizer strength.
  • lambda_bins = 0.005
    Set by hand and fixed across all experiments; joins lambda_peak in the discretization loss.
  • temperature schedule (tau_start, tau_end) = 1.0 -> 0.1
    Annealing schedule chosen by hand; Table 2 shows fast vs fixed vs slow schedules strongly affect utilization and can cause catastrophic collapse.
  • training epochs at each codebook size = 61 epochs at K=16,384; epoch 9 at K=65,536
    The K=65,536 scaling result is only a 9-epoch snapshot, so scaling conclusions depend on this training-budget choice.
assumptions (4)
  • domain assumption The encoder-decoder backbone is fixed VQGAN-style and only the quantizer is varied, making cross-method comparisons fair.
    Section 4.1 states this, but no baseline-tuning details or seeds are given; if baselines are undertuned, the headline comparisons fail.
  • ad hoc to paper Eq. (1) with exp(-||z-c||/tau) is identified as an isotropic Gaussian posterior.
    Section 1 and Section 3.1 call the assignment a Gaussian posterior, but the unsquared Euclidean distance in Eq. (1) corresponds to a Laplace/exponential family, not a Gaussian; the free-energy functional uses L1 distance.
  • standard math The softmax limit theorem requires pairwise distinct centroids.
    Theorem 3.1 assumes c_1,...,c_K are pairwise distinct; in practice, collapsed or overlapping codes would violate this, and the paper does not verify distinctness during training.
  • domain assumption Straight-through estimator bias vanishes as assignments become peaked.
    Section 3.4 relies on this unproven assumption (citing Huh et al.) for gradient correctness; no direct verification is provided for LGQ.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LGQ: Learnable Geometric Quantization for Image Tokenization." pith.science (2026). https://pith.science/paper/YDVHK5ID

@misc{pith2026260216086,
  author       = {Pith},
  title        = {Pith review of: LGQ: Learnable Geometric Quantization for Image Tokenization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YDVHK5ID}},
  note         = {Machine review of arXiv:2602.16086}
}
read the original abstract

Recent collapse-free quantizers such as FSQ achieve stable training by replacing the learnable codebook with an engineered geometry: a fixed scalar grid whose structure is dictated by the codebook size K. We show this trade-off is unnecessary. We introduce Learnable Geometric Quantization (LGQ), which retains a learnable codebook of codes and performs soft-to-hard assignment via temperature annealing, regularized by two cheap terms: A diversity term scaled by codebook size that penalizes concentrated batch-average usage is the primary driver of collapse resistance, complemented by a peakedness term that sharpens each token's soft-assignment toward one-hot; together they prevent codebook collapse without EMA, reset heuristics, or codebook reparameterization. Under a fixed VQ-GAN backbone, we benchmark LGQ against RotVQ, FSQ, SimVQ, and IBQ on ImageNet 256x256 at K=16,384 and sweep LGQ over K={4096,..,65,536} without any per-K hyperparameter tuning. LGQ attains the best reconstruction FID at K = 16,384 while maintaining 100% codebook utilization, and continues to improve as the codebook grows to K = 65,536 with utilization unchanged. Training MaskGIT on the frozen tokenizers, LGQ further attains the best class-conditional generation among the compared quantizers, leading on reconstruction and generation alike. Code is available at https://github.com/KurbanIntelligenceLab/LGQ.

Figures

Figures reproduced from arXiv: 2602.16086 by the authors.

Figure 1
Figure 1. Discretization geometries in latent tokenizers. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. LGQ-VAE pipeline. The encoder 𝑓𝜃 maps an input image 𝑥 to a continuous latent representation 𝑧𝑒 , which is discretized using Learnable Geometric Quantization (LGQ) before reconstruction by the decoder 𝑔𝜙 . Each latent token is softly assigned to a shared learnable codebook via temperature-controlled distance-based probabilities, inducing a continuous assignment geometry over codebook entries. During training, soft a… view at source ↗
Figure 3
Figure 3. Training dynamics of reconstruction quality met [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Visualization of encoder outputs (blue) and active codebook entries (red) using UMAP. Blue contours represent the [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Evolution of discretization bin centers during training. Right: Trajectories of a subset of individual bin centers over [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Rate–distortion behavior across discretization meth [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 8
Figure 8. Figure 8: Entropy-based rate–distortion analy￾sis.Reconstruction distortion (rFID) as a function of entropy-based rate. Each point corresponds to a different training epoch [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 7
Figure 7. Figure 7: Perplexity and marginal entropy dynamics over [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

18 extracted references · 1 canonical work pages

  1. [1]

    Hao Chen, Ze Wang, Xiang Li, Ximeng Sun, Fangyi Chen, Jiang Liu, Jindong Wang, Bhiksha Raj, Zicheng Liu, and Emad Barsoum. 2025. SoftVQ-VAE: Efficient 1-Dimensional Continuous Tokenizer. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 28358–28370

    2025

  2. [2]

    Patrick Esser, Robin Rombach, and Bjorn Ommer. 2021. Taming Transformers for High-Resolution Image Synthesis. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 12873–12883

    2021

  3. [3]

    Junkins, Dennis Duan, Aniketh Iyengar, Jerry W

    Christopher Fifty, Ronald G. Junkins, Dennis Duan, Aniketh Iyengar, Jerry W. Liu, Ehsan Amid, Sebastian Thrun, and Christopher Ré. 2025. Restructuring Vector Quantization with the Rotation Trick. arXiv:2410.06424 [cs.LG] https: //arxiv.org/abs/2410.06424

    arXiv 2025

  4. [4]

    Kyle Hsu, William Dorrell, James Whittington, Jiajun Wu, and Chelsea Finn. 2023. Disentanglement via Latent Quantization. InAdvances in Neural Information Processing Systems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36. Curran Associates, Inc., 45463–45488. https://proceedings.neurips.cc/paper_files/paper/2023/file/...

    2023

  5. [5]

    Minyoung Huh, Brian Cheung, Pulkit Agrawal, and Phillip Isola. 2023. Straight- ening out the straight-through estimator: Overcoming optimization challenges in vector quantized networks. InInternational Conference on Machine Learning. PMLR, 14096–14113

    2023

  6. [6]

    Iris A. M. Huijben, Matthijs Douze, Matthew Muckley, Ruud J. G. van Sloun, and Jakob Verbeek. 2024. Residual Quantization with Implicit Neural Codebooks. arXiv:2401.14732 [cs.LG] https://arxiv.org/abs/2401.14732

    arXiv 2024

  7. [7]

    Kazuki Irie, Róbert Csordás, and Jürgen Schmidhuber. 2024. Self-organising Neu- ral Discrete Representation Learning à la Kohonen. InArtificial Neural Networks and Machine Learning – ICANN 2024, Michael Wand, Kristína Malinovská, Jür- gen Schmidhuber, and Igor V. Tetko (Eds.). Springer Nature Switzerland, Cham, 343–362

    2024

  8. [8]

    Doyup Lee, Chiheon Kim, Saehoon Kim, Minsu Cho, and Wook-Shin Han. 2022. Autoregressive Image Generation using Residual Quantization. arXiv:2203.01941 [cs.CV] https://arxiv.org/abs/2203.01941

    arXiv 2022

Show all 18 references
  1. [9]

    Fabian Mentzer, David Minnen, Eirikur Agustsson, and Michael Tschannen. 2023. Finite Scalar Quantization: VQ-VAE Made Simple. arXiv:2309.15505 [cs.CV] https://arxiv.org/abs/2309.15505

    2023 arXiv

  2. [10]

    Ali Razavi, Aaron van den Oord, and Oriol Vinyals. 2019. Generating Diverse High-Fidelity Images with VQ-VAE-2. InAdvances in Neural Information Process- ing Systems, H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett (Eds.), Vol. 32. Curran Asso...

    2019

  3. [11]

    Mohammad Hassan Vali, Tom Bäckström, and Arno Solin. 2025. Di- VeQ: Differentiable Vector Quantization Using the Reparameterization Trick. arXiv:2509.26469 [cs.LG] https://arxiv.org/abs/2509.26469

    2025 arXiv

  4. [12]

    Aaron van den Oord, Oriol Vinyals, and koray kavukcuoglu. 2017. Neural Discrete Representation Learning. InAdvances in Neural Information Processing Systems, I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (Eds.), Vol. 30. Curran Ass...

    2017

  5. [13]

    Aaron van den Oord, Oriol Vinyals, and Koray Kavukcuoglu. 2018. Neural Discrete Representation Learning. arXiv:1711.00937 [cs.LG] https://arxiv.org/ abs/1711.00937

    2018 arXiv

  6. [14]

    Gundavarapu, Luca Versari, Kihyuk Sohn, David Minnen, Yong Cheng, Vighnesh Birodkar, Agrim Gupta, Xiuye Gu, Alexander G

    Lijun Yu, José Lezama, Nitesh B. Gundavarapu, Luca Versari, Kihyuk Sohn, David Minnen, Yong Cheng, Vighnesh Birodkar, Agrim Gupta, Xiuye Gu, Alexander G. Hauptmann, Boqing Gong, Ming-Hsuan Yang, Irfan Essa, David A. Ross, and Lu Jiang. 2024. Language Model Beats Diffusion – To...

    2024 arXiv

  7. [15]

    Yue Zhao, Yuanjun Xiong, and Philipp Krähenbühl. 2024. Image and Video Tokenization with Binary Spherical Quantization. arXiv:2406.07548 [cs.CV] https://arxiv.org/abs/2406.07548

    2024 arXiv

  8. [16]

    Lei Zhu, Fangyun Wei, Yanye Lu, and Dong Chen. 2024. Scaling the Codebook Size of VQ-GAN to 100,000 with a Utilization Rate of 99%. InAdvances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (Eds.), Vo...

    2024 doi

  9. [17]

    Yongxin Zhu, Bocheng Li, Yifei Xin, Zhihua Xia, and Linli Xu. 2025. Addressing Representation Collapse in Vector Quantized Models with One Linear Layer. arXiv:2411.02038 [cs.LG] https://arxiv.org/abs/2411.02038

    2025

  10. [18]

    Yongxin Zhu, Bocheng Li, Hang Zhang, Xin Li, Linli Xu, and Lidong Bing. 2024. Stabilize the Latent Space for Image Autoregressive Modeling: A Unified Per- spective. arXiv:2410.12490 [cs.CV] https://arxiv.org/abs/2410.12490 A Appendix A.1 Ablation study on the auxilary losses T...

    2024 arXiv

Pith tools

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