acceptodds
Under review as a conference paper at ICLR 2027

Beyond Scalar Assignments: Geometric Binary Quantization for Visual Tokenization

Abstract

Lookup-free quantization (LFQ) constructs large visual vocabularies compositionally from binary variables. Compared with conventional vector quantization, which relies on an explicit learned vector codebook and vector-level nearest-neighbor search, LFQ replaces this machinery with independent sign assignments, offering a more scalable discrete representation. However, this simplicity fixes the quantizer-side binary support to an axis-aligned hypercube. Although the encoder can adapt its representation toward this support, the quantizer geometry itself remains prescribed. To address this limitation, we introduce Geometric Binary Quantization (GBQ), which learns linear transformations to adapt the binary code geometry. However, directly applying a single transformation to the full binary latent would make exact nearest-code search prohibitively expensive. GBQ therefore factorizes the latent into small blocks and learns a local transformation within each block, enabling vector-level assignment locally while preserving exact and tractable assignment globally. Using the same tokenizer architecture and reconstruction objective on ImageNet-1K, GBQ achieves better reconstruction than WeTok with substantially fewer training-image exposures. Under matched-budget controlled training, the reconstruction advantage emerges early and persists throughout optimization, while GBQ maintains high code utilization without explicit entropy regularization. GBQ also retains competitive zero-shot reconstruction on out-of-domain data.

Primary area:
generative models
Keywords:
Vector Quantization, Binary Quantization, Lookup-Free Quantization, Visual Tokenization, Learnable Code Geometry

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_LXT3OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces Geometric Binary Quantization (GBQ) for visual tokenization. The authors' approach is motivated by the observation that existing lookup-free binary quantization methods (such as LFQ) typically constrain discrete codes to a fixed, axis-aligned binary hypercube and assign signs to each latent dimension independently, resulting in a fixed geometric structure for the quantizer itself. GBQ partitions the latent representation into small blocks and applies a learnable linear transformation to the full binary state space within each block, thereby constructing a structured local codebook, and performs precise quantization via block-wise nearest-neighbor search.

Critical strengths

The experiments are comprehensive. Reconstruction evaluation of the visual tokenizer was primarily conducted on ImageNet-1K, with comparisons made against LFQ, WeTok, and other visual tokenizers; additionally, zero-shot reconstruction was tested on MS-COCO, and generation experiments were performed using the BitDance framework.

Critical weaknesses
  1. The paper overstates its novelty. As I understand it, GBQ can be viewed as PQ + SIMVQ + LFQ; specifically, the proposed GBQ essentially groups the LFQ codebook and introduces a linear layer within each group, similar to the approach in SimVQ. In other words, the GBQ formulation is very close to the existing SimVQ method, differing only by the addition of a grouped/product quantization structure and the specialization of SimVQ’s generic base codebook into the binary format used in LFQ. This issue affects Equations 6, 7, and 8; while the authors seem intent on highlighting the differences from SimVQ, anyone familiar with the field would recognize the underlying similarity.

  2. Following up on the first point, the current experiments fail to address a more critical question: the paper lacks a "grouped SimVQ" baseline that directly matches GBQ, as well as a rigorously controlled comparison against product/grouped VQ methods that freely learn 2b2^b local code vectors. Without these comparisons, the performance gains attributed to this quantization method could simply stem from the use of SimVQ and a larger codebook, thereby significantly diminishing the authors' contribution.

  3. I am particularly puzzled by the lack of visualizations. Typical VQ papers include numerous visualizations to demonstrate effectiveness; however, this paper offers very few visualizations for the quantization reconstruction component and none at all for the generation experiments. Furthermore, there is no appendix; notably, the authors have not explicitly stated that the code will be open-sourced, nor have they provided an appendix.

Questions for authors

My primary focus is on the relationship between GBQ and existing methods that combine grouped/product quantization with SimVQ-style codebook reparameterization. At a high level, GBQ partitions latent vectors into blocks and parameterizes each local codebook as a linear transformation of fixed binary states. Could the authors clarify the fundamental difference between this approach and independently applying SimVQ-style shared linear transformations within each group? More importantly, have you provided controlled experimental results comparing GBQ against such "grouped SimVQ" baselines, or against "grouped/product VQ" baselines that utilize identical block sizes, numbers of local candidates, backbone networks, and training budgets? Such comparisons are crucial for my assessment: determining whether the performance gains stem from the proposed binary geometric structure or simply from the introduction of local vector assignment and codebook reparameterization.

