An Image is Worth 32 Tokens for Reconstruction and Generation

Introduction

In recent years, image generation has experienced remarkable progress, driven by the significant advancements in both transformers and diffusion models . Mirroring the trends in generative language models , the architecture of many contemporary image generation models incorporate a standard image tokenizer and de-tokenizer. This array of models utilizes tokenized image representations—ranging from continuous to discrete vectors —to perform a critical function: translating raw pixels into a latent space. The latent space (e.g., $32\times 32$) is significantly more compact than the original image space ($256\times 256\times 3$). It offers a compressed yet expressive representation, and thus not only facilitates efficient training and inference of generative models but also paves the way to scale up the model size.

Although image tokenizers achieve great success in image generation workflows, they encounter a fundamental limitation tied to their intrinsic design. These tokenizers are based on an assumption that the latent space should retain a 2D structure, to maintain a direct mapping for locations between the latent tokens and image patches. For example, the top-left latent token directly corresponds to the top-left image patch. This restricts the tokenizer’s ability to effectively leverage the redundancy inherent in images to cultivate a more compressed latent space.

Taking one step back, we raise the question “is 2D structure necessary for image tokenization?” To answer the question, we draw inspiration from several image understanding tasks where model predictions are based solely on high-level information extracted from input images —such as in image classification , object detection , segmentation , and multi-modal large language models . These tasks do not need de-tokenizers, since the outputs typically manifest in specific structures other than images. In other words, they often format a higher-level 1D sequence as output that can still capture all task-relevant information. Prior arts, such as object queries or the perceiver resampler , encode images into a 1D sequence of a predetermined number of tokens (e.g., 64). These tokens facilitate the generation of outputs like bounding boxes or captions. The success of these methods motivates us to investigate a more compact 1D sequence as image latent representation in the context of image reconstruction and generation. It is noteworthy that the synthesis of both high-level and low-level information is crucial for the generation of high-quality images, providing a challenge for extremely compact latent representations.

In this work, we introduce a transformer-based framework designed to tokenize an image to a 1D discrete sequence, which can later be decoded back to the image space via a de-tokenizer. Specifically, we present Transformer-based 1-Dimensional Tokenizer (TiTok), consisting of a Vision Transformer (ViT) encoder, a ViT decoder, and a vector quantizer following the typical Vector-Quantized (VQ) model designs . In the tokenization phase, the image is split and flattened into a series of patches, followed by concatenation with a 1D sequence of latent tokens. After the feature encoding process of ViT encoder, these latent tokens build the latent representation of the image. Subsequent to the vector quantization step , the ViT decoder is utilized to reconstruct the input images from the masked token sequence .

Building upon TiTok, we conduct extensive experiments to probe the dynamics of 1D image tokenization. Our investigation studies the interplay between latent space size, model size, reconstruction fidelity, and generative quality. From this exploration, several compelling insights emerge:

Increasing the number of latent tokens representing an image consistently improves the reconstruction performance, yet the benefit becomes marginal after 128 tokens. Intriguingly, 32 tokens are sufficient for a reasonable image reconstruction.

Scaling up the tokenizer model size significantly improves performance of both reconstruction and generation, especially when number of tokens is limited (e.g., 32 or 64), showcasing a promising pathway towards a compact image representation at latent space.

1D tokenization breaks the grid constraints in prior 2D image tokenizers, which not only enables each latent token to reconstruct regions beyond a fixed image grid and leads to a more flexible tokenizer design, but also learns more high-level and semantic-rich image information, especially at a compact latent space.

1D tokenization exhibits superior performance in generative training, with not only a significant speed-up for both training and inference but also a competitive FID score compared to a typical 2D tokenizer, while using much fewer tokens.

