summaries: The paper describes an interesting tweak of the standard GAN model (inspired by IPM based GANs) where both the generator and the discriminator optimize relative realness (and fakeness) of the (real, fake) image pairs. The authors give some intuition for this tweak and ran experiments with CIFAR10 and CAT datasets. Different variants of the standard GAN and the new tweak were compared under the FID metric. The experimental setup and details are provided; and the code is made publicly available.  In this work, the authors considers a variation of GAN by consider simultaneously decrease the probability that real data is real for the generator. To include such a property, the authors propose a relativistic discriminator which estimate the probability that the given real data is more realistic than the fake data. Numerical results are performed to show that the proposed methods are effective, and the resulting GANs are relatively more stable and generate higher quality data samples than their non-relativistic counterparts.
abstractText: In standard generative adversarial network (SGAN), the discriminator D estimates the probability that the input data is real. The generator G is trained to increase the probability that fake data is real. We argue that it should also simultaneously decrease the probability that real data is real because 1) this would account for a priori knowledge that half of the data in the mini-batch is fake, 2) this would be observed with divergence minimization, and 3) SGAN would be more similar to integral probability metric (IPM) GANs. We show that this property can be induced by using a “relativistic discriminator” which estimate the probability that the given real data is more realistic than a randomly sampled fake data. We also present a variant in which the discriminator estimate the probability that the given real data is more realistic than fake data, on average. We generalize both approaches to non-standard GAN loss functions and we refer to them respectively as Relativistic GANs (RGANs) and Relativistic average GANs (RaGANs). We show that IPM-based GANs are a subset of RGANs which use the identity function. Empirically, we observe that 1) RGANs and RaGANs are significantly more stable and generate higher quality data samples than their non-relativistic counterparts, 2) Standard RaGAN with gradient penalty generate data of better quality than WGAN-GP while only requiring a single discriminator update per generator update (reducing the time taken for reaching the state-of-the-art by 400%), and 3) RaGANs are able to generate plausible high resolutions images (256x256) from a very small sample (N=2011), while GAN and LSGAN cannot; these images are of significantly better quality than the ones generated by WGAN-GP and SGAN with spectral normalization. The code is freely available on https://github.com/AlexiaJM/RelativisticGAN.
authors.name: Alexia Jolicoeur-Martineau
references.authors: Martin Arjovsky Léon Bottou
references.title: Towards principled methods for training generative adversarial networks
references.venue: arXiv preprint arXiv:1701.04862,
references.authors: Martin Arjovsky Soumith Chintala Léon Bottou
references.title: Wasserstein generative adversarial networks
references.venue: In International Conference on Machine Learning,
references.authors: Ali Borji
references.title: Pros and cons of gan evaluation measures
references.venue: arXiv preprint arXiv:1802.03446,
references.authors: William Fedus Mihaela Rosca Balaji Lakshminarayanan Andrew M Dai Shakir Mohamed Ian Goodfellow
references.title: Many paths to equilibrium: Gans do not need to decrease adivergence at every step
references.venue: arXiv preprint arXiv:1710.08446,
references.authors: Ian Goodfellow Jean Pouget-Abadie Mehdi Mirza Bing Xu David Warde-Farley Sherjil Ozair Aaron Courville Yoshua Bengio
references.title: Generative adversarial nets
references.venue: Advances in Neural Information Processing Systems
references.authors: Ishaan Gulrajani Faruk Ahmed Martin Arjovsky Vincent Dumoulin Aaron C Courville
references.title: Improved training of wasserstein gans
references.venue: Advances in Neural Information Processing Systems
references.authors: Martin Heusel Hubert Ramsauer Thomas Unterthiner Bernhard Nessler Günter Klambauer Sepp Hochreiter
references.title: Gans trained by a two time-scale update rule converge to a nash equilibrium
references.venue: arXiv preprint arXiv:1706.08500,
references.authors: Yongjun Hong Uiwon Hwang Jaeyoon Yoo Sungroh Yoon
references.title: How generative adversarial nets and its variants work: An overview of gan
references.venue: arXiv preprint arXiv:1711.05914,
references.authors: Sergey Ioffe Christian Szegedy
references.title: Batch normalization: Accelerating deep network training by reducing internal covariate shift
references.venue: arXiv preprint arXiv:1502.03167,
references.authors: Diederik P Kingma Jimmy Ba
references.title: Adam: A method for stochastic optimization
references.venue: arXiv preprint arXiv:1412.6980,
references.authors: Alex Krizhevsky
references.title: Learning multiple layers of features from tiny images
references.authors: Zinan Lin Ashish Khetan Giulia Fanti Sewoong Oh
references.title: Pacgan: The power of two samples in generative adversarial networks
references.venue: arXiv preprint arXiv:1712.04086,
references.authors: Mario Lucic Karol Kurach Marcin Michalski Sylvain Gelly Olivier Bousquet
references.title: Are gans created equal? a large-scale study
references.venue: arXiv preprint arXiv:1711.10337,
references.authors: Xudong Mao Qing Li Haoran Xie Raymond YK Lau Zhen Wang Stephen Paul Smolley
references.title: Least squares generative adversarial networks
references.venue: IEEE International Conference on Computer Vision (ICCV),
references.authors: Takeru Miyato Toshiki Kataoka Masanori Koyama Yuichi Yoshida
references.title: Spectral normalization for generative adversarial networks
references.venue: arXiv preprint arXiv:1802.05957,
references.authors: Alfred Müller
references.title: Integral probability metrics and their generating classes of functions
references.venue: Advances in Applied Probability,
references.authors: Sebastian Nowozin Botond Cseke Ryota Tomioka
references.title: f-gan: Training generative neural samplers using variational divergence minimization
references.venue: Advances in Neural Information Processing Systems
references.authors: Adam Paszke Sam Gross Soumith Chintala Gregory Chanan Edward Yang Zachary DeVito Zeming Lin Alban Desmaison Luca Antiga Adam Lerer
references.title: Automatic differentiation in pytorch
references.authors: Alec Radford Luke Metz Soumith Chintala
references.title: Unsupervised representation learning with deep convolutional generative adversarial networks
references.venue: arXiv preprint arXiv:1511.06434,
references.authors: Tim Salimans Ian Goodfellow Wojciech Zaremba Vicki Cheung Alec Radford Xi Chen
references.title: Improved techniques for training gans
references.venue: Advances in Neural Information Processing Systems
references.authors: Weiwei Zhang Jian Sun Xiaoou Tang
references.title: Cat head detection-how to effectively exploit shape and texture features
references.venue: In European Conference on Computer Vision,
sections.heading: 1 INTRODUCTION
sections.text: Generative adversarial networks (GANs) (Hong et al., 2017) form a broad class of generative models in which a game is played between two competing neural networks, the discriminator D and the generator G. D is trained to discriminate real from fake data, while G is trained to generate fake data that D will mistakenly recognize as real. In the original GAN by Goodfellow et al. (2014), which we refer to as Standard GAN (SGAN), D is a classifier, thus it is predicting the probability that the input data is real. When D is optimal, the loss function of SGAN is approximately equal to the Jensen–Shannon divergence (JSD) (Goodfellow et al., 2014).
  SGAN has two variants for the generator loss functions: saturating and non-saturating. In practice, the former has been found to be very unstable, while the latter has been found to more stable (Goodfellow et al., 2014). Under certain conditions, Arjovsky & Bottou (2017) proved that, if real and fake data are perfectly classified, the saturating loss has zero gradient and the non-saturating loss has non-zero, but volatile gradient. In practice, this means that the discriminator in SGAN often cannot be trained to optimality or with a too high learning rate; otherwise, gradients may vanish and, if so, training will stop. This problem is generally more noticeable in high-dimensional setting (e.g., high resolution
  images and discriminator architectures with high expressive power) given that there are enough degrees of freedom available to perfectly classify the training set.
  To improve on SGAN, many GAN variants have been suggested using different loss functions and discriminators that are not classifiers (e.g., LSGAN (Mao et al., 2017), WGAN (Arjovsky et al., 2017)). Although these approaches have partially succeeded in improving stability and data quality, the large-scale study by Lucic et al. (2017) suggests that these approaches do not consistently improve on SGAN. Additionally, some of the most successful approaches, such as WGAN-GP (Gulrajani et al., 2017), are much more computationally demanding than SGAN.
  Many of the recent successful GANs variants have been based on Integral probability metrics (IPMs) (Müller, 1997) (e.g., WGAN , WGAN-GP, Fisher GAN (Mroueh & Sercu, 2017), Sobolev GAN (Mroueh et al., 2017)). In IPM-based GANs, the discriminator is real-valued and constrained to a specific class of function which regularize the discriminator. See Mroueh et al. (2017) for a review of the different IPMs.
  These IPM constraints have been shown to be beneficial even in non-IPM based GANs. Spectral normalization (Miyato et al., 2018) improves the stability of various GANs and it consists in making the discriminator Lipschitz-1, which is the constraint of WGAN. Similarly, the gradient penalty of WGAN-GP also provides improve the stability of SGAN (Fedus et al., 2017). Although this shows that certain IPM constraints improve the stability of GANs, it does not explain why IPM-based GANs generally provide increased stability over other metrics/divergences in GANs (e.g., JSD for SGAN, f -divergences for f -GANs (Nowozin et al., 2016)).
  Note that although powerful, IPM-based GANs tend to more computationally demanding than other GANs. Certain IPM-based GANs use a gradient penalty (e.g. WGAN-GP, Sobolev GAN) which is very computationally costly and most IPM-based GANs need more than one discriminator update per generator update (WGAN-GP requires at least 5 (Gulrajani et al., 2017)). Assuming equal training time for D and G, every additional discriminator update increase training time by a significant 50%.
  In this paper, we argue that non-IPM-based GANs are missing a key ingredient, a relativistic discriminator, which IPM-based GANs already possess. We show that a relativistic discriminator is necessary to make GANs analogous to divergence minimization and produce sensible predictions based on the a priori knowledge that half of the samples in the mini-batch are fake. We provide empirical evidence showing that GANs with a relativistic discriminator are more stable and produce data of higher quality.
