Year: 2021

Abstract:
Vision Transformer (ViT) is emerging as the state-of-the-art architecture for image recognition. While recent studies suggest that ViTs are more robust than their convolutional counterparts, our experiments find that ViTs trained on ImageNet are overly reliant on local features (e.g., nuisances and texture) and fail to make adequate use of global context (e.g., shape and structure). ViTs thus have difficulties generalizing to out-of-distribution, real-world data. To address this deficiency, we present a simple and effective architecture modification to ViT’s input layer by adding discrete tokens produced by a vector-quantized encoder. Different from the standard continuous pixel tokens, discrete tokens are invariant under small perturbations and contain less information individually, which promote ViTs to learn global information that is invariant. Experimental results demonstrate that adding discrete representation on four architecture variants strengthens ViT robustness by up to 12% across seven ImageNet robustness benchmarks while maintaining the performance on ImageNet.

heading: 1 INTRODUCTION
text: Despite their high performance on in-distribution test sets, deep neural networks fail to generalize under real-world distribution shifts (Barbu et al., 2019). This gap between training and inference poses many challenges for deploying deep learning models in real-world applications where closedworld assumptions are violated. This lack of robustness can be ascribed to learned representations that are overly sensitive to minor variations in local texture and insufficiently adept at representing more robust scene and object characteristics, such as shape and texture.
Vision Transformer (ViT) (Dosovitskiy et al., 2020) has started to rival Convolutional Neural Networks (CNNs) in many computer vision tasks. Recent works found that ViTs are more robust than CNNs (Paul & Chen, 2021; Mao et al., 2021b; Bhojanapalli et al., 2021) and generalize favorably on a variety of visual robustness benchmarks (Hendrycks et al., 2021b; Hendrycks & Dietterich, 2019). These work suggested that ViTs’ robustness comes from the self-attention architecture that captures a globally-contextualized inductive bias than CNNs.
However, though self-attention is well capable of modeling the global context, recent studies found that ImageNet-trained ViT may not take this advantage. For example, Chen et al. (2021b) compared training ViT on ImageNet with and without using position embedding, and showed that spatial structure captured in position embedding contributes less than ∼3% of ViT’s performance. Without using position embedding, ViT treats the image as an orderless bag-of-patches, but achieves similar performance as ViT with position embedding. This suggests that ViT unintentionally relies on local detail (e.g., texture) than the shape or structure of the object. We hypothesize that this deficiency in robustness comes from the high-dimensional, individually informative, linear tokenization which allows ViT to minimize empirical risk without learning much spatial structure.
In this paper, we propose a simple yet novel input layer for vision transformers, where image patches are represented by discrete tokens. To be specific, we discretize an image and represent an image patch as a discrete token or “visual word” in a codebook. Our key insight is that discrete tokens capture important features in a low-dimensional space (Oord et al., 2017) preserving shape and structure of the object (see Figure 2). Our approach capitalizes on this discrete representation to promote the robustness of ViT. Using discrete tokens drives ViT towards better modeling of spatial interactions between tokens, given that individual tokens no longer carry enough information to
depend on. We also concatenate a low dimensional pixel token to the discrete token to compensate for the potentially missed local details encoded by discrete tokens, especially for small objects.
Our approach only changes the image patch tokenizer to improve generalization and robustness, which is orthogonal to all existing approaches for robustness, and can be integrated into architectures that extend vision transformer. We call the ViT model using our Discrete representation the Dr. ViT.
Our experiments and visualizations show that incorporating discrete tokens in ViT significantly improves generalization accuracy for all seven out-of-distribution ImageNet benchmarks: ImageNetRendition by up to 10%, Stylized-ImageNet by up to 12%, ImageNet-Sketch by up to 10%, and ImageNet-C by up to 10%. Our method establishes the new state-of-the-art by on four benchmarks without any dataset-specific data augmentation. Our work is the first to connect discrete representations to robustness and demonstrate consistent robustness improvements. We will release the code and models to support comparisons and future research.

heading: 2 RELATED WORK
text: Vision Transformer (ViT) (Dosovitskiy et al., 2020), inspired by the Transformer (Vaswani et al., 2017) in NLP, is the first CNN-free architecture that achieves state-of-the-art image classification accuracy. Since its inception, numerous works have proposed improvements to the ViT architecture (Wang et al., 2021; Chu et al., 2021; Liu et al., 2021; d’Ascoli et al., 2021), objective (Chen et al., 2021a), training strategy (Touvron et al., 2021), etc.. Given the difficulty to study all existing ViT models, this paper focuses on the classical ViT model (Dosovitskiy et al., 2020) and its recent published versions. Specifically, Steiner et al. (2021) proposed ViT-AugReg that applies stronger data augmentation and regularization to the ViT model. Tolstikhin et al. (2021) introduced MLPMixer to replace self-attention in ViT with multi-layer perceptions (MLP).
We select the above ViT model family (Dosovitskiy et al., 2020; Steiner et al., 2021; Tolstikhin et al., 2021) in our robustness study for three reasons. First, they represent both the very first and one-of-the-best vision transformers in the literature. Second, these models demonstrated competitive performance when pre-trained on sufficiently large datasets such as ImageNet-21K and JFT-300M. Finally, unlike other Transformer models, they provide architectures consisting of solely Transformer layers as well as a hybrid of CNN and Transformer layers. These properties improve our understanding of robustness for different types of network layers and datasets.
Robustness. Recent works established multiple content robustness datasets to evaluate the out-ofdistribution generalization of deep models (Barbu et al., 2019; Hendrycks et al., 2021b;a; Wang et al., 2019; Geirhos et al., 2019; Hendrycks & Dietterich, 2019; Recht et al., 2019). In this paper, we consider 7 ImageNet robustness benchmarks of real-world test images (or proxies) where deep models trained on ImageNet are shown to suffer from notable performance drop. Existing works on robustness are targeted at closing the gap in a subset of these ImageNet robustness benchmarks and were extensively verified with the CNNs. Among them, carefully-designed data augmentations (Hendrycks et al., 2021a; Cubuk et al., 2018; Steiner et al., 2021; Mao et al., 2021b;a), model regularization (Wang et al., 2019; Huang et al., 2020b; Hendrycks et al., 2019), and multitask learning (Zamir et al., 2020) are effective to address the issue.
More recently, a few studies (Paul & Chen, 2021; Bhojanapalli et al., 2021; Naseer et al., 2021; Shao et al., 2021) suggest that ViTs are more robust than CNNs. Existing works mainly focused on analyzing the cause of superior generalizability in the ViT model and exploring new data augmentations. As our work focuses on discrete token input, we train the models using the same data augmentation as the ViT-AugReg baseline (Steiner et al., 2021). While tailoring data augmentation (Mao et al., 2021b) may further improve our results, we leave it out of the scope of this paper.
Discrete Representation was used as a visual representation prior to the deep learning revolution, such as in bag-of-visual-words model (Sivic & Zisserman, 2003; Csurka et al., 2004) and VLAD model (Arandjelovic & Zisserman, 2013). Recently, (Oord et al., 2017; Vahdat et al., 2018) proposed neural discrete representation to encode an image as integer tokens. Recent works used discrete representation mainly for image synthesis (Ramesh et al., 2021; Esser et al., 2021). To the best of our knowledge, our work is the first to demonstrate discrete representations strengthening robustness. The closest work to ours is BEiT (Bao et al., 2021) that pretrains the ViTs to predict the masked tokens. However, the tokens are discarded after pretraining, where the ViT model can still overfit the non-robust nuisances in the pixel tokens at later finetuning stage, undermining its robustness.
3 1 2 5 4 8 0 1
0 3 5 5 3 2 9 5
Linear Projection
Fine-tuned CodeBook
0 [0.01, 0.2, 0.53, …, 0.04] 1 [0.6, 0.22, 0.83, …, 0.01]
1024 [0.26, 0.75, 0.27, …, 0.98]
Position Embedding
Classification Prediction
Transformer Encoder
Pixel Token Pixel Embedding
Vector Quantized Model
Discrete Token Discrete Embedding
Input Image
Reconstructed Image
*Class Token Decode Figure 1: Overview of the proposed ViT using discrete representations. In addition to the pixel embeddings (orange), we introduce discrete tokens and embeddings (pink) as the input to the standard Transformer Encoder of the ViT model (Dosovitskiy et al., 2020).

