Transformer in Transformer
Year: 2021

Abstract:
Transformer is a new kind of neural architecture which encodes the input data as powerful features via the attention mechanism. Basically, the visual transformers first divide the input images into several local patches and then calculate both representations and their relationship. Since natural images are of high complexity with abundant detail and color information, the granularity of the patch dividing is not fine enough for excavating features of objects in different scales and locations. In this paper, we point out that the attention inside these local patches are also essential for building visual transformers with high performance and we explore a new architecture, namely, Transformer iN Transformer (TNT). Specifically, we regard the local patches (e.g., 16×16) as “visual sentences” and present to further divide them into smaller patches (e.g., 4×4) as “visual words”. The attention of each word will be calculated with other words in the given visual sentence with negligible computational costs. Features of both words and sentences will be aggregated to enhance the representation ability. Experiments on several benchmarks demonstrate the effectiveness of the proposed TNT architecture, e.g., we achieve an 81.5% top-1 accuracy on the ImageNet, which is about 1.7% higher than that of the state-of-the-art visual transformer with similar computational cost. The PyTorch code is available at https://github.com/huawei-noah/CV-Backbones, and the MindSpore code is available at https://gitee.com/mindspore/models/ tree/master/research/cv/TNT.

heading: 1 Introduction
text: In the past decade, the mainstream deep neural architectures used in the computer vision (CV) are mainly established on convolutional neural networks (CNNs) [17, 12, 11]. Differently, transformer is a type of neural network mainly based on self-attention mechanism [35], which can provide the relationships between different features. Transformer is widely used in the field of natural language processing (NLP), e.g., the famous BERT [8] and GPT-3 [2] models. The power of these transformer models inspires the whole community to investigate the use of transformer for visual tasks.
To utilize the transformer architectures for conducting visual tasks, a number of researchers have explored for representing the sequence information from different data. For example, Wang et al. explore self-attention mechanism in non-local networks [37] for capturing long-range dependencies in video and image recognition. Carion et al. present DETR [3], which treats object detection as a direct set prediction problem and solve it using a transformer encoder-decoder architecture. Chen et al. propose the iGPT [5], which is the pioneering work applying pure transformer model (i.e., without convolution) on image recognition by self-supervised pre-training.
∗Corresponding author.
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
Different from the data in NLP tasks, there exists a semantic gap between input images and the ground-truth labels in CV tasks. To this end, Dosovitskiy et al. develop the ViT [9], which paves the way for transferring the success of transformer based NLP models. Concretely, ViT divides the given image into several local patches as a visual sequence. Then, the attention can be naturally calculated between any two image patches for generating effective feature representations for the recognition task. Subsequently, Touvron et al. explore the data-efficient training and distillation to enhance the performance of ViT on the ImageNet benchmark and obtain an about 81.8% ImageNet top-1 accuracy, which is comparable to that of the state-of-the-art convolutional networks. Chen et al. further treat the image processing tasks (e.g., denosing and super-resolution) as a series of translations and develop the IPT model for handling multiple low-level computer vision problems [4]. Nowadays, transformer architectures have been used in a growing number of computer vision tasks [10] such as image recognition [6, 40, 29], object detection [46], and segmentation [43, 38].
Although the aforementioned visual transformers have made great efforts to boost the models’ performances, most of existing works follow the conventional representation scheme used in ViT, i.e., dividing the input images into patches. Such a exquisite paradigm can effectively capture the visual sequential information and estimate the attention between different image patches. However, the diversity of natural images in modern benchmarks is very high, e.g., there are over 120 M images with 1000 different categories in the ImageNet dataset [26]. As shown in Figure 1, representing the given image into local patches can help us to find the relationship and similarity between them. However, there are also some sub-patches inside them with high similarity. Therefore, we are motivated to explore a more exquisite visual image dividing method for generating visual sequences and improve the performance.
In this paper, we propose a novel Transformer-iN-Transformer (TNT) architecture for visual recognition as shown in Figure 1. To enhance the feature representation ability of visual transformers, we first divide the input images into several patches as “visual sentences” and then further divide them into sub-patches as “visual words”. Besides the conventional transformer blocks for extracting features and attentions of visual sentences, we further embed a sub-transformer into the architecture for excavating the features and details of smaller visual words. Specifically, features and attentions between visual words in each visual sentence are calculated independently using a shared network so that the increased amount of parameters and FLOPs (floating-point operations) is negligible. Then, features of words will be aggregated into the corresponding visual sentence. The class token is also used for the subsequent visual recognition task via a fully-connected head. Through the proposed TNT model, we can extract visual information with fine granularity and provide features with more details. We then conduct a series of experiments on the ImageNet benchmark and downstream tasks to demonstrate its superiority and thoroughly analyze the impact of the size for dividing visual words. The results show that our TNT can achieve better accuracy and FLOPs trade-off over the state-of-the-art transformer networks.

