GENERATIVE RATIO MATCHING NETWORKS
Year: 2020

Abstract:
Deep generative models can learn to generate realistic-looking images, but many of the most effective methods are adversarial and involve a saddlepoint optimization, which requires a careful balancing of training between a generator network and a critic network. Maximum mean discrepancy networks (MMD-nets) avoid this issue by using kernel as a fixed adversary, but unfortunately, they have not on their own been able to match the generative quality of adversarial training. In this work, we take their insight of using kernels as fixed adversaries further and present a novel method for training deep generative models that does not involve saddlepoint optimization. We call our method generative ratio matching or GRAM for short. In GRAM, the generator and the critic networks do not play a zero-sum game against each other, instead they do so against a fixed kernel. Thus GRAM networks are not only stable to train like MMD-nets but they also match and beat the generative quality of adversarially trained generative networks. 1

heading: 1 INTRODUCTION
text: Deep generative models (Kingma & Welling, 2013; Goodfellow et al., 2014; Kingma & Dhariwal, 2018) have been shown to learn to generate realistic-looking images. These methods train a deep neural network, called a generator, to transform samples from a noise distribution to samples from the data distribution. Most methods use adversarial learning (Goodfellow et al., 2014), in which the generator is pitted against a critic function, also called a discriminator, which is trained to distinguish between the samples from the data distribution and from the generator. Upon successful training the two sets of samples become indistinguishable with respect to the critic.
Maximum mean discrepancy networks (MMD-nets) (Li et al., 2015; Dziugaite et al., 2015) are a class of generative models that are trained to minimize the MMD (Gretton et al., 2012) between the true data distribution and the model distribution. MMD-nets are similar in spirit to generative adversarial networks (GANs) (Goodfellow et al., 2014; Nowozin et al., 2016), in the sense that the MMD is defined by maximizing over a class of critic functions. However, in contrast to GANs, where finding the right balance between generator and critic is difficult, training is simpler for MMD-nets because using the kernel trick the MMD can be estimated without the need to numerically optimize over the critic function. This avoids the need in GANs to numerically solve a saddlepoint problem.
Unfortunately, although MMD-nets work well on low dimensional data, these networks have not on their own matched the generative performance of adversarial methods on higher dimensional datasets, such as natural images (Dziugaite et al., 2015). Several authors (Li et al., 2017; Bińkowski et al., 2018a) suggest that a reason is that MMD is sensitive to the choice of kernel. Li et al. (2017) propose a method called MMD-GAN, in which the critic maps the samples from the generator and the data into a lower-dimensional representation, and MMD is applied in this transformed space. This ∗Equal contributions. †Additional affiliations: The University of Edinburgh and IBM Research. ‡Additional affiliations: The University of Edinburgh and The Alan Turing Institute 1Official implementations are available at https://github.com/GRAM-nets.
can be interpreted as a method for learning the kernel in MMD. The critic is learned adversarially by maximizing the MMD at the same time as it is minimized with respect to the generator. This is much more effective than MMD-nets, but training MMD-GANs can be challenging, because in this saddlepoint optimization problem, the need to balance training of the learned kernel and the generator can create a sensitivity to hyperparameter settings. In practice, it is necessary to introduce several additional penalties to the loss function in order for training to be effective.
In this work, we present a novel training method that builds on MMD-nets’ insight to use kernels as fixed adversaries in order to avoid saddlepoint optimization based training for the critic and the generator. Our goal is for the critic to map the samples into a lower-dimensional space in which the MMD-net estimator will be more effective. Our proposal is that the critic should be trained to preserve density ratios, namely, the ratio of the true density to the model density. If the critic is successful in this, then matching the generator to the true data in the lower dimensional space will also match the distributions in the original space. We call networks that have been trained using this criterion generative ratio matching (GRAM) networks, or GRAM-nets2. We show empirically that our method is not only able to generate high quality images but by virtue of avoiding a zero-sum game (in critic and generator) it avoids saddlepoint optimization and hence is more stable to train and robust to the choice of hyperparameters.

