Title: GENERATIVE RATIO MATCHING NETWORKS

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. INTRODUCTION:

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; Biń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 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.

1.1 RELATED WORK 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 q x and p x 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 θ : R D → R K to map the samples to a lower dimensional space R K , 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 k 0 is a kernel in R K , then k(x, x ) = k 0 (f θ (x), f θ (x )) is a kernel in R D . 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, Biń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.

2. BACKGROUND:

Given data x i ∈ R D for i ∈ {1 . . . N } from a distribution of interest with density p x , the goal of deep generative modeling is to learn a parameterized function G γ : R h → R D , called a generator network, that maps samples z ∈ R h where h < D from a noise distribution p z to samples from the model distribution. Since G γ defines a new random variable, we denote its density function by q x , and also write x q = G γ (z), where we suppress the dependency of x q on γ. The parameters γ of the generator are chosen to minimize a loss criterion which encourages q x to match p x .

2.1. MAXIMUM MEAN DISCREPANCY:

Maximum mean discrepancy measures the discrepancy between two distributions as the maximum difference between the expectations of a class of functions F, that is,

EQUATION

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 space R with a characteristic kernel k. Given samples x 1 . . . x N ∼ p and y i . . . y M ∼ q, we can estimate MMD R as

MMD 2 R (p, q) = 1 N 2 N i=1 N i =1 k(x i , x i ) - 2 N M N i=1 M j=1 k(x i , y j ) + 1 M 2 M j=1 M j =1

k(y j , y j ).

(2)

2.2 DENSITY RATIO ESTIMATION 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

EQUATION

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 R D can be more accurately done in lower dimensional sub-spaces R K . 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.

3. METHOD:

Our aim will be to enjoy the advantages of MMD-nets, but to improve their sample quality by mapping the data (R D ) into a lower-dimensional space (R K ), 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 ∼ p z . 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 p x /q x 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 R D , 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 θ (x i )} with transformed outputs from the generator {f (G γ (z i )} 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).

3.1. TRAINING THE CRITIC USING SQUARED RATIO DIFFERENCE:

Our principle is to choose f θ so that the resulting densities p and q preserve the density ratio between p x and q x . We will choose f θ to minimize the distance between the two density ratio functions

r x (x) = p x (x)/q x (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

EQUATION

)

This objective is minimized only when the ratios match exactly, that is, when r x = r θ for all x in the support of q x . 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 p x and q x are "intrinsically low dimensional" in the following sense. Suppose K < D, and consider two distributions p 0 and q 0 over R K , and an injective map T : R K → R D . Suppose that T maps samples from p 0 and q 0 to samples from p x and q x , by which we mean p x (x) = J(DT )p 0 (T -1 (x)), and similarly for q x . 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

EQUATION

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 x q 1 . . . x q M ∼ q x , to maximize the critic loss function

EQUATION

)

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 x q 1 . . . x q M . In other words, we need to approximate the vector r q,θ = [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 r q,θ can then be computed as rq,θ = K -1 q,q K q,p 1 1 1.

Here K q,q and K q,p denote the Gram matrices defined by

[K q,q ] i,j = k(f θ (x q i ), f θ (x q j )) and [K q,p ] i,j = k(f θ (x q i ), f θ (x p j )).

Substituting these estimates into (7) and adding a positivity constraint rT q,θ .1 1 1 for using the MMD density ratio estimator (Sugiyama et al., 2012) , we get

EQUATION

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 q x , and approximating the density ratio.

Thus maximising this objective leads to the preservation of density ratio (Sugiyama et al., 2011) .

3.2. GENERATOR LOSS:

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 z 1 . . . z M ∼ p z from the input distribution of the generator. Then using the empirical estimate (2) of the MMD, we define the generator loss function as

EQUATION

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 {x p i } N i=1 ∼ p x and generated samples {x q i } M i=1 ∼ q x ; Using f θ to transform data as {f θ (x p i )} N i=1 and generated samples as {f θ (x q i )} M i=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 M y = MMD(p, q) = 0.

Then for all x, we have r x (x) = r θ * (x) because D * (θ * ) = 0, and that r θ * (x) = 1, because M y = 0. This means that r x (x) = 1, so we have that p x = q x .

3.4. STABILITY OF GRAM-NETS:

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 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 (R D ) and the bottom row visualizes the projected space (R K ). 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. 

z ∼ p z x q x p ∼ p x L γ L θ γ θ θ θ (a) GAN z ∼ p z x p ∼ p x x q K L γ γ (b) MMD-net z ∼ p z x p ∼ p x x q f θ (x p ) f θ (x q ) K L γ L θ γ θ θ (c) MMD-GAN z ∼ p z x p ∼ p x x q f θ (x p ) f θ (x q ) K L γ L θ γ θ θ (d) GRAM-net

Figure 3 : Computation graphs of GAN, MMD-net, MMD-GAN and GRAM-net. K is the kernel Gram matrix. Solid arrows represents the flow of the computation and dashed lines represents min-max relationship between the losses, i.e. saddle-point optimization in which minimizing one loss maximizes the other. Therefore in the zero-sum game case (GAN, MMD-GAN) the two objectives (L γ and L θ ) cannot be optimized simultaneously (Mescheder et al., 2017) .

3.4.1. COMPUTATION GRAPHS:

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.

4. EXPERIMENTS:

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(x p , x q ) = µ xp -µ xq 2 2 + 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. 

4.1. IMAGE QUALITY:

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 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 MMD-GAN. 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.

4.2. SENSITIVITY TO HYPERPARAMETERS AND EFFECT OF THE CRITIC DIMENSIONALITY:

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. 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]

