# pixel_recurrent_neural_networks__f39dba57.pdf

Pixel Recurrent Neural Networks

A aron van den Oord AVDNOORD@GOOGLE.COM Nal Kalchbrenner NALK@GOOGLE.COM Koray Kavukcuoglu KORAYK@GOOGLE.COM

Google Deep Mind

Modeling the distribution of natural images is a landmark problem in unsupervised learning. This task requires an image model that is at once expressive, tractable and scalable. We present a deep neural network that sequentially predicts the pixels in an image along the two spatial dimensions. Our method models the discrete probability of the raw pixel values and encodes the complete set of dependencies in the image. Architectural novelties include fast twodimensional recurrent layers and an effective use of residual connections in deep recurrent networks. We achieve log-likelihood scores on natural images that are considerably better than the previous state of the art. Our main results also provide benchmarks on the diverse Image Net dataset. Samples generated from the model appear crisp, varied and globally coherent.

1. Introduction

Generative image modeling is a central problem in unsupervised learning. Probabilistic density models can be used for a wide variety of tasks that range from image compression and forms of reconstruction such as image inpainting (e.g., see Figure 1) and deblurring, to generation of new images. When the model is conditioned on external information, possible applications also include creating images based on text descriptions or simulating future frames in a planning task. One of the great advantages in generative modeling is that there are practically endless amounts of image data available to learn from. However, because images are high dimensional and highly structured, estimating the distribution of natural images is extremely challenging.

One of the most important obstacles in generative modeling is building complex and expressive models that are

Proceedings of the 33 rd International Conference on Machine Learning, New York, NY, USA, 2016. JMLR: W&CP volume 48. Copyright 2016 by the author(s).

occluded completions original

Figure 1. Image completions sampled from a Pixel RNN.

also tractable and scalable. This trade-off has resulted in a large variety of generative models, each having their advantages. Most work focuses on stochastic latent variable models such as VAE s (Rezende et al., 2014; Kingma & Welling, 2013) that aim to extract meaningful representations, but often come with an intractable inference step that can hinder their performance.

One effective approach to tractably model a joint distribution of the pixels in the image is to cast it as a product of conditional distributions; this approach has been adopted in autoregressive models such as NADE (Larochelle & Murray, 2011) and fully visible sigmoid belief networks (Neal, 1992). The factorization turns the joint modeling problem into a sequence problem, where one learns to predict the next pixel given all the previously generated pixels. But to model the highly nonlinear and long-range correlations between pixels and the complex conditional distributions that result, a highly expressive sequence model is necessary.

Recurrent Neural Networks (RNN) are powerful models that offer a compact, shared parametrization of a series of conditional distributions. RNNs have been shown to excel at hard sequence problems ranging from handwriting generation (Graves, 2013), to character prediction (Sutskever et al., 2011) and to machine translation (Kalchbrenner & Blunsom, 2013). A two-dimensional RNN has produced very promising results in modeling grayscale images and textures (Theis & Bethge, 2015).

In this paper we advance two-dimensional RNNs and apply them to large-scale modeling of natural images. The resulting Pixel RNNs are composed of up to twelve, fast two-dimensional Long Short-Term Memory (LSTM) lay-

Pixel Recurrent Neural Networks

Multi-scale context

Figure 2. Left: To generate pixel xi one conditions on all the previously generated pixels left and above of xi. Center: To generate a pixel in the multi-scale case we can also condition on the subsampled image pixels (in light blue). Right: Diagram of the connectivity inside a masked convolution. In the first layer, each of the RGB channels is connected to previous channels and to the context, but is not connected to itself. In subsequent layers, the channels are also connected to themselves.

ers. These layers use LSTM units in their state (Hochreiter & Schmidhuber, 1997; Graves & Schmidhuber, 2009) and adopt a convolution to compute at once all the states along one of the spatial dimensions of the data. We design two types of these layers. The first type is the Row LSTM layer where the convolution is applied along each row; a similar technique is described in (Stollenga et al., 2015). The second type is the Diagonal Bi LSTM layer where the convolution is applied in a novel fashion along the diagonals of the image. The networks also incorporate residual connections (He et al., 2015) around LSTM layers; we observe that this helps with training of the Pixel RNN for up to twelve layers of depth.

We also consider a second, simplified architecture which shares the same core components as the Pixel RNN. We observe that Convolutional Neural Networks (CNN) can also be used as sequence model with a fixed dependency range, by using Masked convolutions. The Pixel CNN architecture is a fully convolutional network of fifteen layers that preserves the spatial resolution of its input throughout the layers and outputs a conditional distribution at each location.