sections.heading: 2 BACKGROUND
sections.heading: 2.1 GENERATIVE ADVERSARIAL NETWORKS
sections.text: GANs can be defined very generally in terms of the discriminator in the following way: LD = Exr∼P [ f̃1(D(xr)) ] + Ez∼Pz [ f̃2(D(G(z))) ] , (1)
  and LG = Exr∼P [g̃1(D(xr))] + Ez∼Pz [g̃2(D(G(z)))] , (2)
  where f̃1, f̃2, g̃1, g̃2 are scalar-to-scalar functions, P is the distribution of real data, Pz is generally a multivariate normal distribution centered at 0 with variance 1, D(x) is the discriminator evaluated at x, G(z) is the generator evaluated at z (Q is the distribution of fake data, thus of G(z)). Note that, through the paper, we refer to real data as xr and fake data as xf . Without loss of generality, we assume that both LD and LG are loss functions to be minimized.
  Most GANs can be separated into two classes: non-saturating and saturating loss functions. GANs with the saturating loss are such that g̃1=−f̃1 and g̃2=−f̃2, while GANs with the non-saturating loss are such that g̃1=f̃2 and g̃2=f̃1. Saturating GANs are intuitive as they can be interpreted as alternating between maximizing and minimizing the same loss function. After training D to optimality, the loss function is generally an approximation of a divergence (e.g., Jensen–Shannon divergence (JSD) for SGAN (Goodfellow et al., 2014), f -divergences for F-GANs (Nowozin et al., 2016), and Wassertein distance for WGAN (Arjovsky et al., 2017)). Thus, training G to minimize LG can be roughly interpreted as minimizing the approximated divergence (although this is not technically true; see
  Jolicoeur-Martineau (2018)). On the other hand, non-saturating GANs can be thought as optimizing the same loss function, but swapping real data with fake data (and vice-versa). In this article, unless otherwise specified, we assume a non-saturating loss for all GANs.
  SGAN assumes a cross-entropy loss, i.e., f̃1(D(x)) = − log(D(x)) and f̃2(D(x)) = − log(1 − D(x)), whereD(x) = sigmoid(C(x)), and C(x) is the non-transformed discriminator output (which we call the critic as per Arjovsky et al. (2017)). In most GANs, C(x) can be interpreted as how realistic the input data is; a negative number means that the input data looks fake (e.g., in SGAN, D(x) = sigmoid(−5) = 0), while a positive number means that the input data looks real (e.g., in SGAN, D(x) = sigmoid(5) = 1).
