Year: 2021

Abstract:
Transformers have been successful in many vision tasks, thanks to their capability of capturing long-range dependency. However, their quadratic computational complexity poses a major obstacle for applying them to vision tasks requiring dense predictions, such as object detection, feature matching, stereo, etc. We introduce QuadTree Attention, which reduces the computational complexity from quadratic to linear. Our quadtree transformer builds token pyramids and computes attention in a coarse-to-fine manner. At each level, the top K patches with the highest attention scores are selected, such that at the next level, attention is only evaluated within the relevant regions corresponding to these top K patches. We demonstrate that quadtree attention achieves state-of-the-art performance in various vision tasks, e.g. with 2.7% improvement in feature matching on ScanNet, about 50% flops reduction in stereo matching, 0.6-1.4% improvement in top-1 accuracy on ImageNet classification, and 1.3-1.6% improvement with 30% flops reduction on COCO object detection.

heading: 1 INTROCUTION
text: Transformers can capture long-range dependencies by the attention module and have demonstrated tremendous success in natural language processing tasks. In recent years, transformers have also been adapted to computer vision tasks for image classification (Dosovitskiy et al., 2020), object detection (Wang et al., 2021c), semantic segmentation (Liu et al., 2021), feature matching (Sarlin et al., 2020), and stereo (Li et al., 2021), etc. Typically, images are divided into patches and these patches are flattened and fed to a transformer as word tokens to evaluate attention scores. However, transformers have quadratic computational complexity in terms of the number of tokens, i.e. number of image patches. Thus, applying transformers to computer vision applications requires careful simplification of the involved computation.
To utilize the standard transformer in vision tasks, many works opt to apply it on low resolution or sparse tokens. ViT (Dosovitskiy et al., 2020) uses coarse image patches of 16 × 16 pixels to limit the number of tokens. DPT (Ranftl et al., 2021) up-samples low-resolution results from ViT to high resolution maps to achieve dense predictions. SuperGlue (Sarlin et al., 2020) applies transformer on sparse image keypoints. Focusing on correspondence and stereo matching applications, Germain et al. (2021) and Li et al. (2021) also apply transformers at a low resolution feature map.
However, as demonstrated in several works (Wang et al. (2021c); Liu et al. (2021); Sun et al. (2021); Li et al. (2021)), applying transformers on high resolution is beneficial for a variety of tasks. Thus, many efforts have been made to design efficient transformers to reduce computational complexity. Linear approximate transformers (Katharopoulos et al., 2020; Wang et al., 2020) approximate standard attention computation with linear methods. However, empirical studies (Germain et al., 2021; Chen et al., 2021) show those linear transformers are inferior in vision tasks. To reduce the computational cost, the PVT (Wang et al., 2021c) uses downsampled keys and values, which is harmful to capture pixel-level details. In comparison, the Swin Transformer (Liu et al., 2021) restricts the attention in local windows in a single attention block, which might hurt long-range dependencies, the most important merit of transformers.
Unlike all these previous works, we design an efficient vision transformer that captures both fine image details and long-range dependencies. Inspired by the observation that most image regions are irrelevant, we build token pyramids and compute attention in a coarse to fine manner. In this way, we can quickly skip irrelevant regions in the fine level if their corresponding coarse level regions are
not promising. For example, as in Figure 1, at the 1st level, we compute the attention of the blue image patch in image A with all the patches in image B and choose the top K (here, K = 2) patches which are also highlighted in blue. In the 2nd level, for the four framed sub-patches in image A (which are children patches of the blue patch at the 1st level), we only compute their attentions with the sub-patches corresponding to the top K patches in image B at the 1st level. All the other shaded sub-patches are skipped to reduce computation. We highlight two sub-patches in image A in yellow and green. Their corresponding top K patches in image B are also highlighted in the same color. This process is iterated in the 3rd level, where we only show the sub-sub-patches corresponding to the green sub-patch at the 2nd level. In this manner, our method can both obtain fine scale attention and retain long-range connections. Most importantly, only sparse attention is evaluated in the whole process. Thus, our method has low memory and computational costs. Since a quadtree structure is formed in this process, we refer to our method as QuadTree Attention, or QuadTree Transformer.
In experiments, we demonstrate the effectiveness of our quadtree transformer in both tasks requiring cross attention, e.g. feature matching and stereo, and tasks only utilizing self-attention, e.g. image classification and object detection. Our method achieves state-of-the-art performance with significantly reduced computation, comparing to relevant efficient transformers (Katharopoulos et al. (2020); Wang et al. (2021c); Liu et al. (2021)). In feature matching, we achieve 60.3 AUC@20◦ in ScanNet (Dai et al., 2017), 2.7 higher than the linear transformer (Katharopoulos et al., 2020) but with similar flops. In stereo matching, we achieve a similar end-point-error as standard transformer, (Li et al., 2021) but with about 50% flops reduction and 40% memory reduction. In image classification, we achieve 82.6% top-1 accuracy in ImageNet (Deng et al., 2009), 6.2% higher than ResNet (He et al., 2016) and 1.3% higher than the Swin Transformer-T (Liu et al., 2021), with fewer parameters and flops. In object detection, our QuadTree Attention + RetinaNet achieves 46.2 AP in COCO (Lin et al., 2014), 1.6 higher than the backbone PVTv2 (Wang et al., 2021b) but around 35% reduction in flops.