Both Pixel RNN and Pixel CNN capture the full generality of pixel inter-dependencies without introducing independence assumptions as in e.g., latent variable models. The dependencies are also maintained between the RGB color values within each individual pixel. Furthermore, in contrast to previous approaches that model the pixels as continuous values (e.g., Theis & Bethge (2015); Gregor et al. (2014)), we model the pixels as discrete values using a multinomial distribution implemented with a simple softmax layer. We observe that this approach gives both representational and training advantages for our models.

The contributions of the paper are as follows. In Section 3 we design two types of Pixel RNNs corresponding to the two types of LSTM layers; we describe the purely convolutional Pixel CNN that is our fastest architecture; and we

design a Multi-Scale version of the Pixel RNN. In Section 5 we show the relative benefits of using the discrete softmax distribution in our models and of adopting residual connections for the LSTM layers. Next we test the models on MNIST and on CIFAR-10 and show that they obtain loglikelihood scores that are considerably better than previous results. We also provide results for the large-scale Image Net dataset resized to both 32 32 and 64 64 pixels; to our knowledge likelihood values from generative models have not previously been reported on this dataset. Finally, we give a qualitative evaluation of the samples generated from the Pixel RNNs.

Our aim is to estimate a distribution over natural images that can be used to tractably compute the likelihood of images and to generate new ones. The network scans the image one row at a time and one pixel at a time within each row. For each pixel it predicts the conditional distribution over the possible pixel values given the scanned context. Figure 2 illustrates this process. The joint distribution over the image pixels is factorized into a product of conditional distributions. The parameters used in the predictions are shared across all pixel positions in the image.

To capture the generation process, Theis & Bethge (2015) propose to use a two-dimensional LSTM network (Graves & Schmidhuber, 2009) that starts at the top left pixel and proceeds towards the bottom right pixel. The advantage of the LSTM network is that it effectively handles long-range dependencies that are central to object and scene understanding. The two-dimensional structure ensures that the signals are well propagated both in the left-to-right and topto-bottom directions.

In this section we first focus on the form of the distribution, whereas the next section will be devoted to describing the architectural innovations inside Pixel RNN.

2.1. Generating an Image Pixel by Pixel

The goal is to assign a probability p(x) to each image x formed of n n pixels. We can write the image x as a onedimensional sequence x1, ..., xn2 where pixels are taken from the image row by row. To estimate the joint distribution p(x) we write it as the product of the conditional distributions over the pixels:

i=1 p(xi|x1, ..., xi 1) (1)

The value p(xi|x1, ..., xi 1) is the probability of the i-th pixel xi given all the previous pixels x1, ..., xi 1. The generation proceeds row by row and pixel by pixel. Figure 2 (Left) illustrates the conditioning scheme.

Each pixel xi is in turn jointly determined by three values,

Pixel Recurrent Neural Networks

Figure 3. In the Diagonal Bi LSTM, to allow for parallelization along the diagonals, the input map is skewed by offseting each row by one position with respect to the previous row. When the spatial layer is computed left to right and column by column, the output map is shifted back into the original size. The convolution uses a kernel of size 2 1.

one for each of the color channels Red, Green and Blue (RGB). We rewrite the distribution p(xi|x<i) as the following product:

p(xi,R|x<i)p(xi,G|x<i, xi,R)p(xi,B|x<i, xi,R, xi,G) (2)

Each of the colors is thus conditioned on the other channels as well as on all the previously generated pixels.

Note that during training and evaluation the distributions over the pixel values are computed in parallel, while the generation of an image is sequential.

2.2. Pixels as Discrete Variables

Previous approaches use a continuous distribution for the values of the pixels in the image (e.g. Theis & Bethge (2015); Uria et al. (2014)). By contrast we model p(x) as a discrete distribution, with every conditional distribution in Equation 2 being a multinomial that is modeled with a softmax layer. Each channel variable xi, simply takes one of 256 distinct values. The discrete distribution is representationally simple and has the advantage of being arbitrarily multimodal without prior on the shape (see Fig. 6). Experimentally we also find the discrete distribution to be easy to learn and to produce better performance compared to a continuous distribution (Section 5).

3. Pixel Recurrent Neural Networks