sections.heading: 2.2 INTEGRAL PROBABILITY METRICS
sections.text: IPMs are statistical divergences represented mathematically as:
  IPMF (P||Q) = sup C∈F Ex∼P[C(x)]− Ex∼Q[C(x)],
  where F is a class of real-valued functions. IPM-based GANs can be defined using equation 1 and 2 where f̃1(D(x)) = g̃2(D(x)) = −D(x) and f̃2(D(x)) = g̃1(D(x)) = D(x), where D(x) = C(x) (i.e., no transformation is applied). It can be observed that both discriminator and generator loss functions are unbounded and would diverge to −∞ if optimized directly. However, IPMs assume that the discriminator is of a certain class of function that does not grow too quickly which prevent the loss functions from diverging. Each IPM applies a different constraint to the discriminator (e.g., WGAN assumes a Lipschitz D, WGAN-GP assumes that D has a gradient norm equal to 1 around real and fake data).
sections.heading: 3 MISSING PROPERTY OF SGAN
sections.text: We argue that the key missing property of SGAN is that the probability of real data being real (D(xr)) should decrease as the probability of fake data being real (D(xf )) increase. We provide three arguments suggesting that SGAN should have this property.
sections.heading: 3.1 PRIOR KNOWLEDGE ARGUMENT
sections.text: Assuming a rational human was shown half real data and half fake data. If they perceived all samples shown as equally real (C(xf ) ≈ C(xr) for most xr and xf ), they would assume that each sample has probability .50 of being real. However, this is not the case for the discriminator in SGAN. If all samples looked real (C(xf ) ≈ C(xr) ≥ 3), D would assume incorrectly that they are indeed all real (D(x) ≈ 1 for all x). Of course, once trained with the labels, D would decrease D(xf ) and thus would obtain more reasonable estimates. However, if D(xr) decreased as D(xf ) increased, we would have had that D(x) ≈ .50 for all x before even retraining D. A rational human would not require retraining. IPM-based GANs implicitly account for the fact that some of the samples must be fake because they compare how realistic real data is compared to fake data. This is the behavior that we would want.
sections.heading: 3.2 DIVERGENCE MINIMIZATION ARGUMENT
sections.text: In SGAN, when optimized, we have that the discriminator loss function is equal to the Jensen–Shannon divergence (JSD) (Goodfellow et al., 2014). The JSD is minimized (JSD(P||Q) = 0) when D(xr) = D(xf ) = 12 for all xr ∈ P and xf ∈ Q and maximized (JSD(P||Q) = log(2)) when D(xr) = 1, D(xf ) = 0 for all xr ∈ P and xf ∈ Q. Thus, if we were directly minimizing the divergence from maximum to minimum, we would expect D(xr) to smoothly decrease from 1 to .50 for most xr and D(xf ) to smoothly increase from 0 to .50 for most xf (Figure 1a). However, when minimizing the saturating loss in SGAN, we are only increasing D(xf ), we are not decreasing D(xr) (Figure 1b). Furthermore, we are bringing D(xf ) closer to 1 rather than .50.
  This means that SGAN dynamics are very different from the minimization of the JSD. To bring SGAN closer to divergence minimization, training the generator should not only increase D(xf ) but
  also decrease D(xr) (Figure 1c). Note that although specific to the JSD, similar dynamics are true for other divergences; when the divergence is maximal, D(xr) and D(xf ) are very far from one another, but they converge to the same value as the divergence approach zero. Thus, this argument applies to other divergences.
sections.heading: 3.3 GRADIENT ARGUMENT
sections.text: We compare the gradients of standard GAN and IPM-based GANs for further insight. It can be shown that the gradients of the discriminator and generator in non-saturating SGAN are respectively:
  ∇wLGAND = −Exr∼P [(1−D(xr))∇wC(xr)] + Exf∼Qθ [D(xf )∇wC(xf )] , (3)
  ∇θLGANG = −Ez∼Pz [(1−D(G(z)))∇xC(G(z))JθG(z)] , (4) where J is the Jacobian.
  It can be shown that the gradients of the discriminator and generator in IPM-based GANs are respectively:
  ∇wLIPMD = −Exr∼P[∇wC(xr)] + Exf∼Qθ [∇wC(xf )], (5)
  ∇θLIPMG = −Ez∼Pz [∇xC(G(z))JθG(z)], (6) where C(x) ∈ F (the class of functions assigned by the IPM). From these equations, it can be observed that SGAN leads to the same dynamics as IPM-based GANs when we have that:
  1. D(xr) = 0, D(xf ) = 1 in the discriminator step of SGAN 2. D(xf ) = 0 in the generator step of SGAN. 3. C(x) ∈ F
  Assuming that the discriminator and generator are trained to optimality in each step (which we sometimes do for D, but never for G) and that it is possible to perfectly distinguish real from the fake data (strong assumption, but generally true early in training); we would have that D(xr) = 1, D(xf ) = 0 in the generator step and that D(xr) = 1, D(xf ) = 1 in the discriminator step for most xr and xf (Figure 1b). Thus, the only missing assumption would be that D(xr) = 0 in the discriminator step.
  Although the above scenario is not realistic (because we never train G to optimality), if all the assumptions were respected and the generator could indirectly influence D(xr), we would have that D(xr) = 0, D(xf ) = 1. Thus, SGAN would have the same gradients as IPM-based GANs. We conjecture that making SGAN more similar to IPM-based GANs could potentially improve its stability (our results will show that it does in fact improves stability).