In light of these findings, we introduce the TiTok family, encompassing models of varying model sizes and latent sizes, capable of achieving highly compact tokenization with as few as 32 tokens. We further confirm the model’s efficacy in image generation through the MaskGIT framework. TiTok is demonstrated to facilitate state-of-the-art performance in image generation, while requiring latent spaces that are $8\times$ to $64\times$ smaller, resulting in significant accelerations during both the training and inference phases. It also generates images with similar or higher quality but up to $410\times$ faster than state-of-the-art diffusion models such as DiT (Fig. 2).

Related Work

Image Tokenization. Images have been compressed since the early days of deep learning with autoencoders . The general design of using an encoder that compresses high-dimensional images into a low-dimensional latent representation and then using a decoder to reverse the process, has proven to be successful over the years. Variational Autoencoders (VAEs) extend the paradigm by learning to map the input to a distribution. Instead of modeling a continuous distribution, VQ-VAEs learn a discrete representation forming a categorical distribution. VQGAN further improves the training process by using adversarial training . The transformer design of the autoencoder is further explored in ViT-VQGAN and Efficient-VQGAN . Orthogonal to this, RQ-VAE and MoVQ study the effect of using multiple vector quantization steps per latent embedding, while MAGVIT-v2 and FSQ propose a lookup-free quantization. However, all aforementioned works share the same workflow of an image always being patchwise encoded into a 2D grid latent representation. In this work, we explore an innovative 1D sequence latent representation for image reconstruction and generation.

Tokenization for Image Understanding. For image understanding tasks (e.g., image classification , object detection , segmentation , and Multi-modal Large Language Models (MLLMs) ), it is common to use a general feature encoder instead of an autoencoder to tokenize the image. Specifically, many MLLMs uses a CLIP encoder to tokenize the image into highly semantic tokens, which proves effective for image captioning and VQA . Some MLLMs also explore discrete tokens or “de-tokenize” the CLIP embeddings back to images through diffusion models . However, due to the nature of CLIP models that focus on high-level information, these methods can only reconstruct an image with high-level semantic similarities (i.e., the layouts and details are not well-reconstructed due to CLIP features). Therefore, our method is significantly different from theirs, since the proposed TiTok aims to reconstruct both the high-level and low-level details of an image, same as typical VQ-VAE tokenizers .

Image Generation. Image generation methods range from sampling the VAE , using GANs to Diffusion Models and autoregressive models . Prior studies that are most related to this work build on top of a learned VQ-VAE codebook to generate images. Autoregressive transformer , similar to decoder-only language models, model each patch in a step-by-step fashion, thus requiring as many steps as token number, e.g., 256 or 1024. Non-autoregressive (or bidirectional) transformers , such as MaskGIT , generally predict more than a single token per step and thus require significantly fewer steps to predict a complete image. Apart from that, further studies looked into improved sampling strategies . As we focus on the tokenization stage, we apply the commonly used non-autoregressive sampling scheme of MaskGIT to generate a sequence of tokens that is later decoded into an image.

Method

The image tokenizer plays a pivotal role in facilitating the generative models by providing a compact image representation at latent space. For the scope of our discussion, we primarily focus on the Vector-Quantized (VQ) tokenizer , given its broad applicability across various domains, including but not limited to image and video generation , large-scale pretraining and multi-modal models .

During de-tokenization, the reconstructed image $\mathbf{\hat{I}}$ is obtained via the decoder $Dec$ as follows:

Despite the numerous improvements over VQ-VAE (e.g., loss function , model architecture , and quantization/codebook strategies ), the fundamental workflow (e.g., the 2D grid-based latent representations) has largely remained unchanged.

2 TiTok: From 2D to 1D Tokenization

While existing VQ models have demonstrated significant achievements, a notable limitation within the standard workflow exists: the latent representation $\mathbf{Z}_{2D}$ is often envisioned as a static 2D grid. Such a configuration inherently assumes a strict one-to-one mapping between the latent grids and the original image patches. This assumption limits the VQ model’s ability to fully exploit the redundancies present in images, such as similarities among adjacent patches. Additionally, this approach constrains the flexibility in selecting the latent size, with the most prevalent configurations being $f=4$, $f=8$, or $f=16$ , resulting in $4096$, $1024$, or $256$ tokens for an image of dimensions $256\times 256\times 3$. Inspired by the success of 1D sequence representations in addressing a broad spectrum of computer vision problems , we propose to use a 1D sequence, without the fixed correspondence between latent representation and image patches in 2D tokenization, as an efficient and effective latent representation for image reconstruction and generation.

