Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

VQ-Logits: Compressing the Output Bottleneck of Large Language Models via Vector Quantized Logits

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

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

Pith's one-line read The final vocabulary-sized projection of an LLM can be replaced by a K-vector codebook and a fixed word-to-code mapping, cutting output-layer parameters by up to 99% and logit computation by up to 6x with only ~4% perplexity loss.

desk verdict A solid engineering study that restates clustered softmax with better ablations, but needs fair baselines and honest speedup accounting before it's publishable. read the letter →

arxiv 2505.10202 v1 pith:P7R4LHDG submitted 2025-05-15 cs.CL

Jintian Shao , Hongyi Huang , Jiayi Wu , YiMing Cheng , ZhiYu Wu , You Shan , MingKai Zheng This is my paper · ORCID
classification cs.CL
keywords vectorquantizationoutputlayercompressionlanguagemodelingsoftmaxapproximationcodebookperplexityLLMinference
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

This paper claims that the large output projection of a language model, which maps hidden states to a full vocabulary of logits, can be replaced by a small codebook of K prototype vectors plus a fixed assignment from each word to one prototype. The model computes logits only over K codes and then scatters them to the full vocabulary before softmax, shrinking output-layer parameters by up to 99% and speeding logit computation by up to 6x on WikiText-103 while raising perplexity by only about 4%. A sympathetic reader would care because this offers a simple architectural swap that eases the dominant memory and compute bottleneck of large-vocabulary inference without requiring hierarchical softmax trees or frequency cutoffs.

What carries the argument

The central object is the pair of the codebook $C$ and the fixed vocabulary-to-codebook mapping $M$. The codebook is a small learnable matrix of $K$ representative embedding vectors, and $M$ is typically obtained by k-means clustering of a pre-trained model's output embeddings, then held fixed during fine-tuning. The scatter operation copies each code logit to every vocabulary position assigned to that code, so the expensive $d_{\text{model}} \times V$ multiplication is replaced by a $d_{\text{model}} \times K$ multiplication followed by memory-bound indexing; the mapping's cluster coherence is what determines how much information is lost by giving distinct words the same probability.

What would settle it

Evaluate VQ-Logits on a held-out set of rare but information-dense words, such as proper nouns or technical terms that k-means forces to share codes with very frequent words, and compare their per-token perplexity against the full softmax baseline; if those words degrade by far more than the average 4% gap, the cluster-coherence assumption behind the method fails.

Watch

Extended reading notes

Core claim

VQ-Logits establishes that the output embedding matrix $W_{\text{out}} \in \mathbb{R}^{d_{\text{model}} \times V}$ can be replaced by a codebook $C \in \mathbb{R}^{K \times d_{\text{model}}}$ and a map $M: \{0,\dots,V-1\} \to \{0,\dots,K-1\}$, so that each vocabulary token's logit is exactly the logit of its assigned code vector: $L_v[b,s,i] = L_c[b,s,M(i)] = h[b,s] \cdot c_{M(i)}$. Because softmax is applied after scattering, all words assigned to the same code receive identical logits and therefore identical probabilities. The paper's experiments show that this forced sharing is not too costly: with $K=2048$ on WikiText-103, perplexity rises from 18.0 to 18.7 while output-layer parameters drop from 205.2M to 1.57M and logit computation becomes 5x faster, with similar trends on C4 and Penn Treebank.

Load-bearing premise

The load-bearing premise is that a fixed k-means mapping from the full vocabulary to $K$ code vectors creates clusters coherent enough that giving every word in a cluster the same logit, and hence the same probability, costs only a few percent in perplexity; if the clustering is poor, the reported trade-off collapses.

Editorial extensions

If this is right

  • Output-layer storage and FLOPs scale with $K$ instead of $V$, so larger vocabularies become feasible on a fixed GPU budget.
  • The perplexity-versus-compression trade-off is controlled by a single integer $K$, with $K \in [1024, 4096]$ described as a useful operating range for a 267k-word vocabulary.
  • VQ-Logits is compatible with other compression methods because it targets only the output projection, leaving the rest of the network unchanged.
  • Tying input embeddings to the codebook cuts parameters further but raises perplexity by about 1.2 points, so retaining separate full-vocabulary input embeddings is preferred.
  • The fixed mapping can be initialized by k-means on pre-trained output embeddings, random initialization, or frequency binning, with k-means giving the best perplexity.