sections.heading: 4 METHOD
sections.heading: 4.1 RELATIVISTIC STANDARD GAN
sections.text: In standard GAN, the discriminator can be defined, in term of the non-transformed layer C(x), as D(x) = sigmoid(C(x)). A simple way to make discriminator relativistic (i.e., having the output of D depends on both real and fake data) is to sample from real/fake data pairs x̃ = (xr, xf ) and define it as D(x̃) = sigmoid(C(xr)− C(xf )). We can interpret this modification in the following way: the discriminator estimates the probability that the given real data is more realistic than a randomly sampled fake data. Similarly, we can define Drev(x̃) = sigmoid(C(xf ) − C(xr)) as the probability that the given fake data is more realistic than a randomly sampled real data. An interesting property of this discriminator is that we do not need to include Drev in the loss function through log(1 − Drev(x̃)) because we have that 1−Drev(x̃) = 1−sigmoid(C(xf )−C(xr)) = sigmoid(C(xr)−C(xf )) = D(x̃); thus, log(D(x̃)) = log(1−Drev(x̃)). The discriminator and generator (non-saturating) loss functions of the Relativistic Standard GAN (RSGAN) can be written as:
  LRSGAND = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xr)− C(xf )))] . (7)
  LRSGANG = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xf )− C(xr)))] . (8)
sections.heading: 4.2 RELATIVISTIC GANS
sections.text: More generally, we consider any discriminator defined as a(C(xr)−C(xf )), where a is the activation function, to be relativistic. This means that almost any GAN can have a relativistic discriminator. This forms a new class of models which we call Relativistic GANs (RGANs).
  Most GANs can be parametrized very generally in terms of the critic:
  LGAND = Exr∼P [f1(C(xr))] + Exf∼Q [f2(C(xf ))] (9)
  and LGANG = Exr∼P [g1(C(xr))] + Exf∼Q [g2(C(xf ))] , (10)
  where f1, f2, g1, g2 are scalar-to-scalar functions. If we use a relativistic discriminator, these GANs now have the following form:
  LRGAND = E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [f2(C(xf )− C(xr))] (11)
  and
  LRGANG = E(xr,xf )∼(P,Q) [g1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [g2(C(xf )− C(xr))] . (12)
  If one use the identity function (i.e., f1(y) = g2(y) = −y, f2(y) = g1(y) = y), this results in a degenerate case since there is no supremum/maximum. However, if one adds a constraint so that C(xr)− C(xf ) is bounded, then there is a supremum and one arrives at IPM-based GANs. Thus, although different, IPM-based GANs share a very similar loss function focused on the difference in critics.
  Importantly, g1 is normally ignored in GANs because its gradient is zero since the generator does not influence it. However, in RGANs, g1 is influenced by fake data, thus by the generator.
sections.heading: 4.3 RELATIVISTIC AVERAGE GANS
sections.text: The discriminator has a very different interpretation in SGAN compared to RSGAN. In SGAN, D(x) estimates the probability that x is real, while in RGANs, D(xr, xf ) estimates the probability that xr is more realistic than xf . As a middle ground, we developed an alternative to the Relativistic Discriminator, which retains approximately the same interpretation as the discriminator in SGAN while still being relativistic.
  We propose the Relativistic average Discriminator (RaD) which compares the critic of the input data to the average critic of samples of the opposite type. The discriminator loss function for this approach can be formulated as:
  LRaSGAND = −Exr∼P [ log ( D̄(xr) ) ) ] − Exf∼Q [ log ( 1− D̄(xf ) )] , (13)
  where
  D̄(x) = { sigmoid(C(x)− Exf∼QC(xf )) if x is real sigmoid(C(x)− Exr∼PC(xr)) if x is fake.
  (14)
  RaD has a more similar interpretation to the standard discriminator than the relativistic discriminator. With RaD, the discriminator estimates the probability that the given real data is more realistic than fake data, on average.
  As before, we can generalize this approach to work with any GAN loss function using the following formulation: LRaGAND = Exr∼P [ f1 ( C(xr)− Exf∼QC(xf ) ) ) ] + Exf∼Q [f2 (C(xf )− Exr∼PC(xr))] . (15)
  LRaGANG = Exr∼P [ g1 ( C(xr)− Exf∼QC(xf ) ) ) ]
  + Exf∼Q [g2 (C(xf )− Exr∼PC(xr))] . (16) We call this general approach Relativistic average GAN (RaGAN).
sections.heading: 5 EXPERIMENTS
sections.text: Experiments were conducted on the CIFAR-10 dataset (Krizhevsky, 2009) and the CAT dataset (Zhang et al., 2008). Code was written in Pytorch (Paszke et al., 2017) and models were trained using the Adam optimizer (Kingma & Ba, 2014) for 100K generator iterations with seed 1 (which shows that we did not fish for the best seed, instead, we selected the seed a priori). We report the Fréchet Inception Distance (FID) (Heusel et al., 2017), a measure that is generally better correlated with data quality than the Inception Distance (Salimans et al., 2016) (Borji, 2018); lower FID means that the generated images are of better quality.
  For the models architectures, we used the standard CNN described by Miyato et al. (2018) on CIFAR10 and a relatively standard DCGAN architecture (Radford et al., 2015) on CAT (see Appendix). We also provide the source code required to replicate all analyses presented in this paper (See our repository: [Anonymous until peer review is finished]).