heading: 2 RELATED WORK
text: Efficient Transformers. Transformers have shown great success in both natural language processing and computer vision. Due to the quadratic computational complexity, the computation of full attention is unaffordable when dealing with long sequence tokens. Therefore, many works design efficient transformers, aiming to reduce computational complexity (Katharopoulos et al., 2020; Choromanski et al., 2020; Wang et al., 2020; Lee et al., 2019; Ying et al., 2018). Current efficient transformers can be categorized into three classes. 1) Linear approximate attention (Katharopoulos
et al., 2020; Choromanski et al., 2020; Wang et al., 2020; Beltagy et al., 2020; Zaheer et al., 2020) approximates the full attention matrix by linearizing the softmax attention and thus can accelerate the computation by first computing the product of keys and values. 2) Inducing point-based linear transformers (Lee et al., 2019; Ying et al., 2018) use learned inducing points with fixed size to compute attention with input tokens, thus can reduce the computation to linear complexity. However, these linear transformers are shown to have inferior results than standard transformers in different works (Germain et al., 2021; Chen et al., 2021). 3) Sparse attention, including Longformer (Beltagy et al., 2020), Big Bird (Zaheer et al., 2020), etc, attends each query token to part of key and value tokens instead of the entire sequence. Unlike these works, our quadtree attention can quickly skip the irrelevant tokens according to the attention scores at coarse levels. Thus, it achieves less information loss while keeps high efficiency.
Vision Transformers. Transformers have shown extraordinary performance in many vision tasks. ViT (Dosovitskiy et al., 2020) applies transformers to image recognition, demonstrating the superiority of transformers for image classification at a large scale. However, due to the computational complexity of full attention, it is hard to apply transformers in dense prediction tasks, e.g. object detection, semantic segmentation, etc. To address this problem, Swin Transformer (Liu et al., 2021) restricts attention computation in a local window. Focal transformer (Yang et al., 2021) uses twolevel windows to increase the ability to capture long-range connection for local attention methods. Pyramid vision transformer (PVT) (Wang et al., 2021c) reduce the computation of global attention methods by downsampling key and value tokens. Although these methods have shown improvements in various tasks, they have drawbacks either in capturing long-range dependencies (Liu et al., 2021) or fine level attention (Wang et al., 2021c). Different from these methods, our method simultaneously capture both local and global attention by computing attention from full image levels to the finest token levels with token pyramids in one single block. Besides, the K-NN transformers (Wang et al., 2021a; Zhao et al., 2019) aggregate messages from top K most similar tokens as ours, but they compute the attention scores among all pairs of query and key tokens, and thus still has quadratic complexity.
Beyond self-attention, many tasks can largely benefit from cross attention. Superglue (Sarlin et al., 2020) processes detected local descriptors with self- and cross attention and shows significant improvement in feature matching. Standard transformers can be applied in SuperGlue because only sparse keypoints are considered. SGMNet (Chen et al., 2021) further reduces the computation by attending to seeded matches. LoFTR (Sun et al., 2021) utilizes linear transformer (Katharopoulos et al., 2020) on low-resolution feature maps to generate dense matches. For stereo matching, STTR (Li et al., 2021) applies self- and cross attention along epipolar lines and reduces the memory by gradient checkpointing engineering techniques. However, due to the requirement of processing a large number of points, these works either use linear transformers, which compromise performance, or a standard transformer, which compromises efficiency. In contrast, our transformer with quadtree attention achieves a significant performance boost compared with linear transformer or efficiency improvement compared with standard transformer. Besides, it can be applied to both self-attention and cross attention.