heading: 2 Approach
text: In this section, we describe the proposed transformer-in-transformer architecture and analyze the computation and parameter complexity in details.

heading: 2.1 Preliminaries
text: We first briefly describe the basic components in transformer [35], including MSA (Multi-head Self-Attention), MLP (Multi-Layer Perceptron) and LN (Layer Normalization).
MSA. In the self-attention module, the inputs X ∈ Rn×d are linearly transformed to three parts, i.e., queries Q ∈ Rn×dk , keys K ∈ Rn×dk and values V ∈ Rn×dv where n is the sequence length, d, dk, dv are the dimensions of inputs, queries (keys) and values, respectively. The scaled dot-product attention is applied on Q,K, V :
Attention(Q,K, V ) = softmax( QKT√ dk )V. (1)
Finally, a linear layer is used to produce the output. Multi-head self-attention splits the queries, keys and values to h parts and perform the attention function in parallel, and then the output values of each head are concatenated and linearly projected to form the final output.
MLP. The MLP is applied between self-attention layers for feature transformation and non-linearity:
MLP(X) = FC(σ(FC(X))), FC(X) = XW + b, (2)
where W and b are the weight and bias term of fully-connected layer respectively, and σ(·) is the activation function such as GELU [13].
LN. Layer normalization [1] is a key part in transformer for stable training and faster convergence. LN is applied over each sample x ∈ Rd as follows:
LN(x) = x− µ δ ◦ γ + β (3)
where µ ∈ R, δ ∈ R are the mean and standard deviation of the feature respectively, ◦ is the element-wise dot, and γ ∈ Rd, β ∈ Rd are learnable affine transform parameters.

