We propose a simple algorithm to train stochastic neural networks to draw samples from given target distributions for probabilistic inference. Our method is based on iteratively adjusting the neural network parameters so that the output changes along a Stein variational gradient (Liu & Wang, 2016) that maximumly decreases the KL divergence with the target distribution. Our method works for any target distribution specified by their unnormalized density function, and can train any black-box architectures that are differentiable in terms of the parameters we want to adapt. As an application of our method, we propose an amortized MLE algorithm for training deep energy model, where a neural sampler is adaptively trained to approximate the likelihood function. Our method mimics an adversarial game between the deep energy model and the neural sampler, and obtains realistic-looking images competitive with the state-of-the-art results.
1 INTRODUCTION
Modern machine learning increasingly relies on highly complex probabilistic models to reason about uncertainty. A key computational challenge is to develop efficient inference techniques to approximate, or draw samples from complex distributions. Currently, most inference methods, including MCMC and variational inference, are hand-designed by researchers or domain experts. This makes it difficult to fully optimize the choice of different methods and their parameters, and exploit the structures in the problems of interest in an automatic way. The hand-designed algorithm can also be inefficient when it requires to make fast inference repeatedly on a large number of different distributions with similar structures. This happens, for example, when we need to reason about a number of observed datasets in settings like online learning, or need fast inference as inner loops for other algorithms such as maximum likelihood training. Therefore, it is highly desirable to develop more intelligent probabilistic inference systems that can adaptively improve its own performance to fully the optimize computational efficiency, and generalize to new tasks with similar structures.
Specifically, denote by p(x) a probability density of interest specified up to the normalization constant, which we want to draw sample from, or marginalize to estimate its normalization constant. We want to study the following problem:
Problem 1. Given a distribution with density p(x) and a function f(η; ξ) with parameter η and random input ξ, for which we only have assess to draws of the random input ξ (without knowing its true distribution q0), and the output values of f(η; ξ) and its derivative ∂ηf(η; ξ) given η and ξ. We want to find an optimal parameter η so that the density of the random output variable x = f(η; ξ) with ξ ∼ q0 closely matches the target density p(x).
Because we have no assumption on the structure of f(η; ξ) and the distribution of random input, we can not directly calculate the actual distribution of the output random variable x = f(η; ξ); this makes it difficult to solve Problem 1 using the traditional variational inference (VI) methods. Recall that traditional VI approximates p(x) using simple proposal distributions qη(x) indexed by parameter η, and finds the optimal η by minimizing KL divergence KL(qη || p) = Eqη [log(qη/p)], which requires to calculate the density qη(x) or its derivative that is not computable by our assump-
tion (even when the Monte Carlo gradient estimation and the reparametrization trick (Kingma & Welling, 2013) are applied).
In fact, it is this requirement of calculating qη(x) that has been the major constraint for the designing of state-of-the-art variational inference methods with rich approximation families; the recent successful algorithms (e.g., Rezende & Mohamed, 2015b; Tran et al., 2015; Ranganath et al., 2015, to name only a few) have to handcraft special variational families to ensure the computational tractability of qη(x) and simultaneously obtain high approximation accuracy, which require substantial mathematical insights and research effects. Methods that do not require to explicitly calculate qη(x) can significantly simplify the design and applications of VI methods, allowing practical users to focus more on choosing proposals that work best with their specific tasks. We will use the term wild variational inference to refer to new variants of variational methods that require no tractability qη(x), to distinguish with the black-box variational inference (Ranganath et al., 2014) which refers to methods that work for generic target distributions p(x) without significant model-by-model consideration (but still require to calculate the proposal density qη(x)).
A similar problem also appears in importance sampling (IS), where it requires to calculate the IS proposal density q(x) in order to calculate the importance weight w(x) = p(x)/q(x). However, there exist methods that use no explicit information of q(x), which, seemingly counter-intuitively, give better asymptotic variance or converge rates than the typical IS that uses the proposal information (e.g., Liu & Lee, 2016; Briol et al., 2015; Henmi et al., 2007; Delyon & Portier, 2014). Discussions on this phenomenon dates back to O’Hagan (1987), who argued that “Monte Carlo (that uses the proposal information) is fundamentally unsound” for violating the Likelihood Principle, and developed Bayesian Monte Carlo (O’Hagan, 1991) as an example that uses no information on q(x), yet gives better convergence rate than the typical Monte Carlo O(n−1/2) rate (Briol et al., 2015). Despite the substantial difference between IS and VI, these results intuitively suggest the possibility of developing efficient variational inference without calculating q(x) explicitly.
In this work, we propose a simple algorithm for Problem 1 by iteratively adjusting the network parameter η to make its output random variable changes along a Stein variational gradient direction (SVGD) (Liu & Wang, 2016) that optimally decreases its KL divergence with the target distribution. Critically, the SVGD gradient includes a repulsive term to ensure that the generated samples have the right amount of variability that matches p(x). In this way, we “amortize SVGD” using a neural network, which makes it possible for our method to adaptively improve its own efficiency by leveraging fast experience, especially in cases when it needs to perform fast inference repeatedly on a large number of similar tasks. As an application, we use our method to amortize the MLE training of deep energy models, where a neural sampler is adaptively trained to approximate the likelihood function. Our method, which we call SteinGAN, mimics an adversarial game between the energy model and the neural sampler, and obtains realistic-looking images competitive with the state-of-theart results produced by generative adversarial networks (GAN) (Goodfellow et al., 2014; Radford et al., 2015).
Related Work The idea of amortized inference (Gershman & Goodman, 2014) has been recently applied in various domains of probabilistic reasoning, including both amortized variational inference (e.g., Kingma & Welling, 2013; Rezende & Mohamed, 2015a), and data-driven proposals for (sequential) Monte Carlo methods (e.g., Paige & Wood, 2016), to name only a few. Most of these methods, however, require to explicitly calculate q(x) (or its gradient). One exception is a very recent paper (Ranganath et al., 2016) that avoids calculating q(x) using an idea related to Stein discrepancy (Gorham & Mackey, 2015; Liu et al., 2016; Oates et al., 2014; Chwialkowski et al., 2016). There is also a raising interest recently on a similar problem of “learning to optimize” (e.g., Andrychowicz et al., 2016; Daniel et al., 2016; Li & Malik, 2016), which is technically easier than the more general problem of “learning to sample”. In fact, we show that our algorithm reduces to “learning to optimize” when only one particle is used in SVGD.
Generative adversarial network (GAN) and its variants have recently gained remarkable success on generating realistic-looking images (Goodfellow et al., 2014; Salimans et al., 2016; Radford et al., 2015; Li et al., 2015; Dziugaite et al., 2015; Nowozin et al., 2016). All these methods are set up to train latent variable models (the generator) under the assistant of the discriminator. Our SteinGAN instead performs traditional MLE training for a deep energy model, with the help of a neural sampler that learns to draw samples from the energy model to approximate the likelihood
function; this admits an adversarial interpretation: we can view the neural sampler as a generator that attends to fool the deep energy model, which in turn serves as a discriminator that distinguishes the real samples and the simulated samples given by the neural sampler. This idea of training MLE with neural samplers was first discussed by Kim & Bengio (2016); one of the key differences is that the neural sampler in Kim & Bengio (2016) is trained with the help of a heuristic diversity regularizer based on batch normalization, while SVGD enforces the diversity in a more principled way. Another method by Zhao et al. (2016) also trains an energy score to distinguish real and simulated samples, but within a non-probabilistic framework (see Section 5 for more discussion). Other more traditional approaches for training energy-based models (e.g., Ngiam et al., 2011; Xie et al., 2016) are often based on variants of MCMC-MLE or contrastive divergence (Geyer, 1991; Hinton, 2002; Tieleman, 2008), and have difficulty generating realistic-looking images from scratch.
2 STEIN VARIATIONAL GRADIENT DESCENT (SVGD)
Stein variational gradient descent (SVGD) (Liu & Wang, 2016) is a general purpose Bayesian inference algorithm motivated by Stein’s method (Stein, 1972; Barbour & Chen, 2005) and kernelized Stein discrepancy (Liu et al., 2016; Chwialkowski et al., 2016; Oates et al., 2014). It uses an efficient deterministic gradient-based update to iteratively evolve a set of particles {xi}ni=1 to minimize the KL divergence with the target distribution. SVGD has a simple form that reduces to the typical gradient descent for maximizing log p when using only one particle (n = 1), and hence can be easily combined with the successful tricks for gradient optimization, including stochastic gradient, adaptive learning rates (such as adagrad), and momentum.
To give a quick overview of the main idea of SVGD, let p(x) be a positive density function on Rd which we want to approximate with a set of particles {xi}ni=1. SVGD initializes the particles by sampling from some simple distribution q0, and updates the particles iteratively by
xi ← xi + φ(xi), ∀i = 1, . . . , n, (1) where is a step size, and φ(x) is a “particle gradient direction” chosen to maximumly decrease the KL divergence between the distribution of particles and the target distribution, in the sense that
φ = arg max φ∈F { − d d KL(q[ φ] || p) ∣∣ =0 } , (2)
where q[ φ] denotes the density of the updated particle x′ = x + φ(x) when the density of the original particle x is q, and F is the set of perturbation directions that we optimize over. We choose F to be the unit ball of a vector-valued reproducing kernel Hilbert space (RKHS)Hd = H×· · ·×H with eachH associating with a positive definite kernel k(x, x′); note thatH is dense in the space of continuous functions with universal kernels such as the Gaussian RBF kernel.
Critically, the gradient of KL divergence in (2) equals a simple linear functional of φ, allowing us to obtain a closed form solution for the optimal φ. Liu & Wang (2016) showed that
− d d KL(q[ φ] || p) ∣∣ =0 = Ex∼q[Tpφ(x)], (3)
with Tpφ(x) = ∇x log p(x)>φ(x) +∇x · φ(x), (4) where Tp is considered as a linear operator acting on function φ and is called the Stein operator in connection with Stein’s identity which shows that the RHS of (3) equals zero if p = q:
Ep[Tpφ] = Ep[∇x log p>φ +∇x · φ] = 0. (5) This is a result of integration by parts assuming the value of p(x)φ(x) vanishes on the boundary of the integration domain.
Therefore, the optimization in (2) reduces to
D(q || p) def= max φ∈Hd {Ex∼q[Tpφ(x)] s.t. ||φ||Hd ≤ 1}, (6)
where D(q || p) is the kernelized Stein discrepancy defined in Liu et al. (2016), which equals zero if and only if p = q under mild regularity conditions. Importantly, the optimal solution of (6) yields a closed form
φ∗(x′) ∝ Ex∼q[∇x log p(x)k(x, x′) +∇xk(x, x′)].
Algorithm 1 Amortized SVGD for Problem 1 Set batch size m, step-size scheme { t} and kernel k(x, x′). Initialize η0. for iteration t do
Draw random {ξi}mi=1, calculate xi = f(ηt; ξi), and the Stein variational gradient ∆xi in (7). Update parameter η using (8), (9) or (10).
end for
By approximating the expectation under q with the empirical average of the current particles {xi}ni=1, SVGD admits a simple form of update:
xi ← xi + ∆xi, ∀i = 1, . . . , n, where ∆xi = Êx∈{xi}ni=1 [∇x log p(x)k(x, xi) +∇xk(x, xi)], (7)
and Êx∼{xi}ni=1 [f(x)] = ∑ i f(xi)/n. The two terms in ∆xi play two different roles: the term with the gradient ∇x log p(x) drives the particles toward the high probability regions of p(x), while the term with ∇xk(x, xi) serves as a repulsive force to encourage diversity; to see this, consider a stationary kernel k(x, x′) = k(x − x′), then the second term reduces to Êx∇xk(x, xi) = −Êx∇xik(x, xi), which can be treated as the negative gradient for minimizing the average similarity Êxk(x, xi) in terms of xi. Overall, this particle update produces diverse points for distributional approximation and uncertainty assessment, and also has an interesting “momentum” effect in which the particles move collaboratively to escape the local optima.
It is easy to see from (7) that ∆xi reduces to the typical gradient ∇x log p(xi) when there is only a single particle (n = 1) and ∇xk(x, xi) when x = xi, in which case SVGD reduces to the standard gradient ascent for maximizing log p(x) (i.e., maximum a posteriori (MAP)).
3 AMORTIZED SVGD: TOWARDS AN AUTOMATIC NEURAL SAMPLER
SVGD and other particle-based methods become inefficient when we need to repeatedly infer a large number different target distributions for multiple tasks, including online learning or inner loops of other algorithms, because they can not improve based on the experience from the past tasks, and may require a large memory to restore a large number of particles. We propose to “amortize SVGD” by training a neural network f(η; ξ) to mimic the SVGD dynamics, yielding a solution for Problem 1.
One straightforward way to achieve this is to run SVGD to convergence and train f(η; ξ) to fit the SVGD results. This, however, requires to run many epochs of fully converged SVGD and can be slow in practice. We instead propose an incremental approach in which η is iteratively adjusted so that the network outputs x = f(η; ξ) changes along the Stein variational gradient direction in (7) in order to decrease the KL divergence between the target and approximation distribution.
To be specific, denote by ηt the estimated parameter at the t-th iteration of our method; each iteration of our method draws a batch of random inputs {ξi}mi=1 and calculate their corresponding output xi = f(η; ξi) based on ηt; here m is a mini-batch size (e.g., m = 100). The Stein variational gradient ∆xi in (7) would then ensure that x′i = xi + ∆xi forms a better approximation of the target distribution p. Therefore, we should adjust η to make its output matches {x′i}, that is, we want to update η by
ηt+1 ← arg min η m∑ i=1 ||f(η; ξi)− x′i||22, where x′i = xi + ∆xi. (8)
See Algorithm 1 for the summary of this procedure. If we assume is very small, then (8) reduces to a least square optimization. To see this, note that f(η; ξi) ≈ f(ηt; ξi) + ∂ηf(ηt; ξi)(η − ηt) by Taylor expansion. Since xi = f(ηt; ξi), we have
||f(η; ξi)− x′i||22 ≈ ||∂ηf(ηt; ξi)(η − ηt)− ∆xi||22. As a result, (8) reduces to the following least square optimization:
ηt+1 ← ηt + ∆ηt, where ∆ηt = arg min δ m∑ i=1 ||∂ηf(ηt; ξi)δ −∆xi||22. (9)
Update (9) can still be computationally expensive because of the matrix inversion. We can derive a further approximation by performing only one step of gradient descent of (8) (or (9)), which gives
ηt+1 ← ηt + m∑ i=1 ∂ηf(η t; ξi)∆xi. (10)
Although update (10) is derived as an approximation of (8)-(9), it is computationally faster and we find it works very effectively in practice; this is because when is small, one step of gradient update can be sufficiently close to the optimum.
Update (10) also has a simple and intuitive form: (10) can be thought as a “chain rule” that backpropagates the Stein variational gradient to the network parameter η. This can be justified by considering the special case when we use only a single particle (n = 1) in which case ∆xi in (7) reduces to the typical gradient ∇x log p(xi) of log p(x), and update (10) reduces to the typical gradient ascent for maximizing Eξ[log p(f(η; ξ))], in which case f(η; ξ) is trained to maximize log p(x) (that is, learning to optimize), instead of learning to draw samples from p for which it is crucial to use Stein variational gradient ∆xi to diversify the network outputs.
Update (10) also has a close connection with the typical variational inference with the reparameterization trick (Kingma & Welling, 2013). Let qη(x) be the density function of x = f(η; ξ), ξ ∼ q0. Using the reparameterization trick, the gradient of KL(qη || p) w.r.t. η can be shown to be
∇ηKL(qη || p) = −Eξ∼q0 [∂ηf(η; ξ)(∇x log p(x)−∇x log qη(x))].
With {ξi} i.i.d. drawn from q0 and xi = f(η; ξi), ∀i, the standard stochastic gradient descent for minimizing the KL divergence is
ηt+1 ← ηt + ∑ i ∂ηf(η t; ξi)∆̃xi, where ∆̃xi = ∇x log p(xi)−∇x log qη(xi). (11)
This is similar with (10), but replaces the Stein gradient ∆xi defined in (7) with ∆̃xi. The advantage of using ∆xi is that it does not require to explicitly calculate qη , and hence admits a solution to Problem 1 in which qη is not computable for complex network f(η; ξ) and unknown input distribution q0. Further insights can be obtained by noting that
∆xi ≈ Ex∼q[∇x log p(x)k(x, xi) +∇xk(x, xi)] = Ex∼q[(∇x log p(x)−∇x log q(x))k(x, xi)] (12) = Ex∼q[(∆̃x)k(x, xi)],
where (12) is obtained by using Stein’s identity (5). Therefore, ∆xi can be treated as a kernel smoothed version of ∆̃xi.
4 AMORTIZED MLE FOR GENERATIVE ADVERSARIAL TRAINING
Our method allows us to design efficient approximate sampling methods adaptively and automatically, and enables a host of novel applications. In this paper, we apply it in an amortized MLE method for training deep generative models.
Maximum likelihood estimator (MLE) provides a fundamental approach for learning probabilistic models from data, but can be computationally prohibitive on distributions for which drawing samples or computing likelihood is intractable due to the normalization constant. Traditional methods such as MCMC-MLE use hand-designed methods (e.g., MCMC) to approximate the intractable likelihood function but do not work efficiently in practice. We propose to adaptively train a generative neural network to draw samples from the distribution during MLE training, which not only provides computational advantage, and also allows us to generate realistic-looking images competitive with, or better than the state-of-the-art generative adversarial networks (GAN) (Goodfellow et al., 2014; Radford et al., 2015) (see Figure 1-5).
Algorithm 2 Amortized MLE as Generative Adversarial Learning Goal: MLE training for energy model p(x|θ) = exp(−φ(x, θ)− Φ(θ)). Initialize η and θ. for iteration t do
Updating η: Draw ξi ∼ q0, xi = f(η; ξi); update η using (8), (9) or (10) with p(x) = p(x|θ). Repeat several times when needed. Updating θ: Draw a mini-batch of observed data {xi,obs}, and simulated data xi = f(η; ξi), update θ by (13).
end for
To be specific, denote by {xi,obs} a set of observed data. We consider the maximum likelihood training of energy-based models of form
p(x|θ) = exp(−φ(x, θ)− Φ(θ)), Φ(θ) = log ∫ exp(−φ(x, θ))dx,
where φ(x; θ) is an energy function for x indexed by parameter θ and Φ(θ) is the log-normalization constant. The log-likelihood function of θ is
L(θ) = 1
n n∑ i=1 log p(xi,obs|θ),
whose gradient is
∇θL(θ) = −Êobs[∂θφ(x; θ)] + Eθ[∂θφ(x; θ)],
where Êobs[·] and Eθ[·] denote the empirical average on the observed data {xi,obs} and the expectation under model p(x|θ), respectively. The key computational difficulty is to approximate the model expectation Eθ[·]. To address this problem, we use a generative neural network x = f(η; ξ) trained by Algorithm 1 to approximately sample from p(x|θ), yielding a gradient update for θ of form
θ ← θ + ∇̂θL(θ), ∇̂θL(θ) = −Êobs[∂θφ(x; θ)] + Êη[∂θφ(x; θ)], (13)
where Êη denotes the empirical average on {xi} where xi = f(η; ξi), {ξi} ∼ q0. As θ is updated by gradient ascent, η is successively updated via Algorithm 1 to follow p(x|θ). See Algorithm 2. We call our method SteinGAN, because it can be intuitively interpreted as an adversarial game between the generative network f(η; ξ) and the energy model p(x|θ) which serves as a discriminator: The MLE gradient update of p(x|θ) effectively decreases the energy of the training data and increases the energy of the simulated data from f(η; ξ), while the SVGD update of f(η; ξ) decreases the energy of the simulated data to fit better with p(x|θ). Compared with the traditional methods based on MCMC-MLE or contrastive divergence, we amortize the sampler as we train, which gives much faster speed and simultaneously provides a high quality generative neural network that can generate realistic-looking images; see Kim & Bengio (2016) for a similar idea and discussions.
5 EMPIRICAL RESULTS
We evaluated our SteinGAN on four datasets, MNIST, CIFAR-10, CelebA (Liu et al., 2015), and Large-scale Scene Understanding (LSUN) (Yu et al., 2015), on which we find our method tends to generate realistic-looking images competitive with, sometimes better than DCGAN (Radford et al., 2015) (see Figure 2 - Figure 3). Our code is available at https://github.com/DartML/ SteinGAN.
Model Setup In order to generate realistic-looking images, we define our energy model based on an autoencoder:
p(x|θ) ∝ exp(−||x−D(E(x; θ); θ)||), (14)
where x denotes the image. This choice is motivated by Energy-based GAN (Zhao et al., 2016) in which the autoencoder loss is used as a discriminator but without a probabilistic interpretation. We
assume f(η; ξ) to be a neural network whose input ξ is a 100-dimensional random vector drawn by Uniform([−1, 1]). The positive definite kernel in SVGD is defined by the RBF kernel on the hidden representation obtained by the autoencoder in (14), that is,
k(x, x′) = exp(− 1 h2 ||E(x; θ)− E(x′; θ)||2).
As it is discussed in Section 3, the kernel provides a repulsive force to produce an amount of variability required for generating samples from p(x). This is similar to the heuristic repelling regularizer in Zhao et al. (2016) and the batch normalization based regularizer in Kim & Bengio (2016), but is derived in a more principled way. We take the bandwidth to be h = 0.5 ×med, where med is the median of the pairwise distances between E(x) on the image simulated by f(η; ξ). This makes the kernel change adaptively based on both θ (through E(x; θ)) and η (through bandwidth h).
Some datasets include both images x and their associated discrete labels y. In these cases, we train a joint energy model on (x, y) to capture both the inner structure of the images and its predictive relation with the label, allowing us to simulate images with a control on which category it belongs to. Our joint energy model is defined to be
p(x, y|θ) ∝ exp { − ||x−D(E(x; θ); θ)|| −max[m, σ(y, E(x; θ))] } , (15)
where σ(·, ·) is the cross entropy loss function of a fully connected output layer. In this case, our neural sampler first draws a label y randomly according to the empirical counts in the dataset, and then passes y into a neural network together with a 100 × 1 random vector ξ to generate image x. This allows us to generate images for particular categories by controlling the value of input y.
Stabilization In practice, we find it is useful to modify (13) to be θ ← θ − Êobs[∇θφ(x, θ)] + (1− γ)Êη[∇θφ(x, θ)]. (16)
where γ is a discount factor (which we take to be γ = 0.7). This is equivalent to maximizing a regularized likelihood:
max θ {log p(x|θ) + γΦ(θ)}
where Φ(θ) is the log-partition function; note that exp(γΦ(θ)) is a conjugate prior of p(x|θ). We initialize the weights of both the generator and discriminator from Gaussian distribution N (0, 0.02), and train them using Adam (Kingma & Ba, 2014) with a learning rate of 0.001 for the generator and 0.0001 for the energy model (the discriminator). In order to keep the generator and discriminator approximately aligned during training, we speed up the MLE update (16) of the discriminator (by increasing its learning rate to 0.0005) when the energy of the real data batch is larger than the energy of the simulated images, while slow down it (by freezing the MLE update of θ in (16)) if the magnitude of the energy difference between the real images and the simulated images goes above a threshold of 0.5. We used the bag of architecture guidelines for stable training suggested in DCGAN (Radford et al., 2015).
Discussion The MNIST dataset has a training set of 60, 000 examples. Both DCGAN and our model produce high quality images, both visually indistinguishable from real images; see figure 1.
CIFAR-10 is very diverse, and with only 50,000 training examples. Figure 2 shows examples of simulated images by DCGAN and SteinGAN generated conditional on each category, which look equally well visually. We also provide quantitively evaluation using a recently proposed inception score (Salimans et al., 2016), as well as the classification accuracy when training ResNet using 50, 000 simulated images as train sets, evaluated on a separate held-out testing set never seen by the GAN models. Besides DCGAN and SteinGAN, we also evaluate another simple baseline obtained by subsampling 500 real images from the training set and duplicating them 100 times. We observe that these scores capture rather different perspectives of image generation: The inception score favors images that look realistic individually and have uniformly distributed labels; as a result, the inception score of the duplicated 500 images is almost as high as the real training set. We find that the inception score of SteinGAN is comparable, or slightly lower than that of DCGAN. On the other hand, the classification accuracy measures the amount information captured in the simulated image sets; we find that SteinGAN achieves the highest classification accuracy, suggesting that it captures more information in the training set.
Figure 3 and 4 visualize the results on CelebA (with more than 200k face images) and LSUN (with nearly 3M bedroom images), respectively. We cropped and resized both dataset images into 64×64.
6 CONCLUSION
We propose a new method to train neural samplers for given distributions, together with a new SteinGAN method for generative adversarial training. Future directions involve more applications and theoretical understandings for training neural samplers.
This paper considers the energy-based model interpretation of GAN, where the discriminator is an unnormalized model for the likelihood of a generative model p(x|theta) and the generator is a directed model that approximates this distribution. The generator is used to draw approximate negative phase samples that are used in stochastic maximum likelihood / contrastive divergence learning of the EBM / discriminator.
The main idea in the paper is to fit the generator by following the Stein variational gradient. In practice this gradient consists of the usual gradient provided by the discriminator with an added term that provides a repulsive force between the sampled data points to increase sample diversity.
The idea of using a kernel to push apart the sampled points is interesting, and will work in low dimensions, but it is hard to see how it can work in full scale images. For high dimensional samples x, the proposed kernel is unlikely to provide a useful distance measure between points. There are no convincing experiments in the paper that show otherwise. Specifically:
- There is no experiment that compares between standard GAN and GAN + repulsion, using the same architecture. (please address this in the rebuttal)
- If the Stein variational idea is taken literally, the right thing to do would be to fully optimize the generator at every step, and then taking a single optimization step on the discriminator. Instead, each is updated in turn, and the learning rates of both steps are adjusted to keep the two "in line".
- The kernel used to fit the generator is defined in the auto-encoder space of the discriminator, and thus depends on the discriminator parameters. The objective that is used to fit the generator thus changes at every step, and the procedure can no longer be interpreted as stochastic gradient descent with respect to any single well defined objective.
The authors obtain good results: The generated images clearly look better than those generated by DCGAN. However, their approach has a number of changes compared to DCGAN, so it is not clear where the improvement comes from. In addition, by now the DCGAN is no longer a very strong baseline, as various other techniques have been proposed.
Note: The use of phi for both the "particle gradient direction" and energy function is confusing