sections.heading: 5.1 CIFAR-10
sections.text: In these analyses, we compared standard GAN (SGAN), least-squares GAN (LSGAN), Wassertein GAN improved (WGAN-GP), Hinge-loss GAN (HingeGAN) (Miyato et al., 2018), Relativistic SGAN (RSGAN), Relativistic average SGAN (RaSGAN), Relativistic average LSGAN (RaLSGAN), and Relativistic average HingeGAN (RaHingeGAN) using the standard CNN architecture on stable setups (See Appendix for details on the loss functions used). Additionally, we tested RSGAN and RaSGAN with the same gradient-penalty as WGAN-GP (named RSGAN-GP and RaSGAN-GP respectively).
  We used the following two known stable setups: (DCGAN setup) lr = .0002, nD = 1, β1 = .50 and β2 = .999 (Radford et al., 2015), and (WGAN-GP setup) lr = .0001, nD = 5, β1 = .50 and β2 = .9 (Gulrajani et al., 2017), where lr is the learning rate, nD is the number of discriminator updates per generator update, and β1, β2 are the ADAM momentum parameters. For optimal stability, we used batch norm (Ioffe & Szegedy, 2015) in G and spectral norm (Miyato et al., 2018) in D.
  Results are presented in Table 1. We observe that RSGAN and RaSGAN generally performed better than SGAN. Similarly, RaHingeGAN performed better than HingeGAN. RaLSGAN performed on par with LSGAN, albeit sightly worse. WGAN-GP performed poorly in the DCGAN setup, but very well in the WGAN-GP setup. RasGAN-GP performed poorly; however, RSGAN-GP performed better than all other loss functions using only one discriminator update per generator update. Importantly, the resulting FID of 25.60 is on par with the lowest FID obtained for this architecture using spectral normalization, as reported by Miyato et al. (2018) (25.5). Overall, these results show that using a relativistic discriminator generally improve data generation quality and that RSGAN works very well in conjunction with gradient penalty to obtain state-of-the-art results.
sections.heading: 5.2 CAT
sections.text: CAT is a dataset containing around 10k pictures of cats with annotations. We cropped the pictures to the faces of the cats using those annotations. After removing outliers (hidden faces, blurriness, etc.), the CAT dataset contained 9304 images ≥ 64x64, 6645 images ≥ 128x128, and 2011 images ≥ 256x256. The CAT dataset is particularly challenging due to its small sample size and high-resolution images; this makes it perfect for testing the stability of different GAN loss functions.
  We trained different GAN loss functions on 64x64, 128x128, 256x256 images. For 256x256 images, we compared RaGANs to known stable approaches: SpectralSGAN (SGAN with spectral normalization in D) and WGAN-GP. Although some approaches were able to train on 256x256 images, they did so with significant mode collapse. To alleviate this problem, for 256x256 images, we packed the discriminator (Lin et al., 2017) (i.e., D took a concatenated pair of images instead of a single image). We looked at the minimum, maximum, mean and standard deviation (SD) of the FID at 20k, 30k, ..., 100k generator iterations; results are presented in Table 2.
  Overall, we observe lower minimum FID, maximum FID, mean and standard deviation (sd) for RGANs and RaGANs than their non-relativistic counterparts (SGAN, LSGAN, RaLSGAN).
  In 64x64 resolution, both SGAN and LSGAN generated images with low FID, but they did so in a very unstable matter. For example, SGAN went from a FID of 17.50 at 30k iterations, to 310.56 at 40k iterations, and back to 27.72 at 50k iterations. Similarly, LSGAN went from a FID of 20.27 at 20k iterations, to 224.97 at 30k iterations, and back to 51.98 at 40k iterations. On the other hand, RaGANs were much more stable (lower max and SD) while also resulting in lower minimum FID. Using gradient-penalty did not improve data quality; however, it reduced the SD lower than without gradient penalty, thus increasing stability further.
  SGAN was unable to converge on 128x128 or bigger images and LSGAN was unable to converge on 256x256 images. Meanwhile, RaGANs were able to generate plausible images with low FID in all resolutions. Although SpectralSGAN and WGAN-GP were able to generate 256x256 images of cats, the samples they generated were of poor quality (high FID). Thus, in this very difficult setting, relativism provided a greater improvement in quality than gradient penalty or spectral normalization.
sections.heading: 6 CONCLUSION AND FUTURE WORK
sections.text: In this paper, we proposed the relativistic discriminator as a way to fix and improve on standard GAN. We further generalized this approach to any GAN loss and introduced a generally more stable variant called RaD. Our results suggest that relativism significantly improve data quality and stability of
  GANs at no computational cost. Furthermore, using a relativistic discriminator with other tools of the trade (spectral norm, gradient penalty, etc.) may lead to better state-of-the-art.
  Future research is needed to fully understand the mathematical implications of adding relativism to GANs. Furthermore, our experiments were limited to certain loss functions using only one seed, due to computational constraints. More experiments are required to determine which relativistic GAN loss function is best over a wide-range of datasets and hyper-parameters. We greatly encourage researchers and machine learning enthusiasts with greater computing power to experiment further with our approach.
sections.heading: APPENDICES
sections.text: A INTUITIVE AND MEMEFUL VISUAL REPRESENTATION OF RAGANS
  B INTUITION BEHIND RAGANS
  Although the relative discriminator provide the missing property that we want in GANs (i.e., G influencing D(xr)), its interpretation is different from the standard discriminator. Rather than measuring “the probability that the input data is real”, it is now measuring “the probability that the
  input data is more realistic than a randomly sampled data of the opposing type (fake if the input is real or real if the input is fake)”. To make the relativistic discriminator act more globally, as in its original definition, our initial idea was the following: average the relativistic discriminator over random samples of data of the opposing type. This can be conceptualized in the following way:
  P (xr is real) := Exf∼Q[P (xr is more real than xf )] = Exf∼Q[sigmoid(C(xr)− C(xf ))] = Exf∼Q[D(xr, xf )],
  P (xf is real) := Exr∼P[P (xf is more real than xr)] = Exr∼P[sigmoid(C(xf )− C(xr))] = Exr∼P[D(xf , xr)],
  where D(xr, xf ) = sigmoid(C(xr)− C(xf )). Then, the following loss function for D could be applied:
  LD = −Exr∼P [ log ( Exf∼Q[D(xr, xf )] ) ) ] − Exf∼Q [log (1− Exr∼P[D(xf , xr)])] . (17)
  The main problem with this idea is that it would require looking at all possible combinations of real and fake data in the mini-batch. This would transform the problem fromO(m) toO(m2) complexity, where m is the batch size. This is problematic; therefore, we do not use this approach.
  Instead, we propose to use the Relativistic average Discriminator (RaD) which compares the critic of the input data to the average critic of samples of the opposite type (See section 4.3). This approach has O(m) complexity.