heading: 3 METHOD
text: We first briefly review the attention mechanism in transformers in Section 3.1 and then formulate our quadtree attention in Section 3.2.

heading: 3.1 ATTENTION IN TRANSFORMER
text: Vision transformers have shown great success in many tasks. At the heart of a transformer is the attention module, which can capture long-range information between feature embeddings. Given two image embeddings X1 and X2, the attention module passes information between them. Selfattention is the case when X1 and X2 are the same, while cross attention covers a more general situation when X1 and X2 are different. It first generates the query Q, key K, and value V by the
Under review as a conference paper at ICLR 2022
level 3
qi
Under review as a conference paper at ICLR 2022
QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K
⌦li
⌦l+1i
⌦l+2i
mli
ml+1i
ml+2i
li
l+1i
l+2i
REFERENCES
1
Under review as a conference paper at ICLR 2022
QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦li
⌦l+1i
⌦l+2i
mli
ml+1i
ml+2i
li
l+1i
l+2i
⇤li
⇤l+1i
⇤l+2i
REFERENCES
1
level 2level 1
QuadTree-A
Under review as a conference paper at ICLR 2022
QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦1i
⌦2i
⌦3i
m1i
m2i
m3i
1
2
3
⇤li
⇤l+1i
⇤l+2i
REFERENCES
1
QuadTree-B
Under review as a conference paper at ICLR 2022
QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦1i
⌦2i
⌦3i
m1i
m2i
m3i
1i
2i
3i
⇤li
⇤l+1i
⇤l+2i
REFERENCES
1
(b)
(c)
(a)
0.1
0.2
0.3
0.4
0.25
0.30
0.10 0.05
0.10
0.05
0.050.10
Under review as a conference paper at ICLR 2022 QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦1i
⌦2i
⌦3i
m1i
m2i
m3i
1i
2i
3i
⇤li
⇤l+1i
⇤l+2i
level 1 level 2 level 3
m1i
m2i
m3i
REFERENCES
1
Under review as a conference paper at ICLR 2022 QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦1i
⌦2i
⌦3i
m1i
m2i
m3i
1i
2i
3i
⇤li
⇤l+1i
⇤l+2i
level 1 level 2 level 3
m1i
m2i
m3i
REFERENCES
1
Under review as a conference paper at ICLR 2022 QUADTREE ATTENTION FOR VISION TRANSFORMER
Anonymous authors Paper under double-blind review
Q
K\V ⌦1i
⌦2i
⌦3i
m1i
m2i
m3i
1i
2i
3i
⇤li
⇤l+1i
⇤l+2i
level 1 level 2 level 3
m1i
m2i
m3i
REFERENCES
1
Under review as a conference paper at ICLR 2022 QUADTREE ATTENTION FOR VISION TRANSFORMER Anonymous authors Paper under double-blind review Q K\V ⌦1i ⌦2i ⌦3i m1i m2i m3i 1i 2i 3i ⇤li ⇤l+1i
⇤l+2i
level 1 level 2 level 3
m1i
m2i
m3i
REFERENCES
1
Figure 2: Illustration of quadtree message aggregation for a query token qi. (a) shows the token pyramids and involved key/value tokens in each level. Attention scores are marked in the first two levels for clarification, and the top K scores are highlighted in red. (b) shows message aggregation for QuadTree-A architecture. The message is assembled from different levels along a quadtree. (c) shows message aggregation for QuadTree-B architecture. The message is collected from overlapping regions from different levels.
following equation,
Q = WqX1,
K = WkX2,
V = WvX2,
where Wq , Wk and Wv are learnable parameters. Then, it performs message aggregation by computing the attention scores between query and key as following,
Y = softmax( QKT√
C )V, (1)
where C is the embedding channel dimension. The above process has O(N2) computational complexity, where N is the number of image patches in a vision transformer. This quadratic complexity hinders transformers from being applied to tasks requiring high resolution output. To address this problem, PVT (Wang et al. (2021c)) downsamples K and V, while Swin Transformer (Liu et al. (2021)) limits the attention computation within local windows.