In LFQ-style tokenization, the binary identity corresponds directly to the quantized latent vector; in contrast, with GBQ, the generator predicts a binary identity ss, yet the decoder receives a transformed representation DgsD_gs. Given that BitDance models and generates binary representations, and that GBQ deliberately alters the geometric structure associated with these binary identities. Could the authors discuss whether this geometric mismatch complicates downstream token generation? While current BitDance results demonstrate that GBQ remains compatible with the generator, the improvement in generation performance is relatively modest compared to the gains in reconstruction performance. Any analysis or existing evidence linking the learned geometric structure to downstream generation quality would help clarify whether GBQ enhances visual tokenization beyond mere reconstruction.

7 comments

We thank the reviewer for the detailed and insightful comments. We would like to clarify the motivation, design, and contributions of GBQ.

W1, W2 & Q1: Relation to SimVQ and Product Quantization

Thank you for your insightful comments. LFQ-based visual tokenizers such as WeTok enable efficient scalar assignment, but their fixed code geometry cannot adapt to encoder features, limiting reconstruction quality.

Inspired by SimVQ, we introduce learnable linear transformations of binary codes. Block-wise factorization further enables local coupling while preserving tractable exact assignment, extending independent scalar assignment to block-wise vector assignment.

To evaluate this design, we conducted controlled comparisons with PQ and Grouped SimVQ under matched settings at 50K training steps.

MethodPSNR ↑rFID ↓
PQ23.521.241
Grouped SimVQ23.841.161
GBQ (Ours)24.051.132

GBQ outperforms both PQ and Grouped SimVQ in PSNR and rFID.

We further compared GBQ and Grouped SimVQ using the diagnostics introduced in Fig. 1: Relative Quantization Residual, measuring relative code–feature distance, and STE–Reference Gradient Alignment, measuring the cosine similarity between STE and continuous-latent reference gradients.

MethodRelative Residual ↓STE Alignment ↑
Grouped SimVQ0.18030.7410
GBQ (Ours)0.16880.7740

GBQ achieves lower quantization residual and better gradient alignment, consistent with its reconstruction advantage.

We attribute this in part to the binary basis construction inherited from LFQ. Unlike randomly sampled bases, which may introduce sampling variability and uneven coverage, the complete binary state set provides a regular, symmetric, and deterministic structure. GBQ also uses a compact shared transformation instead of independently storing every code vector, facilitating codebook reuse, transfer, and block-wise modification.

More importantly, GBQ provides a precise geometric characterization of binary-variable coupling. The off-diagonal entries of the Gram matrix determine interactions between binary variables, while block size controls their scope. At block size one, GBQ naturally reduces to separable scalar assignment. This provides a controllable transition from scalar to coupled vector assignment while retaining tractable exact quantization.

We will further clarify the motivation and structural properties of GBQ in the revision.

W3: Appendix and Qualitative Results

Thank you for highlighting the importance of reproducibility and qualitative evaluation. We would like to respectfully clarify that our original submission already includes Appendices A–D, covering implementation details and reconstruction visualizations.

Appendix A provides the model architecture, training hyperparameters, and evaluation settings. Appendix D (Fig. 3) presents GBQ–WeTok reconstruction comparisons on ImageNet validation images, including fine structures, edges, and local textures.

Appendix B analyzes code geometry, assignment separability, representational capacity, and complexity, while Appendix C provides additional diagnostics, training analyses, and ablations.

We also appreciate your suggestion to include more visualizations. Since generation differences are relatively subtle, we previously focused on quantitative evaluation. We will complement these results with additional reconstruction comparisons and representative generated images in the revision.

Q2: Reconstruction Robustness and Downstream Generation

Thank you for raising this important question. During generation, predicted tokens may contain errors, affecting the images recovered by the tokenizer. Evaluating reconstruction under token perturbations therefore helps examine how learned code geometry may influence downstream generation.

We evaluated GBQ and WeTok by randomly flipping bits in their binary tokens. We sampled 2,000 ImageNet validation images and averaged results over three independently trained seeds per method. We tested four settings: no perturbation, independent bit flips at 1% and 5%, and exactly one random bit flip per token.