C STABILITY OF MMD-GANS

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 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. Table 8 : Inception Scores for MMD-GAN, GAN, GRAM-net and MMD-nets on CIFAR10 for three random initializations.

MMD-GAN GAN GRAM-net:

Inception Score 5.35 ± 0.12 5.21 ± 0.14 5.31 ± 0.10 5.17 ± 0.13 4.94 ± 0.15 5.27 ± 0.05 5.73 ± 0.10 5.44 ± 0.12 5.45 ± 0.18

:

Interestingly, the training of GRAM-nets heavily relies on the use of kernel Gram matrices.

As 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.

We use a standard implementation available from https://github.com/bioinf-jku/TTUR

Available at https://github.com/OctoberChang/MMD-GAN.

When 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.

Figures and Tables:

(a) Data and samples in the original (top) and projected space (bottom) during training; four plots are at iteration 10, 100, 1000 and 10, 000 respectively. Notice how the projected space separates p and q. Trace of Lγ and D * (equation (5)) during training. The left plot is for iteration 1 to 100 and the right plot is for 100 to 5,000, with the same y-axes in the log scale.

Figure 1: Training results with projected dimension fixed to 2.

Figure 2: Training after 2,000 epochs by varying noise dimension h and the hidden layer size of critic model. For each model, each row is a different layer size in [20, 100, 200] and each column is a different h in [2, 4, 8, 16]. Half of the GAN training diverges while all GRAM training converges.

Figure 4: Nearest training images to samples from a GRAM-net trained on Cifar10. In each column, the top image is a sample from the generator, and the images below it are the nearest neighbors.

Figure 5: Hyper-parameter sensitivity of MMD-GAN, GAN and GRAM-net on Cifar10 dataset. Sample quality measured by FID.

Figure 7: Corresponding plots to Figure 2 for MMD-nets and MMD-GANs.