heading: 2.2 Transformer in Transformer
text: Given a 2D image, we uniformly split it into n patches X = [X1, X2, · · · , Xn] ∈ Rn×p×p×3, where (p, p) is the resolution of each image patch. ViT [9] just utilizes a standard transformer to process the sequence of patches which corrupts the local structure of a patch, as shown in Fig. 1(a). Instead, we propose Transformer-iN-Transformer (TNT) architecture to learn both global and local information in an image. In TNT, we view the patches as visual sentences that represent the image. Each patch is further divided into m sub-patches, i.e., a visual sentence is composed of a sequence of visual words:
Xi → [xi,1, xi,2, · · · , xi,m], (4) where xi,j ∈ Rs×s×3 is the j-th visual word of the i-th visual sentence, (s, s) is the spatial size of sub-patches, and j = 1, 2, · · · ,m. With a linear projection, we transform the visual words into a sequence of word embeddings:
Y i = [yi,1, yi,2, · · · , yi,m], yi,j = FC(Vec(xi,j)), (5) where yi,j ∈ Rc is the j-th word embedding, c is the dimension of word embedding, and Vec(·) is the vectorization operation.
In TNT, we have two data flows in which one flow operates across the visual sentences and the other processes the visual words inside each sentence. For the word embeddings, we utilize a transformer block to explore the relation between visual words:
Y ′ i l = Y i l−1 + MSA(LN(Y i l−1)), (6)
Y il = Y ′i l + MLP(LN(Y ′i l)). (7)
where l = 1, 2, · · · , L is the index of the l-th block, and L is the total number of stacked blocks. The input of the first block Y i0 is just Y
i in Eq. 5. All word embeddings in the image after transformation are Yl = [Y 1l , Y 2l , · · · , Y nl ]. This can be viewed as an inner transformer block, denoted as Tin. This process builds the relationships among visual words by computing interactions between any two visual words. For example, in a patch of human face, a word corresponding to the eye is more related to other words of eyes while interacts less with forehead part.
For the sentence level, we create the sentence embedding memories to store the sequence of sentencelevel representations: Z0 = [Zclass, Z10 , Z20 , · · · , Zn0 ] ∈ R(n+1)×d where Zclass is the class token similar to ViT [9], and all of them are initialized as zero. In each layer, the sequence of word embeddings are transformed into the domain of sentence embedding by linear projection and added into the sentence embedding:
Zil−1 = Z i l−1 + FC(Vec(Y i l )), (8)
where Zil−1 ∈ Rd and the fully-connected layer FC makes the dimension match for addition. With the above addition operation, the representation of sentence embedding is augmented by the word-level features. We use the standard transformer block for transforming the sentence embeddings:
Z ′l = Zl−1 + MSA(LN(Zl−1)), (9) Zl = Z ′l + MLP(LN(Z ′l)). (10)
This outer transformer block Tout is used for modeling relationships among sentence embeddings.
In summary, the inputs and outputs of the TNT block include the visual word embeddings and sentence embeddings as shown in Fig. 1(b), so the TNT can be formulated as
Yl,Zl = TNT(Yl−1,Zl−1). (11)
In our TNT block, the inner transformer block is used to model the relationship between visual words for local feature extraction, and the outer transformer block captures the intrinsic information from the sequence of sentences. By stacking the TNT blocks for L times, we build the transformerin-transformer network. Finally, the classification token serves as the image representation and a fully-connected layer is applied for classification.
Position encoding. Spatial information is an important factor in image recognition. For sentence embeddings and word embeddings, we both add the corresponding position encodings to retain spatial information as shown in Fig. 1. The standard learnable 1D position encodings are utilized here. Specifically, each sentence is assigned with a position encodings:
Z0 ← Z0 + Esentence, (12)
where Esentence ∈ R(n+1)×d are the sentence position encodings. As for the visual words in a sentence, a word position encoding is added to each word embedding:
Y i0 ← Y i0 + Eword, i = 1, 2, · · · , n (13)
where Eword ∈ Rm×c are the word position encodings which are shared across sentences. In this way, sentence position encoding can maintain the global spatial information, while word position encoding is used for preserving the local relative position.

heading: 2.3 Complexity Analysis
text: A standard transformer block includes two parts, i.e., the multi-head self-attention and multi-layer perceptron. The FLOPs of MSA are 2nd(dk + dv) + n2(dk + dv), and the FLOPs of MLP are 2ndvrdv where r is the dimension expansion ratio of hidden layer in MLP. Overall, the FLOPs of a standard transformer block are
FLOPsT = 2nd(dk + dv) + n 2(dk + dv) + 2nddr. (14)
Since r is usually set as 4, and the dimensions of input, key (query) and value are usually set as the same, the FLOPs calculation can be simplified as
FLOPsT = 2nd(6d+ n). (15)
The number of parameters can be obtained as
ParamsT = 12dd. (16)
Our TNT block consists of three parts: an inner transformer block Tin, an outer transformer block Tout and a linear layer. The computation complexity of Tin and Tout are 2nmc(6c + m) and 2nd(6d+ n) respectively. The linear layer has FLOPs of nmcd. In total, the FLOPs of TNT block are
FLOPsTNT = 2nmc(6c+m) + nmcd+ 2nd(6d+ n). (17)
Similarly, the parameter complexity of TNT block is calculated as
ParamsTNT = 12cc+mcd+ 12dd. (18)
Although we add two more components in our TNT block, the increase of FLOPs is small since c d and O(m) ≈ O(n) in practice. For example, in the DeiT-S configuration, we have d = 384 and n = 196. We set c = 24 and m = 16 in our structure of TNT-S correspondingly. From Eq. 15 and Eq. 17, we can obtain that FLOPsT = 376M and FLOPsTNT = 429M . The FLOPs ratio of TNT block over standard transformer block is about 1.14×. Similarly, the parameters ratio is about 1.08×. With a small increase of computation and memory cost, our TNT block can efficiently model the local structure information and achieve a much better trade-off between accuracy and complexity as demonstrated in the experiments.

