Spherical Leech Quantization for Visual Tokenization and Generation

TL;DR

Λ24-SQ proposes a non-parametric image quantizer with a fixed, ~196K-vector codebook built from the Leech lattice’s first shell on the unit hypersphere. The framing is the paper’s central contribution: it unifies BSQ, FSQ, and related lookup-free quantizers under lattice coding, shows that the awkward entropy / commitment penalties used by prior NPQ recipes are really lattice relocation problems, and then proposes the densest hypersphere-packing lattice (Leech in 24 dimensions) as the principled choice. The result is a quantizer that needs no auxiliary loss terms during autoencoder training, gets state-of-the-art rate-distortion across all reconstruction metrics at slightly lower bit-rate than BSQ, and — for the first time on a discrete visual autoregressive generator — operates with a ~200K codebook without index subgrouping, multihead prediction, or self-correction tricks.

Key claims

A unified lattice-coding formulation covers BSQ, FSQ, and related non-parametric quantization methods; entropy penalties in those methods are equivalent to lattice relocation moves, which makes the choice of lattice the central design lever rather than the regularizer [§3.1, §3.2].
The densest hypersphere-packing lattice in 24 dimensions is the Leech lattice; using its first shell as a normalized codebook (~196,560 vectors on $S^{23}$ ) is the natural quantizer under this formulation [§3.3].
Λ24-SQ removes the entropy / commitment auxiliary losses that BSQ and prior NPQ variants require — training is reconstruction-only and stable [Abstract, §3.2].
On ImageNet-1K and Kodak image-compression benchmarks, Λ24-SQ beats BSQ across all reconstruction metrics while consuming slightly fewer bits per token [Abstract].
Λ24-SQ scales discrete visual autoregression to ~200K codebook size — comparable to frontier language-model vocabulary — without index subgrouping, multi-head prediction, or bit-flip self-correction [§Intro].
Near-oracle generation performance on ImageNet under the large-codebook setting [Abstract].

Method

The encoder is a standard ViT autoencoder that emits per-patch feature vectors $z \in \mathbb{R}^{24}$ projected onto the unit hypersphere. The quantizer maps each $z$ to its nearest codebook vector $c_i \in C$ , where $C$ is the set of ~196,560 minimal-norm points of the Leech lattice $\Lambda_{24}$ scaled onto $S^{23}$ . There is no learned codebook: $C$ is fixed and known analytically. The decoder reconstructs the image from the quantized stream. Training is purely reconstruction (L1 + LPIPS + adversarial in the standard recipe), no entropy or commitment loss.

The lattice-coding framing in §3 makes this concrete. Prior NPQ methods (FSQ rounds onto an axis-aligned grid; BSQ rounds onto vertices of a hypercube) implicitly choose some lattice. The auxiliary losses they need exist to push codes toward used lattice points — a relocation operation. The Leech lattice’s extreme symmetry (largest kissing number in known low dimensions, isotropic angular distribution) means used codes are already evenly distributed on the sphere, so no relocation is needed and no regularizer is required. A side benefit is that nearest-neighbor lookup in $\Lambda_{24}$ has efficient closed-form decoders (Conway–Sloane), so the ~200K codebook does not impose the standard VQ argmax cost.

Results

The headline experiments are on (i) reconstruction-compression for image tokenization (ImageNet-1K) and image compression (Kodak), and (ii) discrete visual autoregressive generation on ImageNet. On reconstruction, Λ24-SQ beats BSQ (the previously-strongest lookup-free quantizer) on every reported metric — rFID, PSNR, SSIM, LPIPS — while using slightly fewer bits per token [Abstract]. On generation, the headline is the absence of the usual workarounds: a single AR head, a single ~200K-entry softmax, no codebook subgrouping, no bit-flipping correction, and the resulting model reaches near-oracle gFID on ImageNet [§Intro]. The paper positions this against the broader argument that scaling discrete visual generation to LM-scale codebooks has previously required engineering crutches (subgrouped heads, multi-token prediction, bit self-correction) precisely because the quantizer was the wrong primitive.

Why it’s interesting

This is the discrete-tokenizer counterpart to the continuous-VAE tokenizer arc the wiki has been tracking. The continuous side (Diffusion Transformers with Representation Autoencoders, Towards Scalable Pre-training of Visual Tokenizers for Generation, One Layer Is Enough: Adapting Pretrained Visual Encoders for Image Generation, Unified Latents (UL): How to train your latents) argues “redesign the latent / encoder so the downstream generator doesn’t have to fight it.” Λ24-SQ makes the same move on the discrete side — redesign the quantizer (its codebook geometry, not the loss menu around it) so the AR generator gets a workable ~200K vocabulary without index-subgrouping crutches. The lattice-coding framing also sharpens Making Reconstruction FID Predictive of Diffusion Generation FID‘s mechanism for why tokenizers fail downstream: BSQ-style codes have non-uniform angular distribution on the sphere, which biases the implicit interpolation structure of the latent — exactly the kind of geometry-of-the-latent problem iFID was built to detect.

The “no auxiliary losses needed” claim is the load-bearing engineering result. BSQ and FSQ both ship with hand-tuned entropy / commitment penalties that researchers report as fiddly to balance; removing them removes a common source of tokenizer-training instability. The other potentially load-bearing claim — that ~200K codebook works without subgrouping / MTP / self-correction — is worth a hard read against Image Tokenizer Needs Post-Training‘s thesis that generator-induced errors are the real downstream problem for discrete tokenizers. RobusTok’s post-training fix may compose with Λ24-SQ even if the quantizer alone closes most of the gap.