heading: 3 METHOD

heading: 3.1 PRELIMINARY ON VISION TRANSFORMER
text: Vision Transformer (Dosovitskiy et al., 2020) is a pure transformer architecture that operates on a sequence of image patches. The 2D image x ∈ RH×W×C is flattened into a sequence of image patches, following the raster scan, denoted by xp ∈ RL×(P
2·C), where L = H×WP 2 is the effective sequence length and P 2×C is the dimension of image patch. A learnable classification token xclass is prepended to the patch sequence, then the position embedding Epos is added to formulate the final input embedding h0.
h0 = [xclass; x 1 pE; x 2 pE; · · · ; xLpE] +Epos, E ∈ R(P 2·C)×D, Epos ∈ R(L+1)×D (1) h′` = MSA(LN(h`−1)) + h`−1, ` = 1, . . . , Lf (2) h` = MLP(LN(h′`)) + h ′ `, ` = 1, . . . , Lf (3)
y = LN(h0L), (4)
The architecture of ViT follows that of the Transformer (Vaswani et al., 2017), which alternates layers of multi-headed self-attention (MSA) and multi-layer perceptron (MLP) with LayerNorm (LN) and residual connections being applied to every block. We denote the number of blocks as Lf .
This paper considers the ViT model family consisting of 4 ViT backbones: the vanilla ViT discussed above, ViT-AugReg (Steiner et al., 2021) which shares the same ViT architecture but applies stronger data augmentation and regularization, MLP-Mixer (Tolstikhin et al., 2021) which replaces self-attention in ViT with MLP, a variant called Hybrid-ViT which replaces the raw image patches in Equation 1 with the CNN features extracted by a ResNet-50 (He et al., 2016).

heading: 3.2 ARCHITECTURE
text: Existing ViTs represent an image patch as a sequence of pixel tokens, which are linear projections of flattened image pixels. We propose a novel architecture modification to the input layer of the vision transformer, where an image patch xp is represented by a combination of two embeddings. As illustrated in Fig. 1, in addition to the original pixel-wise linear projection, we discretize an image patch into an discrete token in a codebook V ∈ RK×dc , where K is the codebook size and dc is the dimension of the embedding. The discretization is achieved by a vector quantized (VQ) encoder pθ that produces an integer z for an image patch x as:
pθ(z = k|x) = 1(k = argmin j=1:K ‖ze(x)− Vj‖2), (5)
where ze(x) denotes the output of the encoder network and 1(·) is the indicator function.
The encoder is applied to the patch sequence xp ∈ RL×(P 2·C) to obtain an integer sequence zd ∈ {1, 2, ...,K}L. Afterward, we use the embeddings of both discrete and pixel tokens to construct the input embedding to the ViT model. Specifically, the input embedding in Equation 1 is replaced by:
h0 = [xclass; f(Vz1d ,x 1 pE); f(Vz2d ,x 2 pE); · · · ; f(VzLd ,x L pE)] +Epos, (6)
where f is the function, embodied as a neural network layer, to combine the two embeddings. We empirically compared four network designs for f and found that the simplest concatenation works best. Note that our model only modifies the input layer of ViT (Equation 1) and leaves intact the remaining layers depicted in Equation 2-4.
4 1 2 8 9 7 5 9 2 decode
t abby catt abby cat vul t ur e f l ami ngo f l ami ngo
cout i nous t okens ( i mage pat ch)
di scr et e t okens
Figure 2: Comparison of pixel tokens (top) and the reconstructed image decoded from the discrete tokens (bottom). Discrete tokens capture important shapes and structures but may lose local texture.
Comparison of pixel and discrete embeddings: Pixel and discrete embeddings represent different aspects of the input image. Discrete embeddings capture important features in a low-dimension space (Oord et al., 2017) that preserves the global structure of an object but lose local details. Fig. 2 compares the original image (top) and the reconstructed images decoded from the discrete embeddings of our model (bottom). As shown, the decoded images from discrete embeddings reasonably depict the object shape and global context. Due to the quantization, the decoder hallucinates the local textures, e.g., in the cat’s eye, or the text in the “vulture” and “flamingo” images. It is worth noting that the VQ encoder/decoder is only trained on ImageNet 2012 but they can generalize to out-of-distribution images. Please see more examples in Appendix A.
On the flip side, pixel embeddings capture rich details through the linear projection from raw pixels. However, given the expressive power of transformers, ViTs can spend capacity on local textures or nuance patterns that are often circumferential to robust recognition. Since humans recognize images primarily relying on the shape and semantic structure, this discrepancy to human perception undermines ViT’s generalization on out-of-distribution data. Our proposed model leverages the power of both embeddings to promote the interaction between modeling global and local features.