heading: 2.4 Network Architecture
text: We build our TNT architectures by following the basic configuration of ViT [9] and DeiT [31]. The patch size is set as 16×16. The number of sub-patches is set as m = 4 · 4 = 16 by default. Other size values are evaluated in the ablation studies. As shown in Table 1, there are three variants of TNT networks with different model sizes, namely, TNT-Ti, TNT-S and TNT-B. They consist of 6.1M, 23.8M and 65.6M parameters respectively. The corresponding FLOPs for processing a 224×224 image are 1.4B, 5.2B and 14.1B respectively.

heading: 3 Experiments
text: In this section, we conduct extensive experiments on visual benchmarks to evaluate the effectiveness of the proposed TNT architecture.

heading: 3.1 Datasets and Experimental Settings
text: Datasets. ImageNet ILSVRC 2012 [26] is an image classification benchmark consisting of 1.2M training images belonging to 1000 classes, and 50K validation images with 50 images per class. We adopt the same data augmentation strategy as that in DeiT [31] including random crop, random clip, Rand-Augment [7], Random Erasing [44], Mixup [42] and CutMix [41]. For the license of ImageNet dataset, please refer to http://www.image-net.org/download.
In addition to ImageNet, we also test on the downstream tasks with transfer learning to evaluate the generalization ability of TNT. The details of used visual datasets are listed in Table 2. The data augmentation strategy of image classification datasets are the same as that of ImageNet. For COCO and ADE20K, the data augmentation strategy follows that in PVT [36]. For the licenses of these datasets, please refer to the original papers.
Implementation Details. We utilize the training strategy provided in DeiT [31]. The main advanced technologies apart from common settings [12] include AdamW [20], label smoothing [27], DropPath [18], and repeated augmentation [14]. We list the hyper-parameters in Table 3 for better understanding. All the models are implemented with PyTorch [24] and MindSpore [15] and trained on NVIDIA Tesla V100 GPUs. The potential negative societal impacts may include energy consumption and carbon dioxide emissions of GPU computation.

