draw
Reimplementation of DRAW
view repo
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.
READ FULL TEXT VIEW PDFReimplementation of DRAW
Torch implementation of DRAW: A Recurrent Neural Network For Image Generation
DRAW implementation with deepy
Tensorflow implementation of the DRAW Network (http://arxiv.org/abs/1502.04623)
Recurrent Variational Auto-encoders with Gaussian Attention
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.
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.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.
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 :
(1) | ||||
(2) |
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 :
(3) | ||||
(4) | ||||
(5) | ||||
(6) | ||||
(7) | ||||
(8) |
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.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 :
(9) |
The latent loss for a sequence of latent distributions
is defined as the summed Kullback-Leibler divergence of some latent prior
from :(10) |
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(11) |
The total loss for the network is the expectation of the sum of the reconstruction and latent losses:
(12) |
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.
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 :
(13) | ||||
(14) | ||||
(15) | ||||
(16) |
Note that the encoder is not involved in image generation.
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.
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
(17) | ||||
(18) |
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”.
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).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:
(19) | ||||
(20) |
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
:(21) | |||
(22) | |||
(23) | |||
(24) |
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:
(25) | ||||
(26) |
where is a point in the attention patch, is a point in the input image, and are normalisation constants that ensure that and .
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:
(27) |
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:
(28) | ||||
(29) |
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.
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).
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.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% |
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.
Model | ||
---|---|---|
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 |
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.
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.
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.
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 | - | - | |||
MNIST Model | |||||
SVHN Model | |||||
CIFAR Model |
s
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.
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.
Proceedings of the 31st International Conference on Machine Learning
, 2014.Learning to combine foveal glimpses with a third-order boltzmann machine.
In Advances in Neural Information Processing Systems, pp. 1243–1251. 2010.The neural autoregressive distribution estimator.
Journal of Machine Learning Research, 15:29–37, 2011.International Conference on Artificial Intelligence and Statistics
, pp. 448–455, 2009.On the quantitative analysis of Deep Belief Networks.
In Proceedings of the 25th Annual International Conference on Machine Learning, pp. 872–879. Omnipress, 2008.International Journal of Computer Vision
, pp. 1–13, 2014.