where $\oplus$ denotes concatenation, and we only retain the latent tokens from the encoder output.

where the latent tokens $\mathbf{Z}_{1D}$ is first vector-quantized by $Quant$ and then concatenated with the mask tokens $\mathbf{M}$ before feeding to the decoder $Dec$.

Despite its simplicity, we emphasize that the concept of compact 1D image tokenization remains underexplored in existing literature. The proposed TiTok thus serves as a foundational platform for exploring the potentials of 1D tokenization and de-tokenization for natural images. It is worth noting that although one may flatten 2D grid latents into a 1D sequence, it significantly differs from the proposed 1D tokenizer, due to the fact that the implicit 2D grid mapping constraints still persist.

Image Generation with TiTok. Besides the image reconstruction task which the tokenizer is trained for, we also evaluate its effectiveness for image generation, following the typical pipeline . Specifically, we adopt MaskGIT as our generation framework due to its simplicity and effectiveness, allowing us to train a MaskGIT model by simply replacing its VQGAN tokenizer with our TiTok. We do not make any other specific modifications to MaskGIT, but for completeness, we briefly describe its whole generation process with TiTok.

The image is pre-tokenized into 1D discrete tokens. At each training step, a random ratio of the latent tokens are replaced with mask tokens. Then, a bidirectional transformer takes the masked token sequence as input, and predicts the corresponding discrete token ID of those masked tokens. The inference process consists of multiple sampling steps, where at each step the transformer’s prediction for masked tokens will be sampled based on the prediction confidence, which are then used to update the masked images. In this way, the image is “progressively generated” from a sequence full of mask tokens to an image with generated tokens, which can later be de-tokenized back into pixel spaces. The MaskGIT framework shows a significant speed-up in the generation process compared to auto-regressive models. We refer readers to for more details.

3 Two-Stage Training of TiTok with Proxy Codes

Existing Training Strategies for VQ Models. Although most VQ models adhere to a straightforward formulation, their training process is notably sensitive, and the model’s performance is heavily influenced by the adoption of more effective training paradigms. For instance, VQGAN achieves a significant improvement in reconstruction FID (rFID) on the ImageNet validation set, when compared to dVAE from DALL-E . This enhancement is attributed to advancements in perceptual loss and adversarial loss . Moreover, MaskGIT’s modern implementation of VQGAN utilizes refined training techniques without architectural improvements to boost the performance further. Notably, most of these improvements are exclusively applied during the training phase (i.e., through auxiliary losses) and significantly affect the models’ efficacy. Given the complexity of the loss functions, extensive tuning of hyper-parameters involved, and, most critically, the missing of a publicly available code-base for reference or reproduction , establishing an optimal experimental setup for the proposed TiTok presents a substantial challenge, especially when the target is a compact 1D tokenization which was rarely studied in literature.

Two-Stage Training Comes to the Rescue. Although training TiTok with the typical Taming-VQGAN setting is feasible, we introduce a two-stage training paradigm for an improved performance. The two-stage training strategy contains “warm-up” and “decoder fine-tuning” stages. Specifically, in the first “warm-up” stage, instead of directly regressing the RGB values and employing a variety of loss functions (as in existing methods), we propose to train 1D VQ models with the discrete codes generated by an off-the-shelf MaskGIT-VQGAN model, which we refer to as proxy codes. This approach allows us to bypass the intricate loss functions and GAN architectures, thereby concentrating our efforts on optimizing the 1D tokenization settings. Importantly, this modification does not harm the functionality of the tokenizer and quantizer within TiTok, which can still fully function for image tokeniztion and de-tokenization; the main adaptation simply involves the processing of TiTok’s de-tokenizer output. Specifically, this output, comprising a set of proxy codes, is subsequently fed into the same off-the-shelf VQGAN decoder to generate the final RGB outputs. It is noteworthy that the introduction of proxy codes differs from a simple distillation . As verified in our experiments, TiTok yields significantly better generation performance than MaskGIT-VQGAN.