heading: 3.2 QUADTREE ATTENTION
text: In order to reduce the computational cost of vision transformers, we present QuadTree Attention. As the name implies, we borrow the idea from quadtrees, which are often used to partition a twodimensional space by recursively subdividing it into four quadrants or regions. Quadtree attention computes attention in a coarse to fine manner. According to the results at the coarse level, irrelevant image regions are skipped quickly at the fine level. This design achieves less information loss while keeping high efficiency.
The same as the regular transformers, we first linearly project X1 and X2 to the query, key, and value tokens. To facilitate fast attention computation, we construct L-level pyramids for query Q, key
K, and value V tokens by downsampling feature maps. For query and key tokens, we use average pooling layers. For value tokens, average pooling is used for cross attention tasks and convolutionalnormalization-activation layers with stride 2 are used for self attention tasks if no special statement. As shown in Figure 1, after computing attention scores in the coarse level, for each query token, we select the top K key tokens with the highest attention scores. At the fine level, query sub-tokens only need to be evaluated with those key sub-tokens that correspond to one of the selected K key tokens at the coarse level. This process is repeated until the finest level. After computing the attention scores, we aggregate messages at all levels, where we design two architectures named as QuadTree-A and QuadTree-B.
QuadTree-A. Considering the i-th query token qi at the finest level, we need to compute its received message mi from all key tokens. This design assembles the full message by collecting partial messages from different pyramid levels. Specifically,
mi = ∑
1≤l≤L
mli, (2)
where mli indicates the partial message evaluated at level l. This partial message m l i assemble messages at the l-th level from tokens within the region Ωli, which will be defined later. In this way, messages from less related regions are computed from coarse levels, while messages from highly related regions are computed in fine levels. This scheme is illustrated in Figure 2 (b), message mi is generated by assembling three partial messages that are computed from different image regions with different colors, which collectively cover the entire image space. The green region indicates the most relevant region and is evaluated at the finest level, while the red region is the most irrelevant region and is evaluated at the coarsest level. The region Ωli can be defined as Γ l i − Γ l+1 i , where the image region Γli corresponds to the top K tokens at the level l − 1. The regions Γli are illustrated in Figure 2 (c). The region Γ1i covers the entire image.
The partial messages are computed as, mli = ∑ j∈Ωli slijv l j , (3)
where slij is the attention score between the query and key tokens at level l. Figure 2 (a) highlights query and key tokens involved in computing mli with the same color as Ω l i. Attention scores are computed recursively, slij = s l−1 ij t l ij . (4) Here, sl−1ij is the score of corresponding parent query and key tokens and s 1 ij = 1. The tentative attention score tlij is evaluated according to Equation 1 among the 2 × 2 tokens of the same parent query token. For QuadTree-A, we use average pooling layers to downsample all query, key and value tokens.
QuadTree-B. The attention scores slij in QuadTree-A are recursively computed from all levels, which makes scores smaller at finer levels and reduces the contributions of fine image features. Besides, fine level scores are also largely affected by the inaccuracy at coarse levels. So we design a different scheme, referred as QuadTree-B in this paper, to address this problem. Specifically, we compute mi as a weighted average of the partial messages from different levels,
mi = ∑
1≤l≤L
wlim l i, (5)
where wli is a learned weight. As shown in Figure 2 (c), the partial messages here overlap with each other, which are computed as,
mli = Attention(q l i,K l Γli ,VlΓli ), (6)
where Attention is the attention message computation as Equation 1. Here, Kl Γli and Vl Γli are matrices formed by stacking all keys and values within the region Γli.
Both QuadTree-A and QuadTree-B involve only sparse attention evaluation. Thus, our method largely reduces computational complexity. As analyzed in Appendix A.1, the computational complexity of our quadtree attention is linear to the number of tokens.
Multiscale position encoding. The computation of attention is permutation invariant to tokens, and thus positional information is missed. To address this problem, we adopt the locally-enhanced positional encoding (LePE) (Dong et al., 2021) at each level to design a multiscale position encoding. Specifically, for level l, we apply unshared depth-wise convolution layers to value tokens Vl to encode the positional information.