ConditionGBQ PSNR ↑WeTok PSNR ↑
No perturbation24.49323.952
Independent 1% bit flips22.78322.355
Independent 5% bit flips19.09218.704
One random bit flip per token20.43920.150

GBQ maintains higher reconstruction PSNR under all perturbation settings. Its reconstruction advantage thus persists even when binary tokens contain errors, providing further evidence that learned code geometry can benefit the decoding of imperfect token predictions in downstream generation.

Explicitly incorporating bit-flip robustness into tokenizer training is an interesting direction that we leave for future work.

As far as I am aware, ICLR allows for the submission of revised manuscripts during the rebuttal phase; authors may upload a revised version, incorporating the relevant additional content, before providing their response to reviewers. Visualization cannot be perceived within text.

Thank you for the helpful suggestion. We have added further qualitative reconstruction comparisons with WeTok, PQ, and Grouped SimVQ, along with representative GBQ generation samples, all included in Appendix E of the revised manuscript. We hope these additional visualizations help clarify the reconstruction improvements and provide a more complete qualitative evaluation.

Reviewer_4ESvOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes Geometric Binary Quantization (GBQ) for visual tokenization. Instead of assigning binary variables independently, GBQ learns a linear geometry within small blocks and performs exact nearest-code assignment jointly inside each block. Its analysis relates assignment separability to the Gram matrix of the learned transformation and shows how coupled blocks can represent configurations unavailable to separable binary quantizers. Image reconstruction, generation, geometry ablations, and timing experiments evaluate the resulting trade-off between reconstruction quality and assignment cost.

Critical strengths

The connection between the problem and the proposed solution is convincing. The analysis identifies a specific limitation of independent binary assignment and explains why off-diagonal interactions change the assignment problem. Small blocks provide a practical way to introduce those interactions without searching the full binary vocabulary. I found this more informative than an empirical argument that a more flexible quantizer simply performs better.

The controlled reconstruction experiments support the idea. Under the matched 250K-step setup in Table 4, GBQ improves rFID from 0.86 for WeTok to 0.69 and PSNR from 23.90 to 24.50. Table 5 also shows consistent improvement as block size increases at a fixed bit budget. Together with the modest measured overhead in Table 7, these results make a reasonably strong case for the practical value of the method.

Critical weaknesses

The geometry controls do not completely isolate the proposed explanation. The global orthogonal rotation in Table 4 preserves an identity Gram matrix, while the block-size-one setting only permits coordinate-wise scaling. Neither tests a learned rotation combined with independent scales, which would retain diagonal D⊤DD^\top D while allowing both orientation and scale adaptation. The existing results establish an advantage over the tested controls, but leave some uncertainty about how much specifically requires non-separable interactions.

The positioning against other learned binary/compositional codebooks could be sharper. FoldToken's SoftGVQ and SoftCVQ [1] constructions are relevant to learning geometry from binary identities, although they differ from GBQ's block-local exact assignment. Clarifying this relationship would help identify the precise methodological increment. The strongest empirical support is also in reconstruction; the smaller generation differences in Table 3 should be interpreted cautiously without run-to-run uncertainty.

[1] Gao, Z., Tan, C., Wang, J., Huang, Y., Wu, L., & Li, S. Z. (2025, April). Foldtoken: Learning protein language via vector quantization and beyond. In Proceedings of the AAAI Conference on Artificial Intelligence (Vol. 39, No. 1, pp. 219-227).

Questions for authors
  1. Can you clarify the relationship to FoldToken's SoftGVQ/SoftCVQ constructions, particularly which representational and assignment properties distinguish GBQ? I am asking about the method, not whether the protein experiments should be reproduced.

  2. Do you have evidence comparing GBQ with a separable rotation-plus-scaling control? Such a control would directly address whether the non-diagonal Gram terms are responsible for the observed advantage.

  3. How much variability is there in the matched reconstruction results and the smaller generation improvements? Even a limited repeated-run check would help distinguish the robust gains from differences that should be described as comparable performance.

3 comments

We thank the reviewer for the thoughtful comments. We address your concerns below.

W1 & Q2: Rotation-and-Scaling Control

Thank you for identifying this missing control. As you correctly noted, Table 4 evaluates global rotation, while Table 5 examines independent scaling at block size b=1b=1. Neither tests their combination.