After the first training stage with proxy codes, we optionally have the second “decoder fine-tuning” stage, inspired by , to improve the reconstruction quality. Specifically, we keep the encoder and quantizer frozen, and only train the decoder towards pixel space with the typical VQGAN training recipe . We observe that such a two-stage training strategy significantly improves the training stability and reconstructed image quality, as shown in the experiments.

Experimental Results

Building upon TiTok, we explore a range of configurations, including the model size and the number of tokens, to identify the most efficient and effective setup for a 1D image tokenizer. These preliminary experiments serve to provide a thorough evaluation, seeking a practical configuration of TiTok.

Evaluation Protocol. Evaluation is conducted across multiple metrics to thoroughly assess the models, including both reconstruction and generation FID metrics (i.e., rFID and gFID) on the ImageNet dataset. We examine training/inference throughput to offer a direct comparison of generative model’s efficiency relative to different latent sizes. Furthermore, given that the 1D VQ model inherently serves as a form of compact image compression, we further investigate the semantic information retained by the model through linear probing following MAE setting . For the complete details of the training and testing protocols (e.g., hyper-parameters, training costs), we refer the reader to the supplementary material Sec. A.

After the setup, we now summarize the preliminary experimental findings below.

An Image Can be Represented by 32 Tokens. The redundancy inherent in image representation is well-acknowledged, as evidenced by the practice of masking significant portions of images (e.g., 75% in MAE ) to expedite the training process without negatively affecting performance. This strategy has been validated across a variety of computer vision tasks that rely on high-level image features . However, the efficacy of such approaches in the context of image reconstruction and generation—where both low-level and high-level details are crucial for creating realistic reconstructed and generated outputs—remains underexplored. Consequently, in this experiment, we aim to determine the minimum number of tokens required to reconstruct and generate high-quality images. As depicted in Fig. 4a, although model performance progressively improves with an increase in the number of latent tokens, significant enhancements are predominantly observed when $K$ ranges from $16$ to $128$. Beyond this point, increasing the latent space size yields only marginal gains. Intriguingly, we find that with merely $32$ latent tokens, TiTok-L achieves performance better than a 2D VQGAN model using 256 tokens. This observation suggests that as few as $32$ tokens may suffice as an effective image latent representation, optimizing the utilization of image redundancy.

Scaling Up Tokenizer Enables More Compact Latent Size. Another intriguing observation from Fig. 4a is that larger tokenizers facilitate more compact representations. Specifically, TiTok-B with $64$ latent tokens achieves performance comparable to TiTok-S with $128$ latent tokens, while TiTok-L with $32$ latent tokens matches the performance of TiTok-B with $64$ latent tokens. This pattern indicates that with each incremental increase in TiTok size (e.g., from S to B, or from B to L), it is possible to reduce the size of the latent image representation without compromising performance. This trend underscores the potential benefits of scaling up the tokenizer to achieve even more compact image representations.

Semantics Emerges with Compact Latent Space. To evaluate the learned image representation, we perform linear probing experiments on the image tokenizer, as shown in Fig. 4b. Specifically, we add a batch normalization layer followed by a linear layer on top of the frozen features from TiTok encoder, with all hyper-parameters strictly following the MAE protocol . We find that as the size of the latent representation decreases, the tokenizer increasingly learns semantically rich representations, as indicated by the improved linear probing accuracy. This suggests that the model learns high-level information in scenarios of constrained representation space.