heading: 4 EXPERIMENT
text: We experiment our quadtree transformer with four representative tasks, including feature matching, stereo, image classification, and object detection. The first two tasks require cross attention to fuse information across different images, while the latter two involve only self-attention. We implement our quadtree transformer using PyTorch and CUDA kernels. More implementation details are provided in Appendix B.

heading: 4.1 CROSS ATTENTION TASKS

heading: 4.1.1 FEATURE MATCHING
text: Finding feature correspondence (Luo et al., 2019; DeTone et al., 2018) across different images is a precedent problem for many 3D computer vision tasks. It is typically evaluated by the accuracy of the camera pose estimated from the corresponding points. We follow the framework proposed in a recent state-of-the-art work LoFTR (Sun et al., 2021), which consists of a CNN-based feature extractor and a transformer-based matcher. We replace the linear transformer (Katharopoulos et al., 2020) in LoFTR with our quadtree transformer. Besides, we also implement a new version of LoFTR with the spatial reduction (SR) attention (Wang et al., 2021c) for additional comparison.
Setting. We experiment on ScanNet (Dai et al., 2017) with 1,513 scans. In order to accelerate training, we design the LoFTR-lite setting, which uses half of the feature channels of LoFTR and 453 training scans. Ablation studies in section 4.3 are conducted in this setting. We train both LoFTRlite and LoFTR for 30 epochs with batch size 8. For quadtree transformer, we build pyramids of three levels with the coarsest resolution at 15× 20 pixels. We set the parameter K to 8 at the finest level, and double it at coarser levels. For the SR attention, we average pool the value and key tokens to the size 8× 8 to keep similar memory usage and flops as our quadtree attention. More details are included in Appendix B.1.
Results. Table 1 shows the AUC of camera pose errors1 under (5◦, 10◦, 20◦). We can see that the SR attention achieves similar results with linear transformer. In comparison, both QuadTree-A and QuadTree-B outperform linear transformer and SR attention by a large margin. Quadtree-B
1Camera pose errors are evaluated as the differences between estimated and ground truth camera orientation and translation direction, both measured in degrees.
generally performs better than Quadtree-A. Quadtree-B has 2.6 and 1.9 improvements in terms of AUC@20◦ over linear transformer on LoFTR-lite and LoFTR respectively. To further enhance the results, we train a model with K = 16 and initialize the backbone ResNet-18 with the weights published in (Sun et al., 2021). This model achieves 2.7 improvements on AUC@20◦ over (Sun et al., 2021), where the LoFTR model is trained with a batch size of 64 with 64 GPUs, a more preferable setting leading to slightly better results than our linear transformer implementation shown in Table 1.

heading: 4.1.2 STEREO MATCHING
text: Stereo matching aims to find corresponding pixels on epipolar lines between two rectified images. The recent work STTR (Li et al., 2021) applies transformers to feature points between epipolar lines and achieves state-of-the-art performance. Note here, both self- and cross attention are applied along epipolar lines, pixels across different lines are not considered in the attention computation. We replace the standard transformer in STTR (Li et al., 2021) with our quadtree transformer.
Setting. We experiment on the Scene Flow FlyingThings3D (Mayer et al., 2016) synthetic dataset, which contains 25,466 images with a resolution of 960 × 540. We build pyramids of four levels to evaluate quadtree attention. While the STTR is applied to features of 1/3 of image resolution, we use feature maps of 1/2 of image resolution. More details about the network are included in Appendix B.2.
Results. We report EPE (End-Point-Error) in non-occluded regions and IOU (Intersection-overUnion) for occlusion estimation in Table 2 as (Li et al., 2021). Computational complexity and memory usage are also reported. Compared with STTR based on the standard transformer, our quadtree transformer achieves similar EPE (0.45 px vs 0.46 px) and higher IOU for occlusion estimation, but with much lower computational and memory costs, with only 52% FLOPs and 63% memory consumption.

heading: 4.2 SELF-ATTENTION TASK
text: This section presents results on image classification and object detection. In the past, convolutional neural networks (CNNs) have dominated these tasks for a long time. Recently, vision transformers (Dosovitskiy et al., 2020; Liu et al., 2021; Wang et al., 2021c) show excellent potential on these problems, thanks to their capability in capturing long-range interactions. To compare our method with these vision transformers on image classification, we use the public codes of PVTv2 (Wang et al., 2021c) and replace all the spatial reduction attention with our quadtree attention. For object detection, we further apply a representative object detection framework, RetinaNet (Lin et al., 2017), which is a widely used single-stage object detector.