heading: 3.3 TRAINING PROCEDURE
text: The training comprises two stages: pretraining and finetuning. First, we pretrain the VQ-VAE encoder and decoder (Oord et al., 2017) on the given training set. We do not use labels in this step. In the finetuning stage, as shown in Fig. 3a, we train the proposed ViT model from scratch and finetune the discrete embeddings. Due to the straight-through gradient estimation in VQ-VAE (Oord et al., 2017), we stop the back-propagation after the discrete embedding.
Now we discuss the objective that the proposed ViT model optimizes. Let qφ(z|x) denote the VQ encoder, parameterized by network weights φ, to represent an image x into a sequence of integer tokens z. The decoder models the distribution pθ(x|z) over the RGB image generated from discrete tokens. pψ(y|x, z) stands for the proposed vision transformer shown in Fig. 1. We factorize the joint distribution of image x, label y, and the discrete token z by p(x, y, z) = pφ(x|z)pψ(y|x, z)p(z). Our overall training procedure is to maximize the evidence lower bound (ELBO) on the joint likelihood:
log p(x, y) ≥ Eqφ(z|x)[log pθ(x|z)]−DKL[qφ(z|x)‖pψ(y|x, z)p(z)] (7)
In the first stage, we maximize the ELBO with respect to φ and θ, which corresponds to learning the VQ-VAE encoder and decoder. Following (Oord et al., 2017), we assume a uniform prior for both pψ(y|x, z) and p(z). Given that qφ(z|x) predicts a one-hot output, the regularization term (KL divergence in Equation 7) will be a constant. Note that the DALL-E model (Ramesh et al., 2021) uses a similar assumption to stabilize the training. Our observation is consistent with that of Ramesh et al. (2021), where this strategy works better than jointly training with pψ(y|x, z). Our implementation uses VQ-GAN (Esser et al., 2021) which adds a GAN loss for better decoding quality. We also include results with VQ-VAE (Oord et al., 2017) in Appendix A.8 for reference.
In the finetuning stage, we optimize ψ while holding θ and φ fixed, which corresponds to learning a ViT and finetuning the discrete embeddings. This can be seen by rearranging the ELBO:
log p(x, y) ≥ Eqφ(z|x)[log pψ(y|x, z)] + Eqφ(z|x)[log pθ(x|z)p(z) qφ(z|x) ], (8)
where pψ(y|x, z) is the proposed ViT model. The first term denotes the likelihood for classification that is learned by minimizing the multi-class cross-entropy loss. The second term becomes a constant given the fixed θ and φ. It is important to note that the discrete embeddings are learned end-to-end in both pretraining and finetuning. Details are discussed in Appendix A.2.

heading: 4 EXPERIMENTS

heading: 4.1 EXPERIMENTAL SETUP
text: Datasets. In the experiments, we train all the models, including ours, on ImageNet 2012 or ImageNet-21K under the same training settings, where we use identical training data, batch size, and learning rate schedule, etc. Afterward, the trained models are tested on the ImageNet robustness benchmarks to assess their robustness and generalization capability.
In total, we evaluate the models on nine benchmarks. ImageNet and ImageNet-Real are two indistribution datasets. ImageNet (Deng et al., 2009) is the standard validation set of ILSVRC2012. ImageNet-Real (Beyer et al., 2020) revises the ImageNet validation set with a more robust labeling procedure, which measures model’s generalization on different labeling procedures.
Seven out-of-distribution (OOD) datasets are considered. Fig. 4 shows their example images. ImageNet-Rendition (Hendrycks et al., 2021a) is an OOD dataset that contains renditions, such as art, cartoons, of 200 ImageNet classes. Stylized-ImageNet (Geirhos et al., 2019) is used to induce the texture vs. the shape bias by stylizing the ImageNet validation set with 79,434 paintings. The “shape ImageNet labels” are used as the label. ImageNet-Sketch (Wang et al., 2019) is a “black and white” dataset constructed by querying the sketches of the 1,000 ImageNet categories. ObjectNet (Barbu et al., 2019) is an OOD test set that controls the background, context, and viewpoints of the data. Following the standard practice, we evaluate the performance on the 113 overlapping ImageNet categories. ImageNet-V2 (Recht et al., 2019) is a new and more challenging test set collected for ImageNet. The split “matched-frequency” is used. ImageNet-A (Hendrycks et al., 2021b) is a natural adversarial dataset that contains real-world, unmodified, natural examples that cause image classifiers to fail significantly. ImageNet-C (Hendrycks & Dietterich, 2019) evaluates the model’s robustness under common corruptions. It contains 5 serveries of 15 synthetic corruptions including ‘Defocus,’ ‘Fog,’ and ‘JPEG compression’.
Models. We verify our method on three ViT backbones: the classical ViT (Dosovitskiy et al., 2020) termed as ViT Vanilla, ViT-AugReg (Steiner et al., 2021), and MLPMixer (Tolstikhin et al., 2021). By default, we refer ViT to ViT-AugReg considering its superior performance. For ViT, we study the Tiny (Ti), the Small (S), and the Base (B) variants, all using the patch size of 16x16. We also compare with a CNN-based ResNet (He et al., 2016) baseline, and the Hybrid-ViT model (Dosovitskiy et al., 2020) that replaces image patch embedding with a ResNet-50 encoder.
Implementation details On ImageNet, the models are trained with three ViT model variants, i.e. Ti, S, and B, from small to large. The codebook size is K = 1024, and the codebook embeds the discrete token into dc = 256 dimensions. On ImageNet-21K, the quantizer model is a VQGAN and is trained on ImageNet-21K only with codebook size K = 8, 192. All models including ours use the same augmentation (RandAug and Mixup) as in the ViT baseline (Steiner et al., 2021). More details can be found in the Appendix A.12.