heading: 1.1 RELATED WORK
text: Li et al. (2015) and Dziugaite et al. (2015) independently proposed MMD-nets, which use the MMD criterion to train a deep generative model. Unlike f -divergences, MMD is well defined even for distributions that do not have overlapping support, which is an important consideration for training generative models (Arjovsky et al., 2017). Therefore, MMD-nets use equation (2) in order to minimize the discrepancy between the distributions qx and px with respect to Gγ . However, the sample quality of MMD-nets generally degrades for higher dimensional or color image datasets (Li et al., 2015).
To address this problem, Li et al. (2017) introduce MMD-GANs, which use a critic fθ : RD 7→ RK to map the samples to a lower dimensional space RK , and train the generator to minimize MMD in this reduced space. This can be interpreted as learning the kernel function for MMD, because if fθ is injective and k0 is a kernel in RK , then k(x, x′) = k0(fθ(x), fθ(x′)) is a kernel in RD. This injectivity constraint on fθ is imposed by introducing another deep neural network f ′φ, which is trained to approximately invert fθ using an auto-encoding penalty. Though it has been shown before that inverting fθ is not necessary for the method to work. We also confirm this in experiments (See appendix).
The critic fθ is trained using an adversarial criterion (maximizing equation (2) that the generator minimizes), which requires numerical saddlepoint optimization, and avoiding this was one of the main attractions of MMD in the first place. Due to this, successfully training fθ in practice required a penalty term called feasible set reduction on the class of functions that fθ can learn to represent. Furthermore, f is restricted to be k-Lipschitz continuous by using a low learning rate and explicitly clipping the gradients during update steps of f akin to WGAN (Arjovsky et al., 2017). Recently, Bińkowski et al. (2018b); Li et al. (2019) have proposed improvements to stabilize the training of the MMD-GAN method. But these method still rely on solving the same saddle-point problem to train the critic.

heading: 2 BACKGROUND
text: Given data xi ∈ RD for i ∈ {1 . . . N} from a distribution of interest with density px, the goal of deep generative modeling is to learn a parameterized function Gγ : Rh 7→ RD, called a generator network, that maps samples z ∈ Rh where h < D from a noise distribution pz to samples from the model distribution. Since Gγ defines a new random variable, we denote its density function by qx, and also write xq = Gγ(z), where we suppress the dependency of xq on γ. The parameters γ of the generator are chosen to minimize a loss criterion which encourages qx to match px.
2Interestingly, the training of GRAM-nets heavily relies on the use of kernel Gram matrices.

heading: 2.1 MAXIMUM MEAN DISCREPANCY
text: Maximum mean discrepancy measures the discrepancy between two distributions as the maximum difference between the expectations of a class of functions F , that is,
MMDF (p, q) = sup f∈F (Ep[f(x)]− Eq[f(x)]) , (1)
where E denotes expectation. If F is chosen to be a rich enough class, then MMD(p, q) = 0 implies that p = q. Gretton et al. (2012) show that it is sufficient to choose F to be a unit ball in an reproducing kernel Hilbert spaceR with a characteristic kernel k. Given samples x1 . . . xN ∼ p and yi . . . yM ∼ q, we can estimate MMDR as
ˆMMD 2 R(p, q) = 1
N2 N∑ i=1 N∑ i′=1 k(xi, xi′)− 2 NM N∑ i=1 M∑ j=1 k(xi, yj) + 1 M2 M∑ j=1 M∑ j′=1 k(yj , yj′). (2)

heading: 2.2 DENSITY RATIO ESTIMATION
text: Sugiyama et al. (2012) present an elegant MMD-based estimator for the ratio between the densities p and q; r(x) = p(x)q(x) that only needs samples from p and q. This estimator is derived by optimizing
min r∈R ∥∥∥∥∫ k(x; .)p(x)dx− ∫ k(x; .)r(x)q(x)dx∥∥∥∥2 R , (3)
where k is a kernel function. It is easy to see that at the minimum, we have r = p/q. This estimator is not guaranteed to be non-negative. As such, a positivity constraint should be imposed if needed.
Sugiyama et al. (2011) suggest that density ratio estimation for distributions p and q over RD can be more accurately done in lower dimensional sub-spaces RK . They propose to first learn a linear projection to a lower dimensional space by maximizing an f -divergence between the distributions p̄ and q̄ of the projected data and then estimate the ratio of p̄ and q̄ (using direct density ratio estimation). They showed that the projected distributions preserve the original density ratio.