Reading between the lines

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

  • The paper leaves implicit that the perplexity loss should be predictable from the token-weighted entropy of the code clusters: if words in a cluster are not approximately exchangeable in context, the fixed map will underperform; this suggests a quantitative bound could guide the choice of $K$ before training.
  • A natural extension is a hierarchical codebook that keeps frequent words on their own codes while letting rare related words share prototypes, which would preserve the speedup for the bulk of the vocabulary without forcing all clusters to be equally coarse.
  • Because the scatter operation gives every word in a code the same probability, the method is effectively a hard version of word-class modeling; one could test whether a soft, probabilistic assignment between words and codes recovers the lost rare-word accuracy at modest extra cost.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. VQ-Logits proposes to replace the standard V×d_model output projection of an LLM with a K×d_model codebook C and a fixed vocabulary-to-codebook mapping M. The model computes logits over the K codebook vectors and scatters them to the full vocabulary before softmax. With K ≪ V, the output-layer parameters drop from d_model·V to d_model·K plus V integers for M, and the matrix multiplication cost drops from O(B·S·d_model·V) to O(B·S·d_model·K). On WikiText-103, the authors report perplexity 19.2 for K=1024 versus 18.0 for a full softmax (≈4% increase), a 99.2% reduction in output-layer parameters, and a 6.5× speedup in logit computation; similar trends are reported on C4 and PTB. They also study codebook initialization via k-means on pretrained embeddings, fixed versus learnable codebooks, mapping strategies, and fine-tuning scope.

Significance. If the central claim survives scrutiny, VQ-Logits is a simple, architecture-agnostic output-layer compression scheme that is complementary to weight quantization and other model-compression methods. The use of k-means on pretrained output embeddings to define a tie-breaking-free quantization is natural, and the paper provides a clean complexity analysis (Appendix D) plus ablations isolating the contributions of mapping initialization, codebook learning, and tying. The main weakness is empirical verification: no code or data are released, no error bars are given, one figure is explicitly labeled illustrative, and the low-rank baseline is not parameter-matched. These issues are fixable and do not undermine the mathematical correctness of the method itself, but they must be addressed before the headline claims (99% compression, 6× speedup, better-than-low-rank) can be accepted.

major comments (4)
  1. [§4.3, Table 1] The low-rank factorization baseline is not parameter-matched, and the stated rationale is incorrect. The paper says drank=512 is chosen to make d_model·drank 'somewhat comparable' to d_model·K, but the actual parameter count of a factorized output W_out = W1·W2 is d_model·drank + drank·V, not d_model·drank. At V≈267k, the drank·V term contributes 136.7M parameters, giving 137.1M output parameters, which is ~175× larger than VQ-Logits's 0.78M. A fair comparison against a low-rank baseline with comparable total output parameters would require rank r ≈ d_model·K/(d_model+V), i.e., r≈2–3 for K=1024. The paper should either run that matched-rank baseline or explicitly justify why the current comparison remains informative.
  2. [Tables 1 and 3, §5.4, Appendix D] The 6× speedup claim must be pinned to a precise definition of 'logit computation.' Section 5.4 states that the timings 'include hC^T and the scatter operation,' but Table 1's 'Speed (Logits)' column does not say this, and Appendix D notes that a naive gather implementation of the scatter involves O(B·S·V) memory accesses. If the Table 1 speedup excludes scatter, the headline number overstates the output-layer speedup; if it includes scatter, state that explicitly in the caption and main text. Either way, report the scatter cost separately and, if possible, provide a wall-clock breakdown of the full output layer (hC^T, scatter, softmax) on the actual hardware.
  3. [Fig. 2, §5.2] Figures 2a and 2b are labeled 'illustrative based on trends from Table 1,' which is inappropriate for a results section in a research paper. Replace them with actual measured values from the runs, including error bars if multiple seeds are available. The absence of any repeated-seed runs or variance information in Tables 1, 2, 9, and 10 makes it unclear whether the 0.3–0.9 perplexity differences between variants are meaningful. Please add at least a few repeated runs for the main configurations or an explicit statement that all results are single-run.
  4. [§3.2, Eq. (3), §3.3] The uniform-within-cluster penalty is never analyzed. Because Eq. (3) assigns exactly the same logit to every vocabulary token in a code, the softmax over scattered logits gives all words in a cluster identical probability. The quality of the method therefore depends on the purity of the k-means clusters, and the paper's own examples (Monday/Tuesday/Wednesday, January/February, etc.) show that merging destroys distinctions that matter for prediction. A token-weighted cluster-entropy bound, or at least a quantitative measure of how often the target token's code contains other tokens with high frequency, would make the trade-off principled. Without this, the method's performance is empirically rather than theoretically justified.