heading: 4.2 MAIN RESULTS
text: Table 1 shows the results of the models trained on ImageNet. All models are trained under the same setting with the same data augmentation from (Steiner et al., 2021) except for the ViT-B Vanilla row, which uses the data augmentation from (Dosovitskiy et al., 2020). Our improvement is entirely attributed to the additional discrete representations. By adding discrete representations, all ViT variants, including Ti, S, and B, improve robustness across all eight benchmarks. When only using discrete representations as denoted by “(discrete only)”, we observe a larger margin of improvement (10%-12%) on the datasets depicting object shape: Rendition, Sketch, and Stylized-ImageNet. It is worth noting that it is a challenging robustness test to obtain gains across all the benchmarks as different datasets may capture distinct types of data distributions.
Our approach scales as more training data is available. Table 2 shows the performance for the models pretrained on ImageNet-21K and finetuned on ImageNet. Training on sufficiently large datasets inherently improves robustness (Bhojanapalli et al., 2021) but also renders further improvement even more challenging. Nevertheless, our model consistently improves the baseline ViT-B model across all robustness benchmarks (by up to 10% on ImageNet-C). The results in Table 1 and Table 2 validate our model as a generic approach that is highly effective for the models pretrained on the sufficiently large ImageNet-21k dataset.
Comparison to the State-of-the-Art We compare our model with the state-of-the-art results on four datasets in Table 3 and Table 4. It is noteworthy that different from the compared approaches that are tailored to specific datasets, our method is generic and uses the same data augmentation as our ViT baseline (Steiner et al., 2021), i.e. RandAug and Mixup, for all datasets.
On ImageNet-Rendition, we compare with the leaderboard numbers from (Hendrycks et al., 2021a). Trained on ImageNet, our approach beats the state-of-the-art DeepAugment+AugMix approach by
Under review as a conference paper at ICLR 2022
I m a g e N e t
R e n d i t i o n S t y l i z e d
car
or i gi nal
S k e t c h O b j e c t N e t I m a g e N e t - A I m a g e N e t - C I m a g e N e t - V 2
decoded or i gi nal decoded or i gi nal decoded or i gi nal decoded
Figure 4: Visualization of the eight evaluation benchmarks. Each image consists of the original test image (Left) and the decoded image from the finetuned discrete embeddings (Right). Note that the encoder and decoder are trained only on ImageNet 2012 data but generalize on outof-distribution datasets. See more examples in Appendix A.1.1.
2%. Notice that the augmentation we used—RandAug+MixUp—is 17% worse than the DeepAugment+AugMix on ResNets. Our performance can be further improved by another 6% when pretrained on ImageNet-21K. On ImageNet-Sketch, we surpass the state-of-the-art (Hermann et al., 2020) by 8%. On Stylized-ImageNet, our approach improves 18% top-5 accuracy by switching to discrete representation. On ImageNet-C, our approach slashes the prior mCE by up to 10%. Note that most baselines are trained with CNN architectures that have a smaller capacity than ViT-B. The comparison is fair for the bottom entries that are all built on the same ViT-B backbone.

heading: 4.3 IN-DEPTH ANALYSIS
text: In this subsection, we demonstrate, both quantitatively and qualitatively, that discrete representations facilitate ViT to better capture object shape and global contexts.
Quantitative results. Result in Table 3c studies the OOD generalization setting “IN-SIN” used in (Geirhos et al., 2019), where the model is trained only on the ImageNet (IN) and tested on the Stylized ImageNet (SIN) images with conflicting shape and texture information, e.g. the images of a cat with elephant texture. The Stylized-ImageNet dataset is designed to measure the model’s ability to recognize shapes rather than textures, and higher performance in Table 3c is direct evidence of our model’s superiority in recognizing objects by shape. While ViT outperforms CNN on the task, our discrete representations yield another 10+% gain. However, if the discrete token is replaced with the global CNN features, such robustness gain is gone (cf. Table 8). This substantiates the benefit of discrete representations in recognizing object shapes.
Additionally, we conduct the “shape vs. texture biases” analysis following (Geirhos et al., 2019) under the OOD setting “IN-SIN” (cf. Appendix A.5). Figure. 5a compares shape bias between
Table 4: State-of-the-art mean Corruption Error (mCE) ↓ rate on ImageNet-C (the smaller the better).
Model mCE
y Gauss Shot Impul Defoc Glass Motion Zoom Snow Frost Fog Bright Contrast Elastic Pixel JPEG
Resnet152 (He et al., 2016) 69.27 72.5 73.4 76.3 66.9 81.4 65.7 74.5 70.7 67.8 62.1 51.0 67.1 75.6 68.9 65.1 +Stylized (Geirhos et al., 2019) 64.19 63.3 63.1 64.6 66.1 77.0 63.5 71.6 62.4 65.4 59.4 52.0 62.0 73.2 55.3 62.9 +GenInt (Mao et al., 2021a) 61.70 59.2 60.2 62.4 60.7 70.8 59.5 69.9 64.4 63.8 58.3 48.7 61.5 70.9 55.2 60.0 DA (Hendrycks et al., 2021a) 53.60 - - - - - - - - - - - - - - -
ViT-B 52.71 43.0 47.2 44.4 63.2 73.4 55.1 70.8 51.6 45.6 35.2 44.2 41.3 61.6 54.0 59.4 ViT-B + Ours 46.22 36.9 38.6 36.0 54.6 57.4 53.4 63.2 45.4 38.7 34.1 40.9 39.6 56.6 45.0 53.0 ViT-B *21K 49.62 47.0 48.3 46.0 55.7 65.6 46.7 54.0 40.0 40.6 32.2 42.3 42.0 57.1 63.1 63.6 ViT-B + Ours *21K 38.74 30.5 30.6 29.2 47.3 54.3 44.4 49.4 34.5 31.7 25.7 34.7 33.1 52.9 39.5 43.2
humans and three models: ResNet-50, ViT-B, and Ours. It shows the scores on 16 categories along their average denoted by the colored horizontal line. As shown, humans are highly biased towards shape with an average fraction of 0.96 to correctly recognize an image by shape. ViT (0.42) is more shape-biased than CNN ResNet-50 (0.20), which is consistent with the prior work studies (Naseer et al., 2021). Adding discrete representation (0.62) greatly shrinks the gap between the ViT (0.42) and human baseline (0.96). Such behavior is not observed when adding global CNN features whose average fraction of shape decisions is 0.3, lower than the baseline ViT, and hence is not displayed in the figure.
Finally, we validate discrete representation’s ability in modeling global context via position embedding. Following (Chen et al., 2021b), we compare training ViT with and without using position embedding. As position embedding is the only vehicle to equip ViT with global input information, its contribution suggests to what degree the model makes use of global contexts for recognition. As shown in Table 5, removing position embedding from the ViT model only leads to a marginal performance drop (2.8%) on ImageNet, which is consistent with (Chen et al., 2021b). However, without position embedding, our model accuracy drops by 29%, and degrades by a significant 36%- 94% on the robustness benchmarks. This result shows that spatial information is more crucial when discrete representation is used, which also suggests our model relies on more global contexts for recognition. This result quantitatively substantiates that discrete representations improve ViT to better capture global contexts.
Qualitative results. First, following (Dosovitskiy et al., 2020), we visualize the learned pixel embeddings, called filters, of the ViT-B model and compare them with ours in Fig. 3b with respect to (1) randomly selected filters (the top row in Fig. 3b) and (2) the first principle components (the bottom). We visualize the filters of our default model here and include more visualization in Appendix A.1.3. The evident visual differences suggest that our learned filters capture structural patterns.
Second, we compare the attention from the classification tokens in Fig. 5b, where (i) visualizes the individual images and (ii) averages attention values of all the image in the same mini-batch. Our model attends to image regions that are semantically relevant for classification and captures more global contexts relative to the central object.
Finally, we investigate what information is preserved in discrete representations. Specifically, we reconstruct images by the VQ-GAN decoder from the discrete tokens and finetuned discrete embed-
dings. Fig. 4 visualizes representative examples from ImageNet and the seven robustness benchmarks. By comparing the original and decoded images in Fig. 4, we find the discrete representation preserves object shape but can perturb unimportant local signals like textures. For example, the decoded image changes the background but keeps the dog shape in the last image of the first row. Similarly, it hallucinates the text but keeps the bag shape in the first image of the third row. In the first image of ImageNet-C, the decoding deblurs the bird image by making the shape sharper. Note that the discrete representation is learned only on ImageNet, but it can generalize to the other out-of-distribution test datasets. We present more results with failure cases in Appendix A.1.1.