We therefore tested the combined transformation WDWD, where WW is a learnable global orthogonal matrix and DD is diagonal. Since (WD)⊤(WD)=D⊤D(WD)^\top(WD)=D^\top D, this allows both orientation and scale adaptation while preserving a diagonal Gram matrix and separable assignment.

MethodGram StructurerFID ↓PSNR ↑
WeTokIdentity0.8623.90
LFQ + global rotationIdentity0.9023.66
GBQ (b=1b=1)Diagonal0.8723.77
GBQ (b=1b=1) + global rotationDiagonal0.9123.83
GBQ (Ours)General0.6924.50

The combined control still falls well short of full GBQ. This supports the importance of non-separable coupling beyond orientation and scaling alone.

W2 & Q1: Relation to FoldToken

Thank you for bringing FoldToken to our attention. This connection helps clarify how GBQ differs from other methods learning continuous representations from binary identities.

Although GBQ, SoftGVQ, and SoftCVQ associate binary identities with learnable vectors, they differ in their quantization mechanisms and optimization goals.

GBQ advances STE-based hard quantization through learnable code geometry, while FoldToken adopts differentiable soft assignment.

SoftGVQ and SoftCVQ build upon SoftVQ, which uses temperature-controlled attention to compute a weighted average of codebook vectors. Given a feature hih_i and code vectors vjv_j, SoftVQ computes:

\qquad q_{\mathrm{soft}}=\sum_j a_{ij}v_j.$$ SoftGVQ applies this mechanism to groups of learnable positive/negative basis vectors, while SoftCVQ uses a ConditionNet to construct continuous code vectors from binary identities before soft querying. GBQ instead performs exact hard nearest-code assignment within each block: $$s_g^* = \operatorname*{argmin}_{s \in \lbrace -1,+1 \rbrace^b} \Vert z_g-D_gs \Vert_2^2, \qquad q_g = D_gs_g^*.$$ Reconstruction gradients are propagated through the identity straight-through estimator: $$q_{\mathrm{ST}}=z+\operatorname{sg}(q-z).$$ Thus, GBQ uses selected discrete codes rather than soft averages during both training and inference. These approaches involve **different optimization trade-offs**. Soft assignment provides differentiable gradients without relying on STE, but its continuous training representation may differ from the hard codes used at inference. In visual tokenization, this soft-to-hard transition can introduce optimization difficulties and train–inference mismatch, as discussed in IBQ (Shi et al., ICCV 2025, Supplementary Sec. 2, *Comparison with Soft Vector Quantization*). This does not negate the effectiveness of soft quantization in FoldToken's protein-modeling setting. The different mechanisms also serve different goals. SoftGVQ and SoftCVQ support subsequent FoldGPT training for protein generation. GBQ instead addresses the fixed code geometry of LFQ-based visual tokenizers. Rather than replacing hard quantization with soft assignments, we make code geometry learnable while retaining exact hard assignment and STE-based training. We further examine how geometry affects the STE approximation. As shown in Fig. 1, GBQ improves median STE–reference gradient alignment from 0.61 to 0.89 compared with WeTok. These results show that learned geometry improves gradient consistency without changing the hard-quantization paradigm. We will clarify these differences and the relation to FoldToken in the revision. ### W2 & Q3: Variability Across Runs Thank you for suggesting repeated-run evaluations. We trained WeTok and GBQ with three random seeds under the same 250K-step setting. The mean and sample standard deviation are: | Method | PSNR ↑ | rFID ↓ | LPIPS-V ↓ | |---|---:|---:|---:| | WeTok | 23.987 ± 0.096 | 0.8313 ± 0.0313 | 0.1633 ± 0.0030 | | **GBQ** | **24.526 ± 0.019** | **0.6896 ± 0.0053** | **0.1586 ± 0.0005** | The individual results are: | Method | Seed | PSNR ↑ | rFID ↓ | LPIPS-V ↓ | |---|---:|---:|---:|---:| | WeTok | 42 | 23.902 | 0.8568 | 0.1665 | | WeTok | 43 | 24.092 | 0.7964 | 0.1605 | | WeTok | 44 | 23.967 | 0.8408 | 0.1630 | | GBQ | 42 | 24.506 | 0.6885 | 0.1592 | | GBQ | 43 | 24.543 | 0.6953 | 0.1585 | | GBQ | 44 | 24.529 | 0.6849 | 0.1581 | GBQ consistently outperforms WeTok across all three runs, with smaller run-to-run variation, supporting the consistency of the reconstruction gains. For generation, performance remains comparable to the baseline. The modest improvements may partly benefit from higher tokenizer reconstruction fidelity, which we will clarify in the revision.