In this section we describe the architectural components that compose the Pixel RNN. In Sections 3.1 and 3.2, we describe the two types of LSTM layers that use convolutions to compute at once the states along one of the spatial dimensions. In Section 3.3 we describe how to incorporate residual connections to improve the training of a Pixel RNN with many LSTM layers. In Section 3.4 we describe the softmax layer that computes the discrete joint distribution of the colors and the masking technique that ensures the proper conditioning scheme. In Section 3.5 we describe the Pixel CNN architecture. Finally in Section 3.6 we describe the multi-scale architecture.

3.1. Row LSTM

The Row LSTM is a unidirectional layer that processes the image row by row from top to bottom computing features for a whole row at once; the computation is performed with a one-dimensional convolution. For a pixel xi the layer captures a roughly triangular context above the pixel as shown in Figure 4 (center). The kernel of the onedimensional convolution has size k 1 where k 3; the larger the value of k the broader the context that is captured. The weight sharing in the convolution ensures translation invariance of the computed features along each row.

The computation proceeds as follows. An LSTM layer has an input-to-state component and a recurrent state-to-state component that together determine the four gates inside the LSTM core. To enhance parallelization in the Row LSTM the input-to-state component is first computed for the entire two-dimensional input map; for this a k 1 convolution is used to follow the row-wise orientation of the LSTM itself. The convolution is masked to include only the valid context (see Section 3.4) and produces a tensor of size 4h n n, representing the four gate vectors for each position in the input map, where h is the number of output feature maps.

To compute one step of the state-to-state component of the LSTM layer, one is given the previous hidden and cell states hi 1 and ci 1, each of size h n 1. The new hidden and cell states hi, ci are obtained as follows:

[oi, fi, ii, gi] = σ(Kss hi 1 + Kis xi) ci = fi ci 1 + ii gi hi = oi tanh(ci) (3)

where xi of size h n 1 is row i of the input map, and represents the convolution operation and the elementwise multiplication. The weights Kss and Kis are the kernel weights for the state-to-state and the input-to-state components, where the latter is precomputed as described above. In the case of the output, forget and input gates oi, fi and ii, the activation σ is the logistic sigmoid function, whereas for the content gate gi, σ is the tanh function. Each step computes at once the new state for an entire row of the input map. Because the Row LSTM has a triangular receptive field (Figure 4), it is unable to capture the entire available context.

3.2. Diagonal Bi LSTM

The Diagonal Bi LSTM is designed to both parallelize the computation and to capture the entire available context for any image size. Each of the two directions of the layer scans the image in a diagonal fashion starting from a corner at the top and reaching the opposite corner at the bottom. Each step in the computation computes at once the LSTM state along a diagonal in the image. Figure 4 (right)

Pixel Recurrent Neural Networks

Pixel CNN Row LSTM Diagonal Bi LSTM

Figure 4. Visualization of the input-to-state and state-to-state mappings for the three proposed architectures.

illustrates the computation and the resulting receptive field.

The diagonal computation proceeds as follows. We first skew the input map into a space that makes it easy to apply convolutions along diagonals. The skewing operation offsets each row of the input map by one position with respect to the previous row, as illustrated in Figure 3; this results in a map of size n (2n 1). At this point we can compute the input-to-state and state-to-state components of the Diagonal Bi LSTM. For each of the two directions, the input-to-state component is simply a 1 1 convolution Kis

that contributes to the four gates in the LSTM core; the operation generates a 4h n n tensor. The state-to-state recurrent component is then computed with a column-wise convolution Kss that has a kernel of size 2 1. The step takes the previous hidden and cell states, combines the contribution of the input-to-state component and produces the next hidden and cell states, as defined in Equation 3. The output feature map is then skewed back into an n n map by removing the offset positions. This computation is repeated for each of the two directions. Given the two output maps, to prevent the layer from seeing future pixels, the right output map is then shifted down by one row and added to the left output map.

Besides reaching the full dependency field, the Diagonal Bi LSTM has the additional advantage that it uses a convolutional kernel of size 2 1 that processes a minimal amount of information at each step yielding a highly nonlinear computation. Kernel sizes larger than 2 1 are not particularly useful as they do not broaden the already global receptive field of the Diagonal Bi LSTM.

3.3. Residual Connections

We train Pixel RNNs of up to twelve layers of depth. As a means to both increase convergence speed and propagate signals more directly through the network, we deploy residual connections (He et al., 2015) from one LSTM layer to the next. Figure 5 shows a diagram of the residual blocks. The input map to the Pixel RNN LSTM layer has 2h features. The input-to-state component reduces the number of features by producing h features per gate. After applying