heading: 4.4 ABLATION STUDIES
text: Model capacity vs. robustness. Does our robustness come from using larger models? Fig. 6 shows the robustness vs. the number of parameters for the ViT baselines (blue) and our models (orange). We use ViT variants Ti, S, B, and two hybrid variants Hybrid-S and Hybrid-B, as baselines. We use “+Our” to denote our method and “+Small” to indicate that we use the small version of quantization encoder (cf. Appendix A.11.1). With a similar amount of model parameters, our model outperforms the ViT and Hybrid-ViT in robustness.
Codebook size vs. robustness. In Table 6, we conduct an ablation study on the size of the codebook, from 1024 to 8192, using the small variant of our quantized encoder trained on ImageNet. A larger codebook size gives the model more capacity, making the model closer to a continuous one. Overall, Stylized-ImageNet benefits the most when the feature is highly quantized. With a medium codebook size, the model strikes a good balance between quantization and capacity, achieving the best overall performance. A large codebook size learned on ImageNet can hurt performance.
Discrete vs. Continuous global representation. In Appendix A.4, instead of using our discrete token, we study whether concatenate continuous CNN representations with global information can improve robustness. Results show that concatenating global CNN representation performs no better than the baseline, which demonstrates the necessity of discrete representations.
Network designs for combining the embeddings. In Appendix A.9, we experiment with 4 different designs, including addition, concatenation, gate filtering, and cross-attention, to combine the discrete and pixel embeddings. Among them, the simple concatenation yields the best overall result.