heading: 4.2.1 IMAGE CLASSIFICATION
text: Settings. We evaluate image classification on the ImageNet-1K dataset (Deng et al., 2009), which consists of 1.28M training images and 50K validation images from 1,000 categories. We build token pyramids with the coarsest level at a resolution of 7×7 and set K = 8. We crop and resize the input images to 224 × 224 pixels and train the model with a mini-batch of 128. All models are trained for 300 epochs from scratch on 8 GPUs. All the other training settings are the same as in (Wang et al., 2021c). We build three different quadtree transformers at different complexity, named as b0, b1, b2. These models are gradually deeper and wider. There are 8 transformer blocks in b0 and b1, while there are 16 transformer blocks in b2. Furthermore, the number of feature channels in b1 is two times of that in b0. More configuration details can be found in Appendix. B.3.
Results. We provide the top-1 accuracy of various methods and network settings in Table 3. These results are grouped into three sections, each with several methods of similar network complexity as indicated by the number of parameters. As shown in Table 3, QuadTree-B outperforms PVTv2 by 0.5%-0.9% in top-1 accuracy with fewer parameters. Swin Transformer-T adopts local attention and is surpassed by our QuadTree-B-b2 by 1.3% in top-1 accuracy, although it has 5.8M more parameters and 0.2 more flops. This result proves that global information is important. In general, our quadtree transformer leverages both global information at the coarse level and local information at fine levels, and outperforms both PVTv2 and Swin Transformer.

heading: 4.2.2 OBJECT DETECTION
text: Settings. We experiment on the COCO dataset. All models are trained on COCO train2017 (118k images) and evaluated on val2017 (5k images). We initialize the quadtree backbone with the weights pre-trained on ImageNet. We adopt the same setting as PVTv2, training the model with a batch size of 16 and AdamW optimizer with an initial learning rate of 1 × 10−4 for 12 epochs. We use the standard metric average precision to evaluate our method.
Results. We mainly compare our method with PVTv2, ResNet (He et al., 2016), and ResNeXt (Xie et al., 2017), which are state-of-the-art backbones for dense prediction. Table 4 lists the average precision of different methods and their backbone flops for images of resolution of 800 × 1, 333. Benefiting from the coarse to fine mechanism, a small K is enough for our method. Thus, the computation can be reduced when using high resolution images. We can see that QuadTree-B achieves slightly higher performance, but with much fewer flops than PVTv2. Our quadtree transformer also outperforms ResNet and ResNeXt. For example, QuadTree-B-b2 outperform ResNet101 and ResNeXt101-32x4d by 6.4 AP and 5.0 AP respectively with about 40% backbone flops reduction.

heading: 4.3 ANALYSIS
text: Top K numbers. Table 6 and Table 7 shows the performance of QuadTree-B architecture with different value of K for object detection and feature matching respectively. The performance is improved when K becomes larger and saturates quickly. This indicates only a few tokens with high attention scores should be subdivided in the next level for computing attentions.
Comparison with other attention mechanisms. For a fair comparison with other attention mechanisms, we test these attention mechanisms under the same backbone and training settings. Specifically, we replace the original attention module in PVTv2-Bb with the attention method used in Swin Transformer and Focal Transformer. For more fair comparison, we adopt the same positional encoding LePE (Dong et al., 2021) to PVTv2, Swin and Focal transformer. As shown in Tab. 5, QuadTree attention obtain consistently better performance than Swin and PVTv2 in both classification task and detection task. Compared with focal attention, our method gets 1.0 higher results in object detection, which might be because that QuadTree attention can always cover the whole images, while Focal attention only covers 1/6 of the image in the first stage. For cross attention tasks, we provide visualization of attention score as shown in Fig.5 in Appendix E. Our method can attend to much more related regions than PVT (Wang et al., 2021b) and Linear attention (Katharopoulos et al., 2020).

heading: 5 CONCLUSION
text: We introduce QuadTree Attention to reduce the computational complexity of vision transformers from quadratic to linear. Quadtree transformers build token pyramids and compute attention in a coarse-to-fine manner. At each level, top K regions with the highest attention scores are selected, such that in finer level, computation in irrelevant regions can be quickly skipped. Quadtree attention can be applied to cross attention as well as self-attention. It achieves state-of-the-art performance in various tasks including feature matching, stereo, image classification, and object detection.