the recurrent layer, the output map is upsampled back to 2h features per position via a 1 1 convolution and the input map is added to the output map. This method is related to previous approaches that use gating along the depth of the recurrent network (Kalchbrenner et al., 2015; Zhang et al., 2016), but has the advantage of not requiring additional gates. Apart from residual connections, one can also use learnable skip connections from each layer to the output. In the experiments we evaluate the relative effectiveness of residual and layer-to-output skip connections.

Re LU - 1x1 Conv

Re LU - 3x3 Conv

Re LU - 1x1 Conv

Figure 5. Residual blocks for a Pixel CNN (left) and Pixel RNNs.

3.4. Masked Convolution

The h features for each input position at every layer in the network are split into three parts, each corresponding to one of the RGB channels. When predicting the R channel for the current pixel xi, only the generated pixels left and above of xi can be used as context. When predicting the G channel, the value of the R channel can also be used as context in addition to the previously generated pixels. Likewise, for the B channel, the values of both the R and G channels can be used. To restrict connections in the network to these dependencies, we apply a mask to the inputto-state convolutions and to other purely convolutional layers in a Pixel RNN.

We use two types of masks that we indicate with mask A and mask B, as shown in Figure 2 (Right). Mask A is applied only to the first convolutional layer in a Pixel RNN and restricts the connections to those neighboring pixels and to those colors in the current pixels that have already been predicted. On the other hand, mask B is applied to all the subsequent input-to-state convolutional transitions and relaxes the restrictions of mask A by also allowing the connection from a color to itself. The masks can be easily implemented by zeroing out the corresponding weights in the input-to-state convolutions after each update. Similar masks have also been used in variational autoencoders (Gregor et al., 2014; Germain et al., 2015).

3.5. Pixel CNN

The Row and Diagonal LSTM layers have a potentially unbounded dependency range within their receptive field. This comes with a computational cost as each state needs to be computed sequentially. One simple workaround is to make the receptive field large, but not unbounded. We

Pixel Recurrent Neural Networks

Pixel CNN Row LSTM Diagonal Bi LSTM

7 7 conv mask A

Multiple residual blocks: (see fig 5)

Conv Row LSTM Diagonal Bi LSTM 3 3 mask B i-s: 3 1 mask B i-s: 1 1 mask B s-s: 3 1 no mask s-s: 1 2 no mask

Re LU followed by 1 1 conv, mask B (2 layers)

256-way Softmax for each RGB color (Natural images) or Sigmoid (MNIST)

Table 1. Details of the architectures. In the LSTM architectures i-s and s-s stand for input-state and state-state convolutions.

can use standard convolutional layers to capture a bounded receptive field and compute features for all pixel positions at once. The Pixel CNN uses multiple convolutional layers that preserve the spatial resolution; pooling layers are not used. Masks are adopted in the convolutions to avoid seeing the future context; masks have previously also been used in non-convolutional models such as MADE (Germain et al., 2015). Note that the advantage of parallelization of the Pixel CNN over the Pixel RNN is only available during training or during evaluating of test images. The image generation process is sequential for both kinds of networks, as each sampled pixel needs to be given as input back into the network.

3.6. Multi-Scale Pixel RNN

The Multi-Scale Pixel RNN is composed of an unconditional Pixel RNN and one or more conditional Pixel RNNs. The unconditional network first generates in the standard way a smaller s s image that is subsampled from the original image. The conditional network then takes the s s image as an additional input and generates a larger n n image, as shown in Figure 2 (Middle).

The conditional network is similar to a standard Pixel RNN, but each of its layers is biased with an upsampled version of the small s s image. The upsampling and biasing processes are defined as follows. In the upsampling process, one uses a convolutional network with deconvolutional layers to construct an enlarged feature map of size c n n, where c is the number of features in the output map of the upsampling network. Then, in the biasing process, for each layer in the conditional Pixel RNN, one simply maps the c n n conditioning map into a 4h n n map that is added to the input-to-state map of the corresponding layer; this is performed using a 1 1 unmasked convolution. The larger n n image is then generated as usual.

4. Specifications of Models

In this section we give the specifications of the Pixel RNNs used in the experiments. We have four types of networks:

the Pixel RNN based on Row LSTM, the one based on Diagonal Bi LSTM, the fully convolutional one and the Multi Scale one.