heading: 5 CONCLUSION
text: This paper introduces a simple yet highly effective input representations for vision transformers, in which an image patch is represented as the combined embeddings of pixel and discrete tokens. The results show the proposed method is generic and works with several vision transformer architectures, improving robustness across seven out-of-distribution ImageNet benchmarks. Our new findings connect the robustness of vision transformer to discrete representation, which hints towards a new direction for understanding and improving robustness.
Ethics statement: The authors attest that they have reviewed the ICLR Code of Ethics for the 2022 conference and acknowledge that this code applies to our submission. Our explicit intent with this research paper is to improve the state-of-the-art in terms of accuracy and robustness for Vision Transformers. Our work uses well-established datasets and benchmarks and undertakes detailed evaluation of these with our novel and improved approaches to showcase state-of-the-art improvements. We did not undertake any subject studies or conduct any data-collection for this project. We are committed in our work to abide by the eight General Ethical Principles listed at ICLR Code of Ethics (https://iclr.cc/public/CodeOfEthics).
Reproducibility statement Our approach is simple in terms of implementation, as we only change the input embedding layer for the standard ViT while keeping everything else, such as the data augmentation, the same as the established ViT work. We use the standard, public available training and testing dataset for all our experiments. We include flow graph for our architecture in Fig. 1, pseudo JAX code in Fig. 3a, and implementation details in Section 4.1 and Appendix A.11. We will release our model and code to assist in comparisons and to support other researchers in reproducing our experiments and results.

heading: A APPENDIX
text: The Appendix is organized as follows. Appendix A.2 extends the discussion on learning objective. Appendix A.1 presents more figures to visualize the attention, the decoded images, and the decoding failure cases. Appendix A.9 compares designs for combing the pixel and discrete embeddings. In the end, Appendix A.11 discusses the implementation details.
A.1 VISUALIZATION

heading: A.1.1 RECONSTRUCTED IMAGES FROM DISCRETE REPRESENTATION
text: Fig. 7 shows more examples of reconstructed images decoded from the finetuned discrete embedding. Generally, the discrete representation reasonably preserves object shape but can perturb local signals. Besides, Fig 7 also shows the distribution diversity in the experimented robustness benchmarks, e.g., the objects in ImageNet-A are much smaller. Note that while the discrete representation is learned only on the ImageNet 2012 training dataset (the first row in Fig. 7), it can generalize to the other out-of-distribution test datasets.

heading: A.1.2 LIMITATIONS OF DISCRETE REPRESENTATION
text: We find four failure cases that the discrete representation are unable to capture: text, human faces, parallel lines, and small objects or parts. The example images are illustrated in Fig. 8. Without prior knowledge, the discrete representation has difficulty to reconstruct text in image. On the other hand, it is interesting to find the decoder can model animal faces but not human faces. This may be a result of lacking facial images in the training data of ImageNet and ImageNet-21K.
The serious problem we found for recognition is its failure to capture small objects or parts. Though this can be beneficial sometimes, e.g. force the model to recognize the tire without using the “BMW” logo (see the first image in the last row of Fig. 8), it can cause problems in many cases, e.g. recognizing the small whales in the last image. As a result, our proposed model leverages the power of both embeddings to promote the interaction between modeling global and local features.

heading: A.1.3 FILTERS
text: In Fig. 3b of the main paper, we illustrate the visual comparison of the learned pixel embeddings between the standard ViT and our best-performing model. In this subsection, we extend the visualization to our models with a varying number of pixel dimensions when concatenating the discrete and pixel embedding, where their classification performances are compared in Table 13. As the dimension of pixel embedding grows, the filters started to pick up more high-frequency signals. However, the default setting in the paper using only 32 pixel dimensions (pixel dim=32), which seems to induce an inductive bias by limiting the budget of pixel representation, turns out to be the best performing model.

heading: A.1.4 ATTENTIONS
text: We visualize the attention following the steps in (Dosovitskiy et al., 2020). To be specific, to compute maps of the attention from the output token to the input space, we use Attention Rollout (Abnar & Zuidema, 2020). Briefly, we average attention weights of ViT-B and ViT-B+Ours across all heads and then recursively multiply the weight matrices of all layers. Both ViT and ViT+Ours are trained on ImageNet.
In Fig. 11, Fig. 12 and Fig. 13, we visualize the attention of individual images in the first mini-batch of each test set. As shown, our model attends to image regions that are semantically relevant for
classification and captures more global contexts relative to the central object. This can be better seen from Fig. 10, where the heat map averages the attention values of all images in the first minibatch of each test set. As found in prior works (Dosovitskiy et al., 2020; Naseer et al., 2021), ViTs put much attentions on the corners of the image, our attentions are more global and do not exhibit the same defect.

heading: A.2 DETAILS ON LEARNING OBJECTIVE
text: Let x denote an image with the class label y, and z represent the discrete tokens z ∈ Z. For notational convenience, we use a single random variable to represent the discrete latent variables whereas our implementation actually represents an image as a flattened 1-D sequence following the raster scan.
• qφ(z|x) denotes the VQ-VAE encoder, parameterized by φ, to represent an image x into the discrete token z.
• pθ(x|z) is the decoder that models the distribution over the RGB image generated from discrete tokens.
• pψ(y|x, z) stands for the vision transformer model shown in Fig. 1 of the main paper.
We model the joint distribution of image x, label y, and the discrete token z using the factorization p(x, y, z) = pθ(x|z)pψ(y|x, z)p(z). Our overall procedure can be viewed as maximizing the evidence lower bound (ELBO) on the joint likelihood, which yields:
DKL[qφ(z|x), p(z|x, y))] = − ∑ z qφ(z|x) log p(z|x, y) qφ(z|x)
(9)
= − ∑ z qφ(z|x) log p(x, y, z) p(x, y)qφ(z|x) (10)
Since the f -divergence is non-negative, we have:
− ∑ z qφ(z|x) log p(x, y, z) qφ(z|x) + log p(x, y)[ ∑ z qφ(z|x)] ≥ 0 (11)
log p(x, y) ≥ ∑ z qφ(z|x) log p(x, y, z) qφ(z|x) (12)
Using the factorization, we have:
log p(x, y) ≥ Eqφ(z|x)[log pψ(y|x, z)pθ(x|z)p(z)
qφ(z|x) ] (13)
Equation 13 yields the ELBO:
log p(x, y) ≥ Eqφ(z|x)[log pθ(x|z)] + Eqφ(z|x)[log pψ(y|x, z)p(z)
qφ(z|x) ] (14)
≥ Eqφ(z|x)[log pθ(x|z)]−DKL[qφ(z|x)‖pψ(y|x, z)p(z)] (15)
In the first stage, we maximize the ELBO with respect to φ and θ, which corresponds to learning the VQ-VAE encoder and decoder. We assume a uniform prior for both pψ(y|x, z) and p(z). Given that qφ(z|x) predicts a one-hot output, the regularization term (KL divergence) will be a constant logK, where K is the size of the codebook V.As in the VQ-VAE model, the distribution pθ is deterministic. We note a similar assumption as in the DALL-E model (Ramesh et al., 2021) is used to stabilize the training, which means the transformer is not learned at this stage. We have the same observation as in DALL-E that this strategy works better than jointly training with pψ(y|x, z). In addition to the reconstruction loss, the VQ-VAE’s training objective adds a dictionary learning loss and a commitment loss, calculated from:
LVQ-VAE = log p(x|zq(x)) + ‖sg[ze(x)]− v‖2 + β‖ze(x)− sg[v]‖, (16)
where ze(x) and zq(x) represent the encoder output and the decoder input, respectively. v denotes the discrete embedding for the image x. sg(·) is the stop gradient function. The training used straight-through estimation which just copies gradients from zq(x) to ze(x). Notice that our implementation uses VQ-GAN (Esser et al., 2021) which adds an additional GAN loss:
LVQ-GAN = log p(x|zq(x)) + ‖sg[ze(x)]− v‖2 + β‖ze(x)− sg[v]‖+ λLGAN, (17)
where β = 0.25 and λ = 0.1 are used to balance different loss terms.
In the second stage of finetuning, we optimize ψ while holding φ and θ fixed, which corresponds to learning a vision transformer for classification and finetuning the discrete embedding V. By rearranging Equation 14, we have:
log p(x, y) ≥ Eqφ(z|x)[log pψ(y|x, z)] + Eqφ(z|x)[log pθ(x|z)p(z) qφ(z|x) ], (18)
where pψ(y|x, z) is the proposed ViT model as illustrated in Fig. 1 of the main paper. The first term denotes the likelihood for classification that is learned by minimizing the multi-class cross-entropy loss. The second term becomes a constant given the fixed θ and φ.
In the finetuning stage, two sets of parameters are updated: the vision transformer ψ is learned from scratch and the discrete embedding V is finetuned. We fix the encoder and stop the gradient propagating back to the encoder considering the instability of straight-through estimation and the stop gradient operation in the dictionary learning loss, i.e. Equation 16. Empirically, we also compared the proposed pretraining-finetuning strategy with the joint learning strategy in which all parameters are optimized simultaneously. We find the joint learning significantly underperforms the proposed learning strategy.