minor comments (4)
  1. [§3.3, §4.4] The description of Option B for random initialization is inconsistent: §3.3 says random initialization of M uses 'dividing vocabulary into K contiguous blocks' when no prior embeddings are available, while §4.4 says M is initialized by 'k-means on input embeddings.' The relationship between these two cases should be clarified.
  2. [§2.3] There is a placeholder '(??)' in the sentence about quantization of weights and activations; please insert the intended citations.
  3. [Appendix A] The C4 paragraph says a SentencePiece unigram model was trained with a target vocabulary of 32,000 BPE tokens; unigram and BPE are different subword algorithms, so the wording should be corrected.
  4. [Table 2] The row 'Random init, Learned C, FixedM' does not specify how M is initialized in that case; the text in §5.3 says 'k-means mapping from input embeddings,' but the table caption should state this to avoid ambiguity.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the empirical trade-off is measured against external benchmarks and a full softmax baseline.

full rationale

The paper's central claim is that replacing the V×d_model output projection with a K×d_model codebook plus a fixed scatter mapping reduces output-layer parameters and logit computation cost at a modest perplexity cost. The derivation chain is explicit and self-contained: Eq. 1 defines the standard logits L = hW_out; Eq. 2 computes codebook logits L_c = hC^T; Eq. 3 scatters these logits via the fixed mapping M; Eq. 4 applies softmax. The mapping M is initialized by k-means on the pretrained model's output embeddings (Section 3.3, Option A), and the reported perplexity numbers in Tables 1, 9, and 10 are measured on standard held-out corpora (WikiText-103, C4 subset, PTB) against a full softmax baseline. The perplexity values are not derived from the k-means fit; they are empirical outcomes of training and evaluation. The parameter reduction from d_model×V to d_model×K is arithmetic by construction, but the paper's actual claim is the resulting trade-off (e.g., PPL 19.2 vs. 18.0 at K=1024), which is an independently measured result, not a fitted parameter renamed as a prediction. The paper contains no load-bearing self-citations, no imported uniqueness theorem, and no ansatz smuggled in via citation. Concerns about the fairness of the low-rank baseline configuration (d_rank=512 ignoring the d_rank×V term) and about excluding the O(B·S·V) scatter cost from the speedup figure are legitimate correctness or comparison-quality issues, but they are not circularity: the comparison is still to an externally defined baseline, and the speedup claim is an empirical measurement rather than a consequence of the method's definitions. Therefore the appropriate finding is no significant circularity, score 0.

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

The method relies on standard linear algebra, softmax, and cross-entropy, plus the domain assumption that k-means on output embeddings yields semantically coherent clusters that preserve language modeling accuracy. The codebook size K and the mapping M are data-derived hyperparameters, not fitted constants. No new particles, forces, or latent variables are introduced.

free parameters (3)
  • Codebook size K = 256 to 8192
    Chosen by hand; controls trade-off between compression and perplexity. Central to the method's performance.
  • Vocabulary-to-codebook mapping M = k-means cluster assignments on pretrained output embeddings
    Derived from the pretrained model's output embeddings; fixed during fine-tuning. The quality of this mapping determines the perplexity penalty.
  • k-means iterations = 20
    Used for clustering; a minor implementation choice.
assumptions (3)
  • domain assumption k-means on pretrained output embeddings yields semantically coherent clusters
    The method's low perplexity degradation depends on this. Section 3.3, and Section 5.5 provides examples.
  • domain assumption Uniform probability within each codebook cluster is acceptable for language modeling
    Eq. 4 applies softmax to scattered logits, forcing all words in a code to have equal probability. The paper does not bound the added loss from non-uniform within-cluster distributions.
  • domain assumption The scatter operation and full softmax over V can be implemented efficiently
    The reported speedup counts logit computation only, and the overall speedup is much smaller. Section 5.4 and Table 3.

how reviews work

0 comments
Cite this review

Pith. "Pith review of VQ-Logits: Compressing the Output Bottleneck of Large Language Models via Vector Quantized Logits." pith.science (2026). https://pith.science/paper/P7R4LHDG