(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. of Lγ and D * (equation (5)) during training. The left plot is for iteration 1 to 100 and the right plot is for 100 to 5,000, with the same y-axes in the log scale.

Figure 8: Training results of GRAM-nets on the MNIST dataset.

Figure 10: Random Samples from a randomly selected epoch (>100).

Sample quality (measured by FID; lower is better) of GRAM-nets compared to GANs.

Table content: <table><tr><td>Arch.</td><td>Dataset</td><td>MMD-GAN</td><td>GAN</td><td>GRAM-net</td></tr><tr><td colspan="2">DCGAN Cifar10</td><td colspan="3">40.00 ± 0.56 26.82 ± 0.49 24.85 ± 0.94</td></tr><tr><td>Weaker</td><td colspan="4">Cifar10 210.85 ± 8.92 31.64 ± 2.10 24.82 ± 0.62</td></tr><tr><td colspan="5">DCGAN CelebA 41.105 ± 1.42 30.97 ± 5.32 27.04 ± 4.24</td></tr></table>

FID with fully convolutional architecture originally used byLi et al. (2017).

Table content: <table><tr><td>Dataset MMD-GAN</td></tr><tr><td>Cifar10 38.39 ± 0.28</td></tr><tr><td>CelebA 40.27 ± 1.32</td></tr></table>

Peer review (iclr2020):
The proposed approach amounts to a non-adversarial way to update the parameters theta of a kernel K_theta(x, y) = k(f_theta(x), f_theta(y)) in an MMD-net, rather than adversarially as in MMD-GANs. Avoiding the saddle point problem clearly gives a more stable optimization problem, as shown in Section 3.4, which is very nice. Theory/motivation: The motivation based on density ratio estimation, however, very much assumes that these densities exist. As convincingly argued by Arjovsky and Bottou (ICLR 17, *Towards principled methods for training generative adversarial networks*), the densities p_x, q_x of (4) typically do not exist (w.r.t. Lebesgue measure), and moreover the support of the distributions are typically almost disjoint. Algorithmically, this doesn*t seem to be a major issue for your approach: the estimator (8) corresponds to some kind of smoothing by the kernel. But it would be nice from a motivation point of view to have a better understanding of: - What assumptions exactly does (8) make about the existence of densities? For example, in the case of a Gaussian kernel, does it correspond to the distance between distributions convolved with Gaussian noises with a smaller Gaussian kernel? Does the algorithm *make sense* when distributions don*t exist? - Can we say something about when a density exists for the dimensionality-reduced data f_theta(x) even when it doesn*t exist for the data x? - Relatedly, the dimension-reduced Pearson divergence is clearly somehow different from the plain Pearson divergence. Can we understand a little bit more how it*s different? How does the choice of architecture of f_theta affect the distance metric? - Is it the case, as in Arjovsky et al. (2017) or in Arbel et al. (NeurIPS 2018, *On gradient regularizers for MMD GANs*), that the overall loss function with an optimal f_theta is continuous with respect to the GAN distribution? Certainly not all of these theoretical questions require answers for an initial ICLR paper, but they would be illuminating for understanding the method. Motivating experiments: - In Figure 2, it seems that except in the first image (h=2) the mapping f_theta becomes essentially the identity. Is this expected to be generally true in your 2d cases, because the density ratio can already be well-represented there? A more interesting example for this aspect of the model might involve higher-dimensional distributions with some low-dimensional manifold structure; would f_theta pick up some reasonable representation of the manifold in those cases? - Can you plot the density ratio estimate in a simple 2d example like this? How does it look visually? Is a good estimate necessary for good performance of your generative model? Experiments: - As shown by Binkowski et al., it*s extremely important to specify the sample size for FID scores, which you don*t do. - That said, the FID scores of the MMD GAN models of Binkowski et al using DCGAN discriminators (which replace the FSR and AE penalties of Li et al. with a single gradient penalty) found substantially smaller penalties for performance of MMD-GANs with using a smaller discriminator (1/4 as many hidden units rather than 1/2 as you use) than you did. They also reported substantially better numbers on CelebA than you did. If not too difficult code-wise, it might be worth trying either their code or that of the followup Arbel et al. (citation above) to compare to your approach. - The results of, for example, Mescheder et al. (ICML-18, *Which Training Methods for GANs do actually Converge?*) and Arbel et al. (NeurIPS-18, *On gradient regularizers for MMD GANs*) seem to be much better visually with comparably-sized models than the results of Figure 8 (and of course StyleGAN/etc are *far* better but with drastically larger models). It would be good to compare empirically to some more recent models than original MMD GANs (whose empirical results were substantially improved with only minor tweaks by Binkowski et al. mere months later) or DCGAN, which are fairly old approaches in this space. - Two more extremely relevant methods it would be worth comparing to or at least mentioning: - Ravuri et al. (ICML 2018, *Learning Implicit Generative Models with the Method of Learned Moments*) can be interpreted as learning f_theta for an MMD-net as you do by taking the gradients of an auxiliary classification network. Although it is still somewhat *adversarial,* they need to update the kernel function extremely rarely (every 2,000 generator update steps) and the optimization seems overall much more stable. - dos Santos et al. (https://arxiv.org/abs/1904.02762 *Learning Implicit Generative Models by Matching Perceptual Features*) effectively use an MMD-net (with some slight tweaks) with a *fixed* kernel. Though results aren*t quite as good, it*s worth at least mentioning. Minor typos/etc: - Top of page 3: it is sufficient to choose F a unit ball in an RKHS with a _characteristic_ kernel. - Page 4: *this issue in next.* - Figure 1 caption: (both) should probably be (bottom). Overall initial thoughts: This seems like a nice alternative to adversarial methods, but it does not compare to more recent (last 2 years) models in this space or very thoroughly establish the applicability of its motivation. I think it*s worthy of a weak accept as is, but could be much more convinced with some additional work.