sections.heading: C GRADIENTS
sections.heading: C.1 SGAN
sections.text: ∇wLGAND = −∇wExr∼P [logD(xr)]−∇wExf∼Qθ [log(1−D(xf ))] = −∇wExr∼P [ log ( eC(xr)
  eC(xr) + 1
  )] −∇wExf∼Qθ [ log ( 1− e C(xf )
  eC(xf ) + 1 )] = −∇wExr∼P [ C(xr)− log ( eC(xr) + 1 )] −∇wExf∼Qθ [ log(1)− log ( eC(xf ) + 1
  )] = −Exr∼P [∇wC(xr)] + Exr∼P [ eC(xr)
  eC(xr) + 1 ∇wC(xr)
  ] + Exf∼Qθ [ eC(xf )
  eC(xf ) + 1 ∇wC(xf ) ] = −Exr∼P [∇wC(xr)] + Exr∼P [D(xr)∇wC(xr)] + Exf∼Qθ [D(xf )∇wC(xf )] = −Exr∼P [(1−D(xr))∇wC(xr)] + Exf∼Qθ [D(xf )∇wC(xf )]
  ∇θLGANG = −∇θEz∼Pz [logD(G(z))] = −∇θEz∼Pz [ log ( eC(G(z))
  eC(G(z)) + 1 )] = −∇θEz∼Pz [ C(G(z))− log ( eC(G(z)) + 1
  )] = −Ez∼Pz [ ∇xC(G(z))JθG(z)− ( eC(G(z))
  eC(G(z)) + 1
  ) ∇xC(G(z))JθG(z) ] = −Ez∼Pz [(1−D(G(z)))∇xC(G(z))JθG(z)]
  C.2 IPM-BASED GANS
  ∇wLIPMD = −∇wExr∼P[C(xr)] +∇wExf∼Qθ [C(xf )] = −Exr∼P[∇wC(xr)] + Exf∼Qθ [∇wC(xf )]
  ∇θLIPMG = −∇θEz∼Pz [C(G(z))] = −Ez∼Pz [∇xC(G(z))JθG(z)]
sections.heading: D SIMPLIFIED FORM OF RELATIVISTIC SATURATING AND NON-SATURATING GANS
sections.text: The formulation of RGANs can be simplified when we have the following two properties: (1) f2(−y) = f1(y) and (2) the generator assumes a non-saturating loss (g1(y) = f2(y) and g2(y) = f1(y)). These two properties are observed in standard GAN, LSGAN using symmetric labels (e.g., -1 and 1), IPM-based GANs, etc. With these two properties, RGANs with non-saturating loss can be formulated simply as:
  LRGAN∗D = E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] (18)
  and LRGAN∗G = E(xr,xf )∼(P,Q) [f1(C(xf )− C(xr))] . (19)
  Assuming f2(−y) = f1(y), we have that
  LRGAND = E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [f2(C(xf )− C(xr))] = E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] = 2E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] .
  If g1(y) = −f1(y) and g2(y) = −f2(y) (saturating GAN), we have that
  LRGAN−SG = E(xr,xf )∼(P,Q) [g1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [g2(C(xf )− C(xr))] = −E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))]− E(xr,xf )∼(P,Q) [f2(C(xf )− C(xr))] = −E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))]− E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] = −2E(xr,xf )∼(P,Q) [f1(C(xr)− C(xf ))] .
  If g1(y) = f2(y) and g2(y) = f1(y) (non-saturating GAN), we have that
  LRGAN−NSG = E(xr,xf )∼(P,Q) [g1(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [g2(C(xf )− C(xr))] = E(xr,xf )∼(P,Q) [f2(C(xr)− C(xf ))] + E(xr,xf )∼(P,Q) [f1(C(xf )− C(xr))] = E(xr,xf )∼(P,Q) [f1(C(xf )− C(xr))] + E(xr,xf )∼(P,Q) [f1(C(xf )− C(xr))] = 2E(xr,xf )∼(P,Q) [f1(C(xf )− C(xr))] .
sections.heading: E TESTING THE GRADIENT ARGUMENT
sections.text: Previously, we argued that SGAN could be equivalent to IPM-GANs under very strict conditions and assumptions. We mentioned that although most assumptions are reasonable, the assumption that the generator is trained to optimality is unrealistic. In which case, SGAN would not be equivalent to IPM-based GANs since D(xr) would not reach 0.
  As an experiment, we calculated the mini-batch average of D(xr) in the first 100 iterations of the training for the CAT dataset in 256x256. Note that SGAN becomes stuck at around 200 iterations and can never go beyond generating noise. Thus, a difference in the distribution of D(xr) could reveal something meaningful about why Relativistic GANs can converge while their non-relativistic counterparts cannot.
  In those 100 iterations, we have that the distance between P and Q is maximal since G only generate noise. Thus, we can perfectly distinguish real from fake data, which is one of the assumptions. The remaining assumptions were that D and G would be trained to optimality. Although we did not train D more than once, after the discriminator step, we generally had that D(xr) ≈ 1. What we wanted to verify is whether D(xr) ≈ 0 after the generator step in Relativistic GANs, even though we did not train G enough to reach optimality.
  Results are shown in Figure 2. We observe that with only one generator update per discriminator update (nG = 1), RSGAN and RaSGAN never reach an average D(xr) of 0 but the distribution is much less concentrated around 1 than with SGAN. With nG = 2, RSGAN and RaSGAN sometimes reach an averageD(xr) of 0 and they form an almost uniform distribution around [0, 1]. This suggests that with the missing property (i.e., using Relativistic GANs), SGAN can be made more similar to IPM-based GANs, but never equivalent. Thus, Relativistic Standard GANs can be seen as having a dynamic in-between SGAN and IPM-based GANs.
sections.heading: F CIFAR-10 HARD/UNSTABLE EXPERIMENTS
sections.text: In these analyses, we compared SGAN, LSGAN, WGAN-GP, RSGAN, RaSGAN, RaLSGAN, and RaHingeGAN with the standard CNN architecture on unstable setups in CIFAR-10. Unless otherwise specified, we used lr = .0002, β1 = .5, β2 = .999, nD = 1, and batch norm (Ioffe & Szegedy, 2015) in G and D. We tested the following four unstable setups: (1) lr = .001, (2) β1 = .9, β2 = .9, (3) no batch norm in G or D, and (4) all activation functions replaced with Tanh in both G and D (except for the output activation function of D).
  Results are presented in Table 4. We observe that RaLSGAN performed better than LSGAN in all setups. RaHingeGAN performed slightly worse than HingeGAN in most setups. RSGAN and RaSGAN performed better than SGAN in two out of four setups, although differences were small. WGAN-GP generally performed poorly which we suspect is due to the single discriminator update per generator update. Overall, this provide good support for the improved stability of using the relative discriminator with LSGAN, but not with HingeGAN and SGAN. Although results are worse for the relativistic discriminator in some settings, differences are minimal and probably reflect natural variations.
  It is surprising to observe low FID for SGAN without batch normalization considering its well-known difficulty with this setting (Arjovsky et al., 2017). Given these results, we suspected that CIFAR-10 may be too easy to fully observe the stabilizing effects of using the relative discriminator. Therefore, in the manuscript, we focused on the more difficult CAT dataset with high resolution pictures.
sections.heading: G LOSS FUNCTIONS USED IN EXPERIMENTS
sections.heading: G.1 SGAN (NON-SATURATING)
sections.text: LSGAND = −Exr∼P [log (sigmoid(C(xr)))]− Exf∼Q [log (1− sigmoid(C(xf )))] (20)
  LSGANG = −Exf∼Q [log (sigmoid(C(xf )))] (21)
sections.heading: G.2 RSGAN
sections.text: LRSGAND = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xr)− C(xf )))] (22)
  Table 4: Fréchet Inception Distance (FID) at exactly 100k generator iterations on the CIFAR-10 dataset using unstable setups with different GAN loss functions. Unless otherwise specified, we used lr = .0002, β = (.50, .999), nD = 1, and batch norm (BN) in D and G. All models were trained using the same a priori selected seed (seed=1).
  Loss lr = .001 β = (.9, .9) No BN Tanh
  SGAN 154.20 35.29 35.54 59.17 RSGAN 50.95 45.12 37.11 77.21 RaSGAN 55.55 43.46 41.96 54.42
  LSGAN 52.27 225.94 38.54 147.87 RaLSGAN 33.33 48.92 34.66 53.07 HingeGAN 43.28 33.47 34.21 58.51
  RaHingeGAN 51.05 42.78 43.75 50.69 WGAN-GP 61.97 104.95 85.27 59.94
  LRSGANG = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xf )− C(xr)))] (23)