heading: A.3 COMPARING TO DATA AUGMENTATIONS
text: Since our model only changes the token representation in the ViT architecture, it is conceptually different and complementary to data augmentation. Nevertheless, this subsection compares our method with seven combinations of recent data augmentation strategies, including CutOut (DeVries & Taylor, 2017), CutMix (Yun et al., 2019), RandAug (Cubuk et al., 2020), and Mixup (Zhang et al., 2018). As discussed following (Steiner et al., 2021), the ViT baseline and our model both use the default augmentation (RandAug + Mixup).
As shown in Table 7, our method achieves the best performance on the robustness benchmarks while is marginally worse than the best baseline with state-of-the-art data augmentation strategy (CutMix + RandAug) on the ImageNet in-distribution validation set. Incorporating state-of-the-art data augmentation in our model is worthy of future research.

heading: A.4 THE IMPORTANCE OF DISCRETE INFORMATION
text: This subsection compares to a new baseline that directly concatenates the global feature extracted by CNN to the input token of ViT. The only difference between this baseline and our model is that ours concatenates discrete embeddings rather than global CNN features. In Table 8, we extensively search the concatenation dimension of the CNN features in [64, 128, 256, 384, 512, 640]. However, none of the models improve robustness. Our results show that concatenating the global CNN feature performs no better than the ViT baseline and significantly worse than concatenating discrete representations, demonstrating the necessity of discrete representations for robustness.

heading: A.5 TEXTURE VS. SHAPE STUDY
text: In Fig. 5a of the main paper, we performs the “shape vs. texture biases” analysis following (Geirhos et al., 2019) (see Figure 4 in their paper). It uses the score “fraction of shape decision” to quantify a
model’s shape-bias between 0 and 1. To compute the score, we follow the steps on their Github1as follows: 1) evaluate the model on all 1280 images in Stylized ImageNet; 2) map the model decision to 16 classes; 3) exclude images without a cue conflict; 4) take the subset of “correctly” classified images (either shape or texture category correctly predicted); (5) compute “shape bias” as the fraction between correct shape decisions and (correct shape decisions + correct texture decisions).
Fig. 5a in the main paper presents the scores on 16 categories along their average denoted by the colored horizontal line. We compute the scores for three models trained on ImageNet, i.e. ResNet50, ViT-B/16, and ours, and quote human scores from (Geirhos et al., 2019). We also compute the score for the concatenating global CNN features baseline which is about 0.3. Note that the OOD generalization setting “IN-SIN” (Geirhos et al., 2019) is used, where the model is trained only on the ImageNet (IN) and tested on the Stylized ImageNet (SIN) images with conflicting shape and texture cue.

heading: A.6 THE EFFECT OF CODEBOOK ENCODER CAPACITY ON ROBUSTNESS
text: We analyze how the capacity of the discrete encoder affects the model’s robustness. We train a small encoder and a standard encoder and compare their performance. We describe the VQ encoder’s architecture configuration in Table 17, where the small encoder has only 13% of the #parameters of the standard VQ encoder. We run experiments in Table 9. Our results show that using the standard VQ-encoder is better but the small VQ-encoder comparatively yields reasonable results considering the reduced model capacity.

heading: A.7 THE EFFECT OF PRETRAINING CODEBOOK WITH MORE DATA ON ROBUSNTESS
text: We analyze the effect of pre-training codebook on sufficiently large data. We use the same model architecture, but pretrain two codebooks (and encoders) on the ImageNet ILSVRC 2012 and the
1https://github.com/rgeirhos/texture-vs-shape
ImageNet21K (about 11x larger), respectively. Using the pre-trained codebook, we train ViTs on ImageNet21K and compare the results in Table 10, where it shows pretraining on large data improves the robustness.

heading: A.8 ADDITIONAL MODELS FOR LEARNING DISCRETE REPRESENTATION
text: The results show that the ability of discrete representations to improve ViT’s robustness is general which is not limited to specific VQ-GAN models.

heading: A.9 COMPARING DESIGNS FOR COMBINING EMBEDDINGS
text: In this subsection, we compare different designs to combine the pixel and discrete embeddings. See the combination operation in Fig. 1 and in Equation 6 of the main paper. The results are used verify our design of using a simple concatenation presented in the paper. Four designs are considered and discussed below. Their performances are compared in Table 12.
Addition. We first use linear projection matrix E to obtain the pixel embedding that shares the same dimension as the discrete embedding which is 256. We then add the two embedding, and project the resulting embedding to the dimension required by the ViT if needed. Formally, we compute
f(Vzd ,xpE) = (Vzd + xpE)E2, (19)
where Vzd and xpE represent the discrete and pixel embeddings, respectively, and E2 is a new MLP projection layer that is needed when the resulting dimension is different to the ViT input.
Concatenation. We concatenate the discrete embedding with the pixel embedding, and then feed the resulting embedding into the transformer encoder. By default, we use a dimension of 32 for the pixel embedding, a dimension of 256 for the discrete embedding, thus we pad 0 to the vector if the input dimension of the ViT is higher than 288.
f(Vzd ,xpE) = [Vzd ;xpE;0], (20) where “;” indicates the concatenation operation.
Residual Gating. As pixel embeddings may contain nuisances, inspired by (Vo et al., 2019), we learn a gate from both embeddings, and then multiply it with the pixel embeddings to filter out details that are unimportant to classification. Specifically, we calculate the gate by a 2-layer MLP, and apply a softmax to the output from the last layer.
G = Softmax(MLP(Vzd ;xpE)) (21)
Then the pixel embeddings are gated by:
P = G xpE (22)
Then we concatenate the gated embedding with the discrete embedding:
f(Vzd ,xpE) = [Vzd ;P;0] (23)
Cross-Attention. We use the discrete embedding as the query, and the pixel token as the key and value in a standard multi-head cross-attention module (MCA).
A = MCA(Vzd ,xpE,xpE) (24)
We then concatenate the attended feature output with the discrete embedding. We also pad 0 if the ViT requires larger input dimensionality.
f(Vzd ,xpE) = [Vzd ;A;0] (25)

heading: A.9.1 THE ROBUSTNESS EFFECT OF USING CONTINUOUS REPRESENTATION WITH DISCRETE REPRESENTTION.
text: The above study shows that concatenation is the most effective way to combine the discrete and continuous representations. As we fixed the dimensionality for the discrete token to be 256, we can study the optimal ratio between continuous and discrete representations by changing the dimensionality on the pixel token.