Table 1 specifies each layer in the single-scale networks. The first layer is a 7 7 convolution that uses the mask of type A. The two types of LSTM networks then use a variable number of recurrent layers. The input-to-state convolution in this layer uses a mask of type B, whereas the state-to-state convolution is not masked. The Pixel CNN uses convolutions of size 3 3 with a mask of type B. The top feature map is then passed through a couple of layers consisting of a Rectified Linear Unit (Re LU) and a 1 1 convolution. For the CIFAR-10 and Image Net experiments, these layers have 1024 feature maps; for the MNIST experiment, the layers have 32 feature maps. Residual and layer-to-output connections are used across the layers of all three networks.

The networks used in the experiments have the following hyperparameters. For MNIST we use a Diagonal Bi LSTM with 7 layers and a value of h = 16 (Section 3.3 and Figure 5 right). For CIFAR-10 the Row and Diagonal Bi LSTMs have 12 layers and a number of h = 128 units. The Pixel CNN has 15 layers and h = 128. For 32 32 Image Net we adopt a 12 layer Row LSTM with h = 384 units and for 64 64 Image Net we use a 4 layer Row LSTM with h = 512 units; the latter model does not use residual connections.

5. Experiments

In this section we describe our experiments and results. We begin by describing the way we evaluate and compare our results. In Section 5.2 we give details about the training. Then we give results on the relative effectiveness of architectural components and our best results on the MNIST, CIFAR-10 and Image Net datasets.

5.1. Evaluation

All our models are trained and evaluated on the loglikelihood loss function coming from a discrete distribution. Although natural image data is usually modeled with continuous distributions using density functions, we can compare our results with previous art in the following way. In the literature it is currently best practice to add realvalued noise to the pixel values to dequantize the data when using density functions (Uria et al., 2013). When uniform noise is added (with values in the interval [0, 1]), then the log-likelihoods of continuous and discrete models are directly comparable (Theis et al., 2015). In our case, we can use the values from the discrete distribution as a piecewiseuniform continuous function that has a constant value for every interval [i, i + 1], i = 1, 2, . . . 256. This corresponding distribution will have the same log-likelihood (on data

Pixel Recurrent Neural Networks

with added noise) as the original discrete distribution (on discrete data).

For MNIST we report the negative log-likelihood in nats as it is common practice in literature. For CIFAR-10 and Image Net we report negative log-likelihoods in bits per dimension. The total discrete log-likelihood is normalized by the dimensionality of the images (e.g., 32 32 3 = 3072 for CIFAR-10). These numbers are interpretable as the number of bits that a compression scheme based on this model would need to compress every RGB color value (van den Oord & Schrauwen, 2014b; Theis et al., 2015); in practice there is also a small overhead due to arithmetic coding.

5.2. Training Details

Our models are trained on GPUs using the Torch toolbox. From the different parameter update rules tried, RMSProp gives best convergence performance and is used for all experiments. The learning rate schedules were manually set for every dataset to the highest values that allowed fast convergence. The batch sizes also vary for different datasets. For smaller datasets such as MNIST and CIFAR-10 we use smaller batch sizes of 16 images as this seems to regularize the models. For Image Net we use as large a batch size as allowed by the GPU memory; this corresponds to 64 images/batch for 32 32 Image Net, and 32 images/batch for 64 64 Image Net. Apart from scaling and centering the images at the input of the network, we don t use any other preprocessing or augmentation. For the multinomial loss function we use the raw pixel color values as categories. For all the Pixel RNN models, we learn the initial recurrent state of the network.

5.3. Discrete Softmax Distribution

Apart from being intuitive and easy to implement, we find that using a softmax on discrete pixel values instead of a mixture density approach on continuous pixel values gives better results. For the Row LSTM model with a softmax output distribution we obtain 3.06 bits/dim on the CIFAR10 validation set. For the same model with a Mixture of Conditional Gaussian Scale Mixtures (MCGSM) (Theis & Bethge, 2015) we obtain 3.22 bits/dim.

In Figure 6 we show a few softmax activations from the model. Although we don t embed prior information about the meaning or relations of the 256 color categories, e.g. that pixel values 51 and 52 are neighbors, the distributions predicted by the model are meaningful and can be multimodal, skewed, peaked or long tailed. Also note that values 0 and 255 often get a much higher probability as they are more frequent. Another advantage of the discrete distribution is that we do not worry about parts of the distribution mass lying outside the interval [0, 255], which is something that typically happens with continuous distributions.