heading: 3 METHOD
text: Our aim will be to enjoy the advantages of MMD-nets, but to improve their sample quality by mapping the data (RD) into a lower-dimensional space (RK), using a critic network fθ, before computing the MMD criterion. Because MMD with a fixed kernel performs well for lower-dimensional data (Li et al., 2015; Dziugaite et al., 2015), we hope that by choosing K < D, we will improve the performance of the MMD-net. Instead of training fθ using an adversarial criterion like MMD-GAN, we aim at a stable training method that avoids the saddle-point optimization for training the critic.
More specifically, unlike the MMD-GAN type methods, instead of maximizing the same MMD criterion that the generator is trained to minimize, we train fθ to minimize the squared ratio difference, that is, the difference between density ratios in the original space and in the low-dimensional space induced by fθ (Section 3.1). More specifically, let q̄ be the density of the transformed simulated data, i.e., the density of the random variable fθ(Gγ(z)), where z ∼ pz . Similarly let p̄ be the density of the transformed data, i.e., the density of the random variable fθ(x). The squared ratio difference is minimized when θ is such that px/qx equals p̄/q̄. The motivation is that if density ratios are preserved by fθ, then matching the generator to the data in the transformed space will also match it in the original space (Section 3.2). The reduced dimension of fθ should be chosen to strike a trade-off between dimensionality reduction and ability to approximate the ratio. If the data lie on a lower-dimensional manifold in RD, which is the case for e.g. natural images, then it is reasonable to suppose that we can find a critic that strikes a good trade-off. To compute this criterion, we need to estimate density ratio p̄/q̄, which can be done in closed form using MMD (Section 2.2). The generator is trained as an MMD-net to match the transformed data {fθ(xi)} with transformed outputs from the generator {f(Gγ(zi)} in the lower dimensional space (Section 3.2). Our method performs stochastic gradient (SG) optimization on the critic and the generator jointly (Section 3.3).

heading: 3.1 TRAINING THE CRITIC USING SQUARED RATIO DIFFERENCE
text: Our principle is to choose fθ so that the resulting densities p̄ and q̄ preserve the density ratio between px and qx. We will choose fθ to minimize the distance between the two density ratio functions
rx(x) = px(x)/qx(x) rθ(x) = p̄(fθ(x))/q̄(fθ(x)).
One way to measure how well fθ preserves density ratios is to use the squared distance
D∗(θ) = ∫ qx(x) ( px(x)
qx(x) − p̄(fθ(x)) q̄(fθ(x))
)2 dx. (4)
This objective is minimized only when the ratios match exactly, that is, when rx = rθ for all x in the support of qx. Clearly a distance of zero can be trivially achieved if K = D and if fθ is the identity function.But nontrivial optima can exist as well. For example, suppose that px and qx are “intrinsically low dimensional” in the following sense. Suppose K < D, and consider two distributions p0 and q0 over RK , and an injective map T : RK → RD. Suppose that T maps samples from p0 and q0 to samples from px and qx, by which we mean px(x) = J(DT )p0(T−1(x)), and similarly for qx. Here J(DT ) denotes the Jacobian J(DT ) = √ |δTδT>| of T . Then we have that D∗ is minimized to 0 when fθ = T−1.
However, it is difficult to optimize D∗(θ) directly because density ratio estimation in high dimension, where data lives, is known to be hard, i.e. the term px(x)qx(x) in (4) is difficult to estimate. We will show how to alleviate this issue next.
Avoiding density ratio estimation in data space: To avoid computing the term px(x)qx(x) in (4), we expand the square in (4), apply the law of the unconscious statistician and cancel terms out (See appendix A for detailed steps), which yields
D∗(θ) = C + ∫ q̄(fθ(x)) ( p̄(fθ(x))
q̄(fθ(x))
)2 dfθ(x)− 2 ∫ p̄(fθ(x)) p̄(fθ(x))
q̄(fθ(x)) dfθ(x),
= C ′ − [∫ q̄(fθ(x)) ( p̄(fθ(x))
q̄(fθ(x))
)2 dfθ(x)− 1 ] (5) where C and C ′ = C − 1 does not depend on θ. This implies that minimizing D∗ is equivalent to maximizing the Pearson divergence
PD(p̄, q̄) = ∫ q̄(fθ(x)) ( p̄(fθ(x))
q̄(fθ(x))
)2 dfθ(x)− 1 = ∫ q̄(fθ(x)) ( p̄(fθ(x)) q̄(fθ(x)) − 1 )2 dfθ(x) (6)
between p̄ and q̄, which justifies our terminology of referring to fθ as a critic function. So we can alternatively interpret our squared ratio distance objective as preferring fθ so that the low-dimensional distributions p̄ and q̄ are maximally separated under Pearson divergence. Therefore D∗ can be minimized empirically using samples xq1 . . . x q M ∼ qx, to maximize the critic loss function
L(θ) = 1 M M∑ i=1 [rθ(x q i )− 1] 2 . (7)
Optimizing this requires a way to estimate rθ(x q i ). For this purpose we use the density ratio estimator introduced in Section 2.2. Notice that to compute (7), we need the value of rθ only for the points xq1 . . . x q M . In other words, we need to approximate the vector rq,θ = [rθ(x q 1) . . . rθ(x q M )]
T . Following Sugiyama et al. (2012), we replace the integrals in (3) with Monte Carlo averages over the points fθ(x q 1) . . . fθ(x q M ) and over points fθ(x p 1) . . . fθ(x p N ) ∼ p̄; the minimizing values of rq,θ can then be computed as
r̂q,θ = K −1 q,qKq,p1. (8)
Here Kq,q and Kq,p denote the Gram matrices defined by [Kq,q]i,j = k(fθ(x q i ), fθ(x q j)) and [Kq,p]i,j = k(fθ(x q i ), fθ(x p j )).
Substituting these estimates into (7) and adding a positivity constraint r̂Tq,θ.1 for using the MMD density ratio estimator (Sugiyama et al., 2012), we get
L̂(θ) = 1 M M∑ i=1 [rθ(x q i )− 1] 2 + λr̂Tq,θ.1, (9)
where λ is a parameter to control the constraint, being set to 1 in all our experiments.3 This objective can be maximised to learn the critic fθ. We see that this is an estimator of the Pearson divergence PD(p̄, q̄) in that we are both, averaging over samples from qx, and approximating the density ratio. Thus maximising this objective leads to the preservation of density ratio (Sugiyama et al., 2011).

heading: 3.2 GENERATOR LOSS
text: To train the generator network Gγ , we minimize the MMD in the low-dimensional space, where both the generated data and the true data are transformed by fθ. In other words, we minimize the MMD between p̄ and q̄. We sample points z1 . . . zM ∼ pz from the input distribution of the generator. Then using the empirical estimate (2) of the MMD, we define the generator loss function as
L̂2(γ) = 1 N2 N∑ i=1 N∑ i′=1 k(fθ(xi), fθ(xi′))− 2 NM N∑ i=1 M∑ j=1 k(fθ(xi), fθ(Gγ(zj)))
+ 1
M2 M∑ j=1 M∑ j′=1 k(fθ(Gγ(zj)), fθ(Gγ(zj′)))
, (10)
which we minimize with respect to γ.
3.3 THE GENERATIVE RATIO MATCHING ALGORITHM
Finally, the overall training of the critic and the generator proceeds by jointly performing SG optimization on L̂(θ) and L̂(γ). Unlike WGAN (Arjovsky et al., 2017) and MMD-GAN (Li et al., 2017), we do not require the use of gradient clipping, feasible set reduction and autoencoding regularization terms. Our algorithm is a simple iterative process.
while not converged do Sample a minibatch of data {xpi }Ni=1 ∼ px and generated samples {x q i }Mi=1 ∼ qx;
Using fθ to transform data as {fθ(xpi )}Ni=1 and generated samples as {fθ(x q i )}Mi=1; Compute the Gram matrix K under Gaussian kernels in the transformed space; Compute L̂(θ) via (8) and (9), and L̂(γ) via (10) using the same K; Compute the gradients gθ = ∇θL̂(θ) and gγ = ∇γL̂(γ) ; θ ← θ + ηgθ; γ ← γ − ηgγ ; // Perform SG optimisation for θ and γ
end Algorithm 1: Generative ratio matching
Convergence: If we succeed in matching the generator to the true data in the low-dimensional space, then we have also matched the generator to the data in the original space, in the limit of infinite data. To see this, suppose that we have γ∗ and θ∗ such that D∗(θ∗) = 0 and that My = MMD(p̄, q̄) = 0. Then for all x, we have rx(x) = rθ∗(x) because D∗(θ∗) = 0, and that rθ∗(x) = 1, because My = 0. This means that rx(x) = 1, so we have that px = qx.

heading: 3.4 STABILITY OF GRAM-NETS
text: Unlike GANs, the GRAM formulation avoids the saddle-point optimization which leads to a very stable training of the model. In this section we provide a battery of controlled experiments to
3As it is pointed out by one of the reviewer, instead of adding the regularization term, another way to resolve the non-negativity issue of the ratio estimator is to simply clipping it the estimator be positive. This in fact works well in practice and can further improves the stability of training.
empirically demonstrate that GRAM training relying on the empirical estimators of MMD and Pearson Divergence (PD), i.e. equations (7) and (9). While the MMD estimator is very extensively studied, our novel empirical estimator of PD is not. Therefore we now show that in fact maximizing our estimator for PD can be reliably used for training the critic, i.e. it minimizes equation (4).
Stability of adversarial methods has been extensively studied before by using a simple dataset of eight axis-aligned Gaussian distributions with standard deviations of 0.01, arranged in a ring shape (Roth et al., 2017; Mescheder et al., 2017; Srivastava et al., 2017). Therefore we train a simple generator using GRAM on this 2D ring dataset to study the stability and accuracy of GRAM-nets. We set the projection dimension K = D = 2 in order to facilitate visualization. Both the generator and the projection networks are implemented as two-layer feed-forward neural networks with two hidden layers of size of 100 and ReLU activations.
The generator output (orange) is visualized over the real data (blue) in Figure 1a at 10,100,1000 and 10,000th training iterations. The top row visualizes the observation space (RD) and the bottom row visualizes the projected space (RK). Note, as the training progress the critic (bottom row) tries to find projections that better separate the data and the generator distributions (especially noticeable in columns 1 and 3). This provides a clear and strong gradient signal to the generator optimization that successfully learns to minimize the MMD of the projected distributions and eventually the data and the model distributions as well (as shown in the last column). Notice, how in the final column the critic is no longer able to separate the distributions. Throughout this process the critic and the generator objectives are consistently minimized. This is clearly shown in Figure 1b which records the values of equations (10) for the generator (orange) loss and equation (5) for the critic objective (blue).
Next, we compare GRAM-based training against classical adversarial training that involves a zerosum game. For this purpose we train a GAN with the same exact architecture and hyperparameter as those used for the GRAM-net in the previous experiments. Adversarial models are known to be unstable on the 2D ring dataset (Roth et al., 2017; Mescheder et al., 2017) as the critic can often easily outperform the generator in this simple setting. Figure 2 summarizes the results of this comparison. Both models are trained on three different levels of generator capacity and four different dimensions of the input noise variable (h). GANs are known to be unstable at both low and high dimensional noise but they additionally tend to mode-collapse (Srivastava et al., 2017) on high dimensional noise. This is confirmed in our experiments; GANs failed to learn the true data distribution in every case and in most cases the optimization also diverged. In sharp contrast to this, GRAM training successfully converged in all 12 settings. Adversarial training needs a careful balance between the generator and the critic capacities. In the plot we can see that, as the capacity of the generator becomes larger, the training become more unstable in GAN. This is not the case for GRAM-nets, which train well without requiring to make any adjustments in other hyperparameters. This enlists as an important advantage of GRAM, as one can use the most powerful model (generator and critic) given their computational budget instead of worrying about balancing the optimization. We also provide the corresponding results for MMD-nets and MMD-GANs in Appendix B.3, in which one can see MMD-nets can also capture all modes, but the learned distribution is less separated (or sharp) compared to GRAM-nets and MMD-GANs tend to produces distributions which are too sharp.

heading: 3.4.1 COMPUTATION GRAPHS
text: Figure 3 visualizes the computational graph for GAN, MMD-net, MMD-GAN and GRAM-net. Solid arrows describe the direction of the computation, K denotes the kernel gram matrix and most importantly dashed lines represent the presence of saddlepoint optimization. In case of GAN and MMD-GAN, the dashed lines imply that by formulation, training the critic adversarially affects the training of the generator as they are trained by minimizing and maximizing the same objective i.e. Lγ = −Lθ. Both MMD-nets and GRAM-nets avoid this saddle-point problem. In GRAM-nets, the critic and generator do not play a zero-sum game as they are trained to optimize different objectives, i.e. the critic learns to find a projection in which the density ratios of the pair of input distributions are preserved after the projection and the generator tries to minimize the MMD in the projected space.

heading: 4 EXPERIMENTS
text: In this section we empirically compare GRAM-nets against MMD-GANs and vanilla GANs, on the Cifar10 and CelebA image datasets. Please note that while we have tried include maximum number of evaluations in this section itself, due to space limitations, some of the results are made available in the appendix. To evaluate the sample quality and resilience against mode dropping, we used Frechet
Inception Distance (FID) (Heusel et al., 2017).4 Like the Inception Score (IS), FID also leverages a pre-trained Inception Net to quantify the quality of the generated samples, but it is more robust to noise than IS and can also detect intra-class mode dropping (Lucic et al., 2017). FID first embeds both the real and the generated samples into the feature space of a specific layer of the pre-trained Inception Net. It further assumes this feature space to follow a multivariate Gaussian distribution and calculates the mean and covariance for both sets of embeddings. The sample quality is then defined as the Frechet distance between the two Gaussian distributions, which is
FID(xp, xq) = ‖µxp − µxq‖22 + Tr(Σxp + Σxq − 2(ΣxpΣxq ) 1 2 ),
where (µxp ,Σxp), and (µxq ,Σxq ) are the mean and covariance of the sample embeddings from the data distribution and model distribution. We report FID on a held-out set that was not used to train the models. We run all the models three times from random initializations and report the mean and standard deviation of FID over the initializations.
Architecture: We test all the methods on the same architectures for the generator and the critic, namely a four-layer DCGAN architecture (Radford et al., 2015), because this has been consistently shown to perform well for the datasets that we use. Additionally, to study the effect of changing architecture, we also evaluate a slightly weaker critic, with the same number of layers but half the number of hidden units. Details of the architectures are provided in Appendix D.
Hyperparameters: To facilitate fair comparison with MMD-GAN we set all the hyperparameters shared across the three methods to the values used in Li et al. (2017). Therefore, we use a learning rate of 5e−5 and set the batch size to 64. For the MMD-GAN and GRAM-nets, we used the same set of RBF kernels that were used in Li et al. (2017). We used the implementation of MMD-GANs from Li et al. (2017).5 We leave all the hyper-parameters that are only used by MMD-GAN to the settings in the authors’ original code. For GRAM-nets, we choose K = h, i.e. the projected dimension equals the input noise dimension. We present an evaluation of hyperparameter sensitivity in Section 4.2.
Table 2: FID with fully convolutional architecture originally used by Li et al. (2017).
Dataset MMD-GAN Cifar10 38.39± 0.28 CelebA 40.27± 1.32

heading: 4.1 IMAGE QUALITY
text: We now look at how our method competes against GANs and MMD-GANs on sample quality and mode dropping on Cifar10 and CelebA datasets. Results are shown in Table 1. Clearly, GRAM-nets outperform both baselines. For CelebA, we do not run experiments using the weaker critic, because this is a much larger and higher-dimensional dataset, so a low-capacity critic is unlikely to work well.
It is worth noting that while the difference between the FIDs of GAN and GRAM-net is relatively smaller, it is quite significant that GRAM-net outperforms GAN on both datasets. As shown in a large scale study of adversarial generative models (Lucic et al., 2017), GANs in general perform very well on FID when compared to the state-of-the-art methods such as WGAN (Arjovsky et al., 2017). Interestingly, in the case CIFAR10, GANs are the state-of-art on FID performance.
To provide evidence that GRAM-nets are not simply memorizing the training set, we note that we measure FID on a held-out set, so a network that memorized the training set would be likely to have poor performance. For additional qualitative evidence of this, see Figure 4. This figure shows the five nearest neighbors from the training set for 20 randomly generated samples from the trained generator of our GRAM-net. None of the generated images have an exact copy in the training set, and qualitatively the 20 images appear to be fairly diverse.
Note that our architecture is different from that used in the results of Li et al. (2017). That work uses a fully convolutional architecture for both the critic and the generator, which results in an
4We use a standard implementation available from https://github.com/bioinf-jku/TTUR 5Available at https://github.com/OctoberChang/MMD-GAN.
order of magnitude more weights. This makes a large comparison more expensive, and also risks overfitting on a small dataset like Cifar10. However, for completeness, and to verify the fairness of our comparison, we also report the FID that we were able to obtain with MMD-GAN on this fully-convolutional architecture in Table 2. Compared to our experiments using MMD-GAN to train the DCGAN architecture, the performance of MMD-GAN with the fully convolutional architecture remains unchanged for the larger CelebA dataset. On Cifar10, not surprisingly, the larger fully convolutional architecture performs slightly better than the DCGAN architecture trained using MMDGAN. The difference in FID between the two different architectures is relatively small, justifying our decision to compare the generative training methods on the DCGAN architecture.

heading: 4.2 SENSITIVITY TO HYPERPARAMETERS AND EFFECT OF THE CRITIC DIMENSIONALITY
text: GAN training can be sensitive to the learning rate and the batch size used for training (Lucic et al., 2017). We examine the effect of learning rates and batch sizes on the performance of all three methods. Figure 5a compares the performance as a function of the learning rates. We see that GRAM-nets are much less sensitive to the learning rate than MMD-GAN, and are about as robust to changes in the learning rate as a vanilla GAN. MMD-GAN seems to be especially sensitive to this hyperparameter. We suggest that this might be the case since the critic in MMD-GAN is restricted to the set of k-Lipschitz continuous functions using gradient clipping, and hence needs lower learning rates. Similarly, Figure 5b shows the effect of the batch size on three models. We notice that all models are slightly sensitive to the batch size, and lower batch size is in general better for all methods.
We examine how changing the dimensionality K of the critic affects the performance of our method. We use the Cifar10 data. Results are shown in Figure 5c. Interestingly, we find that there are two regimes: the output dimensionality steadily improves the FID until K = 1000, but larger values sharply degrade performance. This agrees with the intuition in Section 3.1 that dimensionality reduction is especially useful for an “intrinsically low dimensional” distribution. For more inspections of the stability of MMD-GANs, see Appendix C.

heading: 5 SUMMARY
text: We propose a new algorithm for training MMD-nets. While MMD-nets in their original formulation fail to generate high dimensional images in good quality, their performance can be greatly improved by training them under a low dimensional mapping. Unlike the alternative adversarial (MMD-GAN) for learning such a mapping, our training method, GRAM, learns this mapping while avoiding the saddle-point optimization by being trained to match density ratios of the input and the projected pair of distributions. This leads to a sizable improvement in stability and generative quality, that is at par with or better than adversarial generative methods.

heading: A DERIVATION DETAILS
text: The derivation from (4) - (6) relies on the law of unconscious statistician (LOTUS), and therefore no Jacobian correction is needed. Here we show how we applied LOTUS in the derivation, with more detailed steps.
Let r̄(x) = p̄(x)q̄(x) . Expanding (4) we have,
D∗(θ) = ∫ qx(x) ( px(x)
qx(x)
)2 dx− 2 ∫ qx(x) px(x)
qx(x)
p̄(fθ(x)) q̄(fθ(x)) dx+
∫ qx(x) ( p̄(fθ(x))
q̄(fθ(x))
)2 dx
= ∫ px(x) px(x)
qx(x) dx− 2
∫ px(x) p̄(fθ(x))
q̄(fθ(x)) dx+
∫ qx(x) ( p̄(fθ(x))
q̄(fθ(x))
)2 dx
= ∫ px(x) px(x)
qx(x) dx− 2
∫ px(x)r̄(fθ(x))dx+ ∫ qx(x)r̄ 2(fθ(x))dx
We obtain the second line by canceling and rearranging terms and the third line, by plugging in r̄(x). Applying Theorem 3.6.1 from Bogachev (2007) (pg. 190) on the third term, ∫ qx(x)r̄
2(fθ(x)), with g = r̄2 and f = fθ, we get∫
qx(x)r̄ 2(fθ(x))dx = ∫ q̄(fθ(x))r̄ 2(fθ(x))dfθ(x).
Similarly, for the second term, with g = r̄ and f = fθ, we obtain
2 ∫ px(x)r̄(fθ(x))dx = 2 ∫ p̄(fθ(x))r̄(fθ(x))dfθ(x).
Thus,
D∗(θ) = ∫ px(x) px(x)
qx(x) dx− 2
∫ p̄(fθ(x))r̄(fθ(x))dfθ(x) + ∫ q̄(fθ(x))r̄ 2(fθ(x))dfθ(x),
which is the first line of (5).
Note that we use LOTUS "in reverse" of its usual application.

heading: B EXPERIMENTAL DETAILS AND MORE RESULTS FOR SECTION 3.4
text: B.1 EXPERIMENTAL DETAILS
Below list the hyper-parameters used in Section 3.4, except from those being varied in the experiments.
• Number of epochs: 2,000 • Noise distribution: Gaussian • Activation between hidden layers: ReLU • Batch normalisation: not used • Batch size: 200 • Batch size for generated samples: 200 • GAN
– Optimizer: ADAM – Learning rate: 1e-4
– Momentum decay: 0.5 – Critic architecture: 2-100-100-10
• MMD-net – Optimizer: RMSprop – Learning rate: 1e-3 – RBF kernel bandwidth: 1
• GRAM-net – Optimizer: ADAM – Learning rate: 1e-3 – Momentum decay: 0.5 – RBF kernel bandwidth: 1 – Critic architecture: 2-100-100-10
Note that we also provide the experimental details for MMD-nets where we will show the results in Appendix B.3.
All parameter settings are also available in the examples/Hyper.toml file of our submitted code. All parameters being varied are also available in the examples/parallel_exps.jl file of our submitted code.
B.2 3D RING DATASET
We also conduct the same experiment as in Figure 1a with a 3-dimensional data space and a 2- dimensional projection space. We create a 3D ring dataset by augmenting the third dimension with Gaussian noise (0 mean and 0.1 standard deviation), which is then rotated by 60 degrees along the second axis. We repeat the experiments in Figure 1a using this dataset. The results are shown in Figure 6. Unlike the 2D ring example, the optimal choice of the projection function learned here is no
longer the identity function. However, our method can stil, easily learn a low-dimensional manifold that tends to preserve the density ratio.
B.3 STABILITY OF MMD-NETS AND MMD-GANS
In this section we repeat the same stability-related experiments that we conducted on GANs and GRAM-nets in Section 3.4, for MMD-nets and MMD-GANs. Results are shown in Figures 7a and 7b. One can see MMD-nets can capture all the modes, but the learned distribution is less separated (or sharp) compared to GRAM-nets. This is because the MMD is computed with a fixed kernel and in a fixed space, which can only distinguish distributions, subject to the set of kernels being used. Figure 7b shows the results on MMD-GAN modles that are trained for 4,000 epochs, each with 5
steps for the critic network and 1 step for the generative network.6 Compared to Figure 2b, in which GRAM-nets only takes 2,000 training epochs with 1 joint step for both networks, even with longer training, the quality of MMD-GAN is visually worse than GRAM-nets in this synthetic example. Notice, how the generated samples of MMD-GAN are similar to the successful runs for GAN in Figure 2a: generated samples tend to be too concentrated around the mode of the individual clusters. Our method on the other hand, with shorter training time, is clearly able to recover all the 8 clusters along with their spreads.
Note that, unlike GRAM-nets which are robust to changing dimensionality of the projected spaces (2, 4, 8, 16), MMD-GAN training easily diverges for 2-dimensional projected spaces. As a result, for MMD-GAN we only show the results up to the iterations before the training diverges. It’s likely that any change in the neural network size (output dimension) requires a different set of hyperparameters to make MMD-GAN converge. On the other hand, GRAM-nets are robust to these changes, out of the box.
B.4 GRAM-NETS ON THE MNIST DATASET
In this section, we show the results of training GRAM-nets on the MNIST dataset. Figure 8a shows how the generated samples change during the phase of training. Figure 8b shows how the generator loss and the ratio matching objective are being optimized simultaneously. The generator used in this experiment is a multilayer perceptron (MLP) of size 100-600-600-800-784 with ReLU activations between hidden layers and sigmoid activation for the output layer; the noise distribution is a multivariate uniform distribution between [−1, 1] with 100 dimensions. For the critic, we use a convolution architecture specified in Table 3. For the optimisation, we use ADAM with a learning rate of 1e-3, momentum decay of 0.5, and batch size of 200 for both data and generated samples. For the RBF kernels, we use bandwidths of [0.1, 1, 10, 100]

heading: C STABILITY OF MMD-GANS
text: In addition to Figure 7b, which evaluates the stability of MMD-GANs in terms of the projected dimension and the generator capacity, we perform qualitative evaluation by visualizing the projected space during training as well as the effect of stabilization techniques in this section.
C.1 PROJECTED SPACE DURING TRAINING
We first perform the qualitative evaluation (same as Figure 1a and Figure 6) for MMD-GANs on the 2D and 3D ring datasets. The original space and the projected space during training are visualized
6When training MMD-GAN, both the auto-encoding loss and the feasible set reduction loss are used. Parameter clipping is done with -0.1 (lower) and 0.1 (upper). Learning rate is set to 5e-5 and other parameters are the same as GRAM-nets.
(a) Data and samples (top and bottom half in each plot) during training at iteration 100, 250, 500 (first row), at 750, 1,000, 2,000 (second row), and 3,000, 4,000 and 5,000 (last row). The orders for each row are from left to right.
in Figure 9 It is clear that the projected spaces are quite different between MMD-GAN and our method. Unlike GRAM-nets, in the projected space, the generated samples do not overlap with the data samples.
C.2 STABILIZATION TECHNIQUES
We also evaluate the effect of the various stabilization techniques used for training, namely the autoencoder penalty (AE) and the feasible set reduction (FSR) techniques from (Li et al., 2017) on the Cifar10 data over two settings of the batch size. Table 4 shows the results. The performance of
MMD-GAN training clearly relies heavily on FSR. This penalty not only stabilizes the critic but it can also provides additional learning signal to the generator. Because these penalties are important to the performance of MMD-GANs, it requires tuning several weighting parameters, which need to be set carefully for successful training.
We would like to re-emphasize the stability of GRAM-nets with respect to different settings of network sizes, noise dimension, projected dimension, learning rate, batch size without relying on regularization terms with additional hyperparameters.

heading: D ARCHITECTURE
text: For the generator used in Section 4, we used the following DCGAN architecture,
We used two different architectures for the experiments on Cifar10 dataset. Table 6 shows the standard DCGAN discriminator that was used. Table 7 shows the architecture of the weaker DCGAN
discriminator architecture that was also used for Cifar10 experiments. While leaky-ReLU was used
as non-linearity in the discriminator, ReLU was used in the generator, except for the last layer, where it was tanh. Batchnorm was used in both the generator and the discriminator.

heading: E SAMPLES
text: We show some of the randomly generated samples from our method on CIFAR10 and CelebA in Figure 10.
F INCEPTION SCORE
Inception score (IS) is another evaluation metric for quantifying the sample quality in GANs. Compared FID, IS is not very robust to noise and cannot account for mode dropping. In addition to the FID scores that we provide in the paper, here we also report IS for all the methods on CIFAR10 for completeness since the MMD-GAN paper used it as their evaluation criteria.

Review summaries:
This paper proposes GRAM-nets using MMD as the critic to train GANs. Similar to MMD-GAN, the MMD is computed on a projected lower dimensional space to prevent the kernel struggle in the high dimensional observed space. On the other hand, contrary to MMD-GAN, GRAM-nets trains the projection f_{\theta} trying to matching the density ratio of p/q between the observed and the latent space. The proposed density ratio matching criterion avoids the adversarial training in MMD-GAN, thus can potentially fix the two-player optimization problem. The paper shows improved FID scores and nice-looking CIFAR10 generations.