heading: A.10 THE IMPORTANCE OF SPATIAL INFORMATION FOR DIFFERNT ARCHITECTURES
text: In addition to the analysis in the main paper, we also investigate whether it is the convolutional operation in the vector quantized encoder that makes the model use the spatial information better. We remove the position embedding from the Hybrid-B model, whose input is also produced by a convolution encoder. Our results show that removing the positional information from the Hybrid model with a convolutional encoder does not decrease the performance. However, for both our models, the discrete only and the combined one, removing positional embedding causes a large drop in performance. This shows that our robustness gain via the spatial structure is from our discrete design, not convolution.
A.11 IMPLEMENTATION DETAILS

heading: A.11.1 ARCHITECTURE
text: We use three variants of ViT transformer encoder backbone in our experiments. We show the configuration details and the number of parameters in Table 15. We also use hybrid model with ResNet50 as the tokenization backbone. We show the configuration in Table 16.
We use B-16 for the MLPMixer Tolstikhin et al. (2021).
We use two kinds of VQ Encoder in our experiment: Small VQ Encoder and VQ Encoder. The VQ encoder uses the same encoder architecture as the VQGAN encoder (Esser et al., 2021). For Small VQ Encoder, we decrease both the number of the resisual blocks and the number for filter channel by half, which is a lightweight model that decrease the model size by around 8 times. We show the configuration detail in Table 17.

heading: A.12 TRAINING
text: Implementation details We implement our model in Jax and optimize all models with Adam (Kingma & Ba, 2014). Unless specified otherwise, the input images are resized to 224x224, trained with a batch size of 4,096, with a weight decay of 0.1. We use a linear learning rate warmup and cosine decay. On ImageNet, the models are trained for 300 epochs using three ViT model variants, i.e. Ti, S, and B, from small to large. The VQ-GAN model is also trained on ImageNet for 100K steps using a batch size of 256. The codebook size is K = 1024, and the codebook embeds the discrete token into dc = 256 dimensions. For discrete ViT-B, we use average pooling on the final features. On ImageNet-21K, we train 90 epochs. We finetune on a higher resolution on ImageNet, with Adam and 1e-4 learning rate, batch size 512, for 20K iterations. The quantizer model is a VQGAN and is trained on ImageNet-21K only with codebook size K = 8, 192. All models including ours use the same augmentation (RandAug and Mixup) as in the ViT baseline (Steiner et al., 2021). More details can be found in the Appendix.
ImageNet Training We train our model with the Adam (Kingma & Ba, 2014) optimizer. Our batchsize is 4096 and trained on 64 TPU cores. We start from a learning rate of 0.001 and train 300 epoch.
We use linear warm up for 10k iterations and then a cosine annealing for the learning rate schedule. We use 224 × 224 resolution for the input image. We conduct experiment on three variants of the ViT model, Ti, S, and B, from small to large. In addition, we also experiment on the newly released MLPMixer, which also uses image patch as the token embeddings. We denote our approach as using both representations, and we also run a discrete only variant where we only uses the discrete embeddings without pixel embeddings. Due to the small input dimension of Ti, we only use the code representation without concatenate the pixel representation, and we project the 256 dimension to 192 via a linear projection layer. For the other variants, we concatenate both representations, and pad zeros if additional dimension required for the transformer. We use the same augmentation and model regularization as (Steiner et al., 2021), where we use RandAug with hyper-parameter (2,15) and mixup with α = 0.5, and we apply a dropout rate of 0.1 and stochastic block dropout of 0.1. We download pretrained VQGAN model, which is trained on only ImageNet. We use VQ-GAN’s encoder only with a codebook size of 1,024. The codebook integer is embedded into a 256 dimension vector.
ImageNet-21K Training Our models use learning rate of 0.001, weight decay of 0.03, and train 90 epoch. We use linear warm up for 10k iterations and then a cosine annealing for the learning rate schedule. We use 224×224 resolution for the input image. We use the same augmentation as (Steiner et al., 2021). For the quantizer model, we use VAGAN that is trained on unlabeled ImageNet-21K only. We use a codebook size of 8,192, and the codebook integer is embedded into a 256 dimension vector. To evaluate on the standard test set, we further finetune the pretrained ImageNet-21K model on ImageNet. We use Adam and optimize for 20k with 500 steps of warm up. We use a learning rate of 0.0001. We use a larger resolution 384× 384 and 512× 512. We only experiment the ViT-B variant.
For training VQ Encoder and Decoder, we train with batchsize 256 until it converges. We use perceptual loss with weight of 0.1, adversarial loss with weight 0.1. We use L1 gradient penalty of 10 during the optimization. The model is trained with resolution of 256× 256. The model can scale to different image resolution without finetuning.

Review summaries:
The authors have an observation that ViTs trained on ImageNet heavily depend on local features, but fail to use the global features (shape or structure). To address this issue and improve the robustness of ViTs, the authors proposed to replace the linear embedding layer by the a vector-quantized encoder. The authors claims that it can push the ViTs to learn the global information by this replacement. Experiments are conducted on ImageNet and other ImageNet variant datasets. Results show that the proposed method can improve ViTs' robustness on various benchmarks.

The author present an observation in this paper that discrete image token representations derived from a vector quantized image encoder is able to preserve shape and structure object information. Inspired by this observation, the authors propose a modification to ViT architectures that appending these token representations to the input and show that the resultant models generalize better for out-of-distribution data on ImageNet classification. The modification to the input is simple and can be integrated into variants of ViT. Experiments show that the proposed method consistently outperforms baseline models on ImageNet, ImageNet-Real and seven out-of-distribution datasets derived from ImageNet. The margin of improvement is especially larger for the tasks where textures and image style change significantly while object structure is more discriminative. The main contributions of this paper are two-fold: 1) a novel approach to enrich existing ViT architectures with shape and structure information derived from discrete representations and 2) improve the robustness over the baseline ViT models and achieve SoTA results on ImageNet-Rendition, Stylized-ImageNet and ImageNet-Sketch. 

This paper introduces Dr. ViT, which is conducted on 7 ImageNet robustness benchmarks. The motivation of this work is to demonstrate the robustness can be enhanced when adding discrete representation. Sufficient experiments demonstrate the effectiveness of this paper.