heading: 3.2 TNT on ImageNet
text: We train our TNT models with the same training settings as that of DeiT [31]. The recent transformerbased models like ViT [9] and DeiT [31] are compared. To have a better understanding of current progress of visual transformers, we also include the representative CNN-based models such as ResNet [12], RegNet [25] and EfficientNet [28]. The results are shown in Table 4. We can see that our transformer-based model, i.e., TNT outperforms all other visual transformer models. In particular, TNT-S achieves 81.5% top-1 accuracy which is 1.7% higher than the baseline model DeiTS, indicating the benefit of the introduced TNT framework to preserve local structure information inside the patch. Compared to CNNs, TNT can outperform the widely-used ResNet and RegNet. Note that all the transformer-based models are still inferior to EfficientNet which utilizes special depth-wise convolutions, so it is yet a challenge of how to beat EfficientNet using pure transformer.
We also plot the accuracy-parameters and accuracy-FLOPs line charts in Fig. 2 to have an intuitive comparison of these models. Our TNT models consistently outperform other transformer-based models by a significant margin.
Inference speed. Deployment of transformer models on devices is important for practical applications, so we test the inference speed of our TNT model. Following [31], the throughput is measured on an NVIDIA V100 GPU and PyTorch, with 224×224 input size. Since the resolution and content inside the patch is smaller than that of the whole image, we may need fewer blocks to learn its representation. Thus, we can reduce the used TNT blocks and replace some with vanilla transformer blocks. From the results in Table 5, we can see that our TNT is more efficient than DeiT and PVT by achieving higher accuracy with similar inference speed.
3.3 Ablation Studies
Effect of position encodings. Position information is important for image recognition. In TNT structure, sentence position encoding is for maintaining global spatial information, and word position encoding is used to preserve locally relative position. We verify their effect by removing them separately. As shown in Table 6, we can see that TNT-S with both patch position encoding and word position encoding performs
the best by achieving 81.5% top-1 accuracy. Removing sentence/word position encoding results in a 0.8%/0.7% accuracy drop respectively, and removing all position encodings heavily decrease the accuracy by 1.0%.
Number of heads. The effect of #heads in standard transformer has been investigated in multiple works [21, 35] and a head width of 64 is recommended for visual tasks [9, 31]. We adopt the head width of 64 in outer transformer block in our model. The number of heads in inner transformer block
is another hyper-parameter for investigation. We evaluate the effect of #heads in inner transformer block (Table 7). We can see that a proper number of heads (e.g., 2 or 4) achieve the best performance.
Number of visual words. In TNT, the input image is
correspondingly to control the FLOPs. As shown in Table 8, we can see that the value of m has slight influence on the performance, and we use m = 16 by default for its efficiency, unless stated otherwise.

heading: 3.4 Visualization
text: Visualization of Feature Maps. We visualize the learned features of DeiT and TNT to further understand the effect of the proposed method. For better visualization, the input image is resized to 1024×1024. The feature maps are formed by reshaping the patch embeddings according to their spatial positions. The feature maps in the 1-st, 6-th and 12-th blocks are shown in Fig. 3(a) where 12 feature maps are randomly sampled for these blocks each. In TNT, the local information are better preserved compared to DeiT. We also visualize all the 384 feature maps in the 12-th block using t-SNE [33] (Fig. 3(b)). We can see that the features of TNT are more diverse and contain richer information than those of DeiT. These benefits owe to the introduction of inner transformer block for modeling local features.
In addition to the patch-level features, we also visualize the pixel-level embeddings of TNT in Fig. 4. For each patch, we reshape the word embeddings according to their spatial positions to form the feature maps and then average these feature maps by the channel dimension. The averaged feature maps corresponding to the 14×14 patches are shown in Fig. 4. We can see that the local information is well preserved in the shallow layers, and the representations become more abstract gradually as the network goes deeper.
Visualization of Attention Maps. There are two self-attention layers in our TNT block, i.e., an inner self-attention and an outer self-attention for modeling relationship among visual words and sentences respectively. We show the attention maps of different queries in the inner transformer in Figure 5. For a given query visual word, the attention values of visual words with similar appearance are higher, indicating their features will be interacted more relevantly with the query. These interactions are missed in ViT and DeiT, etc. The attention maps in the outer transformer can be found in the supplemental material.