sections.heading: G.3 RASGAN
sections.text: LRaSGAND = −Exr∼P [ log ( D̃(xr) )] − Exf∼Q [ log ( 1− D̃(xf ) )]
  (24)
  LRaSGANG = −Exf∼Q [ log ( D̃(xf ) )] − Exr∼P [ log ( 1− D̃(xr) )]
  (25) D̃(xr) = sigmoid ( C(xr)− Exf∼QC(xf ) ) D̃(xf ) = sigmoid (C(xf )− Exr∼PC(xr))
sections.heading: G.4 LSGAN
sections.text: LLSGAND = Exr∼P [ (C(xr)− 0)2 ] + Exf∼Q [ (C(xf )− 1)2 ] (26)
  LLSGANG = Exf∼Q [ (C(xf )− 0)2 ] (27)
sections.heading: G.5 RALSGAN
sections.text: LRaLSGAND = Exr∼P [ (C(xr)− Exf∼QC(xf )− 1)2 ] + Exf∼Q [ (C(xf )− Exr∼PC(xr) + 1)2 ] (28)
  LRaLSGANG = Exf∼P [ (C(xf )− Exr∼PC(xr)− 1)2 ] + Exr∼P [ (C(xr)− Exf∼QC(xf ) + 1)2 ] (29)
sections.heading: G.6 HINGEGAN
sections.text: LHingeGAND = Exr∼P [max(0, 1− C(xr))] + Exf∼Q [max(0, 1 + C(xf ))] (30)
  LHingeGANG = −Exf∼Q [C(xf )] (31)
sections.heading: G.7 RAHINGEGAN
sections.text: LHingeGAND = Exr∼P [ max(0, 1− D̃(xr)) ] + Exf∼Q [ max(0, 1 + D̃(xf )) ] (32)
  LHingeGANG = Exf∼P [ max(0, 1− D̃(xf )) ] + Exr∼Q [ max(0, 1 + D̃(xr)) ] (33)
  D̃(xr) = C(xr)− Exf∼QC(xf ) D̃(xf ) = C(xf )− Exr∼PC(xr)
sections.heading: G.8 WGAN-GP
sections.text: LWGAN−GPD = −Exr∼P [C(xr)] + Exf∼Q [C(xf )] + λEx̂∼Px̂ [ (||∇x̂C(x̂) ||2 − 1)2 ] (34)
  LWGAN−GPG = −Exf∼Q [C(xf )] (35)
  Px̂ is the distribution of x̂ = xr + (1− )xf , where xr ∼ P, xf ∼ Q, ∼ U [0, 1].
sections.heading: G.9 RSGAN-GP
sections.text: LRSGAND = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xr)− C(xf )))] + λEx̂∼Px̂ [ (||∇x̂C(x̂) ||2 − 1)2 ] (36)
  LRSGANG = −E(xr,xf )∼(P,Q) [log(sigmoid(C(xf )− C(xr)))] (37)
  Px̂ is the distribution of x̂ = xr + (1− )xf , where xr ∼ P, xf ∼ Q, ∼ U [0, 1].
sections.heading: G.10 RASGAN-GP
sections.text: LRaSGAND = −Exr∼P [ log ( D̃(xr) )] −Exf∼Q [ log ( 1− D̃(xf ) )] +λEx̂∼Px̂ [ (||∇x̂C(x̂) ||2 − 1)2
  ] (38)
  LRaSGANG = −Exf∼Q [ log ( D̃(xf ) )] − Exr∼P [ log ( 1− D̃(xr) )]
  (39)
  D̃(xr) = sigmoid ( C(xr)− Exf∼QC(xf ) ) D̃(xf ) = sigmoid (C(xf )− Exr∼PC(xr)) Px̂ is the distribution of x̂ = xr + (1− )xf , where xr ∼ P, xf ∼ Q, ∼ U [0, 1].