Thank you for the serious response. I will maintain my rating.

Thank you for reconsidering our response. Your comments prompted us to examine the combined rotation-and-scaling control, evaluate reconstruction consistency across multiple seeds, and further clarify the distinction from FoldToken. In particular, GBQ retains exact hard assignment while introducing controllable non-separable coupling through learned binary geometry.

We would also appreciate knowing whether any remaining technical concerns continue to affect your overall assessment of the paper. We would be happy to provide further clarification or evidence where helpful.

Reviewer_iFVtOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3(+1)
Soundness
2
Read review
Paper summary

This paper proposes Geometric Binary Quantization (GBQ), which learns linear transformations of binary states within small latent blocks via exact local nearest-code search. On ImageNet, GBQ improves reconstruction quality under matched training budgets and achieves high code utilization without entropy regularization, while matching existing methods on zero-shot reconstruction and autoregressive generation.

Critical strengths
  1. Reconstruction gains under controlled training. Using the same tokenizer architecture and reconstruction objective under a matched training budget, GBQ achieves better rFID and PSNR than WeTok and LFQ.

  2. Theoretically grounded characterization of binary geometry. Theorem 1 constructs an explicit distribution where separable geometry has an irreducible distortion floor that coupled geometry eliminates, and the result is appropriately scoped to a fixed distribution rather than an end-to-end guarantee.

Critical weaknesses
  1. The novelty is trivial. GBQ is a constrained form of product quantization that abandons the lookup-free property of LFQ. The binary-state restriction on local codebooks is not justified. Why not the direct unconstrained local PQ.

  2. The Unconstrained local PQ is a natural baseline but is not compared against. Without a matched comparison against an unconstrained local PQ baseline [1], it remains unclear whether the binary-state restriction helps, hurts, or is simply unnecessary.

  3. The ablations only partially isolate the benefit of coupling. The global-rotation control preserves code radii, while full GBQ can change scale and coupling simultaneously. Table 5 includes a learnable-scaling baseline at block size one, but there is no same-block-size diagonal-Gram control that learns orientation and scale while retaining separable assignment. How much of the gain comes from coupling specifically remains an open question.

  4. Both reconstruction and downstream generation improvements are incremental.

[1] Addressing index collapse of large-codebook speech tokenizer with dual-decoding product-quantized variational auto-encoder

Questions for authors
  1. Were the diagnostics computed using separately trained or shared frozen encoders and decoders? Please specify the checkpoints, gradient objectives, and token-level aggregation. If trained separately, do the residual and alignment improvements hold when the encoder and decoder are fixed?

  2. Under matched architecture, bit budget, block partition, and training budget, how does GBQ compare against unconstrained local PQ and a grouped SimVQ variant? Does a same-block-size diagonal-Gram control isolate whether coupling drives the improvement?

3 comments

We thank the reviewer for the constructive comments and suggestions. We address your concerns below.

W1, W2 & Q2: Motivation and Comparisons with PQ and Grouped SimVQ

Thank you for raising these points. LFQ-based tokenizers such as WeTok use fixed binary codes for efficient scalar quantization and an exponentially large compositional code space. However, their fixed geometry cannot adapt to encoder features, limiting reconstruction quality. Inspired by SimVQ, GBQ learns binary code geometry through block-wise transformations, enabling local coupling while retaining tractable exact assignment.

Following your suggestion, we compared PQ, Grouped SimVQ, and GBQ under matched settings at 50K steps.

MethodPSNR ↑rFID ↓
PQ23.521.241
Grouped SimVQ23.841.161
GBQ (Ours)24.051.132

GBQ achieves the best PSNR and rFID, improving PSNR by 0.53 dB over PQ. We further evaluated Relative Quantization Residual and STE–Reference Gradient Alignment, as introduced in Fig. 1:

MethodRelative Residual ↓STE Alignment ↑
Grouped SimVQ0.18030.7410
GBQ (Ours)0.16880.7740