heading: 3.5 Transfer Learning
text: To demonstrate the strong generalization ability of TNT, we transfer TNT-S, TNT-B models trained on ImageNet to the downstream tasks.
Pure Transformer Image Classification. Following DeiT [31], we evaluate our models on 4 image classification datasets with training set size ranging from 2,040 to 50,000 images. These datasets include superordinate-level object classification (CIFAR-10 [16], CIFAR-100 [16]) and fine-grained object classification (Oxford-IIIT Pets [23], Oxford 102 Flowers [22] and iNaturalist 2019 [34]), shown in Table 2. All models are fine-tuned with an image resolution of 384×384. We adopt the same training settings as those at the pre-training stage by preserving all data augmentation strategies. In order to fine-tune in a different resolution, we also interpolate the position embeddings of new patches. For CIFAR-10 and CIFAR-100, we fine-tune the models for 64 epochs, and for fine-grained datasets, we fine-tune the models for 300 epochs. Table 9 compares the transfer learning results of TNT to those of ViT, DeiT and other convolutional networks. We find that TNT outperforms DeiT in most datasets with less parameters, which shows the superiority of modeling pixel-level relations to get better feature representation.
Pure Transformer Object Detection. We construct a pure transformer object detection pipeline by combining our TNT and DETR [3]. For fair comparison, we adopt the training and testing settings in PVT [36] and add a 2×2 average pooling to make the output size of TNT backbone the same as that of PVT and ResNet. All the compared models are trained using AdamW [20] with batch size of 16 for 50 epochs. The training images are randomly resized to have a shorter side in the range of [640,800] and a longer side within 1333 pixels. For testing, the shorter side is set as 800 pixels. The results on COCO val2017 are shown in Table 10. Under the same setting, DETR with TNT-S backbone outperforms the representative pure transformer detector DETR+PVT-Small by 3.5 AP with similar parameters.
Pure Transformer Semantic Segmentation. We adopt the segmentation framework of Trans2Seg [38] to build the pure transformer semantic segmentation based on TNT backbone. We follow the training and testing configuration in PVT [36] for fair comparison. All the compared models are trained by AdamW optimizer with initial learning rate of 1e-4 and polynomial decay schedule. We apply random resize and crop of 512×512 during training. The ADE20K
results with single scale testing are shown in Table 11. With similar parameters, Trans2Seg with TNT-S backbone achieves 43.6% mIoU, which is 1.0% higher than that of PVT-small backbone and 2.8% higher than that of DeiT-S backbone.

heading: 4 Conclusion
text: In this paper, we propose a novel Transformer-iN-Transformer (TNT) network architecture for visual recognition. In particular, we uniformly split the image into a sequence of patches (visual sentences) and view each patch as a sequence of sub-patches (visual words). We introduce a TNT block in which an outer transformer block is utilized for processing the sentence embeddings and an inner transformer block is used to model the relation among word embeddings. The information of visual word embeddings is added to the visual sentence embedding after the projection of a linear layer. We build our TNT architecture by stacking the TNT blocks. Compared to the conventional vision transformers (ViT) which corrupts the local structure of the patch, our TNT can better preserve and model the local information for visual recognition. Extensive experiments on ImageNet and downstream tasks have demonstrate the effectiveness of the proposed TNT architecture.

heading: Acknowledgement
text: This work was supported by NSFC (62072449, 61632003), Guangdong-Hongkong-Macao Joint Research Grant (2020B1515130004) and Macao FDCT (0018/2019/AKP, 0015/2019/AKP).

Review summaries:
This paper proposes a novel vision transformer (TNT) to better model the fine-grained relationship within local image patches.  Specifically, based on the patch splitting scheme in ViT, the authors further split the local patches ("visual sentence") into smaller ones ("visual words"). Inner transformers are adopted to model relationships between words and improve sentence representation. Experiments on ImageNet classification and several downstream tasks validate the effectiveness of the proposed method.  

This paper presents a new Transformer-based framework "Transformer-iN-Transformer" (TNT) for visual recognition. The proposed TNT module can better preserve and model the local information for visual recognition compared to conventional VIT. Extensional experiments prove its effectiveness in image classification and object detection.

The work proposes a nested vision Transformer variant (TNT), which adds an additional inner Transformer to capture within-patch information. By setting the hidden dimension of the inner Transformer much smaller, the FLOPs and #Params of the proposed TNT won't be overly large. Empirically, authors show that the proposed model performs better than ViT/DeiT on ImageNet classification, COCO object detection and ADE20K semantic segmentation.