0 50 100 150 200 250 0 50 100 150 200 250 0 50 100 150 200 250 0 50 100 150 200 250 0 255 0 255 0 255 0 255

Figure 6. Example softmax activations from the model. The leftmost shows the distribution of the first pixel red value (first value to sample).

5.4. Residual Connections

Another core component of the networks is residual connections. In Table 2 we show the results of having residual connections, having standard skip connections or having both, in the 12-layer CIFAR-10 Row LSTM model. We see that using residual connections is as effective as using skip connections; using both is also effective and preserves the advantage.

No skip Skip

No residual: 3.22 3.09 Residual: 3.07 3.06

Table 2. Effect of residual and skip connections in the Row LSTM network evaluated on the Cifar-10 validation set in bits/dim.

When using both the residual and skip connections, we see in Table 3 that performance of the Row LSTM improves with increased depth. This holds for up to the 12 LSTM layers that we tried.

# layers: 1 2 3 6 9 12

NLL: 3.30 3.20 3.17 3.09 3.08 3.06

Table 3. Effect of the number of layers on the negative log likelihood evaluated on the CIFAR-10 validation set (bits/dim).

Although the goal of our work was to model natural images on a large scale, we also tried our model on the binary version (Salakhutdinov & Murray, 2008) of MNIST (Le Cun et al., 1998) as it is a good sanity check and there is a lot of previous art on this dataset to compare with. In Table 4 we report the performance of the Diagonal Bi LSTM model and that of previous published results. To our knowledge this is the best reported result on MNIST so far.

5.6. CIFAR-10

Next we test our models on the CIFAR-10 dataset (Krizhevsky, 2009). Table 5 lists the results of our models and that of previously published approaches. For the proposed networks, the Diagonal Bi LSTM has the best performance, followed by the Row LSTM and the Pixel-

Pixel Recurrent Neural Networks

Figure 7. Samples from models trained on CIFAR-10 (left) and Image Net 32x32 (right) images. In general we can see that the models capture local spatial dependencies relatively well. The Image Net model seems to be better at capturing more global structures than the CIFAR-10 model. The Image Net model was larger and trained on much more data, which explains the qualitative difference in samples.

Model NLL Test

DBM 2hl [1]: 84.62 DBN 2hl [2]: 84.55 NADE [3]: 88.33 Eo NADE 2hl (128 orderings) [3]: 85.10 Eo NADE-5 2hl (128 orderings) [4]: 84.68 DLGM [5]: 86.60 DLGM 8 leapfrog steps [6]: 85.51 DARN 1hl [7]: 84.13 MADE 2hl (32 masks) [8]: 86.64 DRAW [9]: 80.97

Pixel CNN: 81.30 Row LSTM: 80.54 Diagonal Bi LSTM (1 layer, h = 32): 80.75 Diagonal Bi LSTM (7 layers, h = 16): 79.20

Table 4. Test set performance of different models on MNIST in nats (negative log-likelihood). Prior results taken from [1] (Salakhutdinov & Hinton, 2009), [2] (Murray & Salakhutdinov, 2009), [3] (Uria et al., 2014), [4] (Raiko et al., 2014), [5] (Rezende et al., 2014), [6] (Salimans et al., 2015), [7] (Gregor et al., 2014), [8] (Germain et al., 2015), [9] (Gregor et al., 2015).

CNN. This coincides with the size of the respective receptive fields: the Diagonal Bi LSTM has a global view, the Row LSTM has a partially occluded view and the Pixel CNN sees the fewest pixels in the context. This suggests that effectively capturing a large receptive field is important. Figure 7 (left) shows CIFAR-10 samples generated from the Diagonal Bi LSTM.

Model NLL Test (Train)

Uniform Distribution: 8.00 Multivariate Gaussian: 4.70 NICE [1]: 4.48 Deep Diffusion [2]: 4.20 Deep GMMs [3]: 4.00 RIDE [4]: 3.47

Pixel CNN: 3.14 (3.08) Row LSTM: 3.07 (3.00) Diagonal Bi LSTM: 3.00 (2.93)

Table 5. Test set performance of different models on CIFAR-10 in bits/dim. For our models we give training performance in brackets. [1] (Dinh et al., 2014), [2] (Sohl-Dickstein et al., 2015), [3] (van den Oord & Schrauwen, 2014a), [4] personal communication (Theis & Bethge, 2015).

