DRAW: A Recurrent Neural Network For Image Generation

by   Karol Gregor, et al.

This paper introduces the Deep Recurrent Attentive Writer (DRAW) neural network architecture for image generation. DRAW networks combine a novel spatial attention mechanism that mimics the foveation of the human eye, with a sequential variational auto-encoding framework that allows for the iterative construction of complex images. The system substantially improves on the state of the art for generative models on MNIST, and, when trained on the Street View House Numbers dataset, it generates images that cannot be distinguished from real data with the naked eye.


page 1

page 4

page 5

page 6

page 7

page 8


Sync-DRAW: Automatic Video Generation using Deep Recurrent Attentive Architectures

This paper introduces a novel approach for generating videos called Sync...

Text-to-Image Generation with Attention Based Recurrent Neural Networks

Conditional image modeling based on textual descriptions is a relatively...

Think Again Networks and the Delta Loss

This short paper introduces an abstraction called Think Again Networks (...

Auto-regressive Image Synthesis with Integrated Quantization

Deep generative models have achieved conspicuous progress in realistic i...

CAGAN: Text-To-Image Generation with Combined Attention GANs

Generating images according to natural language descriptions is a challe...

VQ-DRAW: A Sequential Discrete VAE

In this paper, I present VQ-DRAW, an algorithm for learning compact disc...

ILoveEye: Eyeliner Makeup Guidance System with Eye Shape Features

Drawing eyeliner is not an easy task for whom lacks experience in eye ma...

Code Repositories


Torch implementation of DRAW: A Recurrent Neural Network For Image Generation

view repo


DRAW implementation with deepy

view repo


Tensorflow implementation of the DRAW Network (http://arxiv.org/abs/1502.04623)

view repo


Recurrent Variational Auto-encoders with Gaussian Attention

view repo

1 Introduction

A person asked to draw, paint or otherwise recreate a visual scene will naturally do so in a sequential, iterative fashion, reassessing their handiwork after each modification. Rough outlines are gradually replaced by precise forms, lines are sharpened, darkened or erased, shapes are altered, and the final picture emerges. Most approaches to automatic image generation, however, aim to generate entire scenes at once. In the context of generative neural networks, this typically means that all the pixels are conditioned on a single latent distribution (Dayan et al., 1995; Hinton & Salakhutdinov, 2006; Larochelle & Murray, 2011). As well as precluding the possibility of iterative self-correction, the “one shot” approach is fundamentally difficult to scale to large images. The Deep Recurrent Attentive Writer (DRAW) architecture represents a shift towards a more natural form of image construction, in which parts of a scene are created independently from others, and approximate sketches are successively refined.

Figure 1: A trained DRAW network generating MNIST digits. Each row shows successive stages in the generation of a single digit. Note how the lines composing the digits appear to be “drawn” by the network. The red rectangle delimits the area attended to by the network at each time-step, with the focal precision indicated by the width of the rectangle border.

The core of the DRAW architecture is a pair of recurrent neural networks: an encoder network that compresses the real images presented during training, and a decoder

that reconstitutes images after receiving codes. The combined system is trained end-to-end with stochastic gradient descent, where the loss function is a variational upper bound on the log-likelihood of the data. It therefore belongs to the family of

variational auto-encoders, a recently emerged hybrid of deep learning and variational inference that has led to significant advances in generative modelling (Gregor et al., 2014; Kingma & Welling, 2014; Rezende et al., 2014; Mnih & Gregor, 2014; Salimans et al., 2014). Where DRAW differs from its siblings is that, rather than generating images in a single pass, it iteratively constructs scenes through an accumulation of modifications emitted by the decoder, each of which is observed by the encoder.

An obvious correlate of generating images step by step is the ability to selectively attend to parts of the scene while ignoring others. A wealth of results in the past few years suggest that visual structure can be better captured by a sequence of partial glimpses, or foveations, than by a single sweep through the entire image (Larochelle & Hinton, 2010; Denil et al., 2012; Tang et al., 2013; Ranzato, 2014; Zheng et al., 2014; Mnih et al., 2014; Ba et al., 2014; Sermanet et al., 2014)

. The main challenge faced by sequential attention models is learning where to look, which can be addressed with reinforcement learning techniques such as policy gradients 

(Mnih et al., 2014)

. The attention model in DRAW, however, is fully differentiable, making it possible to train with standard backpropagation. In this sense it resembles the selective read and write operations developed for the Neural Turing Machine 

(Graves et al., 2014).

The following section defines the DRAW architecture, along with the loss function used for training and the procedure for image generation. Section 3 presents the selective attention model and shows how it is applied to reading and modifying images. Section 4

provides experimental results on the MNIST, Street View House Numbers and CIFAR-10 datasets, with examples of generated images; and concluding remarks are given in Section 

5. Lastly, we would like to direct the reader to the video accompanying this paper (https://www.youtube.com/watch?v=Zt-7MI9eKEo) which contains examples of DRAW networks reading and generating images.

2 The DRAW Network

The basic structure of a DRAW network is similar to that of other variational auto-encoders: an encoder network determines a distribution over latent codes that capture salient information about the input data; a decoder network receives samples from the code distribuion and uses them to condition its own distribution over images. However there are three key differences. Firstly, both the encoder and decoder are recurrent networks in DRAW, so that a sequence of code samples is exchanged between them; moreover the encoder is privy to the decoder’s previous outputs, allowing it to tailor the codes it sends according to the decoder’s behaviour so far. Secondly, the decoder’s outputs are successively added to the distribution that will ultimately generate the data, as opposed to emitting this distribution in a single step. And thirdly, a dynamically updated attention mechanism is used to restrict both the input region observed by the encoder, and the output region modified by the decoder. In simple terms, the network decides at each time-step “where to read” and “where to write” as well as “what to write”. The architecture is sketched in Fig. 2, alongside a feedforward variational auto-encoder.

Figure 2: Left: Conventional Variational Auto-Encoder. During generation, a sample is drawn from a prior

and passed through the feedforward decoder network to compute the probability of the input

given the sample. During inference the input is passed to the encoder network, producing an approximate posterior over latent variables. During training, is sampled from and then used to compute the total description length , which is minimised with stochastic gradient descent. Right: DRAW Network. At each time-step a sample from the prior is passed to the recurrent decoder network, which then modifies part of the canvas matrix. The final canvas matrix is used to compute . During inference the input is read at every time-step and the result is passed to the encoder RNN. The RNNs at the previous time-step specify where to read. The output of the encoder RNN is used to compute the approximate posterior over the latent variables at that time-step.

2.1 Network Architecture

Let be the function enacted by the encoder network at a single time-step. The output of at time

is the encoder hidden vector

. Similarly the output of the decoder at is the hidden vector . In general the encoder and decoder may be implemented by any recurrent neural network. In our experiments we use the Long Short-Term Memory architecture (LSTM; Hochreiter & Schmidhuber (1997)) for both, in the extended form with forget gates (Gers et al., 2000). We favour LSTM due to its proven track record for handling long-range dependencies in real sequential data (Graves, 2013; Sutskever et al., 2014). Throughout the paper, we use the notation to denote a linear weight matrix with bias from the vector to the vector .

At each time-step , the encoder receives input from both the image and from the previous decoder hidden vector . The precise form of the encoder input depends on a operation, which will be defined in the next section. The output of the encoder is used to parameterise a distribution over the latent vector . In our experiments the latent distribution is a diagonal Gaussian :


Bernoulli distributions are more common than Gaussians for latent variables in auto-encoders (Dayan et al., 1995; Gregor et al., 2014); however a great advantage of Gaussian latents is that the gradient of a function of the samples with respect to the distribution parameters can be easily obtained using the so-called reparameterization trick (Kingma & Welling, 2014; Rezende et al., 2014)

. This makes it straightforward to back-propagate unbiased, low variance stochastic gradients of the loss function through the latent distribution.

At each time-step a sample drawn from the latent distribution is passed as input to the decoder. The output of the decoder is added (via a operation, defined in the sequel) to a cumulative canvas matrix , which is ultimately used to reconstruct the image. The total number of time-steps consumed by the network before performing the reconstruction is a free parameter that must be specified in advance.

For each image presented to the network, are initialised to learned biases, and the DRAW network iteratively computes the following equations for :


where is the error image, is the concatenation of vectors and into a single vector, and

denotes the logistic sigmoid function:

. Note that , and hence , depends on both and the history of previous latent samples. We will sometimes make this dependency explicit by writing , as shown in Fig. 2. can also be passed as input to the operation; however we did not find that this helped performance and therefore omitted it.

2.2 Loss Function

The final canvas matrix is used to parameterise a model of the input data. If the input is binary, the natural choice for is a Bernoulli distribution with means given by . The reconstruction loss is defined as the negative log probability of under :


The latent loss for a sequence of latent distributions

is defined as the summed Kullback-Leibler divergence of some latent prior

from :


Note that this loss depends upon the latent samples drawn from , which depend in turn on the input . If the latent distribution is a diagonal Gaussian with , as defined in Eqs 1 and 2, a simple choice for

is a standard Gaussian with mean zero and standard deviation one, in which case Eq. 

10 becomes


The total loss for the network is the expectation of the sum of the reconstruction and latent losses:


which we optimise using a single sample of for each stochastic gradient descent step.

can be interpreted as the number of nats required to transmit the latent sample sequence to the decoder from the prior, and (if is discrete) is the number of nats required for the decoder to reconstruct given . The total loss is therefore equivalent to the expected compression of the data by the decoder and prior.

2.3 Stochastic Data Generation

An image can be generated by a DRAW network by iteratively picking latent samples from the prior , then running the decoder to update the canvas matrix . After repetitions of this process the generated image is a sample from :


Note that the encoder is not involved in image generation.

3 Read and Write Operations

The DRAW network described in the previous section is not complete until the and operations in Eqs. 4 and 8 have been defined. This section describes two ways to do so, one with selective attention and one without.

3.1 Reading and Writing Without Attention

In the simplest instantiation of DRAW the entire input image is passed to the encoder at every time-step, and the decoder modifies the entire canvas matrix at every time-step. In this case the and operations reduce to


However this approach does not allow the encoder to focus on only part of the input when creating the latent distribution; nor does it allow the decoder to modify only a part of the canvas vector. In other words it does not provide the network with an explicit selective attention mechanism, which we believe to be crucial to large scale image generation. We refer to the above configuration as “DRAW without attention”.

3.2 Selective Attention Model

To endow the network with selective attention without sacrificing the benefits of gradient descent training, we take inspiration from the differentiable attention mechanisms recently used in handwriting synthesis (Graves, 2013)

and Neural Turing Machines 

(Graves et al., 2014)

. Unlike the aforementioned works, we consider an explicitly two-dimensional form of attention, where an array of 2D Gaussian filters is applied to the image, yielding an image ‘patch’ of smoothly varying location and zoom. This configuration, which we refer to simply as “DRAW”, somewhat resembles the affine transformations used in computer graphics-based autoencoders 

(Tieleman, 2014).

Figure 3: Left: A

grid of filters superimposed on an image. The stride (

) and centre location () are indicated. Right: Three patches extracted from the image (). The green rectangles on the left indicate the boundary and precision () of the patches, while the patches themselves are shown to the right. The top patch has a small and high , giving a zoomed-in but blurry view of the centre of the digit; the middle patch has large and low , effectively downsampling the whole image; and the bottom patch has high and .

As illustrated in Fig. 3, the grid of Gaussian filters is positioned on the image by specifying the co-ordinates of the grid centre and the stride distance between adjacent filters. The stride controls the ‘zoom’ of the patch; that is, the larger the stride, the larger an area of the original image will be visible in the attention patch, but the lower the effective resolution of the patch will be. The grid centre and stride (both of which are real-valued) determine the mean location of the filter at row , column in the patch as follows:


Two more parameters are required to fully specify the attention model: the isotropic variance of the Gaussian filters, and a scalar intensity that multiplies the filter response. Given an input image

, all five attention parameters are dynamically determined at each time step via a linear transformation of the decoder output



where the variance, stride and intensity are emitted in the log-scale to ensure positivity. The scaling of , and is chosen to ensure that the initial patch (with a randomly initialised network) roughly covers the whole input image.

Given the attention parameters emitted by the decoder, the horizontal and vertical filterbank matrices and (dimensions and respectively) are defined as follows:


where is a point in the attention patch, is a point in the input image, and are normalisation constants that ensure that and .

Figure 4: Zooming. Top Left: The original image. Top Middle: A patch extracted with 144 2D Gaussian filters. Top Right: The reconstructed image when applying transposed filters on the patch. Bottom: Only two 2D Gaussian filters are displayed. The first one is used to produce the top-left patch feature. The last filter is used to produce the bottom-right patch feature. By using different filter weights, the attention can be moved to a different location.

3.3 Reading and Writing With Attention

Given , and intensity determined by , along with an input image and error image , the read operation returns the concatenation of two patches from the image and error image:


Note that the same filterbanks are used for both the image and error image. For the write operation, a distinct set of attention parameters , and are extracted from , the order of transposition is reversed, and the intensity is inverted:


where is the writing patch emitted by . For colour images each point in the input and error image (and hence in the reading and writing patches) is an RGB triple. In this case the same reading and writing filters are used for all three channels.

4 Experimental Results

We assess the ability of DRAW to generate realistic-looking images by training on three datasets of progressively increasing visual complexity: MNIST (LeCun et al., 1998)

, Street View House Numbers (SVHN

(Netzer et al., 2011) and CIFAR-10 (Krizhevsky, 2009)

. The images generated by the network are always novel (not simply copies of training examples), and are virtually indistinguishable from real data for MNIST and SVHN; the generated CIFAR images are somewhat blurry, but still contain recognisable structure from natural scenes. The binarized MNIST results substantially improve on the state of the art. As a preliminary exercise, we also evaluate the 2D attention module of the DRAW network on cluttered MNIST classification.

For all experiments, the model of the input data was a Bernoulli distribution with means given by . For the MNIST experiments, the reconstruction loss from Eq 9 was the usual binary cross-entropy term. For the SVHN and CIFAR-10 experiments, the red, green and blue pixel intensities were represented as numbers between 0 and 1, which were then interpreted as independent colour emission probabilities. The reconstruction loss was therefore the cross-entropy between the pixel intensities and the model probabilities. Although this approach worked well in practice, it means that the training loss did not correspond to the true compression cost of RGB images.

Network hyper-parameters for all the experiments are presented in Table 3. The Adam optimisation algorithm (Kingma & Ba, 2014) was used throughout. Examples of generation sequences for MNIST and SVHN are provided in the accompanying video (https://www.youtube.com/watch?v=Zt-7MI9eKEo).

4.1 Cluttered MNIST Classification

To test the classification efficacy of the DRAW attention mechanism (as opposed to its ability to aid in image generation), we evaluate its performance on the cluttered translated MNIST task (Mnih et al., 2014)

. Each image in cluttered MNIST contains many digit-like fragments of visual clutter that the network must distinguish from the true digit to be classified. As illustrated in Fig. 

5, having an iterative attention model allows the network to progressively zoom in on the relevant region of the image, and ignore the clutter outside it.

Figure 5: Cluttered MNIST classification with attention. Each sequence shows a succession of four glimpses taken by the network while classifying cluttered translated MNIST. The green rectangle indicates the size and location of the attention patch, while the line width represents the variance of the filters.

Our model consists of an LSTM recurrent network that receives a ‘glimpse’ from the input image at each time-step, using the selective read operation defined in Section 3.2

. After a fixed number of glimpses the network uses a softmax layer to classify the MNIST digit. The network is similar to the recently introduced Recurrent Attention Model (RAM)

(Mnih et al., 2014), except that our attention method is differentiable; we therefore refer to it as “Differentiable RAM”.

The results in Table 1 demonstrate a significant improvement in test error over the original RAM network. Moreover our model had only a single attention patch at each time-step, whereas RAM used four, at different zooms.

Model Error
Convolutional, 2 layers 14.35%
RAM, 4 glimpses, , 4 scales 9.41%
RAM, 8 glimpses, , 4 scales 8.11%
Differentiable RAM, 4 glimpses, 4.18%
Differentiable RAM, 8 glimpses, 3.36%
Table 1: Classification test error on Cluttered Translated MNIST.

4.2 MNIST Generation

We trained the full DRAW network as a generative model on the binarized MNIST dataset (Salakhutdinov & Murray, 2008). This dataset has been widely studied in the literature, allowing us to compare the numerical performance (measured in average nats per image on the test set) of DRAW with existing methods. Table 2 shows that DRAW without selective attention performs comparably to other recent generative models such as DARN, NADE and DBMs, and that DRAW with attention considerably improves on the state of the art.

DBM 2hl [1]
DBN 2hl [2]
NADE [3]
EoNADE 2hl (128 orderings) [3]
EoNADE-5 2hl (128 orderings) [4]
DLGM [5]
DLGM 8 leapfrog steps [6]
DARN 1hl [7]
DARN 12hl [7] - 87.72
DRAW without attention - 87.40
DRAW - 80.97
Table 2: Negative log-likelihood (in nats) per test-set example on the binarised MNIST data set. The right hand column, where present, gives an upper bound (Eq. 12) on the negative log-likelihood. The previous results are 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., 2014), [7] (Gregor et al., 2014).
Figure 6: Generated MNIST images. All digits were generated by DRAW except those in the rightmost column, which shows the training set images closest to those in the column second to the right (pixelwise is the distance measure). Note that the network was trained on binary samples, while the generated images are mean probabilities.
Figure 7: MNIST generation sequences for DRAW without attention. Notice how the network first generates a very blurry image that is subsequently refined.

Once the DRAW network was trained, we generated MNIST digits following the method in Section 2.3, examples of which are presented in Fig. 6. Fig. 7 illustrates the image generation sequence for a DRAW network without selective attention (see Section 3.1). It is interesting to compare this with the generation sequence for DRAW with attention, as depicted in Fig. 1. Whereas without attention it progressively sharpens a blurred image in a global way, with attention it constructs the digit by tracing the lines—much like a person with a pen.

4.3 MNIST Generation with Two Digits

The main motivation for using an attention-based generative model is that large images can be built up iteratively, by adding to a small part of the image at a time. To test this capability in a controlled fashion, we trained DRAW to generate images with two MNIST images chosen at random and placed at random locations in a black background. In cases where the two digits overlap, the pixel intensities were added together at each point and clipped to be no greater than one. Examples of generated data are shown in Fig. 8. The network typically generates one digit and then the other, suggesting an ability to recreate composite scenes from simple pieces.

Figure 8: Generated MNIST images with two digits.

4.4 Street View House Number Generation

MNIST digits are very simplistic in terms of visual structure, and we were keen to see how well DRAW performed on natural images. Our first natural image generation experiment used the multi-digit Street View House Numbers dataset (Netzer et al., 2011). We used the same preprocessing as (Goodfellow et al., 2013), yielding a house number image for each training example. The network was then trained using patches extracted at random locations from the preprocessed images. The SVHN training set contains 231,053 images, and the validation set contains 4,701 images.

Figure 9: Generated SVHN images. The rightmost column shows the training images closest (in distance) to the generated images beside them. Note that the two columns are visually similar, but the numbers are generally different.
Figure 10: SVHN Generation Sequences. The red rectangle indicates the attention patch. Notice how the network draws the digits one at a time, and how it moves and scales the writing patch to produce numbers with different slopes and sizes.
Figure 11: Training and validation cost on SVHN. The validation cost is consistently lower because the validation set patches were extracted from the image centre (rather than from random locations, as in the training set). The network was never able to overfit on the training data.

The house number images generated by the network are highly realistic, as shown in Figs. 9 and  10. Fig. 11 reveals that, despite the long training time, the DRAW network underfit the SVHN training data.

Task #glimpses LSTM # # Read Size Write Size
MNIST Classification - -
SVHN Model


Table 3: Experimental Hyper-Parameters.

4.5 Generating CIFAR Images

The most challenging dataset we applied DRAW to was the CIFAR-10 collection of natural images (Krizhevsky, 2009). CIFAR-10 is very diverse, and with only 50,000 training examples it is very difficult to generate realistic-looking objects without overfitting (in other words, without copying from the training set). Nonetheless the images in Fig. 12 demonstrate that DRAW is able to capture much of the shape, colour and composition of real photographs.

Figure 12: Generated CIFAR images. The rightmost column shows the nearest training examples to the column beside it.

5 Conclusion

This paper introduced the Deep Recurrent Attentive Writer (DRAW) neural network architecture, and demonstrated its ability to generate highly realistic natural images such as photographs of house numbers, as well as improving on the best known results for binarized MNIST generation. We also established that the two-dimensional differentiable attention mechanism embedded in DRAW is beneficial not only to image generation, but also to image classification.


Of the many who assisted in creating this paper, we are especially thankful to Koray Kavukcuoglu, Volodymyr Mnih, Jimmy Ba, Yaroslav Bulatov, Greg Wayne, Andrei Rusu and Shakir Mohamed.