Compact Latent Representation Improves Generative Training. In addition to reconstruction capabilities, we assess TiTok’s effectiveness and efficiency in generative downstream tasks, as illustrated in Fig. 4c and Fig. 4d. We note that variants of different tokenizer sizes yield comparable outcomes when the number of latent tokens is sufficiently large (i.e., $K\geq 128$). However, within the domain of compact latent sizes (i.e., $K\leq 64$), larger tokenizers notably enhance performance. Furthermore, the adaptability of 1D tokenization in TiTok facilitates more efficient and effective generative model training. For instance, model variants with $K=32$, despite inferior reconstruction quality, demonstrate significantly better generative performance, underscoring the advantages of employing a more condensed and semantically rich latent space for generative model training. Additionally, the reduction in latent tokens markedly accelerates training and inference, with a $12.8\times$ increase in training speed (2815.2 vs. 219.7 samples/s/gpu) and a $4.5\times$ speed up sampling speed (123.1 vs. 27.5 samples/s/gpu), when utilizing $K=32$ as opposed to $K=256$.

2 Main Experiments

Based on the observations above, the proposed TiTok family effectively trades off a larger model size to a more compact latent size. In this section, we majorly focus on ImageNet generation benchmarks against prior arts, and evaluate TiTok as a tokenizer in the generative MaskGIT framework .

Implementation Details. We primarily investigate the following TiTok variants: TiTok-S-128 (i.e., small model with 128 tokens), TiTok-B-64 (i.e., base model with 64 tokens), and TiTok-L-32 (i.e., large model with 32 tokens), where each variant designed to halve the latent space size while scaling up the model size. For resolution $512$, we double the latent size to ensure more details are kept at higher resolution, leading to TiTok-L-64 and TiTok-B-128. In the final setting for TiTok training, the codebook is configured to $N=4096$, and the training duration is extended to $1M$ iterations (200 epochs). We also adopt the “decoder fine-tuning” stage to further enhance model performance, where the encoder and quantizer are kept frozen and the decoder is fine-tuned for $500k$ iterations. For the training of generative models, we utilize the MaskGIT framework without any specific modifications, except for the adoption of an arccos masking schedule . All other parameters are the same as previous setups, and all design improvements will be verified in the ablation studies.

Main Results. We summarize the results on ImageNet-1K generation benchmark of resolution $256\times 256$ and $512\times 512$ in Tab. 1 and Tab. 2, respectively.For fairness, we mainly consider tokenizers with vanilla VQ modules. More advanced quantization methods may further benefit TiTok but beyond this paper’s focus on 1D image tokenization. See supplementary material Sec. C for the complete table.

For ImageNet $256\times 256$ results in Tab. 1, TiTok can achieve a similar level of reconstruction FID (rFID) with a much smaller number of latent tokens than other VQ models. Specifically, using merely $32$ tokens, TiTok-L-32 achieves a rFID of $2.21$, comparable to the well trained VQGAN from MaskGIT (rFID 2.28), while using $8\times$ smaller latent representation size. Furthermore, when using the same generator framework and same sampling steps, TiTok-L-32 improves over MaskGIT by a large margin (from $6.18$ to $2.77$ gFID), showcasing the benefits of a more effective generator training with compact 1D tokens. When compared to other diffusion-based generative models, TiTok can also achieve a competitive performance while enjoying an over $\mathbf{100\times}$ speed-up during the sampling process. Specifically, TiTok-L-32 achieves a better gFID than LDM-4 (2.77 vs. 3.60), while generating images dramatically faster by 254 times (101.6 samples/s vs. 0.4 samples/s). Our best-performing variant TiTok-S-128 outperforms state-of-the-art diffusion method DiT-XL/2 (gFID $1.97$ vs. $2.27$), with a $13\times$ speed-up.