GBQ achieves lower residual and better gradient alignment. We attribute this in part to its binary basis inherited from LFQ: the complete binary state set offers a regular, symmetric, deterministic structure without the sampling variability of random bases. Its shared transformation also avoids independently learning every code vector, enabling compact parameterization and flexible block-wise modification.

GBQ further characterizes coupling through the off-diagonal entries of the Gram matrix, with block size controlling the interaction range. At block size one, it naturally reduces to separable scalar assignment. We will clarify these distinctions and the connection to SimVQ in the revision.

W3: Diagonal-Gram Control

Thank you for this suggestion. A diagonal Gram matrix corresponds to an orthogonal transformation with independent scaling. Following our notation, let WW be orthogonal and DD diagonal (b=1b=1). The combined transformation WDWD satisfies (WD)⊤(WD)=D⊤D(WD)^\top(WD)=D^\top D, preserving separable assignment.

Tables 4 and 5 evaluated global rotation and scaling separately. We additionally tested their combination:

MethodGram StructurerFID ↓PSNR ↑
WeTokIdentity0.8623.90
LFQ + global rotationIdentity0.9023.66
GBQ (b=1b=1)Diagonal0.8723.77
GBQ (b=1b=1) + global rotationDiagonal0.9123.83
GBQ (Ours)General0.6924.50

Joint global rotation and scaling still fall well short of full GBQ, supporting the importance of non-separable coupling beyond orientation and scaling.

W4: Reconstruction Improvements Across Seeds

Thank you for suggesting repeated-run evaluations. We trained WeTok and GBQ with three seeds under the same 250K-step setting. The mean ± sample standard deviation is:

MethodPSNR ↑rFID ↓LPIPS-V ↓
WeTok23.987 ± 0.0960.8313 ± 0.03130.1633 ± 0.0030
GBQ24.526 ± 0.0190.6896 ± 0.00530.1586 ± 0.0005

GBQ outperforms WeTok across all three runs, with smaller variation, supporting consistent reconstruction gains. The modest generation improvements may partly benefit from higher tokenizer reconstruction fidelity.

Q1: Mechanism Diagnostics and Frozen Encoder–Decoder Evaluation

Thank you for requesting further details about Fig. 1. The diagnostics used separately trained WeTok and GBQ 250K-step checkpoints under matched settings, rather than shared encoders and decoders. Relative Quantization Residual measures normalized quantization error. STE–Reference Gradient Alignment compares reconstruction pixel MSE gradients through the identity STE with continuous-latent reference gradients. Both metrics are computed per patch token and aggregated by the median.

To control for encoder–decoder co-adaptation, we froze both models' encoders, decoders, and projections. Each checkpoint retained its native quantizer; GBQ was additionally fitted to frozen WeTok features for 10K steps using latent MSE, while WeTok's fixed sign assignment was applied directly to GBQ features.

Relative Quantization Residual ↓

QuantizerWeTok FrozenGBQ Frozen
WeTok0.480.82
GBQ0.480.15

STE–Reference Gradient Alignment ↑

QuantizerWeTok FrozenGBQ Frozen
WeTok0.610.34
GBQ0.730.89

On the frozen WeTok network, GBQ matches the residual while improving gradient alignment. On the frozen GBQ network, WeTok's fixed sign assignment yields much higher residual and lower alignment. These results show that learnable code geometry adapts to different latent representations, with benefits persisting without further encoder–decoder updates.

We sincerely thank you again for the detailed and constructive feedback. In our rebuttal, we provided additional controlled comparisons, geometric ablations, and frozen-network analyses to address your concerns. We have also refined the methodological discussion in Sections 2.1 and 3.2 and incorporated the additional experimental results into Appendix F of the revised manuscript.

As the discussion period is approaching its end, we would greatly appreciate it if you could let us know whether our responses have adequately addressed your concerns. We remain at your disposal for any additional clarification you may need.

Thank you once again for your time and consideration.

Reviewer_iFVtOpenReview ↗

Follow-up on the author response

Thanks to the authors for the extra experiments. The diagonal-Gram control and the multi-seed results are convincing, and I appreciate the effort. That said, my main concern hasn’t changed. GBQ is essentially a constrained version of product quantization: it gives up the lookup-free property that defines LFQ, yet it can never be more expressive than unconstrained PQ. The binary-state constraint may well act as a useful inductive bias, but I don’t think that alone is enough of a contribution. So I’ll keep my score.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.