@misc{pith2026250510202,
  author       = {Pith},
  title        = {Pith review of: VQ-Logits: Compressing the Output Bottleneck of Large Language Models via Vector Quantized Logits},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/P7R4LHDG}},
  note         = {Machine review of arXiv:2505.10202}
}
read the original abstract

Large Language Models (LLMs) have achieved remarkable success but face significant computational and memory challenges, particularly due to their extensive output vocabularies. The final linear projection layer, mapping hidden states to vocabulary-sized logits, often constitutes a substantial portion of the model's parameters and computational cost during inference. Existing methods like adaptive softmax or hierarchical softmax introduce structural complexities. In this paper, we propose VQ-Logits, a novel approach that leverages Vector Quantization (VQ) to drastically reduce the parameter count and computational load of the LLM output layer. VQ-Logits replaces the large V * dmodel output embedding matrix with a small, shared codebook of K embedding vectors (K << V ). Each token in the vocabulary is mapped to one of these K codebook vectors. The LLM predicts logits over this compact codebook, which are then efficiently "scattered" to the full vocabulary space using the learned or preassigned mapping. We demonstrate through extensive experiments on standard language modeling benchmarks (e.g., WikiText-103, C4) that VQ-Logits can achieve up to 99% parameter reduction in the output layer and 6x speedup in logit computation, with only a marginal 4% increase in perplexity compared to full softmax baselines. We further provide detailed ablation studies on codebook size, initialization, and learning strategies, showcasing the robustness and effectiveness of our approach.

Figures

Figures reproduced from arXiv: 2505.10202 by the authors.

