{"id":"cc31c9a2-19f6-4a36-bbc2-21851d9f91fb","arxiv_id":"2602.16086","paper_version":3,"verdict":"REJECT","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"high","formal_verification":"none","parameter_count":4,"one_line_summary":"LGQ reports better ImageNet reconstruction FID than FSQ/SimVQ using soft-to-hard learnable-codebook quantization, but its abstract's generation and utilization claims are contradicted by the body.","lead":"LGQ is a new image tokenizer that uses soft, temperature-annealed assignments to a learnable codebook, plus two regularizers aimed at preventing codebook collapse. The paper claims better reconstruction FID than FSQ and SimVQ at lower active code usage, but several headline claims in the abstract are not backed by experiments in the body.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Abstract claims 100% utilization, MaskGIT generation, and 256x256 experiments; body Table 1 reports 50.0% utilization, Section 6 defers MaskGIT to future work, and §4.1 uses 128x128. The strongest claim is internally contradicted.","rationale":"The reader's verdict (REJECT) is well-founded. The most load-bearing flaw is not an external benchmark-fairness question but an internal contradiction: the abstract's headline assertions are contradicted by the paper's own Table 1, §4.1, and §6. The strongest claim in the abstract ('100% utilization', 'MaskGIT generation', '256x256') is not supported by the body; indeed, the body contradicts it. My stress-test identifies this same core issue, so the reader's weakest_assumption is essentially correct, though I would phrase it as an internal-consistency problem rather than primarily a protocol-fairness problem. No further analysis is needed to reject the claims as stated; the paper needs major revision and independent verification before any positive verdict. Therefore the reader's REJECT should stand.","tokens_in":17309,"tokens_out":3377,"duration_ms":30621,"concrete_test":"Run the released LGQ training code on ImageNet at 128×128 with K=16,384 for 61 epochs and compute codebook utilization from the final checkpoint. If the number of active codes is not 16,384 (i.e., utilization is not 100%), the abstract's '100% utilization' claim is falsified by the authors' own setup. Additionally, search the repository for any MaskGIT training script or 256×256 configuration; absence of both would confirm that the generation and resolution claims are unsupported.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim, as stated in the abstract, is a conjunction of three load-bearing assertions: (i) LGQ maintains 100% codebook utilization at K=16,384 and unchanged at K=65,536; (ii) it attains best class-conditional generation via MaskGIT; (iii) experiments are on ImageNet 256x256. The body directly contradicts each of these. §4.1 states 'All experiments are conducted on the ImageNet dataset resized to 128×128.' Table 1 (main setting, K=16,384) reports LGQ utilization as 50.0% (8,199 active codes), not 100%. The K=65,536 row, described as an 'epoch 9' snapshot, reports LGQ at 22.5% utilization (14,716 active), which is not 'unchanged.' Section 6 (Limitations) explicitly declares: '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 evaluation as future work. Thus the abstract's strongest claims are not merely unverified; they are contrary to the paper's own reported numbers and scope. The body's rFID result (110.64 vs 117.77–125.56) may stand on its own, but the package of claims in the abstract is unsupported. This is not an external critique—it is an internal consistency failure that undermines the headline contribution.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":17678,"tokens_out":5918,"duration_ms":56659,"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":[{"comment":"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","section":"Abstract; §4.1; Table 1; §6"},{"comment":"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.","section":"§3.1, Eq. (1), Eq. (2)"},{"comment":"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.","section":"§3.3, Theorem 3.1"},{"comment":"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.","section":"§4.2, Table 1 (large-vocabulary scaling)"}],"minor_comments":[{"comment":"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.","section":"§3.4 vs. Appendix A.1, Table 2"},{"comment":"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.","section":"§4.3, Figure references"},{"comment":"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.","section":"Throughout"},{"comment":"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.","section":"§4.1, Experimental setup"},{"comment":"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.","section":"Appendix A.1, Table 4"}],"recommendation":"reject","confidential_remarks":"The abstract-body discrepancy is severe and central: the paper's headline claims (100% utilization, MaskGIT generation, ImageNet 256×256, unchanged utilization at K=65,536) are directly contradicted by the paper's own tables and limitations section. This is an internal consistency failure, not a disagreement with the field's consensus. The K=16,384 rFID result may be salvageable, but as submitted the manuscript cannot be published. If the authors resubmit with an honest abstract and a matched-epoch large-vocabulary comparison, the reconstruction benchmark could be evaluated on its merits."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"I read LGQ. The body's rFID result at K=16,384 is worth a look, but the abstract overstates the paper in at least three load-bearing ways, and the mismatch isn't cosmetic.\n\nWhat's actually new is the specific combination: soft Gibbs assignments over a learnable codebook with a usage regularizer that discourages concentrated batch-average usage, a peakedness term, and a linear temperature annealing schedule. The theory (free-energy minimization, soft-to-hard convergence, Lipschitz stability) is standard but clean. The main table shows LGQ at rFID 110.64 versus 117.77–125.56 for the baselines at K=16,384, using roughly 8,199 active codes—an interesting rate–distortion point. The UMAP and center-drift analyses are reasonable supporting evidence.\n\nThe problems are in the abstract, not just the body. (1) It claims 100% codebook utilization at K=16,384, but Table 1 reports 50.0% (8,199 active). The K=65,536 row reports 22.5%, not \"unchanged.\" (2) It claims ImageNet 256x256, but Section 4.1 explicitly says all experiments are at 128x128. (3) It claims MaskGIT generation results, but Section 6 explicitly lists that as future work. These aren't typos; they are the three strongest claims in the abstract, and they're each contradicted by the paper's own numbers and scope. The stress-test note holds up.\n\nThere's also a smaller technical mismatch: Eq. (1) uses exp(-||z-c||/tau), but the text calls it a Gaussian posterior, which would require squared distance. The free-energy functional in Eq. (2) uses ||z-c||, not squared, so that identification doesn't hold as written. And the usage regularizer directly optimizes utilization, so reporting utilization as evidence is mildly circular—but that's secondary because rFID is external to the loss.\n\nI'd send this to a serious referee. The core rFID comparison is plausible and the method is a reasonable incremental contribution—soft VQ with entropy/usage penalties is a combination worth testing. But the authors need to fix the abstract, remove or substantiate the MaskGIT and 256x256 claims, and clarify the Gaussian-posterior mismatch. If they clean that up, the paper could be solid. As is, I would not cite it yet.","headline":"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.","tokens_in":18179,"tokens_out":2049,"would_cite":false,"duration_ms":19473,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A tokenizer that learns its discretization geometry claims better ImageNet reconstruction than fixed-grid quantizers while using about half the codebook.","keywords":["image tokenization","vector quantization","codebook collapse","discrete representation learning","temperature annealing","soft-to-hard assignment","rate-distortion trade-off","ImageNet"],"falsifier":"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.","tokens_in":17183,"feed_emoji":"🖼️","tokens_out":7048,"duration_ms":63122,"temperature":0.7,"texified_at":"2026-08-05T20:56:24.561921+00:00","pith_summary":"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.","texify_model":"deepseek-v4-flash","texify_usage":{"total_tokens":5094,"prompt_tokens":842,"completion_tokens":4252,"prompt_tokens_details":{"cached_tokens":0},"prompt_cache_hit_tokens":0,"prompt_cache_miss_tokens":842,"completion_tokens_details":{"reasoning_tokens":3457}},"feed_headline":"Learned codebook geometry beats fixed grids with half the codes","feed_subtitle":"LGQ reports ImageNet rFID of 110.64 — lower than FSQ, SimVQ, LFQ, and VQ — using only 8,199 of 16,384 codes.","key_machinery":"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","core_discovery":"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","pith_inferences":["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."],"forward_implications":["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."],"fun_headline_variants":["Learnable codebook beats fixed grids for image tokenization","LGQ: full codebook utilization, best ImageNet reconstruction FID","Soft-to-hard assignment learns better codebook geometry","Image tokenizer: learned geometry tops fixed scalar grids","LGQ scales to 65K codes without hyperparameter tuning"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["Learnable codebook beats fixed grids for image tokenization","LGQ: full codebook utilization, best ImageNet reconstruction FID","Soft-to-hard assignment learns better codebook geometry","Image tokenizer: learned geometry tops fixed scalar grids","LGQ scales to 65K codes without hyperparameter tuning"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000243,"raw_usage":{"total_tokens":1399,"prompt_tokens":811,"completion_tokens":588,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":555,"completion_tokens_details":{"reasoning_tokens":516}},"tokens_in":555,"tokens_out":588,"duration_ms":5869,"temperature":1.0,"reasoning_tokens":516,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-02T22:39:09.765027+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[],"review_version":1}