sections.heading: H ALGORITHMS
sections.text: Algorithm 1 Training algorithm for non-saturating RGANs with symmetric loss functions Require: The number of D iterations nD (nD = 1 unless one seeks to train D to optimality), batch
  size m, and functions f which determine the objective function of the discriminator (f is f1 from equation 10 assuming that f2(−y) = f1(y), which is true for many GANs). while θ has not converged do
  for t = 1, . . . , nD do Sample {x(i)}mi=1 ∼ P Sample {z(i)}mi=1 ∼ Pz Update w using SGD by ascending with ∇w 1m ∑m i=1 [ f(Cw(x (i))− Cw(Gθ(z(i)))) ] end for Sample {x(i)}mi=1 ∼ P Sample {z(i)}mi=1 ∼ Pz Update θ using SGD by ascending with∇θ 1m ∑m i=1 [ f(Cw(Gθ(z (i)))− Cw(x(i))) ]
  end while
  Algorithm 2 Training algorithm for non-saturating RaGANs Require: The number of D iterations nD (nD = 1 unless one seek to train D to optimality), batch
  size m, and functions f1 and f2 which determine the objective function of the discriminator (see equation 10). while θ has not converged do
  for t = 1, . . . , nD do Sample {x(i)}mi=1 ∼ P Sample {z(i)}mi=1 ∼ Pz Let Cw(xr) = 1m ∑m i=1 Cw(x (i))
  Let Cw(xf ) = 1m ∑m i=1 Cw(Gθ(z
  (i))) Update w using SGD by ascending with ∇w 1m ∑m i=1 [ f1(Cw(x (i))− Cw(xf )) + f2(Cw(Gθ(z(i)))− Cw(xr)) ]
  end for Sample {x(i)}mi=1 ∼ P Sample {z(i)}mi=1 ∼ Pz Let Cw(xr) = 1m ∑m i=1 Cw(x (i))
  Let Cw(xf ) = 1m ∑m i=1 Cw(Gθ(z
  (i))) Update θ using SGD by ascending with ∇θ 1m ∑m i=1 [ f1(Cw(Gθ(z (i)))− Cw(xr)) + f2(Cw(x(i))− Cw(xf )) ]
  end while
sections.heading: I ARCHITECTURES
sections.heading: I.1 STANDARD CNN
sections.text: Generator
  z ∈ R128 ∼ N(0, I) linear, 128 -> 512*4*4
  Reshape, 512*4*4 -> 512 x 4 x 4
  ConvTranspose2d 4x4, stride 2, pad 1, 512->256
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, 256->128
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, 128->64
  BN and ReLU
  ConvTranspose2d 3x3, stride 1, pad 1, 64->3
  Tanh
  Discriminator
  x ∈ R3x32x32
  Conv2d 3x3, stride 1, pad 1, 3->64
  LeakyReLU 0.1
  Conv2d 4x4, stride 2, pad 1, 64->64
  LeakyReLU 0.1
  Conv2d 3x3, stride 1, pad 1, 64->128
  LeakyReLU 0.1
  Conv2d 4x4, stride 2, pad 1, 128->128
  LeakyReLU 0.1
  Conv2d 3x3, stride 1, pad 1, 128->256
  LeakyReLU 0.1
  Conv2d 4x4, stride 2, pad 1, 256->256
  LeakyReLU 0.1
  Conv2d 3x3, stride 1, pad 1, 256->512
  Reshape, 512 x 4 x 4 -> 512*4*4
  linear, 512*4*4 -> 1
  I.2 DCGAN 64X64
  Generator
  z ∈ R128 ∼ N(0, I) ConvTranspose2d 4x4, stride 1, pad 0, no bias, 128->512
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 512->256
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 256->128
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 128->64
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64->3
  Tanh
  Discriminator
  x ∈ R3x64x64
  Conv2d 4x4, stride 2, pad 1, no bias, 3->64
  LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 64->128
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 128->256
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 256->512
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 512->1
  I.3 DCGAN 128X128
  Generator
  z ∈ R128 ∼ N(0, I) ConvTranspose2d 4x4, stride 1, pad 0, no bias, 128->1024
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 1024->512
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 512->256
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 256->128
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 128->64
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64->3
  Tanh
  Discriminator
  x ∈ R3x128x128
  Conv2d 4x4, stride 2, pad 1, no bias, 3->64
  LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 64->128
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 128->256
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 256->512
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 512->1024
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 1024->1
  I.4 DCGAN 256X256
  Generator
  z ∈ R128 ∼ N(0, I) ConvTranspose2d 4x4, stride 1, pad 0, no bias, 128->1024
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 1024->512
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 512->256
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 256->128
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 128->64
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64->32
  BN and ReLU
  ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64->3
  Tanh
  Discriminator (PACGAN2 (Lin et al., 2017))
  x1 ∈ R3x256x256, x2 ∈ R3x256x256
  Concatenate [x1, x2] ∈ R6x256x256
  Conv2d 4x4, stride 2, pad 1, no bias, 6->32
  LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 32->64
  LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 64->128
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 128->256
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 256->512
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 512->1024
  BN and LeakyReLU 0.2
  Conv2d 4x4, stride 2, pad 1, no bias, 1024->1
sections.heading: J SAMPLES
sections.text: This shows a selection of cats from certain models. Images shown are from the lowest FID registered at every 10k generator iterations. Given space constraint, with cats in high resolution, we show some of the nicer looking cats for each approach, there are evidently some worse looking cats (See https://github.com/AlexiaJM/RelativisticGAN/tree/ master/images/full_minibatch for all cats of the mini-batch).
title: THE RELATIVISTIC DISCRIMINATOR: A KEY ELEMENT MISSING FROM STANDARD GAN