pytorch-vae
A Variational Autoencoder (VAE) implemented in PyTorch
view repo
In just three years, Variational Autoencoders (VAEs) have emerged as one of the most popular approaches to unsupervised learning of complicated distributions. VAEs are appealing because they are built on top of standard function approximators (neural networks), and can be trained with stochastic gradient descent. VAEs have already shown promise in generating many kinds of complicated data, including handwritten digits, faces, house numbers, CIFAR images, physical models of scenes, segmentation, and predicting the future from static images. This tutorial introduces the intuitions behind VAEs, explains the mathematics behind them, and describes some empirical behavior. No prior knowledge of variational Bayesian methods is assumed.
READ FULL TEXT VIEW PDF
Variational autoencoders provide a principled framework for learning dee...
read it
We implement stacked denoising autoencoders, a class of neural networks ...
read it
Classic Autoencoders and variational autoencoders are used to learn comp...
read it
Numerosity, the number of objects in a set, is a basic property of a giv...
read it
We take a Bayesian perspective to illustrate a connection between traini...
read it
Deep Learning based methods have emerged as the indisputable leaders for...
read it
This work develops a simple information theoretic framework that capture...
read it
A Variational Autoencoder (VAE) implemented in PyTorch
None
None
From here-Tutorial on AutoEncoders. https://arxiv.org/abs/1606.05908
Variational Auto Encoder implementation in PyTorch with latent space representation
“Generative modeling” is a broad area of machine learning which deals with models of distributions
, defined over datapoints in some potentially high-dimensional space . For instance, images are a popular kind of data for which we might create generative models. Each “datapoint” (image) has thousands or millions of dimensions (pixels), and the generative model’s job is to somehow capture the dependencies between pixels, e.g., that nearby pixels have similar color, and are organized into objects. Exactly what it means to “capture” these dependencies depends on exactly what we want to do with the model. One straightforward kind of generative model simply allows us to compute numerically. In the case of images,values which look like real images should get high probability, whereas images that look like random noise should get low probability. However, models like this are not necessarily useful: knowing that one image is unlikely does not help us synthesize one that is likely.
Instead, one often cares about producing more examples that are like those already in a database, but not exactly the same. We could start with a database of raw images and synthesize new, unseen images. We might take in a database of 3D models of something like plants and produce more of them to fill a forest in a video game. We could take handwritten text and try to produce more handwritten text. Tools like this might actually be useful for graphic designers. We can formalize this setup by saying that we get examples distributed according to some unknown distribution , and our goal is to learn a model which we can sample from, such that is as similar as possible to .
Training this type of model has been a long-standing problem in the machine learning community, and classically, most approaches have had one of three serious drawbacks. First, they might require strong assumptions about the structure in the data. Second, they might make severe approximations, leading to suboptimal models. Or third, they might rely on computationally expensive inference procedures like Markov Chain Monte Carlo. More recently, some works have made tremendous progress in training neural networks as powerful function approximators through backpropagation
[9]. These advances have given rise to promising frameworks which can use backpropagation-based function approximators to build generative models.One of the most popular such frameworks is the Variational Autoencoder [1, 3], the subject of this tutorial. The assumptions of this model are weak, and training is fast via backpropagation. VAEs do make an approximation, but the error introduced by this approximation is arguably small given high-capacity models. These characteristics have contributed to a quick rise in their popularity.
This tutorial is intended to be an informal introduction to VAEs, and not a formal scientific paper about them. It is aimed at people who might have uses for generative models, but might not have a strong background in the variatonal Bayesian methods and “minimum description length” coding models on which VAEs are based. This tutorial began its life as a presentation for computer vision reading groups at UC Berkeley and Carnegie Mellon, and hence has a bias toward a vision audience. Suggestions for improvement are appreciated.
When training a generative model, the more complicated the dependencies between the dimensions, the more difficult the models are to train. Take, for example, the problem of generating images of handwritten characters. Say for simplicity that we only care about modeling the digits 0-9. If the left half of the character contains the left half of a 5, then the right half cannot contain the left half of a 0, or the character will very clearly not look like any real digit. Intuitively, it helps if the model first decides which character to generate before it assigns a value to any specific pixel. This kind of decision is formally called a latent variable. That is, before our model draws anything, it first randomly samples a digit value from the set , and then makes sure all the strokes match that character. is called ‘latent’ because given just a character produced by the model, we don’t necessarily know which settings of the latent variables generated the character. We would need to infer it using something like computer vision.
Before we can say that our model is representative of our dataset, we need to make sure that for every datapoint in the dataset, there is one (or many) settings of the latent variables which causes the model to generate something very similar to
. Formally, say we have a vector of latent variables
in a high-dimensional spacewhich we can easily sample according to some probability density function (PDF)
defined over . Then, say we have a family of deterministic functions , parameterized by a vector in some space , where . is deterministic, but if is random and is fixed, thenis a random variable in the space
. We wish to optimize such that we can sample from and, with high probability, will be like the ’s in our dataset.To make this notion precise mathematically, we are aiming maximize the probability of each in the training set under the entire generative process, according to:
(1) |
Here, has been replaced by a distribution , which allows us to make the dependence of on
explicit by using the law of total probability. The intuition behind this framework—called “maximum likelihood”—is that if the model is likely to produce training set samples, then it is also likely to produce similar samples, and unlikely to produce dissimilar ones. In VAEs, the choice of this output distribution is often Gaussian, i.e.,
. That is, it has meanand covariance equal to the identity matrix
times some scalar(which is a hyperparameter). This replacement is necessary to formalize the intuition that some
needs to result in samples that are merely like . In general, and particularly early in training, our model will not produce outputs that are identical to any particular. By having a Gaussian distribution, we can use gradient descent (or any other optimization technique) to increase
by making approach for some , i.e., gradually making the training data more likely under the generative model. This wouldn’t be possible if was a Dirac delta function, as it would be if we used deterministically! Note that the output distribution is not required to be Gaussian: for instance, if is binary, then might be a Bernoulli parameterized by . The important property is simply that can be computed, and is continuous in . From here onward, we will omit from to avoid clutter.The mathematical basis of VAEs actually has relatively little to do with classical autoencoders, e.g. sparse autoencoders [10, 11]
[12, 13]. VAEs approximately maximize Equation 1, according to the model shown in Figure 1. They are called “autoencoders” only because the final training objective that derives from this setup does have an encoder and a decoder, and resembles a traditional autoencoder. Unlike sparse autoencoders, there are generally no tuning parameters analogous to the sparsity penalties. And unlike sparse and denoising autoencoders, we can sample directly from (without performing Markov Chain Monte Carlo, as in [14]).To solve Equation 1, there are two problems that VAEs must deal with: how to define the latent variables (i.e., decide what information they represent), and how to deal with the integral over . VAEs give a definite answer to both.
First, how do we choose the latent variables such that we capture latent information? Returning to our digits example, the ‘latent’ decisions that the model needs to make before it begins painting the digit are actually rather complicated. It needs to choose not just the digit, but the angle that the digit is drawn, the stroke width, and also abstract stylistic properties. Worse, these properties may be correlated: a more angled digit may result if one writes faster, which also might tend to result in a thinner stroke. Ideally, we want to avoid deciding by hand what information each dimension of encodes (although we may want to specify it by hand for some dimensions [4]). We also want to avoid explicitly describing the dependencies—i.e., the latent structure—between the dimensions of . VAEs take an unusual approach to dealing with this problem: they assume that there is no simple interpretation of the dimensions of , and instead assert that samples of can be drawn from a simple distribution, i.e., , where is the identity matrix. How is this possible? The key is to notice that any distribution in dimensions can be generated by taking a set of
variables that are normally distributed and mapping them through a sufficiently complicated function
^{1}^{1}1In one dimension, you can use the inverse cumulative distribution function (CDF) of the desired distribution composed with the CDF of a Gaussian. This is an extension of “inverse transform sampling.” For multiple dimensions, do the stated process starting with the marginal distribution for a single dimension, and repeat with the conditional distribution of each additional dimension. See the “inversion method” and the “conditional distribution method” in Devroye et al.
[15]. For example, say we wanted to construct a 2D random variable whose values lie on a ring. If is 2D and normally distributed, is roughly ring-shaped, as shown in Figure 2. Hence, provided powerful function approximators, we can simply learn a function which maps our independent, normally-distributed values to whatever latent variables might be needed for the model, and then map those latent variables to . In fact, recall that . If is a multi-layer neural network, then we can imagine the network using its first few layers to map the normally distributed ’s to the latent values (like digit identity, stroke weight, angle, etc.) with exactly the right statitics. Then it can use later layers to map those latent values to a fully-rendered digit. In general, we don’t need to worry about ensuring that the latent structure exists. If such latent structure helps the model accurately reproduce (i.e. maximize the likelihood of) the training set, then the network will learn that structure at some layer.(a) | (b) | (c) |
Now all that remains is to maximize Equation 1, where . As is common in machine learning, if we can find a computable formula for , and we can take the gradient of that formula, then we can optimize the model using stochastic gradient ascent. It is actually conceptually straightforward to compute approximately: we first sample a large number of values , and compute . The problem here is that in high dimensional spaces,
might need to be extremely large before we have an accurate estimate of
. To see why, consider our example of handwritten digits. Say that our digit datapoints are stored in pixel space, in 28x28 images as shown in Figure 3. Since is an isotropic Gaussian, the negative log probability of is proportional squared Euclidean distance between and . Say that Figure 3(a) is the target () for which we are trying to find . A model which produces the image shown in Figure 3(b) is probably a bad model, since this digit is not much like a 2. Hence, we should set the hyperparameter of our Gaussian distribution such that this kind of erroroneous digit does not contribute to . On the other hand, a model which produces Figure 3(c) (identical to but shifted down and to the right by half a pixel) might be a good model. We would hope that this sample would contribute to . Unfortunately, however, we can’t have it both ways: the squared distance between and Figure 3(c) is .2693 (assuming pixels range between 0 and 1), but between and Figure 3(b) it is just .0387. The lesson here is that in order to reject samples like Figure 3(b), we need to set very small, such that the model needs to generate something significantly more like than Figure 3(c)! Even if our model is an accurate generator of digits, we would likely need to sample many thousands of digits before we produce a 2 that is sufficiently similar to the one in Figure 3(a). We might solve this problem by using a better similarity metric, but in practice these are difficult to engineer in complex domains like vision, and they’re difficult to train without labels that indicate which datapoints are similar to each other. Instead, VAEs alter the sampling procedure to make it faster, without changing the similarity metric.Is there a shortcut we can take when using sampling to compute Equation 1? In practice, for most , will be nearly zero, and hence contribute almost nothing to our estimate of . The key idea behind the variational autoencoder is to attempt to sample values of that are likely to have produced , and compute just from those. This means that we need a new function which can take a value of and give us a distribution over values that are likely to produce . Hopefully the space of values that are likely under will be much smaller than the space of all ’s that are likely under the prior . This lets us, for example, compute relatively easily. However, if is sampled from an arbitrary distribution with PDF , which is not , then how does that help us optimize ? The first thing we need to do is relate and . We’ll see where comes from later.
The relationship between and
is one of the cornerstones of variational Bayesian methods. We begin with the definition of Kullback-Leibler divergence (KL divergence or
) between and , for some arbitrary (which may or may not depend on ):(2) |
We can get both and into this equation by applying Bayes rule to :
(3) |
Here, comes out of the expectation because it does not depend on . Negating both sides, rearranging, and contracting part of into a KL-divergence terms yields:
(4) |
Note that is fixed, and can be any distribution, not just a distribution which does a good job mapping to the ’s that can produce . Since we’re interested in inferring , it makes sense to construct a which does depend on , and in particular, one which makes small:
(5) |
This equation serves is the core of the variational autoencoder, and it’s worth spending some time thinking about what it says^{2}^{2}2 Historically, this math (particularly Equation 5) was known long before VAEs. For example, Helmholtz Machines [16] (see Equation 5) use nearly identical mathematics, with one crucial difference. The integral in our expectations is replaced with a sum in Dayan et al. [16], because Helmholtz Machines assume a discrete distribution for the latent variables. This choice prevents the transformations that make gradient descent tractable in VAEs. . In two sentences, the left hand side has the quantity we want to maximize: (plus an error term, which makes produce ’s that can reproduce a given ; this term will become small if is high-capacity). The right hand side is something we can optimize via stochastic gradient descent given the right choice of (although it may not be obvious yet how). Note that the framework—in particular, the right hand side of Equation 5—has suddenly taken a form which looks like an autoencoder, since is “encoding” into , and is “decoding” it to reconstruct . We’ll explore this connection in more detail later.
Now for a bit more detail on Equatinon 5. Starting with the left hand side, we are maximizing while simultaneously minimizing . is not something we can compute analytically: it describes the values of that are likely to give rise to a sample like under our model in Figure 1. However, the second term on the left is pulling to match . Assuming we use an arbitrarily high-capacity model for , then will hopefully actually match , in which case this KL-divergence term will be zero, and we will be directly optimizing . As an added bonus, we have made the intractable tractable: we can just use to compute it.
So how can we perform stochastic gradient descent on the right hand side of Equation 5? First we need to be a bit more specific about the form that will take. The usual choice is to say that , where and are arbitrary deterministic functions with parameters that can be learned from data (we will omit in later equations). In practice, and are again implemented via neural networks, and is constrained to be a diagonal matrix. The advantages of this choice are computational, as they make it clear how to compute the right hand side. The last term——is now a KL-divergence between two multivariate Gaussian distributions, which can be computed in closed form as:
(6) |
where is the dimensionality of the distribution. In our case, this simplifies to:
(7) |
The first term on the right hand side of Equation 5 is a bit more tricky. We could use sampling to estimate , but getting a good estimate would require passing many samples of through , which would be expensive. Hence, as is standard in stochastic gradient descent, we take one sample of and treat for that as an approximation of . After all, we are already doing stochastic gradient descent over different values of sampled from a dataset . The full equation we want to optimize is:
(8) |
If we take the gradient of this equation, the gradient symbol can be moved into the expectations. Therefore, we can sample a single value of and a single value of from the distribution , and compute the gradient of:
(9) |
We can then average the gradient of this function over arbitrarily many samples of and , and the result converges to the gradient of Equation 8.
There is, however, a significant problem with Equation 9. depends not just on the parameters of , but also on the parameters of . However, in Equation 9, this dependency has disappeared! In order to make VAEs work, it’s essential to drive to produce codes for that can reliably decode. To see the problem a different way, the network described in Equation 9 is much like the network shown in Figure 4 (left). The forward pass of this network works fine and, if the output is averaged over many samples of and , produces the correct expected value. However, we need to back-propagate the error through a layer that samples from , which is a non-continuous operation and has no gradient. Stochastic gradient descent via backpropagation can handle stochastic inputs, but not stochastic units within the network! The solution, called the “reparameterization trick” in [1], is to move the sampling to an input layer. Given and —the mean and covariance of —we can sample from by first sampling , then computing . Thus, the equation we actually take the gradient of is:
(10) |
This is shown schematically in Figure 4 (right). Note that none of the expectations are with respect to distributions that depend on our model parameters, so we can safely move a gradient symbol into them while maintaning equality. That is, given a fixed and , this function is deterministic and continuous in the parameters of and , meaning backpropagation can compute a gradient that will work for stochastic gradient descent. It’s worth pointing out that the “reparameterization trick” only works if we can sample from by evaluating a function , where is noise from a distribution that is not learned. Furthermore, must be continuous in so that we can backprop through it. This means (and therefore ) can’t be a discrete distribution! If is discrete, then for a fixed , either needs to ignore , or there needs to be some point at which “jumps” from one possible value in ’s sample space to another, i.e., a discontinuity.
At test time, when we want to generate new samples, we simply input values of into the decoder. That is, we remove the “encoder,” including the multiplication and addition operations that would change the distribution of . This (remarkably simple) test-time network is shown in Figure 5.
Say that we want to evaluate the probability of a testing example under the model. This is, in general, not tractable. Note, however, that is positive, meaning that the right hand side of Equation 5 is a lower bound to . This lower bound still can’t quite be computed in closed form due to the expectation over , which requires sampling. However, sampling from gives an estimator for the expectation which generally converges much faster than sampling from as discussed in section 2. Hence, this lower bound can be a useful tool for getting a rough idea of how well our model is capturing a particular datapoint .
By now, you are hopefully convinced that the learning in VAEs is tractable, and that it optimizes something like across our entire dataset. However, we are not optimizing exactly , so this section aims to take a deeper look at what the objective function is actually doing. We address three topics. First, we ask how much error is introduced by optimizing in addition to . Second, we describe the VAE framework—especially the r.h.s. of Equation 5—in terms of information theory, linking it to other approaches based on Minimum Description Length. Finally, we investigate whether VAEs have “regularization parameters” analogous to the sparsity penalty in sparse autoencoders.
The tractability of this model relies on our assumption that can be modeled as a Gaussian with some mean
and variance
. converges (in distribution) to the true distribution if only if goes to zero. Unfortunately, it’s not straightforward to ensure that this happens. Even if we assume and are arbitrarily high capacity, the posterior is not necessarily Gaussian for an arbitrary function that we’re using to define . For fixed , this might mean that never goes to zero. However, the good news is that there are infinitely many functions that result in our model generating any given output distribution. Any of these functions will maximize equally well. Hence, all we need is one function which both maximizes and results in being Gaussian for all . If so, will pull our model towards that parameterization of the distribution. So, does such a function exist for all distributions we might want to approximate? I’m not aware of anyone proving this in general just yet, but it turns out that one can prove that such a function does exist, provided is small relative to the curvature of the ground truth distribution’s CDF (at least in 1D; a proof is included in Appendix A). In practice such a small might cause problems for existing machine learning algorithms, since the gradients would become badly scaled. However, it is comforting to know that VAEs have zero approximation error in at least this one scenario. This fact suggests that future theoretical work may show us how much approximation error VAEs have in more practical setups. It seems like it should be possible to extend the proof technique in appendix A to multiple dimensions, but this is left for future work.Another important way to look at the right hand side of Equation 5 is in terms of information theory, and in particular, the “minimum description length” principle which motivated many of the VAE’s predecessors like Helmholtz Machines [16], the Wake-Sleep Algorithm [17], Deep Belief Nets [18]
, and Boltzmann Machines
[19]. can be seen as the total number of bits required to construct under our model using an ideal encoding. The right hand side of Equation 5 views this as a two-step process to construct . We first use some bits to construct . Recall that a KL-divergence is measured in bits (or nats). We measure the bits required to construct using a because under our model, we assume that any which is sampled from can contain no information about . Hence, we need to measure the amount of extra information that we get about when comes from instead of from (for more details, see the “bits back” argument of [20, 21]). In the second step, measures the amount of information required to reconstruct from under an ideal encoding. Hence, the total number of bits () is the sum of these two steps, minus a penalty we pay for being a sub-optimal encoding (). Note that this second step is a fairly wasteful way to encode information about : does not model any of the correlations between the dimensions of under our model, so even an ideal encoding must essentially encode every dimension separately.Looking at Equation 5, it’s interesting to view the as a regularization term, much like the sparsity regularization in sparse autoencoders [10]. From this standpoint, it’s interesting to ask whether the variational autoencoder has any “regularization parameter.” That is, in the sparse autoencoder objective, we have a regularization parameter in an objective function that looks something like this:
(11) |
where and are the encoder and decoder functions, respectively, and is an norm that encourages the encoding to be sparse. This must be set by hand.
Interestingly, a variational autoencoder does not generally have such a regularization parameter, which is good because that’s one less parameter that the programmer needs to adjust. However, for certain models, we can make it appear like such a regularization parameter exists. It’s tempting to think that this parameter can come from changing to something like , but it turns out that this doesn’t change the model. To see this, note that we can absorb this constant into and by writing them in terms of , , and . This will produce an objective function whose value (right hand side of Equation 5) is identical to the loss we had with . Also, the model for sampling will be identical, since .
However, there is another place where a regularization parameter can come from. Recall that : therefore, changing this will change without affecting . In more detail, , where is a constant that does not depend on , and can thus be ignored during optimization. Thus, can be treated as a weighting factor between the two terms of the r.h.s. of Equation 5. Note, however, that the existence of this parameter relies on our choice of the distribution of given . If is binary and we use a Bernoulli output model, then this regularization parameter disappears, and the only way to bring it back is to use hacks like replicating the dimensions of . From an information theory standpoint, this makes sense: when is binary, we can actually count the number of bits that are required to encode , and both terms on the right hand side of Equation 5 are using the same units to count these bits. However, when is continuous, each sample contains infinite information. Our choice of determines how accurately we expect the model to reconstruct , which is necessary so that the information content can become finite.
Let’s return to our running example of generating handwritten digits. Say that we don’t just want to generate new digits, but instead we want to add digits to an existing string of digits written by a single person. This is similar to a truly practical problem in computer graphics called hole filling: given an existing image where a user has removed an unwanted object, the goal is to fill in the hole with plausible-looking pixels. An important difficulty with both problems is that the space of plausible outputs is multi-modal: there are many possibilities for the next digit or the extrapolated pixels. A standard regression model will fail in this situation, because the training objective generally penalizes the distance between a single prediction and the ground truth. Faced with a problem like this, the best solution the regressor can produce is something which is in between the possibilities, since it minimizes the expected distance. In the case of digits, this will most likely look like a meaningless blur that’s an “average image” of all possible digits and all possible styles that could occur^{3}^{3}3 The denoising autoencoder [12, 13] can be seen as a slight generalization of the regression model, which might improve on its behavior. That is, we would say that the “noise distribution” simply deletes pixels, and so the denoising autoencoder must reconstruct the original image given the noisy version. Note, however, that this still doesn’t solve the problem. The standard denoising autoencoder still requires that the conditional distribution of the original sample given the noisy sample follow a simple, parametric distribution. This is not the case for complex data like image patches. . What we need is an algorithm that takes in a string or an image, and produces a complex, multimodal distribution that we can sample from. Enter the conditional variational autoencoder (CVAE) [7, 8], which modifies the math in the previous section by simply conditioning the entire generative process on an input. CVAEs allow us to tackle problems where the input-to-output mapping is one-to-many^{4}^{4}4Often called “structured prediction” in machine learning literature., without requiring us to explicitly specify the structure of the output distribution.
Given an input and an output , we want to create a model which maximizes the probability of the ground truth (I apologize for re-defining here. However, standard machine learning notation maps to , so I will too). We define the model by introducing a latent variable , such that:
(12) |
Where is a deterministic function that we can learn from data. We can rewrite Equations 2 through 5 conditioning on as follows:
(13) |
(14) |
(15) |
Note that is still because our model assumes is sampled independently of at test time. The structure of this model is shown in Figure 6.
At test time, we can sample from the distribution by simply sampling .
Implementations for these examples using Caffe
[22] can be found online at:To demonstrate the distribution learning capabilities of the VAE framework, let’s train a variational autoencoder on MNIST. To show that the framework isn’t heavily dependent on initialization or network structure, we don’t use existing published VAE network structures, but instead adapt the basic MNIST AutoEncoder example that’s included with Caffe [22]
. (However, we use ReLU non-linearities
[9] and ADAM [23], since both are standard techniques to speed convergence.) Although MNIST is real-valued, it is constrained between 0 and 1, so we use the Sigmoid Cross Entropy loss for . This has a probabilistic interpretation: imagine that we created a new datapoint by independently sampling each dimension as . Cross entropy measures the expected probability of . Thus we’re actually modeling, the randomly binarized version of MNIST, but we’re only giving
a summary of this data . Admittedly this is not quite what the VAE framework prescribes but works well in practice, and is used in other VAE literature [6]. Even though our model is considerably deeper than [1] and [3], training the model was not difficult. The training was run to completion exactly once (though it was re-started the training 5 times to find the learning rate which made the loss descend the fastest). Digits generated from noise are shown in Figure 7. It’s worth noting that these samples are difficult to evaluate since there’s no simple way to measure how different these are from the training set [24]. However, the failure cases are interesting: while most of the digits look quite realistic, a significant number are ‘in-between’ different digits. For example, the seventh digit from the top in the leftmost column is clearly in-between a 7 and a 9. This happens because we are mapping a continuous distribution through a smooth function.In practice, the model seems to be quite insensitive to the dimensionality of , unless is excessively large or small. Too few ’s means the model can no longer capture all of the variation: less than 4 dimensions produced noticeably worse results. Results with 1,000 ’s were good, but with 10,000 they were also degraded. In theory, if a model with ’s is good, then a model with should not be worse, since the model can simply learn to ignore the extra dimensions. However, in practice, it seems stochastic gradient descent struggles to keep low when is extremely large.
I had originally intended to show a conditional variational autoencoder completing MNIST digits given only half of each digit. While a CVAE works quite well for this purpose, unfortunately a regressor actually works quite well also, producing relatively crisp samples. The apparent reason is the size of MNIST. A network with similar capacity to the one in section 4.1 can easily memorize the entire dataset, and so the regressor overfits badly. Thus, at test time, it produces predictions that behave something like nearest-neighbor matching, which are actually quite sharp. CVAE models are most likely to outperform simple regression when the output is ambiguous given a training example. Therefore, let’s make two modifications to the problem to make it more ambiguous, at the cost of making it somewhat more artificial. First, the input is a single column of pixels taken from the middle of the digit. In MNIST, each pixel has a value between 0 and 1, meaning that there is still enough information even in this single column of pixels for the network to identify a specific training example. Therefore, the second modification is to replace each pixel in our column with a binary value (0 or 1), choosing 1 with probability equal to the pixel intensity. These binary values were resampled each time a digit was passed to the network. Figure 8 shows the results. Note that the regressor model handles the ambiguity by blurring its output (although there are cases where the regressor is suspiciously confident when making wrong guesses, suggesting overfitting is still an issue). The blur in the regressor’s output minimizes the distance to the set of many digits which might have produced the input. The CVAE, on the other hand, generally picks a specific digit to output and does so without blur, resulting in more believable images.
Acknowledgements: Thanks to everyone in the UCB CS294 Visual Object And Activity Recognition group and CMU Misc-Read group, and to many others who encouraged me to convert the presentation I gave there into a tutorial. I would especially like to thank Philipp Krähenbühl, Jacob Walker, and Deepak Pathak for helping me formulate and refine my description of the method, and Kenny Marino for help editing. I also thank Abhinav Gupta and Alexei Efros for helpful discussions and support, and Google for their fellowship supporting my research.
Let be a 1D distribution that we are trying to approximate using a VAE. We assume that everywhere, that it is infinitely differentiable, and all the derivatives are bounded. Recall that a variational autoencoder optimizes
(16) |
where for , , and . We make the dependence on explicit here since we will send it to 0 to prove convergence. The theoretical best possible solution is where and . By “arbitrarily powerful” learners, we mean that if there exist , and which achieve this best possible solution, then the learning algorithm will find them. Hence, we must merely show that such an , , and exist. First off, can actually be described arbitrarily well as as approaches 0. To show this, let be the cumulative distribution function (CDF) of , and let be the CDF of , which are both guaranteed to exist. Then is distributed
(the uniform distribution), and therefore
is distributed . This means that as , the distribution converges to .From here, we must simply show that as . Let , i.e., the inverse of , and let . Note that is invariant to affine transformations of the sample space. Hence, let and . When I write , I am using the PDF of as a function, and evaluating it at some point. Then:
(17) |
where does not depend on
, and its standard deviation is greater than
. Therefore, it is sufficient to show that for all . Let . Then:(18) |
Here, as , which is a constant, and as , so also tends to a constant. Together with , they ensure that the whole distribution normalizes. We will wrap them both in the constant .
(19) |
Next, we do a Taylor expansion of around :
(20) |
Note that . We rewrite the above using this formula, rearrange terms, and re-write the result as a Gaussian to obtain:
(21) |
Note , since . Furthermore, since is bounded for all , all terms in the sum tend to 0 as . must make the distribution normalize, so we have that the above expression:
(22) |
Looking at Equation 21, the bulk of the approximation error in this setup comes from the curvature of , which is mostly determined by the curvature of the c.d.f. of the ground truth distribution.
Draw: A recurrent neural network for image generation.
In ICCV, 2015.International conference on artificial intelligence and statistics
, pages 448–455, 2009.Proceedings of the sixth annual conference on Computational learning theory
, 1993.
Comments
There are no comments yet.