heading: A APPENDIX
text: A.1 COMPLEXITY ANALYSIS
In this section, we analyze the computational complexity of quadtree attention. Suppose the lengths of the query tokens, key tokens, and value tokens are all H ×W . We build token pyramids of L levels, the lth level has a token length of HW
4l−1 . The flops of computing quadtree attention is,
Flops = 2(H20W 2 0 + L−1∑ l−2 4KHW 4l−1 )
= 2(H20W 2 0 +
4 3 (1− 41−L)KHW ).
Here, H0 and W0 are the height and width of the coarsest level of token pyramids. Therefore, H20W 2 0 is a constant and the computational complexity is O(KHW ). Since K is a constant number, the complexity of quadtree attention is linear to the number of tokens.

heading: B ADDITIONAL TASK INTRODUCTION AND IMPLEMENTATION DETAILS
text: B.1 FEATURE MATCHING
SuperGlue (Sarlin et al., 2020) is the first feature matching method that shows transformers can significantly improve performance. It first detects interest points and extracts local descriptors using convolutional neural networks. Then, cross attention and self-attention are chained alternatively to generate new descriptors from the extracted descriptors. SuperGlue uses full attention, since the number of interest points is small, typically less than 1,000. Recently, another work, LoFTR (Sun et al., 2021) abandons interest point detection and directly matches dense pixels on a 60×80 feature map. After obtaining the coarse match results, the positions are refined by fine matches in local regions through a linear transformer. However, due to the computational costs of full attention, LoFTR compromises to apply linear attention to process high resolution images. It first uses ResNet18 (He et al., 2016) to extract image features from two images and leverages four self- and cross linear attentions to process those features. The costs are computed for features after transformer. It shows significant improvement over SuperGlue.
Implementation details. We train and evaluate the model in ScanNet (Dai et al., 2017), where 230M image pairs is sampled for training, with overlapping scores between 0.4 and 0.8. ScanNet provides RGB images, depth maps, and ground truth camera poses on a well-defined training and testing split. Following the same evaluation settings as Sarlin et al. (2020) and Sun et al. (2021), we evaluate our method on the 1,500 testing pairs from (Sarlin et al., 2020). For both trainig and testing, all images and depth maps are resized to 640 × 480. Following (Sun et al., 2021), we compute the camera pose by solving the essential matrix from predicted matches with RANSAC. We report the AUC of the pose error at thresholds (5◦, 10◦, 20◦), where the pose error is defined as the maximum of angular error in rotation and translation. We only replace the coarse level transformer with quadtree attention.
B.2 STEREO MATCHING
Our network is based on the STTR (Li et al., 2021), where we replace the standard transformer with our quadtree transformer. The network consists of a CNN backbone which outputs feature maps of 1/2 image resolution, a quadtree transformer with both self- and cross attention, a regression head with optimal transport layers (Cuturi, 2013), and a context adjust layer to refine the disparity. Six self- and cross attention layers are used with 128 channels. We build pyramids with four levels for quadtree attention, and apply the Sinkhorn algorithm (Cuturi, 2013) for 10 iteration for optimal transport. We follow STTR to train the network, with 15 epochs of AdamW optimizer. OneCycle learning rate scheduler is used with a leaning rate of 6e-4 and a batch size of 8.
B.3 IMAGE CLASSIFICATION
This paragraph introduces the details of PVTv2-b0, b1, b2. All these three networks have 4 stages. Each stage is down-sampled from the previous stage by a stride of 2. The feature resolutions for each stage is H4 × W 4 , H 8 × W 8 , H 16 × W 16 and H 32 × W 32 respectively, where H and W is the image height and width. For each stage, M quadtree transformers are used with a channel number of I and head number of J . For the network PVTv2-b0, the parameters M , I , J are set to [2, 2, 2, 2], [32, 64, 160, 256], [1, 2, 5, 8] at each stage respectively. For the network PVTv2-b1, the parameters M , I , J are set to [2, 2, 2, 2], [64, 128, 320, 512], [1, 2, 5, 8] respectively. Finally, for PVTv2-b2, the parameters M , I , J are set to [3, 4, 6, 3], [64, 128, 320, 512], [1, 2, 5, 8] respectively.