Image size NLL Validation (Train)

32x32: 3.86 (3.83) 64x64: 3.63 (3.57)

Table 6. Negative log-likelihood performance on 32 32 and 64 64 Image Net in bits/dim.

5.7. Image Net

Although to our knowledge the are no published results on the ILSVRC Image Net dataset (Russakovsky et al., 2015) that we can compare our models with, we give our Image Net log-likelihood performance in Table 6. On Image Net the current Pixel RNNs do not appear to overfit, as we saw

Pixel Recurrent Neural Networks

Figure 8. Samples from models trained on Image Net 64x64 images. Left: normal model, right: multi-scale model. The single-scale model trained on 64x64 images is less able to capture global structure than the 32x32 model. The multi-scale model seems to resolve this problem. Although these models get similar performance in log-likelihood, the samples on the right do seem globally more coherent.

occluded completions original

Figure 9. Image completions sampled from a model that was trained on 32x32 Image Net images. Note that diversity of the completions is high, which can be attributed to the log-likelihood loss function used in this generative model, as it encourages models with high entropy. As these are sampled from the model, we can easily generate millions of different completions. It is also interesting to see that textures such as water, wood and shrubbery are also inputed relative well (see Figure 1).

that their validation performance improved with size and depth. The main constraint on model size are currently computation time and GPU memory.

Note that the Image Net models are in general less compressible than the CIFAR-10 images. Image Net has greater variety of images, and the CIFAR-10 images were most likely resized with a different algorithm than the one we used for Image Net images. The Image Net images are less blurry, which means neighboring pixels are less correlated to each other and thus less predictable. Because the downsampling method can influence the compression performance, we will release the used downsampled images.

Figure 7 (right) shows 32 32 samples drawn from our model trained on Image Net. Figure 8 shows 64 64 samples from the same model with and without multi-scale conditioning. Finally, we also show image completions sampled from the model in Figure 9.

6. Conclusion

In this paper we significantly improve and build upon deep recurrent neural networks as generative models for natural images. We have described novel two-dimensional LSTM layers: the Row LSTM and the Diagonal Bi LSTM, that scale more easily to larger datasets. The models were trained to model the raw RGB pixel values. We treated the pixel values as discrete random variables by using a softmax layer in the conditional distributions. We employed masked convolutions to allow Pixel RNNs to model full dependencies between the color channels. We proposed and evaluated architectural improvements in these models resulting in Pixel RNNs with up to 12 LSTM layers.

We have shown that the Pixel RNNs significantly improve the state of the art on the MNIST and CIFAR-10 datasets. We also provide new benchmarks for generative image modeling on the Image Net dataset. Based on the samples and completions drawn from the models we can conclude that the Pixel RNNs are able to model both spatially local and long-range correlations and are able to produce images that are sharp and coherent. Given that these models improve as we make them larger and that there is practically unlimited data available to train on, more computation and larger models are likely to further improve the results.

Pixel Recurrent Neural Networks

Acknowledgements

The authors would like to thank Shakir Mohamed and Guillaume Desjardins for helpful input on this paper and Lucas Theis, Alex Graves, Karen Simonyan, Lasse Espeholt, Danilo Rezende, Karol Gregor and Ivo Danihelka for insightful discussions.

Dinh, Laurent, Krueger, David, and Bengio, Yoshua. NICE: Non-linear independent components estimation. ar Xiv preprint ar Xiv:1410.8516, 2014.

Germain, Mathieu, Gregor, Karol, Murray, Iain, and Larochelle, Hugo. MADE: Masked autoencoder for distribution estimation. ar Xiv preprint ar Xiv:1502.03509, 2015.

Graves, Alex. Generating sequences with recurrent neural networks. ar Xiv preprint ar Xiv:1308.0850, 2013.

Graves, Alex and Schmidhuber, J urgen. Offline handwriting recognition with multidimensional recurrent neural networks. In Advances in Neural Information Processing Systems, 2009.

Gregor, Karol, Danihelka, Ivo, Mnih, Andriy, Blundell, Charles, and Wierstra, Daan. Deep autoregressive networks. In Proceedings of the 31st International Conference on Machine Learning, 2014.

Gregor, Karol, Danihelka, Ivo, Graves, Alex, and Wierstra, Daan. DRAW: A recurrent neural network for image generation. Proceedings of the 32nd International Conference on Machine Learning, 2015.

He, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Deep residual learning for image recognition. ar Xiv preprint ar Xiv:1512.03385, 2015.