Figure 1
Figure 1. Overview of the VQ-Logits architecture. The [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Impact of codebook size K on perplexity and logit computation speedup for VQ-Logits on WikiText￾103. A clear trade-off is visible (Data corresponds to WikiText-103 with our Transformer model; plots are illustrative based on trends from [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. SoftWater: Class-Aware Rate Allocation for Softmax Quantization

    cs.LG 2026-08 conditional novelty 6.0 of 10

    SoftWater, a KL-divergence-based quantizer for LLM softmax heads, allocates bit rate by class frequency and variance and beats WaterSIC at matched head rates on 59 of 60 test points.

Reference graph

Works this paper leans on

30 extracted references · 9 canonical work pages · cited by 1 Pith paper

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Courville

    Yoshua Bengio, Nicholas L \' e onard, and Aaron C. Courville. 2013. Estimating or propagating gradients through stocahstic neurons for conditional computation. arXiv preprint arXiv:1308.3432

    arXiv 2013

  4. [4]

    Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, and 12 others. 2020. https://arxiv.org/abs/2005.14165 Lan...

    arXiv 2020

  5. [5]

    Patrick Esser, Robin Rombach, and Björn Ommer. 2021. Taming transformers for high-resolution image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 12873--12883

    work page 2021

  6. [6]

    Jonathan Frankle and Michael Carbin. 2018. https://arxiv.org/abs/1803.03635 The lottery ticket hypothesis: Finding sparse, trainable neural networks . arXiv preprint arXiv:1803.03635

    arXiv 2018

  7. [7]

    Edouard Grave, Armand Joulin, Moustapha Ciss \'e , Herv \'e J \'e gou, and Tomas Mikolov. 2017. Efficient softmax approximation for gpus. In International Conference on Machine Learning (ICML), pages 1302--1310. PMLR

    work page 2017

  8. [8]

    Song Han, Jeff Pool, John Tran, and William J. Dally. 2015. https://arxiv.org/abs/1506.02626 Learning both weights and connections for efficient neural networks . arXiv preprint arXiv:1506.02626

    arXiv 2015

Show all 30 references
  1. [9]

    Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. 2015. https://arxiv.org/abs/1503.02531 Distilling the knowledge in a neural network . arXiv preprint arXiv:1503.02531

    2015 arXiv

  2. [10]

    Hazar Inan, Khashayar Khosravi, and Richard Socher. 2016. https://arxiv.org/abs/1611.01462 Tying word vectors and word classifiers: A loss framework for language modeling . arXiv preprint arXiv:1611.01462

    2016 arXiv

  3. [11]

    Eric Jang, Shixiang Gu, and Ben Poole. 2016. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144 (Published at ICLR 2017)

    2016 arXiv

  4. [12]

    S \' e bastien Jean, Kyunghyun Cho, Roland Memisevic, and Yoshua Bengio. 2014. https://arxiv.org/abs/1412.2007 On using very large target vocabulary for neural machine translation . arXiv preprint arXiv:1412.2007

    2014 arXiv

  5. [13]

    Herv \' e J \' e gou, Matthijs Douze, and Cordelia Schmid. 2011. https://doi.org/10.1109/TPAMI.2010.57 Product quantization for nearest neighbor search . IEEE Transactions on Pattern Analysis and Machine Intelligence , 33(1):117--128

    2011 doi

  6. [14]

    Jeff Johnson, Matthijs Douze, and Herv \' e J \' e gou. 2021. https://doi.org/10.1109/TBDATA.2019.2921105 Billion-scale similarity search with GPUs . IEEE Transactions on Big Data , 7(3):535--547

    2021

  7. [15]

    Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. 2017. https://www.aclweb.org/anthology/E17-2068 Bag of tricks for efficient text classification . In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics (...

    2017

  8. [16]

    Taku Kudo and John Richardson. 2018. https://www.aclweb.org/anthology/D18-2012 SentencePiece : A simple and language independent subword tokenizer and detokenizer for neural network text processing . In Proceedings of the 2018 Conference on Empirical Methods in Natural Languag...

    2018

  9. [17]

    Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2019. https://arxiv.org/abs/1909.11942 ALBERT : A lite BERT for self-supervised learning of language representations . arXiv preprint arXiv:1909.11942

    2019 arXiv

  10. [18]

    Ilya Loshchilov and Frank Hutter. 2017. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101 (Published at ICLR 2019)

    2017 arXiv

  11. [19]

    Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini

    Mitchell P. Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. 1993. Building a large annotated corpus of english: The penn treebank. In Computational Linguistics, volume 19, pages 313--330

    1993

  12. [20]

    Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2017. Pointer sentinel mixture models. In International Conference on Learning Representations (ICLR)

    2017

  13. [21]

    Tom \' a s Mikolov, Martin Karafi \' a t, Luk \' a s Burget, Jan C ernock \' y , and Sanjeev Khudanpur. 2010. Recurrent neural network based language model. In INTERSPEECH 2010, 11th Annual Conference of the International Speech Communication Association, pages 1045--1048, Mak...

    2010

  14. [22]

    Andriy Mnih and Geoffrey E. Hinton. 2009. A scalable hierarchical distributed language model. In Advances in Neural Information Processing Systems 21, NIPS 2008, pages 1081--1088

    2009

  15. [23]

    Fr \' e d \' e ric Morin and Yoshua Bengio. 2005. Hierarchical probabilistic neural network language model. In Proceedings of the Tenth International Workshop on Artificial Intelligence and Statistics, AISTATS 2005, 6-8 January 2005, Barbados, pages 246--252

    2005

  16. [24]

    OpenAI . 2023. https://arxiv.org/abs/2303.08774 Gpt-4 technical report . Technical report, OpenAI

    2023 arXiv

  17. [25]

    Ofir Press and Lior Wolf. 2016. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859 (Published at EACL 2017)

    2016 arXiv

  18. [26]

    Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners. OpenAI Blog, 1(8)

    2019

  19. [27]

    Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. http://jmlr.org/papers/v21/20-074.html Exploring the limits of transfer learning with a unified text-to-text transformer . Journal of Machine Lea...

    2020

  20. [28]

    Sainath, Brian Kingsbury, Bhuvana Ramabhadran, Petr Fousek, Petr Novak, and Abdel - rahman Mohamed

    Tara N. Sainath, Brian Kingsbury, Bhuvana Ramabhadran, Petr Fousek, Petr Novak, and Abdel - rahman Mohamed. 2013. https://doi.org/10.1109/ICASSP.2013.6638947 Low-rank matrix factorization for deep neural network training with high-dimensional output targets . In 2013 IEEE Inte...

    2013

  21. [29]

    Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. 2019. https://arxiv.org/abs/1910.01108 Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter . arXiv preprint arXiv:1910.01108

    2019 arXiv

  22. [30]

    Aaron van den Oord, Oriol Vinyals, and Koray Kavukcuoglu. 2017. http://arxiv.org/abs/1711.00937 Neural discrete representation learning . arXiv preprint arXiv:1711.00937

    2017 arXiv

Pith tools

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