For ImageNet $512\times 512$ results in Tab. 2, the significantly better accuracy-cost trade-off of TiTok persists. TiTok maintains a reasonably good rFID compared to other methods, especially considering that TiTok uses much fewer tokens (i.e., higher compression ratio). For generation, all TiTok variants significantly outperform our baseline MaskGIT by a large margin. When compared with diffusion-based models, TiTok-L-64 shows a superior performance to DiT-XL/2 ($2.74$ vs. $3.04$), while running $\mathbf{410\times}$ faster. The best-performing variant TiTok-B-128 can significantly outperform DiT-XL/2 by a large margin (2.13 vs. 3.04) but also generates high-quality samples $\mathbf{74\times}$ faster. We also provide visualization results and analysis in supplementary material Sec. D.

3 Ablation Studies

We report the ablation studies regarding our final model designs in Tab. 3. Specifically, in Tab. 3(a), we ablate the tokenizer designs on image reconstruction. We begin with our baseline TiTok-L-32 which attains 6.59 rFID. Employing a larger codebook size improves the rFID by 0.74, while further increasing the training iterations (from 100 epochs to 200 epochs) yields another 0.37 improvement of rFID. On top of that, the “decoder fine-tuning” (our stage-2 training strategy) can substantially improve the overall reconstruction performance to 2.21 rFID.

In Tab. 3(b), we examine the effects of different masking schedules for MaskGIT with TiTok. Interestingly, unlike the original MaskGIT setting which empirically found that the cosine masking schedule significantly outperforms the other schedules, we observe that MaskGIT equipped with TiTok changes the preference to the arccos or linear schedules. Additionally, unlike which reported that the root schedule performs much worse than the others, we observe that TiTok is quite robust to different masking schedules. We attribute the observations to TiTok’s ability to provide a more compact and more semantic meaningful tokens compared to 2D VQGAN, as compared to the cosine masking schedule, linear and arccos schedules have a lower masking ratio in the early steps. This coincides with the observation that masking ratio is usually higher for redundant signals (e.g., 75% masking ratio in images ) while relatively lower for semantic meaningful inputs (e.g., 15% masking ratio in languages ).

We ablate the effects of training paradigm in Tab. 3(c). We begin with the training setting of Taming-VQGAN , where TiTok-B-64 obtains 5.15 rFID, outperforming the original 2D Taming-VQGAN’s 7.94 rFID under the same training setting. We also show the necessity of 1D tokenization by building a 2D variant of TiTok-B64, where the architecture remains the same except that image patches instead of latent tokens are used as image representation. As a result, we observe that the 2D variant suffers from a much worse performance (15.58 vs. 5.15 rFID), since the fixed correspondences in 2D tokenization limited a reasonable reconstruction under compact latent space. This result demonstrates the effectiveness of the proposed 1D tokenization, especially at a much more compact latent size. Although TiTok can achieve a reasonably well performance under straightforward single-stage training, there exists a performance gap compared to the MaskGIT-VQGAN due to the missing of a strong training recipe, of which no public reference or access exists. Therefore, we adopt the two-stage training with proxy codes, which proves to be effective and can outperform the MaskGIT-VQGAN (1.70 vs. 2.28 rFID). It is noteworthy that the two-stage training is not that crucial to obtain a reasonable 1D tokenizer, and we believe that TiTok, with the simple single-stage Taming-VQGAN’s training setting, could also benefit from training on a lagrer-scale dataset as demonstrated in and we leave it for future work due to the limited compute.

Conclusion

In this paper, we have explored a compact 1D tokenization TiTok for reconstructing and generating natural images. Unlike the existing 2D VQ models that consider the image latent space as a 2D grid, we provide a more compact formulation to tokenize an image into a 1D latent sequence. The proposed TiTok can represent an image with $8$ to $64$ times fewer tokens than the commonly used 2D tokenizers. Moreover, the compact 1D tokens not only significantly improve the generation model’s training and inference throughput, but also achieve a competitive FID on the ImageNet benchmarks. We hope our research can shed some light in the direction towards more efficient image representation and generation models with 1D image tokenization.

References

Appendix

In the supplementary materials, we provide the following additional details:

The comprehensive training and testing hyper-parameters and training costs for TiTok (Sec. A).