Hochreiter, Sepp and Schmidhuber, J urgen. Long shortterm memory. Neural computation, 1997.

Kalchbrenner, Nal and Blunsom, Phil. Recurrent continuous translation models. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, 2013.

Kalchbrenner, Nal, Danihelka, Ivo, and Graves, Alex. Grid long short-term memory. ar Xiv preprint ar Xiv:1507.01526, 2015.

Kingma, Diederik P and Welling, Max. Auto-encoding variational bayes. ar Xiv preprint ar Xiv:1312.6114, 2013.

Krizhevsky, Alex. Learning multiple layers of features from tiny images. 2009.

Larochelle, Hugo and Murray, Iain. The neural autoregressive distribution estimator. The Journal of Machine Learning Research, 2011.

Le Cun, Yann, Bottou, L eon, Bengio, Yoshua, and Haffner, Patrick. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 1998.

Murray, Iain and Salakhutdinov, Ruslan R. Evaluating probabilities under high-dimensional latent variable models. In Advances in Neural Information Processing Systems, 2009.

Neal, Radford M. Connectionist learning of belief networks. Artificial intelligence, 1992.

Raiko, Tapani, Li, Yao, Cho, Kyunghyun, and Bengio, Yoshua. Iterative neural autoregressive distribution estimator NADE-k. In Advances in Neural Information Processing Systems, 2014.

Rezende, Danilo J, Mohamed, Shakir, and Wierstra, Daan. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning, 2014.

Russakovsky, Olga, Deng, Jia, Su, Hao, Krause, Jonathan, Satheesh, Sanjeev, Ma, Sean, Huang, Zhiheng, Karpathy, Andrej, Khosla, Aditya, Bernstein, Michael, Berg, Alexander C., and Fei-Fei, Li. Image Net Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 2015.

Salakhutdinov, Ruslan and Hinton, Geoffrey E. Deep boltzmann machines. In International Conference on Artificial Intelligence and Statistics, 2009.

Salakhutdinov, Ruslan and Murray, Iain. On the quantitative analysis of deep belief networks. In Proceedings of the 25th international conference on Machine learning, 2008.

Salimans, Tim, Kingma, Diederik P, and Welling, Max. Markov chain monte carlo and variational inference: Bridging the gap. Proceedings of the 32nd International Conference on Machine Learning, 2015.

Sohl-Dickstein, Jascha, Weiss, Eric A., Maheswaranathan, Niru, and Ganguli, Surya. Deep unsupervised learning using nonequilibrium thermodynamics. Proceedings of the 32nd International Conference on Machine Learning, 2015.

Stollenga, Marijn F, Byeon, Wonmin, Liwicki, Marcus, and Schmidhuber, Juergen. Parallel multi-dimensional lstm, with application to fast biomedical volumetric image segmentation. In Advances in Neural Information Processing Systems 28. 2015.

Pixel Recurrent Neural Networks

Sutskever, Ilya, Martens, James, and Hinton, Geoffrey E. Generating text with recurrent neural networks. In Proceedings of the 28th International Conference on Machine Learning, 2011.

Theis, Lucas and Bethge, Matthias. Generative image modeling using spatial LSTMs. In Advances in Neural Information Processing Systems, 2015.

Theis, Lucas, van den Oord, A aron, and Bethge, Matthias. A note on the evaluation of generative models. ar Xiv preprint ar Xiv:1511.01844, 2015.

Uria, Benigno, Murray, Iain, and Larochelle, Hugo. RNADE: The real-valued neural autoregressive densityestimator. In Advances in Neural Information Processing Systems, 2013.

Uria, Benigno, Murray, Iain, and Larochelle, Hugo. A deep and tractable density estimator. In Proceedings of the 31st International Conference on Machine Learning, 2014.

van den Oord, A aron and Schrauwen, Benjamin. Factoring variations in natural images with deep gaussian mixture models. In Advances in Neural Information Processing Systems, 2014a.

van den Oord, A aron and Schrauwen, Benjamin. The student-t mixture as a natural image patch prior with application to image compression. The Journal of Machine Learning Research, 2014b.

Zhang, Yu, Chen, Guoguo, Yu, Dong, Yao, Kaisheng, Khudanpur, Sanjeev, and Glass, James. Highway long shortterm memory RNNs for distant speech recognition. In Proceedings of the International Conference on Acoustics, Speech and Signal Processing, 2016.