heading: C TRAINING LOSS
text: Feature matching. We plot the training loss and validation performance for LoFTR-lite in Figure 3 for different efficient transformers, including spatial reduction (SR) transformer (Wang et al., 2021c), linear transformer (Katharopoulos et al., 2020), our Quadtree-A, and Quadtree-B transformers. We can see quadtree-B transformer obtains consistently lower training loss and higher performance over other three transformers. In addition, it is also noted that the spatial reduction (SR)
transformer has lower training but worse AUC@20◦ than QuadTree-A attention, which indicates that it cannot generalize well.
Image classification. We also show traning and validation curve for image classification task with respective to different attentions in Fig. 4. Compared with Swin Transformer (Liu et al., 2021) and PVT (Wang et al., 2021c), the loss of Quadtree attention is consistently lower and the top 1 accuracy is higher.

heading: D RUNNING TIME
text: Currently, we only implement a naive CUDA kernel without many optimizations and it is not as efficient as the well-optimized dense GPU matrix operation. We test the running time of Retinanet under PVTv2-b0 architecture. For PVTv2-b0, The running time is 0.026s to forward one image and for Quadtree-b0, the running time is 0.046s for forwarding once. However, Quadtree-b0 has
much lower memory usage than PVTv2-b0. Quadtree-b0 consumes about 339MB while PVTv2-b0 consumes about 574MB for one 800× 1333 image.

heading: E ABLATIONS
text: QuadTree-A vs QuadTree-B. QuadTree-B architecture consistently outperforms QuadTree-A in feature matching, image classification, and detection experiments. We analyze its reason as shown in Figure 5, where (d) and (e) show the attention score maps of QuadTree-A and QuadTree-B at different levels for the same point in the query image shown in (a). It is clear that the QuadTree-B has more accurate score maps, and is less affected by the inaccuracy in coarse level score estimation. We further visualize the attention scores of spatial reduction (SR) attention (Wang et al., 2021c) and linear transformer (Katharopoulos et al., 2020) in (b) and (c). We can see that SR attention and linear transformer attend the query token on large unrelated regions due to the loss of fine-grained information. In contrast, our quadtree transformer focus on the most relevant area.
Comparison with Swin Transformer and Focal Transformer. We compare with Swin Transformer and Focal Transformer in Table. 8 using the released codes. We replace the corresponding attention in Swin Transformer with Quadtree-B attention. Our method obtains 0.9% higher top 1 accuracy than Swin Transformer and 2.6 higher in object detection. Compared with Focal transformer, quadtree attention achieve the same top 1 accuracy in classification with fewer flops, and 0.9 higher AP in object detection.
Multiscale position encoding. We compare our method with or without multiscale position encoding (MPE). For Quadtree-B-b2 model, MPE can bring an improvement of 1.3 on object detection.

Review summaries:
This paper proposes a new attention mechanism in vision transformers, which is called quadtree attention. This quadtree attention mechanism builds token pyramids and computes the attention in a coarse-to-fine manner. At each level, only top K regions with the highest attention scores from query and key are selected for further attention computation on finer tokens, while other regions simply use (current) coarse attention as a part of output. In the empirical study, the proposed quadtree attention achieves good performance on a wide range of vision tasks (e.g. feature matching, stereo matching, classification and object detection) with less computation.

The paper proposed an attention approach to handle the global or long-range attention by leveraging the idea of quadtree structure, meanwhile reducing the quadratic complexity of original attention operation to linear. Experiments are performed on several tasks, e.g. feature matching, image classification, and objection detection. Superior results are achieved on these tasks. 

This paper aims to address the quadratic computational complexity of vanilla Transformers. The key idea is to build token pyramids and computes attention in a coarse-to-fine manner, which reduces the computational complexity to linear. The resulting attention paradigm forms a quadtree structure, and two variants, QuadTree-A and QuadTree-B, are further proposed to improve message aggregation. Experiments are conducted on four different computer vision tasks involving either self-attention or cross attention. Results show that the proposed approach matches the state of the art with much fewer FLOPs and model parameters.

The paper proposes an efficient attention algorithm based on quadtree for vision transformers. It establishes a feature pyramid for tokens and aggregates sparse key-value features in each pyramid level. The method achieves competitive performance on the stereo, image classification and object detection.