The detailed results of the preliminary experiments reported in main paper’s Fig. 4(Sec. B).

A more comprehensive comparison with more metrics and baselines (Sec. C).

Appendix A Training and Testing Protocols

For image reconstruction (tokenizer) at preliminary experiments, the training augmentation is confined to random cropping and flipping, following . The training regimen spans a short schedule, featuring a batch size of $256$ over $500k$ training iterations, which correlates to roughly $100$ epochs on the ImageNet dataset. We employ the AdamW optimizer with an initial learning rate of $1\times 10^{-4}$ (with cosine decay) and weight decay $1\times 10^{-4}$. We only adopt stage-1 training here (i.e., only the “warm-up” training stage). For the main experiments, we adopt the improvements as shown in the ablation study (Tab. 3 in main paper), including longer training to $200$ epochs and decoder fine-tuning, all other hyper-parameters remain the same. We use patch size $16$ for all vision transformers at resolution $256\times 256$ and increase it to $32$ for resolution $512\times 512$ to ensure a computation efficiency.

TiTok-L refers to using a ViT-L for TiTok encoder and decoder, and TiTok-B, TiTok-S refers to using ViT-B and ViT-S respectively. Moreover, the tokenizer training takes 64 A100-40G for 74 hours (TiTok-L-32), 32 A100-40G for 41 hours (TiTok-B-64), 32 A100-40G for 50 hours (TiTok-S-128), 32 A100-40G for 70 hours (TiTok-B-128 for resolution 512), and 64 A100-40G for 91 hours (TiTok-L-64 for resolution 512), respectively.

For image generation (generator) at preliminary experiments, we majorly build the training and testing protocols on top of . Specifically, all images are pre-tokenized using center crop and random flipping augmentation, and then processed by MaskGIT to generate images via the masked image modeling procedure. During inference, a cosine masking schedule is utilized with 8 steps. The generative models are trained with a batch size of $2048$ and $500k$ iterations to improve training efficiency. We use AdamW optimizer with learning rate $2\times 10^{-4}$ and weight decay $0.03$. The learning rate starts from $2\times 10^{-4}$ and then decay to $1\times 10^{-5}$ following a cosine decaying schedule. We apply a dropout probability of $0.1$ on the class condition. The only differences of main experiments are using an arccos masking schedule as discussed in the ablation study (main paper Tab. 3), all other hyper-parameters remain the same. We follow prior arts to generate $50k$ samples for generation FID evaluation. We also adopt classifier-free guidance following prior arts .

At ImageNet $256\times 256$, we use guidance scale 4.5, temperature 9.5 for TiTok-L-32, guidance scale 3.0, temperature 11.0 for TiTok-B-64, guidance scale 2.0, temperature 3.0 for TiTok-S-128. At ImageNet $512\times 512$, we use guidance scale 2.0, temperature 7.5 for TiTok-L-64, guidance scale 2.5, temperature 6.5 for TiTok-B-128.

The generator training takes 32 A100-40G for 12 hours (TiTok-L-32), 16 hours (TiTok-B-64), 29 hours (TiTok-S-128), 26 hours (TiTok-B-128 for resolution 512), 18 hours (TiTok-L-64 for resolution 512) respectively.

Appendix B Detailed Results of Preliminary Experiments

We summarize the detailed results for Fig. 4 of main paper in Tab. 4.

Appendix C Additional Results

We further report the class-conditional generation results comparison with more metrics and baselines in Tab. 5 and Tab. 6 for ImageNet $256\times 256$ and $512\times 512$ generation benchmarks, respectively. Moreover, we report both results without and with classifier-free guidance under column “w/o guidance" and “w/ guidance" respectively.

