A XIAL A TTENTION
I N M ULTIDIMENSIONAL T RANSFORMERS
Anonymous authors
Paper under double-blind review
A BSTRACT
We propose Axial Transformers, a self-attention-based autoregressive model for images and other data organized as high dimensional tensors.
Existing autoregressive models either suffer from excessively large computational resource requirements for high dimensional data, or make compromises in terms of distribution expressiveness or ease of implementation in order to decrease resource requirements.
Our architecture, by contrast, maintains both full expressiveness over joint distributions over data and ease of implementation with standard deep learning frameworks, while requiring reasonable memory and computation and achieving state-of-the-art results on standard generative modeling benchmarks.
Our models are based on axial attention, a simple generalization of self-attention that naturally aligns with the multiple dimensions of the tensors in both the encoding and the decoding settings.
Notably the proposed structure of the layers allows for the vast majority of the context to be computed in parallel during decoding without introducing any independence assumptions.
This semi-parallel structure goes a long way to making decoding from even a very large Axial Transformer broadly applicable.
We demonstrate state-of-the-art results for the Axial Transformer on the ImageNet-32 and ImageNet-64 image benchmarks as well as on the BAIR Robotic Pushing video benchmark.
We open source the implementation of Axial Transformers.
I NTRODUCTION
Autoregressive models are a family of exact likelihood-based generative models that represent the joint distribution of data x = ( x 1 , . . . , x N ) as a product of conditionals p θ ( x ) = (cid:81) Ni =1 p θ ( x i | x <i ) .
Neural network models in this family have achieved state-of-the-art log likelihoods on highdimensional image and video datasets (van den Oord et al., 2016a;
Chen et al., 2018; Menick &
Kalchbrenner, 2018; Parmar et al., 2018; Child et al., 2019; Weissenborn et al., 2019; Salimans et al., 2017; Kalchbrenner et al., 2017; Uria et al., 2016; Parikh et al., 2016; Theis & Bethge, 2015; van den Oord et al., 2016b) due to architectural innovations that enable the following capabilities:
Large, high information bandwidth receptive ﬁelds for each pixel x i , capable of expressing long-range dependencies over previous pixels x <i , and 2.
Computationally efﬁcient, vectorizable computation of the log likelihood and its gradient.
Autoregressive model architectures that can read long-range dependencies over large receptive ﬁelds are able to express all joint distributions over the data.
Meanwhile, architectures that admit fast log likelihood gradient computation are suitable for training using a stochastic gradient method on a maximum likelihood objective—a straightforward, stable training procedure for generative models.
These desiderata make self-attention a compelling building block for autoregressive model architectures.
Self-attention is a neural network operation that is able to transform a sequence y 1 , . . .
, y N into a sequence y (cid:48) 1 , . . .
, y (cid:48) N , where each y (cid:48)
i depends on all
y i by way of a single vectorizable computation (Vaswani et al., 2017).
Self-attention is remarkably effective at learning long-range dependencies between data dimensions and neural networks that incorporate self-attention in their designs are state-of-the-art on many tasks from language modelling and machine translation to image and video modelling (Parmar et al., 2018; Child et al., 2019). [Figure]
But the power of self-attention comes at the price of computational complexity.
The memory and computation it consumes grow quadratically with the sequence length N making it prohibitively expensive to directly apply self-attention to long sequences.
In the case of autoregressive models of multidimensional tensors such as images or videos, the aim to capture large receptive ﬁelds in multiple dimensions further exacerbates the problem as even a modest number of receptive ﬁeld steps in each dimension can encompass a large total number of locations.
Various approaches have been proposed to alleviate this difﬁculty at the cost of either limiting the receptive ﬁeld or requiring operations that may not be broadly available on GPUs or TPUs.
We propose the Axial Transformer, a simple yet effective self-attention-based autoregressive model for data organized as multidimensional tensors.
Rather than applying attention to a ﬂattened string of tensor elements, our model instead applies attention along a single axis of the tensor without ﬂattening—we refer to this as “axial attention.”
Since the length of any single axis (that is, the height or width of an image) is typically much smaller than the total number of elements, an axial attention operation enjoys a signiﬁcant saving in computation and memory over standard self-attention: for a d -dimensional tensor with shape N =
N 1 /d × · · · × N 1 /d , axial attention saves a O ( N ( d − 1) /d ) factor of resources over standard self-attention.
Our Axial Transformer architecture allows for the majority of the context x <i to be embedded with a high degree of parallelism without introducing conditional independence assumptions among any of the locations, but has an interesting property that it is amenable to a simple-to-implement fast sampling procedure.
To sample one row of an image, the Axial Transformer only runs an autoregressive
Transformer over that one row only, without re-embedding pixels from previous rows. We structure the Axial Transformer, however, so that it always deﬁnes a fully expressive joint distribution.
No dependencies on previous pixels are ever lost.
We evaluate Axial Transformers on image and video modelling benchmarks.
We show that Axial
Transformer achieves state-of-the-art results on ImageNet-32 and on ImageNet-64.
We also show that, simply by stacking a video along the channel dimension, the Axial Transformer can be directly applied to the channel-stacked video without nearly any modiﬁcation.
On the BAIR Robot Pushing benchmark, the Axial Transformer signiﬁcantly outperforms previous results without using an architecture specially designed for videos.
The generated samples on these datasets are of the expected high quality.
Axial Transformers do not require subroutines for GPUs or TPUs that may exhibit unfavorable memory bandwidth and computation trade-offs.
Axial Transformers are simple to implement using efﬁcient operations that are widely available in deep learning frameworks (primarily dense-dense MatMuls).
An open source implementation of our models is available at anonymized URL .
B ACKGROUND
To set the stage for our discussion, we ﬁrst review self-attention and its computational resource requirements in the context of autoregressive modeling.
A self-attention layer takes as input a length
N sequence of D -dimensional embeddings X (a N × D matrix) and produces an output sequence Y (also a N × D matrix) via:
[Equation]
W Q , W K , and W V are D
× D parameter matrices responsible for projecting the entries of the sequence X into keys, queries, and values, respectively.
Each entry of the output sequence Y is a linear combination of values in V weighted by the attention matrix A , which itself is computed from similarities between all pairs of query and key vectors.
Both the expressive power and the resource cost of self-attention come from computing A and Y : it takes O ( N 2 ) time and space to compute the pairwise similarities between Q and K and to compute the linear combination of V vectors.
This quadratic complexity makes it impractical to apply self-attention to images and videos directly as ﬂattened vectors: a small 32 × 32 × 3 image has 3072 dimensions.
Sequences such as these are too long for self-attention, so attempts to scale self-attention to these modalities generally involve restricting these sequence lengths in a modality-aware manner while attempting to preserve modeling performance.
One strategy is to restrict the conditioning context x <i to a carefully designed small subset of the data dimensions.
While this reduces the cost of attention, which is only performed over these small subsets instead of the full data, the model can no longer express all joint distributions over the data.
Parmar et al.
(2018) propose image models with conditioning context x <i restricted to a small window of the full image, but the implementation requires redundant data copies to extract and process these windows.
Weissenborn et al.
(2019) similarly scale video autoregressive models by restricting the context, again preventing their model from expressing all joint distributions over pixels.
Our models do not restrict context and hence we obtain better log likelihoods, as we will see in section 4.
A different strategy is to stack multiple sparse attention layers, each with restricted context for computational efﬁciency, but in a manner that overlapping these layers yields a full-context model.
Child et al.
(2019) propose two sparse attention patterns with this property.
However, the architecture they propose that works best for images (the Strided Sparse Transformer) requires custom sparse attention GPU kernels to implement a speciﬁc block-sparse variant of matrix-matrix-multiply.
The model cannot be easily implemented on other hardware such as TPUs.
See table 1 for a summary of these architecture design tradeoffs.
Our goal in this paper is to design attention-based autoregressive models that attain the best of all worlds.
Our Axial Transformer, described in subsequent sections, has a full conditioning context, so its ability to express joint distributions is never limited.
The Axial Transformer also does not require any redundant data copies or custom kernels to implement in an efﬁcient way.
Indeed, we designed, and will make open source, an efﬁcient implementation that uses only standard operations in deep learning libraries.
[Table]
A XIAL T RANSFORMERS
We now describe Axial Transformers, our self-attention-based autoregressive models for highdimensional data tensors.
We describe its basic building block in section 3.1 and then we complete the description into a full autoregressive model in section 3.2.
3. A XIAL ATTENTION
We ﬁrst introduce our basic building block for developing self-attention-based autoregressive models for high-dimensional data tensors.
The proposed approach does not change the original shape of the multidimensional data tensor and performs a masked or unmasked attention over a single axis of the tensor at a time.
We call this operation axial attention , denoted by Attention k
( x ) .
It performs attention over axis k of the tensor x , mixing information along axis k while keeping information along other axes independent.
It is straightforward to implement: axial attention over axis k can be implemented by transposing all axes except k to the batch axis, calling standard attention as a subroutine, then undoing the transpose (an alternative is to use the einsum operation available in most deep learning libraries).
When the data is an image, we call Attention 1 column attention , as it mixes information within columns while keeping separate columns independent.
We call Attention 2 row attention for analogous reasons.
Axial attention on a square image of size N = S × S performs attention on S sequences of length S —this is a total of O ( S · S 2 )
=
O ( N √ N ) computation—an O ( √ N ) savings in computation over standard self-attention.
In general, for a d -dimensional tensor with N = S d , axial attention saves O ( N ( d − 1) /d ) computation over standard attention.
Of course, a single layer of axial attention along some axis k does not have the full receptive ﬁeld since it covers a single axis, but we will see in section 3.2 that stacking two axial attention layers allows the model to obtain a global receptive ﬁeld.
It will be important for us to also deﬁne MaskedAttention k to be the causally masked variant of
Attention k : component i of the result of MaskedAttention k ( x ) along axis k depends on only components 1 , . .
, i of x along axis k .
The receptive ﬁelds of these attention patterns, both unmasked and masked, are illustrated in ﬁg. 2.
We will use these masked blocks to build our autoregressive model in section 3.2.
Axial attention can be used within standard Transformer layers in a straightforward manner to produce Axial Transformer layers.
The basic building blocks are the same as those found in the standard
Transformer architecture:
• LayerNorm ( x ) : layer normalization (Ba et al., 2016), and • Dense D
( x ) : a dense layer operating over the last axis of the input x .
The letter D denotes the dimension of the output activations.
If the input has shape H × W × C , then this operation is identical to a 1 × 1 convolution, and the output has shape H × W × D .
We use these to deﬁne ResNet axial attention blocks operating on tensors of D -dimensional embeddings (Vaswani et al., 2017; Child et al., 2019):
• FeedforwardBlock ( x ) = x + Dense D
( Nonlinearity ( Dense D (cid:48) ( LayerNorm ( x ))))
• AttentionBlock k
( x ) = x
+ Dense D
( Attention k ( LayerNorm ( x ))) • TransformerBlock k
( x ) =
FeedforwardBlock
( AttentionBlock k ( x ))
D (cid:48) is chosen to be some constant factor larger than D , from 1 to 4 (Vaswani et al., 2017).
We also deﬁne a MaskedTransformerBlock k using MaskedAttention k in place of Attention k .
Operations similar to unmasked axial attention have been proposed in other contexts in computer vision (Huang et al., 2019).
Our focus in forthcoming sections is the use of masked axial attention and its utility in autoregressive image modeling, which is not explored in these works.
3. A XIAL T RANSFORMERS
We now describe Axial Transformers, our axial attention-based autoregressive models for images and videos.
We will use the axial attention operations described in section 3.1 as building blocks in a multi-layer autoregressive model of the form p θ ( x ) = (cid:81) Ni =1 p θ ( x i | x <i ) following the raster scan ordering of pixels.
We will accomplish this by building an autoregressive model over rows (section 3.2.1), then conditioning each row on previous rows (section 3.2.1), then further conditioning on previous channels and frames (section 3.2.2).
Decomposing the model in this manner also leads to a simple fast and partly parallel sampling procedure (section 3.2.1).
3.2. A MODEL FOR SINGLE - CHANNEL IMAGES
We begin with an autoregressive model for a single-channel image x with shape H × W , with each pixel taking an integer value in [0 , 255] representing its intensity.
As is standard practice with Transformers, pixel intensities are ﬁrst embedded into a H × W × D tensor of D -dimensional embeddings, which we call h .
The architecture’s responsibility is to transform h into a H × W ×tensor of logits suitable for classiﬁcation or sampling.
These logits must depend only on previous pixels in the input x along the raster scan ordering to ensure that the architecture deﬁnes a valid autoregressive model.
Inner Decoder: a row-wise model
Our idea is to begin with masked row attention layers to create a “row-wise” model:
[Equation]
Here, L row is the number of masked row attention blocks applied to h .
PositionEmbeddings is a H ×
W × D tensor of position embeddings that inform the attention layers of the position.
For parameter efﬁciency we use “additively factorized” position embeddings, meaning that we parameterize them as a broadcasted sum of H × 1 × D embeddings for rows and 1 × W × D embeddings for columns.
The operation ShiftRight shifts the input right by one pixel, which has the effect of shifting the receptive ﬁeld left by one pixel.
This ensures that the masked row attention layers exclude the current pixel from their receptive ﬁeld, which is crucial for architecture to deﬁne a correct autoregressive model.
As this model employs row attention only, it enjoys the computational efﬁciency beneﬁts described in section 3.1.
However, it clearly does not deﬁne a full-context model because each location in the output does not depend on input pixels in previous rows.
If we were to use the resulting h as logits for pixel intensity prediction, we would obtain a set of H independent autoregressive models p ( x i,j | x i, 1 , . . .
, x i,j − 1 ) for each row i ∈ [1 , H ] , not a single autoregressive model with full context.
We address this issue next.
Outer Decoder: capturing the rows above Each pixel x i,j in the aforementioned model already depends on previous pixels in its own row x i,<j .
We just need to make it depend on all previous rows x <i, : too.
So, we insert unmasked row and masked column layers in the beginning of the model as follows (newly inserted operations are underlined):
[Equation]
h ← MaskedTransformerBlock 2 ( h ) ×
[Table]
practice
Semi-Parallel Sampling Naive implementations of sampling from sequential models are notoriously slow because they require re-evaluating the entire network to sample each location.
In the case of our model for a √ N × √ N square image, each network evaluation takes O ( N √ N ( L upper + L row )) time, so sampling the whole image would take O ( N 2 √ N ( L upper + L row )) , which is far too large.
Fortunately, our architecture is amenable to a particularly simple implementation of a faster sampling that is able to compute large sections of the model in parallel (see Figure 1).
Pseudocode is as follows:
For each row i ∈ [1 , H ] : (a) Compute the upper context u including information about all x <i, ∗ using the upper layers (b) For each column j ∈ [1 , W ] : i. Sample x i,j conditioned on u and prior elements of row i ( x i,<j ).
Because the L row row-wise layers are independent over rows (they depend on other rows only through the upper context, as explained in section 3.2.1), sampling one row can be accomplished by evaluating the row-wise layers for that one row only, completely ignoring other rows.
Thus, in one row of √ N pixels, each pixel can be sampled in O ( NL row ) , so all pixels can be sampled in O ( N 2 L row ) .
Before each of the √ N rows can be sampled, the upper context must be computed in O ( N √ NL upper ) , for a total of O ( N 2 L upper ) over the course of all rows.
Thus we arrive at
O ( N 2 ( L upper + L row )) in total, which is √ N faster than the naive implementation.
To our knowledge, sampling speedups of this type are not possible with contemporary work on scaling Transformers to images and videos (Child et al., 2019; Weissenborn et al., 2019).
3.2. C HANNEL E NCODER FOR M ULTI -C HANNEL I MAGES AND V IDEOS
We have just described an architecture for a single-channel image of shape H × W .
Here, we show how to extend the architecture to multi-channel images or videos of shape H × W × C (here C is either the number of channels in a multi-channel image, or the product of the number of channels and timesteps in a video).
One way to model such data of shape H × W × C is to simply stack the channels on top of each other into a single-channel image of shape ( H · C ) × W or H × ( W · C ) . This [Table] [Table]
is simple to implement, but does increase the sequence length for column attention or row attention, which can be undesirable for large C .
We instead opt to model one channel at a time as a singlechannel image
[Table]
but now conditioned on previous channels using an extra set of unmasked row and unmasked column attention layers.
This means that we have a model of the form p ( x : , : ,c
| x : , : ,<c ) , where previous channels x : , : ,<c are processed into a H × W × D tensor of context information, which is then added into the ﬁrst encoding blocks of the model in section 3.2.1 (Figure 3).
We do not share any parameters among any of these layers.
At training time, we train on a random channel slice of each image: we process the previous slices using these unmasked attention layers to produce a context tensor, and maximize the likelihood of the randomly chosen slice conditioned on this context.
This amounts to training on an unbiased estimate of log likelihood for the whole data tensor.
See ﬁg. 1 for an illustration of this complete model.
E XPERIMENTS
We benchmarked our models on standard datasets for generative image and video models: downsampled ImageNet (van den Oord et al., 2016a) and
BAIR Robot Pushing (Ebert et al., 2017).
All
Axial Transformers have 8 total layers in the encoder, 8 layers in the outer decoder and 4 layers in the inner decoder.
We use a hidden size of 2048 neurons throughout and for all setups andheads with 128 neurons each for the attention component.
We train for approximately 200k steps on
ImageNet32 and ImageNet64 and for 200k steps on BAIR Robot Pushing.
Our models can overﬁt on ImageNet32, but on the other datasets the models keep on gradually improving with more steps.
See table 2 and table 3 for our results.
4. A BLATION STUDY
To push the limits of the semi-parallel sampling by making the inner decoder as small as possible, we train an Axial Transformer with the inner decoder replaced by a single LSTM layer of 2048 units. This slows down training time by about 20% on ImageNet32 and about 80% on ImageNet64 when maintaining the number of steps and all else ﬁxed. We ﬁnd that the Axial Transformer + LSTM inner decoder performs rather well on the ImageNet32 and ImageNet64 benchmarks (table 2), thereby also showing the effectiveness of the remaining parts of the Axial Transformer that capture the context of the rows above.
We also ﬁnd however that the full four layers of the inner decoder of the Axial
Transformer provide an additional boost in performance as well as signiﬁcantly faster training.
The
Axial Transformer + LSTM inner decoder has the advantage of requiring only a couple of matrixvector products to compute the layers at each autogressive step, comparing favourably with about the 12 matrix-vector products required by the Axial Transformer, but the slower training time would make the LSTM inner decoder quickly impractical for larger tensors.
In ﬁg. 4 and ﬁg. 5, we show samples from our 64 × 64 and 32 × 32 ImageNet models.
The samples are globally coherent and show visibly recognizable scenes, meaning that our Axial Transformer architecture successfully captures long-range dependencies across thousands of data dimensions in these image datasets.
The samples also don’t show any architecture-correlated artefacts.
In addition, in ﬁg. 6 we show samples from the BAIR Robotic Pushing dataset.
The ﬁrst frame is each row is given by the dataset and the rest are continuation.
We note the high quality exactness of details and the very large diversity (at temperature 1.0).
C ONCLUSION
We proposed the Axial Transformer, an self-attention-based autoregressive model for data organized as high dimensional tensors.
It is based on axial attention, a simple generalization of self-attention that scales better with the dimension of input data, achieving a O ( N ( d − 1) /d ) savings in computation and memory for a d -dimensional input tensor with N elements.
Axial attention is easy to implement and does not require custom kernels to run efﬁciently on modern accelerators.
Axial
Transformers use axial self-attention layers and a shift operation to naturally and efﬁciently build full receptive ﬁelds of multidimensional tensors.
Our model matches or outperforms the state-of-theart on ImageNet-32 and ImageNet-64 image benchmarks and sets a signiﬁcant new state-of-the-art on the BAIR Robot Pushing video benchmark.