As shown in Tab. 5, both TiTok-L-32 and TiTok-B-64 set a new state-of-the-art performance for results without classifier-free guidance (i.e., w/o guidance column), while generating images at a much faster pace. Specifically, TiTok-L-32 achieves $3.15$ gFID, surpassing current state-of-the-art MAGVIT-v2 ’s gFID $3.65$, while requiring much fewer sampling steps ($8$ vs. $64$) and smaller model size ($177M$ vs. $307M$), leading to a substantial sampling speed-up ($92.4\times$ faster, $101.6$ vs. $1.1$ samples/sec). Additionally, when compared to MaskGIT , which uses the exact same generator model (i.e., MaskGIT-ViT) as ours and the only difference is the toeknizer, TiTok-L-32 achieves significantly a better performance ($3.15$ vs. $6.18$). The improvement demonstrates the efficiency and effectiveness of the learned compact 1D latent space for image representation. When it comes to resolution $512\times 512$ in Tab. 6, MaskGIT requires $1024$ tokens for image latent representation, while TiTok-L-64 requires $16\times$ fewer. As a result, when using the same generator (i.e., MaskGIT-ViT), TiTok-L-64, w/o classifier-free guidance, not only significantly outperforms MaskGIT in terms of gFID ($3.64$ vs. $7.32$) but also generates samples much faster. The advantages of TiTok become even more significant when compared to the diffusion models such as DiT-XL/2 with guidance: TiTok-L-64 not only shows a superior performance ($2.74$ vs. $3.04$), but also enjoys a dramatically higher generation throughput ($410\times$).

An interesting observation is that under w/o guidance case, TiTok-L-32 (for 256 resolution) and TiTok-L-64 (for 512 resolution) can outperform most other methods, including TiTok-S-128 and TiTok-B-128, yet they benefit relatively less from the classifier-free guidance in the w/ guidance column. We note it indicates that the great potential of TiTok at compact latent size is still not fully unleashed yet, and better adaptation of inference time improvements for 1D compact tokens, such as classifier-free guidance, which was designed for methods with much more tokens and steps, could be a promising future direction.

Appendix D Visualizations

We provide visualization of the generated images using TiTok in Fig. 5 and Fig. 6. Moreover, we visualize the reconstruction results under different numbers of tokens and different model sizes in Fig. 7, where we observe that the model tends to keep the high-level layout or salient objects when the latent representation size is limited. Besides, a larger model size reconstructs an image with more details under a compact latent space size, demonstrating an effective way towards a more compact latent space.

Appendix E Limitations

This paper proposes a novel 1D tokenization method designed to eliminate the fixed corresponding constraints of existing 2D tokenization methods. The 1D tokenization model is validated using the Vector Quantization (VQ) tokenizer formulation alongside a Masked Transformer generator framework. Despite the promising results, the proposed 1D tokenization formulation theoretically has the potential to generalize to other tokenizer formulations (e.g., 1D-VAE), other generation frameworks (e.g., Diffusion Models), and beyond the image modality (e.g., video). However, exploring these extensions is beyond the scope of this paper due to limited computational resources, and we leave these as promising directions for future research.

Appendix F Broader Impacts

Generative models have numerous applications with diverse potential social impacts. While these models significantly enhance human creativity, they can also be misused for misinformation, harassment, and perpetuating social and cultural biases. Similar to other deep learning methods, generative models can be heavily influenced by dataset biases, leading to the reinforcement of negative social stereotypes and viewpoints. Developing unbiased models that ensure both robustness and fairness is a critical area of research. However, addressing these issues is beyond the scope of this paper. Considering the potential risks, this paper is limited to class-conditional generation using a fixed, public, and controlled set of classes.

Appendix G Dataset Licenses

The datasets we used for training and/or testing TiTok are described as follows.

ImageNet-1K: We train and evaluate TiTok on ImageNet-1K generation benchmark. This dataset spans 1000 object classes and contains 1,281,167 training images, 50,000 validation images and 100,000 test images. We use the training set for our tokenizer and generator training. The validation set is used to compute reconstruction FID for evaluating tokenizers. The generation results are evaluated with generation FID using pre-computed statistics and scripts from ADM https://github.com/openai/guided-diffusion/tree/main/evaluations.

License: https://image-net.org/accessagreement