Original: DO-GAN: A D OUBLE O RACLE F RAMEWORK FOR G ENERATIVE A DVERSARIAL N ETWORKS
Revised: DO-GAN: A D OUBLE O RACLE F RAMEWORK FOR G ENERATIVE A DVERSARIAL N ETWORKS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: In this paper, we propose a new approach to train Generative Adversarial Networks (GANs) where we deploy a double-oracle framework using the generator and discriminator oracles.
Revised: In this paper, we propose a new approach to train Generative Adversarial Networks (GANs) where we deploy a double-oracle framework using the generator and discriminator oracles.

Original: GAN is essentially a two-player zero-sum game between the generator and the discriminator.
Revised: GAN is essentially a two-player zero-sum game between the generator and the discriminator.

Original: Training GANs is challenging as a pure Nash equilibrium may not exist and even ﬁnding the mixed Nash equilibrium is difﬁcult as GANs have a large-scale strategy space.
Revised: Training GANs is challenging as a pure Nash equilibrium may not exist and even ﬁnding the mixed Nash equilibrium is difﬁcult as GANs have a large-scale strategy space.

Original: In DO-GAN, we extend the double oracle framework to GANs.
Revised: In DO-GAN, we extend the double oracle framework to GANs.

Original: We ﬁrst generalize the player strategies as the trained models of generator and discriminator from the best response oracles.
Revised: We ﬁrst generalize the player strategies as the trained models of generator and discriminator from the best response oracles.

Original: We then compute the meta-strategies using a linear program.
Revised: We then compute the meta-strategies using a linear program.

Original: Next, we prune the weaklydominated player strategies to keep the oracles from becoming intractable.
Revised: Next, we prune the weaklydominated player strategies to keep the oracles from becoming intractable.

Original: We apply our framework to established architectures such as vanilla GAN, Deep Convolutional GAN, Spectral Normalization GAN and Stacked GAN.
Revised: We apply our framework to established architectures such as vanilla GAN, Deep Convolutional GAN, Spectral Normalization GAN and Stacked GAN.

Original: Finally, we conduct evaluations on MNIST, CIFAR-10 and CelebA datasets and show that DO-GAN variants have signiﬁcant improvements in both subjective qualitative evaluation and quantitative metrics, compared with their respective GAN architectures.
Revised: Finally, we conduct evaluations on MNIST, CIFAR-10 and CelebA datasets and show that DO-GAN variants have signiﬁcant improvements in both subjective qualitative evaluation and quantitative metrics, compared with their respective GAN architectures.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have been applied in various domains such as image and video generation, image-to-image translation and text-to-image synthesis (Liu et al., 2017;
Revised: Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have been applied in various domains such as image and video generation, image-to-image translation and text-to-image synthesis (Liu et al., 2017;

Original: Reed et al., 2016).
Revised: Reed et al., 2016).

Original: Various architectures are proposed to generate more realistic samples (Radford et al., 2015; Mirza & Osindero, 2014; Pu et al., 2016) as well as regularization techniques (Arjovsky et al., 2017; Miyato et al., 2018b).
Revised: Various architectures are proposed to generate more realistic samples (Radford et al., 2015; Mirza & Osindero, 2014; Pu et al., 2016) as well as regularization techniques (Arjovsky et al., 2017; Miyato et al., 2018b).

Original: From the game-theoretic perspective, GANs can be viewed as a two-player game where the generator samples the data and the discriminator classiﬁes the data as real or generated.
Revised: From the game-theoretic perspective, GANs can be viewed as a two-player game where the generator samples the data and the discriminator classiﬁes the data as real or generated.

Original: The two networks are alternately trained to maximize their respective utilities until convergence corresponding to a pure Nash Equilibrium (NE).
Revised: The two networks are alternately trained to maximize their respective utilities until convergence corresponding to a pure Nash Equilibrium (NE).

Original: However, pure NE cannot be reliably reached by existing algorithms as pure NE may not exist (Farnia & Ozdaglar, 2020; Mescheder et al., 2017).
Revised: However, pure NE cannot be reliably reached by existing algorithms as pure NE may not exist (Farnia & Ozdaglar, 2020; Mescheder et al., 2017).

Original: This also leads to unstable training in GANs depending on the data and the hyperparameters.
Revised: This also leads to unstable training in GANs depending on the data and the hyperparameters.

Original: Therefore, mixed NE is a more suitable solution concept (Hsieh et al., 2019).
Revised: Therefore, mixed NE is a more suitable solution concept (Hsieh et al., 2019).

Original: Several recent works propose mixture architectures with multiple generators and discriminators that consider mixed NE such as MIX+GAN (Arora et al., 2017) and
Revised: Several recent works propose mixture architectures with multiple generators and discriminators that consider mixed NE such as MIX+GAN (Arora et al., 2017) and

Original: MGAN (Hoang et al., 2018).
Revised: MGAN (Hoang et al., 2018).

Original: MIX+GAN and MGAN cannot guarantee to converge to mixed NE.
Revised: MIX+GAN and MGAN cannot guarantee to converge to mixed NE.

Original: Mirror-GAN (Hsieh et al., 2019) ﬁnds the mixed NE by sampling over the inﬁnite-dimensional strategy space and proposes provably convergent proximal methods.
Revised: Mirror-GAN (Hsieh et al., 2019) ﬁnds the mixed NE by sampling over the inﬁnite-dimensional strategy space and proposes provably convergent proximal methods.

Original: However, the sampling approach may not be efﬁcient as mixed NE may only have a few strategies in the support set.
Revised: However, the sampling approach may not be efﬁcient as mixed NE may only have a few strategies in the support set.

Original: Double Oracle (DO) algorithm (McMahan et al., 2003) is a powerful framework to compute mixed
Revised: Double Oracle (DO) algorithm (McMahan et al., 2003) is a powerful framework to compute mixed

Original: NE in large-scale games.
Revised: NE in large-scale games.

Original: The algorithm starts with a restricted game with a small set of actions and solves it to get the NE strategies of the restricted game.
Revised: The algorithm starts with a restricted game with a small set of actions and solves it to get the NE strategies of the restricted game.

Original: The algorithm then computes players’ best-responses using oracles to the NE strategies and add them into the restricted game for the next iteration.
Revised: The algorithm then computes players’ best-responses using oracles to the NE strategies and add them into the restricted game for the next iteration.

Original: DO framework has been applied in various disciplines (Jain et al., 2011; Bošanský et al., 2013), as well as Multi-agent Reinforcement Learning (MARL) settings (Lanctot et al., 2017).
Revised: DO framework has been applied in various disciplines (Jain et al., 2011; Bošanský et al., 2013), as well as Multi-agent Reinforcement Learning (MARL) settings (Lanctot et al., 2017).

Original: Inspired by the successful applications of DO framework, we, for the ﬁrst time, propose a Double
Revised: Inspired by the successful applications of DO framework, we, for the ﬁrst time, propose a Double

Original: Oracle Framework for Generative Adversarial Networks (DO-GAN).
Revised: Oracle Framework for Generative Adversarial Networks (DO-GAN).

Original: This paper presents four key contributions.
Revised: This paper presents four key contributions.

Original: First, we treat the generator and the discriminator as players and obtain the best responses from their oracles and add the utilities to a meta-matrix.
Revised: First, we treat the generator and the discriminator as players and obtain the best responses from their oracles and add the utilities to a meta-matrix.

Original: Second, we propose a linear program to obtain the probability distributions of the players’ pure strategies (meta-strategies) for the respective oracles.
Revised: Second, we propose a linear program to obtain the probability distributions of the players’ pure strategies (meta-strategies) for the respective oracles.

Original: The linear program computes an exact mixed NE of the meta-matrix game in polynomial time.
Revised: The linear program computes an exact mixed NE of the meta-matrix game in polynomial time.

Original: Third, we propose a pruning method for the support set of best response strategies to prevent the oracles from becoming intractable as there is a risk of the meta-matrix growing very large with each iteration of oracle training.
Revised: Third, we propose a pruning method for the support set of best response strategies to prevent the oracles from becoming intractable as there is a risk of the meta-matrix growing very large with each iteration of oracle training.

Original: Finally, we provide comprehensive evaluation on the performance of DO-GAN with different GAN architectures using both synthetic and real-world datasets.
Revised: Finally, we provide comprehensive evaluation on the performance of DO-GAN with different GAN architectures using both synthetic and real-world datasets.

Original: Experiment results show that DO-GAN variants have signiﬁcant improvements in terms of both subjective qualitative evaluation and quantitative metrics.
Revised: Experiment results show that DO-GAN variants have signiﬁcant improvements in terms of both subjective qualitative evaluation and quantitative metrics.

Original:  R ELATED W ORKS
Revised:  R ELATED W ORKS

Original: In this section, we brieﬂy introduce existing GAN architectures, double oracle algorithm and its applications such as policy-state response oracles that are related to our work.
Revised: In this section, we brieﬂy introduce existing GAN architectures, double oracle algorithm and its applications such as policy-state response oracles that are related to our work.

Original: GAN Architectures.
Revised: GAN Architectures.

Original: Various GAN architectures have been proposed to improve the performance of GANs.
Revised: Various GAN architectures have been proposed to improve the performance of GANs.

Original: Deep Convolutional GAN (DCGAN) (Radford et al., 2015) replaces fully-connected layers in the generator and the discriminator with deconvolution layer of Convolutional Neural Networks (CNN).
Revised: Deep Convolutional GAN (DCGAN) (Radford et al., 2015) replaces fully-connected layers in the generator and the discriminator with deconvolution layer of Convolutional Neural Networks (CNN).

Original: Weight normalization techniques such as Spectral Normalization GAN (SNGAN) (Miyato et al., 2018a) stabilize the training of the discriminator and reduce the intensive hyperparameters tuning.
Revised: Weight normalization techniques such as Spectral Normalization GAN (SNGAN) (Miyato et al., 2018a) stabilize the training of the discriminator and reduce the intensive hyperparameters tuning.

Original: There are also multi-model architectures such as Stacked Generative Adversarial Networks (SGAN)
Revised: There are also multi-model architectures such as Stacked Generative Adversarial Networks (SGAN)

Original: (Huang et al., 2017) that consist of a top-down stack of generators and a bottom-up discriminator network.
Revised: (Huang et al., 2017) that consist of a top-down stack of generators and a bottom-up discriminator network.

Original: Each generator is trained to generate lower-level representations conditioned on higher-level representations that can fool the corresponding representation discriminator.
Revised: Each generator is trained to generate lower-level representations conditioned on higher-level representations that can fool the corresponding representation discriminator.

Original: Training
Revised: Training

Original: GANs is very hard and unstable as pure NE for GANs might not exist and cannot be reliably reached by the existing approaches (Mescheder et al., 2017).
Revised: GANs is very hard and unstable as pure NE for GANs might not exist and cannot be reliably reached by the existing approaches (Mescheder et al., 2017).

Original: Considering mixed NE, MIX+GAN (Arora et al., 2017) maintains a mixture of generators and discriminators with the same network architecture but have their own trainable parameters.
Revised: Considering mixed NE, MIX+GAN (Arora et al., 2017) maintains a mixture of generators and discriminators with the same network architecture but have their own trainable parameters.

Original: However, training a mixture of networks without parameter sharing makes the algorithm computationally expensive.
Revised: However, training a mixture of networks without parameter sharing makes the algorithm computationally expensive.

Original: Mixture Generative Adversarial Nets (MGAN) (Hoang et al., 2018) propose to capture diverse data modes by formulating GAN as a game between a classiﬁer, a discriminator and multiple generators with parameter sharing.
Revised: Mixture Generative Adversarial Nets (MGAN) (Hoang et al., 2018) propose to capture diverse data modes by formulating GAN as a game between a classiﬁer, a discriminator and multiple generators with parameter sharing.

Original: However,
Revised: However,

Original: MIX+GAN and MGAN cannot converge to mixed NE.
Revised: MIX+GAN and MGAN cannot converge to mixed NE.

Original: Mirror-GAN (Hsieh et al., 2019) ﬁnds the mixed NE by sampling over the inﬁnite-dimensional strategy space and proposes provably convergent proximal methods.
Revised: Mirror-GAN (Hsieh et al., 2019) ﬁnds the mixed NE by sampling over the inﬁnite-dimensional strategy space and proposes provably convergent proximal methods.

Original: The sampling approach may be inefﬁcient to compute mixed NE as the mixed NE may only have a few strategies with positive probabilities in the inﬁnite strategy space.
Revised: The sampling approach may be inefﬁcient to compute mixed NE as the mixed NE may only have a few strategies with positive probabilities in the inﬁnite strategy space.

Original: Double Oracle Algorithm.
Revised: Double Oracle Algorithm.

Original: Double Oracle (DO) algorithm starts with a small restricted game between two players and solves it to get the player strategies at NE of the restricted game.
Revised: Double Oracle (DO) algorithm starts with a small restricted game between two players and solves it to get the player strategies at NE of the restricted game.

Original: The algorithm then exploits the respective best response oracles for additional strategies of the players.
Revised: The algorithm then exploits the respective best response oracles for additional strategies of the players.

Original: The
Revised: The

Original: DO algorithm terminates when the best response utilities are not higher than the equilibrium utility of the current restricted game, hence, ﬁnding the NE of the game without enumerating the entire strategy space.
Revised: DO algorithm terminates when the best response utilities are not higher than the equilibrium utility of the current restricted game, hence, ﬁnding the NE of the game without enumerating the entire strategy space.

Original: Moreover, in two-player zero-sum games, DO converges to a min-max equilibrium (McMahan et al., 2003).
Revised: Moreover, in two-player zero-sum games, DO converges to a min-max equilibrium (McMahan et al., 2003).

Original: DO framework is used to solve large-scale normal-form and extensive-form games such as security games (Tsai et al., 2012; Jain et al., 2011), poker games (Waugh et al., 2009) and search games (Bosansky et al., 2012).
Revised: DO framework is used to solve large-scale normal-form and extensive-form games such as security games (Tsai et al., 2012; Jain et al., 2011), poker games (Waugh et al., 2009) and search games (Bosansky et al., 2012).

Original: DO framework is also used in MARL settings (Lanctot et al., 2017; Muller et al., 2020).
Revised: DO framework is also used in MARL settings (Lanctot et al., 2017; Muller et al., 2020).

Original: Policy-Space Response Oracles (PSRO) generalize the double oracle algorithm in a multi-agent reinforcement learning setting (Lanctot et al., 2017).
Revised: Policy-Space Response Oracles (PSRO) generalize the double oracle algorithm in a multi-agent reinforcement learning setting (Lanctot et al., 2017).

Original: PSRO treats the players’ policies as the best responses from the agents’ oracles, builds the meta-matrix game and computes the mixed NE but it uses Projected Replicator Dynamics that update the changes in the probability of each player’s policy at each iteration.
Revised: PSRO treats the players’ policies as the best responses from the agents’ oracles, builds the meta-matrix game and computes the mixed NE but it uses Projected Replicator Dynamics that update the changes in the probability of each player’s policy at each iteration.

Original: Since the dynamics need to simulate the update for several iterations, the use of dynamics takes a longer time to compute the meta-strategies and does not guarantee to compute an exact NE of the meta-matrix game.
Revised: Since the dynamics need to simulate the update for several iterations, the use of dynamics takes a longer time to compute the meta-strategies and does not guarantee to compute an exact NE of the meta-matrix game.

Original: However, in DO-GAN, we can use a linear program to compute the players’ meta-strategies in polynomial time since GAN is a two-player zero-sum game (Schrijver, 1998).
Revised: However, in DO-GAN, we can use a linear program to compute the players’ meta-strategies in polynomial time since GAN is a two-player zero-sum game (Schrijver, 1998).

Original:  P RELIMINARIES
Revised:  P RELIMINARIES

Original: In this section, we mathematically explain the preliminary works that are needed to explain our
Revised: In this section, we mathematically explain the preliminary works that are needed to explain our

Original: DO-GAN approach including generative adversarial networks and game theory concepts such as normal-form game and double oracle algorithm.
Revised: DO-GAN approach including generative adversarial networks and game theory concepts such as normal-form game and double oracle algorithm.

Original: 3. G ENERATIVE A DVERSARIAL N ETWORKS
Revised: 3. G ENERATIVE A DVERSARIAL N ETWORKS

Original: Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have become one of the dominant methods for ﬁtting generative models to complicated real-life data.
Revised: Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have become one of the dominant methods for ﬁtting generative models to complicated real-life data.

Original: GANs are deep neural net architectures comprised of two neural networks trained in an adversarial manner to generate data that resembles a distribution.
Revised: GANs are deep neural net architectures comprised of two neural networks trained in an adversarial manner to generate data that resembles a distribution.

Original: The ﬁrst neural network, a generator G , is given some random distribution
Revised: The ﬁrst neural network, a generator G , is given some random distribution

Original: p z
Revised: p z

Original: ( z ) on the input noise z and a real data distribution p data ( x ) on training data x .
Revised: ( z ) on the input noise z and a real data distribution p data ( x ) on training data x .

Original: The generator is supposed to generate as close as possible to p data ( x ) .
Revised: The generator is supposed to generate as close as possible to p data ( x ) .

Original: The second neural network, a discriminator D , is to discriminate between two different classes of data (real or fake) from the generator.
Revised: The second neural network, a discriminator D , is to discriminate between two different classes of data (real or fake) from the generator.

Original: Let the generator’s differentiable function be denoted as G ( z , π g ) and similarly D ( x , π d ) for the discriminator, where G and D are two neural networks with parameters π g and π d .
Revised: Let the generator’s differentiable function be denoted as G ( z , π g ) and similarly D ( x , π d ) for the discriminator, where G and D are two neural networks with parameters π g and π d .

Original: Thus, D ( x ) represents the probability that x comes from the real data.
Revised: Thus, D ( x ) represents the probability that x comes from the real data.

Original: The generator loss L G and the discriminator loss L D are deﬁned as:
Revised: The generator loss L G and the discriminator loss L D are deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: GAN is then set up as a two-player zero-sum game between G and D as follows:
Revised: GAN is then set up as a two-player zero-sum game between G and D as follows:

Original: [Equation]
Revised: [Equation]

Original: During training, the parameters of G and D are updated alternately until we reach the global optimal solution D ( G ( z ))
Revised: During training, the parameters of G and D are updated alternately until we reach the global optimal solution D ( G ( z ))

Original: = 0 .
Revised: = 0 .

Original: Next, we let Π g and Π d be the set of parameters for G and D , considering the set of probability distributions σ g and σ d , the mixed strategy formulation (Hsieh et al., 2019) is:
Revised: Next, we let Π g and Π d be the set of parameters for G and D , considering the set of probability distributions σ g and σ d , the mixed strategy formulation (Hsieh et al., 2019) is:

Original: [Equation]
Revised: [Equation]

Original: Similarly to GANs, DCGAN, SNGAN and SGAN can also be viewed as two-player zero-sum games with mixed strategies of the players.
Revised: Similarly to GANs, DCGAN, SNGAN and SGAN can also be viewed as two-player zero-sum games with mixed strategies of the players.

Original: DCGAN modiﬁes the vanilla GAN by replacing fully-connected layers with the convolutional layers.
Revised: DCGAN modiﬁes the vanilla GAN by replacing fully-connected layers with the convolutional layers.

Original: SGAN trains multiple generators and discriminators using the loss as a linear combination of 3 loss terms: adversarial loss, conditional loss and entropy loss.
Revised: SGAN trains multiple generators and discriminators using the loss as a linear combination of 3 loss terms: adversarial loss, conditional loss and entropy loss.

Original: 3. N ORMAL F ORM G AME AND D OUBLE O RACLE A LGORITHM
Revised: 3. N ORMAL F ORM G AME AND D OUBLE O RACLE A LGORITHM

Original: A normal-form game is a tuple (Π , U, n ) where n is the number of players,
Revised: A normal-form game is a tuple (Π , U, n ) where n is the number of players,

Original: Π = (Π 1 , . . .
Revised: Π = (Π 1 , . . .

Original: , Π n ) is the set of strategies for each player i ∈ N, where N = { 1 , . . . , n } and U : Π → R n is a payoff table of utilities R for each joint policy played by all players.
Revised: , Π n ) is the set of strategies for each player i ∈ N, where N = { 1 , . . . , n } and U : Π → R n is a payoff table of utilities R for each joint policy played by all players.

Original: Each player chooses the strategy to maximize own expected utility from Π i , or by sampling from a distribution over the set of strategies σ i ∈ ∆(Π i ) .
Revised: Each player chooses the strategy to maximize own expected utility from Π i , or by sampling from a distribution over the set of strategies σ i ∈ ∆(Π i ) .

Original: We can use linear programming, ﬁctitious play (Berger, 2007) or regret minimization (Roughgarden, 2010) to compute the probability distribution over players’ strategies.
Revised: We can use linear programming, ﬁctitious play (Berger, 2007) or regret minimization (Roughgarden, 2010) to compute the probability distribution over players’ strategies.

Original: In the Double Oracle (DO) algorithm (McMahan et al., 2003), there are two best response oracles for the row and column player respectively.
Revised: In the Double Oracle (DO) algorithm (McMahan et al., 2003), there are two best response oracles for the row and column player respectively.

Original: The algorithm creates restricted games from a subset of strategies at the point of each iteration t for row and column players, i.e., Π tr ⊂ Π r and Π tc ⊂ Π c as well as a meta-matrix U t at the t th iteration.
Revised: The algorithm creates restricted games from a subset of strategies at the point of each iteration t for row and column players, i.e., Π tr ⊂ Π r and Π tc ⊂ Π c as well as a meta-matrix U t at the t th iteration.

Original: We then solve the meta-matrix to get the probability distributions on Π tr and Π tc .
Revised: We then solve the meta-matrix to get the probability distributions on Π tr and Π tc .

Original: Given a probability distribution σ c of the column player strategies,
Revised: Given a probability distribution σ c of the column player strategies,

Original: BR r ( σ c ) gives the row player’s best response to σ c .
Revised: BR r ( σ c ) gives the row player’s best response to σ c .

Original: Similarly, given probability distribution σ r of the row player’s strategies, BR c ( σ r ) is the column player’s best response to σ r .
Revised: Similarly, given probability distribution σ r of the row player’s strategies, BR c ( σ r ) is the column player’s best response to σ r .

Original: The best responses are added to the restricted game for the next iteration.
Revised: The best responses are added to the restricted game for the next iteration.

Original: The algorithm terminates when the best response utilities are not higher than the equilibrium utility of current restricted game.
Revised: The algorithm terminates when the best response utilities are not higher than the equilibrium utility of current restricted game.

Original: Although in the worst-case, the entire strategy space may be added to the restricted game, DO is guaranteed to converge to mixed NE in two-player zero-sum games.
Revised: Although in the worst-case, the entire strategy space may be added to the restricted game, DO is guaranteed to converge to mixed NE in two-player zero-sum games.

Original: Beyond games, DO is also used in PSRO (Lanctot et al., 2017) to approximate the best responses to the mixtures of agents’ policies, and compute the meta-strategies for the policy selection. 
Revised: DO is also extended to the multi-agent reinforcement learning in PSRO (Lanctot et al., 2017) to approximate the best responses to the mixtures of agents’ policies, and compute the meta-strategies for the policy selection. [Table] minmax

Revised: [Table]

Original:   DO-GAN: D OUBLE O RACLE F RAMEWORK FOR GAN
Revised: the minmax game between generator & discriminator with their respective set of strategies at epoch t of DO framework [Table] the mixed NE strategy of generator/discriminator at epoch t  DO-GAN: D OUBLE O RACLE F RAMEWORK FOR GAN

Original: As discussed in previous sections, computing mixed NE for GANs is challenging as there is an extremely large number of pure strategies, i.e., possible parameter settings of the generator and discriminator networks.
Revised: As discussed in previous sections, computing mixed NE for GANs is challenging as there is an extremely large number of pure strategies, i.e., possible parameter settings of the generator and discriminator networks.

Original: Thus, we propose a double oracle framework for GANs (DO-GAN) to compute the mixed NE efﬁciently.
Revised: Thus, we propose a double oracle framework for GANs (DO-GAN) to compute the mixed NE efﬁciently.

Original: DO-GAN builds a restricted meta-matrix game between the two players and computes the mixed NE of the meta-matrix game, then DO-GAN iteratively adds more generators and discriminators into the meta-matrix game until termination.
Revised: DO-GAN builds a restricted meta-matrix game between the two players and computes the mixed NE of the meta-matrix game, then DO-GAN iteratively adds more generators and discriminators into the meta-matrix game until termination.

Original: 4. G ENERAL F RAMEWORK OF DO-GAN
Revised: 4. G ENERAL F RAMEWORK OF DO-GAN

Original: GAN can be translated as a two-player zero-sum game between the generator player g and the discriminator player d .
Revised: GAN can be translated as a two-player zero-sum game between the generator player g and the discriminator player d .

Original: To compute the mixed NE of GANs, at iteration t , DO-GAN creates a restricted meta-matrix game U t with the trained generators and discriminators as the strategies of the two players, where the generators and discriminators are parameterized by π g ∈ G and π d ∈ D .
Revised: To compute the mixed NE of GANs, at iteration t , DO-GAN creates a restricted meta-matrix game U t with the trained generators and discriminators as the strategies of the two players, where the generators and discriminators are parameterized by π g ∈ G and π d ∈ D .

Original: We use U t ( π g , π d ) to denote the generator player’s payoff when playing π g against π d , which is deﬁned as L D .
Revised: We use U t ( π g , π d ) to denote the generator player’s payoff when playing π g against π d , which is deﬁned as L D .

Original: Since GAN is zero-sum, the discriminator player’s payoff is − U t ( π g , π d ) .
Revised: Since GAN is zero-sum, the discriminator player’s payoff is − U t ( π g , π d ) .

Original: We deﬁne σ tg and σ t d as the mixed strategies of generator player and discriminator player, respectively.
Revised: We deﬁne σ tg and σ td as the mixed strategies of generator player and discriminator player, respectively.

Original: With a slight abuse of notation, we deﬁne the generator player’s expected utility of the mixed strategies (cid:104) σ tg , σ td (cid:105) as
Revised: With a slight abuse of notation, we deﬁne the generator player’s expected utility of the mixed strategies (cid:104) σ tg , σ td (cid:105) as

Original: U t ( σ tg , σ td ) =
Revised: U t ( σ t g , σ td ) =

Original: (cid:80) π g ∈G (cid:80)
Revised: (cid:80) π g ∈G (cid:80)

Original: π
Revised: π

Original: d ∈D σ tg ( π g ) · σ td ( π d ) · U t ( π g , π d ) .
Revised: d ∈D σ t g ( π g ) · σ td ( π d ) · U t ( π g , π d ) .

Original: We use (cid:104) σ t ∗ g , σ t ∗ d (cid:105) to denote the mixed
Revised: We use (cid:104) σ t ∗ g , σ t ∗ d (cid:105) to denote the mixed

Original: NE of the restricted meta-matrix game U t .
Revised: NE of the restricted meta-matrix game U t .

Original: We solve U t to obtain the mixed NE, compute the best responses and add them into U t for the next iteration.
Revised: We solve U t to obtain the mixed NE, compute the best responses and add them into U t for the next iteration.

Original: Figure 1 presents an illustration of DO-GAN and Algorithm 1 describes the overview of the framework.
Revised: Figure 1 presents an illustration of DO-GAN and Algorithm 1 describes the overview of the framework.

Original: [Figure]
Revised: [Figure]

Original: Our algorithm starts by initializing two empty arrays G and D to store multiple generators and discriminators (line 1).
Revised: Our algorithm starts by initializing two empty arrays G and D to store multiple generators and discriminators (line 1).

Original: We train the ﬁrst π g and π d with the canonical training procedure of GANs (line 2).
Revised: We train the ﬁrst π g and π d with the canonical training procedure of GANs (line 2).

Original: We store the parameters of the trained models in the two arrays G and D (line 3), compute the adversarial loss L D and add it to the meta-matrix U 0 (line 4).
Revised: We store the parameters of the trained models in the two arrays G and D (line 3), compute the adversarial loss L D and add it to the meta-matrix U 0 (line 4).

Original: We initialize the meta-strategies σ 0 ∗ g =
Revised: We initialize the meta-strategies σ 0 ∗ g =

Original: [1] and σ 0 ∗ d = [1] since there is only one pair of generator and discriminator available (line 5).
Revised: [1] and σ 0 ∗ d = [1] since there is only one pair of generator and discriminator available (line 5).

Original: For each epoch, we use generatorOracle () and discriminatorOracle () to obtain the best responses π (cid:48) g and π (cid:48)
Revised: For each epoch, we use generatorOracle () and discriminatorOracle () to obtain the best responses π (cid:48) g and π (cid:48)

Original: d to σ t ∗ d and σ t ∗ g , respectively, then add them into G and D (lines 7-10).
Revised: d to σ t ∗ d and σ t ∗ g via Adam Optimizer, respectively, then add them into G and D (lines 7-10).

Original: We then augment U t − 1 by adding π (cid:48)
Revised: We then augment U t − 1 by adding π (cid:48)

Original: g and π (cid:48)
Revised: g and π (cid:48)

Original: d and calculating U t ( π (cid:48) g , π (cid:48)
Revised: d and calculating U t ( π (cid:48) g , π (cid:48)

Original: d ) to obtain U t and compute the missing entries (line 11).
Revised: d ) to obtain U t and compute the missing entries (line 11).

Original: We compute the missing payoff entries U t ( π (cid:48) g , π d ) , ∀ π d ∈ D and U t ( π g , π (cid:48) d ) , ∀ π g ∈ G by sampling a few batches of training data.
Revised: We compute the missing payoff entries U t ( π (cid:48) g , π d ) , ∀ π d ∈ D and U t ( π g , π (cid:48) d ) , ∀ π g ∈ G by sampling a few batches of training data.

Original: After that, we compute the mixed NE (cid:104) σ t ∗ g , σ t ∗ d (cid:105) of U t with linear programming (line 12).
Revised: After that, we compute the mixed NE (cid:104) σ t ∗ g , σ t ∗ d (cid:105) of U t with linear programming (line 12).

Original: The algorithm terminates if the criteria described in Algorithm 2 is satisﬁed (line 13).
Revised: The algorithm terminates if the criteria described in Algorithm 2 is satisﬁed (line 13).

Original: We also prune the support strategy set of the players as described in Algorithm 3 (line 14) to avoid G and D becoming intractable.
Revised: We also prune the support strategy set of the players as described in Algorithm 3 (line 14) to avoid G and D becoming intractable.

Original: In generatorOracle () , we train π (cid:48)
Revised: In generatorOracle () , we train π (cid:48)

Original: g to obtain the best response against σ t ∗ d , i.e., U t ( π (cid:48) g , σ t ∗ d ) ≥
Revised: g to obtain the best response against σ t ∗ d , i.e., U t ( π (cid:48) g , σ t ∗ d ) ≥

Original: U t ( π g , σ t ∗ d ) , ∀ π g ∈ Π g .
Revised: U t ( π g , σ t ∗ d ) , ∀ π g ∈ Π g .

Original: Similarly, in disciminatorOracle () , we train π (cid:48)
Revised: Similarly, in disciminatorOracle () , we train π (cid:48)

Original: d to obtain the best response against σ t ∗ g , i.e., U t ( σ t ∗ g , π (cid:48)
Revised: d to obtain the best response against σ t ∗ g , i.e., U t ( σ t ∗ g , π (cid:48)

Original: d ) ≥ U t ( σ t ∗ g , π d ) , ∀ π d ∈ Π d .
Revised: d ) ≥ U t ( σ t ∗ g , π d ) , ∀ π d ∈ Π d .

Original: Full details of generator oracle and discriminator oracle can be found in Appendix A.
Revised: Full details of generator oracle and discriminator oracle can be found in Appendix A.

Original: Since the current restricted meta-matrix game U t is a zero-sum game, we can use a linear program to compute the mixed NE in polynomial time (Schrijver, 1998). Given the generator player g ’s mixed strategy σ tg , the discriminator player d will play strategies that minimize the expected utility of g . Thus, the mixed NE strategy for the generator player σ t ∗ g is to maximize the worst-case expected utility, which is obtained by solving the following linear program:
Revised: // Section 4.

Original: [Equation] Similarly, we can obtain the mixed NE strategy for the discriminator σ t ∗ d by solving a linear program that maximizes the worst-case expected utility of the discriminator player. Therefore, we obtain the mixed NE (cid:104) σ t ∗ g , σ t ∗ d (cid:105) of the restricted meta-matrix game U t . // Section 4.
Revised: if TerminationCheck( U t , σ t ∗ g , σ t ∗ d ) then break ; // Section 4.

Original: // Section 4. ( U t , σ t ∗ g , σ t ∗ d ) ; // Section 4.Algorithm
Revised: PruneMetaMatrix( U t , σ t ∗ g , σ t ∗ d ) ; // Section 4.

Original:  U t is of size m × n // | G | = m, | D | = n 1 Compute U t ( σ t ∗ g , σ t ∗ d ) ; 2 Compute U t ( σ t ∗ g , D [ n ]) ; 3 Compute U t ( G [ m ] , σ t ∗ d ) ; 4 genInc =
Revised: // U t is of size m × n // | G | = m, | D | = n 1 Compute U t ( σ t ∗ g , σ t ∗ d ) ; 2 Compute U t ( σ t ∗ g , D [ n ]) ; 3 Compute U t ( G [ m ] , σ t ∗ d ) ; 4 genInc =

Original: U t ( G [ m ] , σ t ∗ d ) − U t ( σ t ∗ g , σ t ∗ d ) ; 5 disInc = − U t ( σ t ∗ g , D [ n ]) − ( − U t ( σ t ∗ g , σ t ∗ d )) ; 6 if genInc < (cid:15) &&disInc < (cid:15) then return True 8 else return False ;Algorithm
Revised: U t ( G [ m ] , σ t ∗ d ) − U t ( σ t ∗ g , σ t ∗ d ) ; 5 disInc = − U t ( σ t ∗ g , D [ n ]) − ( − U t ( σ t ∗ g , σ t ∗ d )) ; 6 if genInc < (cid:15) && return True 8 else return False ;

Original: 1 // I stores indices to be pruned from G and D // G stores models to  from G and D 2{+
+} I g = ∅ ; I d = ∅ 3 K g = ∅ ; K d = ∅ if |G| > s then for i ∈ { 0 , . . .
Revised: 1 // I stores indices to be pruned from G and D // G stores models to be pruned from G and D {+
+} I g = ∅ ; I d = ∅ 3 K g = ∅ ; K d = ∅ if |G| > s then for i ∈ { 0 , . . .

Original: , |G| − 1 } do if σ t ∗ g ( G [ i ])
Revised: , |G| − 1 } do if σ t ∗ g ( G [ i ])

Original: = =
Revised: = =

Original: min σ t ∗ g then I g
Revised: min σ t ∗ g then I g

Original: ← I g ∪ { i } ; K g ← K g ∪ {G [ i ] } ; 6 if |D| > s then for j ∈ { 0 , . .
Revised: ← I g ∪ { i } ; K g ← K g ∪ {G [ i ] } ; 6 if |D| > s then for j ∈ { 0 , . .

Original: . , |D| − 1 } do if σ t ∗ d ( D [ j ]) =
Revised: . , |D| − 1 } do if σ t ∗ d ( D [ j ]) =

Original: =
Revised: =

Original: min σ t ∗ d then I d ← I d ∪ { j } ; K d ← K d ∪ {D [ j ] } ; 9 G ← G \ K g ; D ← D \ K d ; 10 U ← J I g ,m · U t · J TI d ,n
Revised: min σ t ∗ d then I d ← I d ∪ { j } ; K d ← K d ∪ {D [ j ] } ; 9 G ← G \ K g ; D ← D \ K d ; 10 U ← J I g ,m · U t · J TI d ,n

Revised: 4. L INEAR P ROGRAM OF M ETA - MATRIX G AME

Revised: Since the current restricted meta-matrix game U t is a zero-sum game, we can use a linear program to compute the mixed NE in polynomial time (Schrijver, 1998).

Revised: Given the generator player g ’s mixed strategy σ tg , the discriminator player d will play strategies that minimize the expected utility of g .

Revised: Thus, the mixed NE strategy for the generator player σ t ∗ g is to maximize the worst-case expected utility, which is obtained by solving the following linear program:

Original:  4. T ERMINATION C HECK
Revised: [Equation] Similarly, we can obtain the mixed NE strategy for the discriminator σ t ∗ d by solving a linear program that maximizes the worst-case expected utility of the discriminator player. Therefore, we obtain the mixed NE (cid:104) σ t ∗ g , σ t ∗ d (cid:105) of the restricted meta-matrix game U t . 4. T ERMINATION C HECK

Original: DO terminates the training by checking whether the best response π (cid:48) g (or π (cid:48) d ) is in the support set G (or
Revised: DO terminates the training by checking whether the best response π (cid:48) g (or π (cid:48) d ) is in the support set G (or

Original: D ) (Jain et al., 2011), but we cannot apply this approach to DO-GAN as GAN has inﬁnite-dimensional strategy space (Hsieh et al., 2019).
Revised: D ) (Jain et al., 2011), but we cannot apply this approach to DO-GAN as GAN has inﬁnite-dimensional strategy space (Hsieh et al., 2019).

Original: Hence, we terminate the training if the best responses cannot bring a higher utility to the two players than the entries of the current support sets, as discussed in (Lanctot et al., 2017; Muller et al., 2020).
Revised: Hence, we terminate the training if the best responses cannot bring a higher utility to the two players than the entries of the current support sets, as discussed in (Lanctot et al., 2017; Muller et al., 2020).

Original: Speciﬁcally, we ﬁrst compute U t ( σ t ∗ g , σ t ∗ d ) and the expected utilities for new generator and discriminator U t ( G [ m ] , σ t ∗ d ) , U t ( σ t ∗ g , D [ n ]) (line 1-3).
Revised: Speciﬁcally, we ﬁrst compute U t ( σ t ∗ g , σ t ∗ d ) and the expected utilities for new generator and discriminator U t ( G [ m ] , σ t ∗ d ) , U t ( σ t ∗ g , D [ n ]) (line 1-3).

Original: Then, we calculate the utility increment (lines 4-5) and returns True if both U t ( G [ m ] , σ t ∗ d ) and U t ( σ t ∗ g , D [ n ]) cannot bring a higher utility than U t ( σ t ∗ g , σ t ∗ d ) by (cid:15) (lines 6-8).
Revised: Then, we calculate the utility increment (lines 4-5) and returns True if both U t ( G [ m ] , σ t ∗ d ) and U t ( σ t ∗ g , D [ n ]) cannot bring a higher utility than U t ( σ t ∗ g , σ t ∗ d ) by (cid:15) (lines 6-8).

Original: 4. P RUNING M ETA - MATRIX
Revised: 4. P RUNING M ETA - MATRIX

Original: As the meta-matrix grows with every epoch of DO, there is a risk that the support strategy set becomes very large and G and D become intractable.
Revised: As the meta-matrix grows with every epoch of DO, there is a risk that the support strategy set becomes very large and G and D become intractable.

Original: To avoid this, we adapt the greedy pruning algorithm from (Cheng & Wellman, 2007), as depicted in Algorithm 3.
Revised: To avoid this, we adapt the greedy pruning algorithm from (Cheng & Wellman, 2007), as depicted in Algorithm 3.

Original: When either |G| or |D| is greater than the limit of the support set size s , we prune at least one strategy with the least probability, which is the strategy that contributes the least to the player’s winning.
Revised: When either |G| or |D| is greater than the limit of the support set size s , we prune at least one strategy with the least probability, which is the strategy that contributes the least to the player’s winning.

Original: Speciﬁcally, we deﬁne J I,b where I is the set of row numbers to be removed, b is the total rows of a matrix.
Revised: Speciﬁcally, we deﬁne J I,b where I is the set of row numbers to be removed, b is the total rows of a matrix.

Original: To remove the 2 nd row of a matrix having 3 rows, we deﬁne I = { 1 } , b = 3 and J { 1 } , 3 = (cid:18) 1 00 0(cid:19) .
Revised: To remove the 2 nd row of a matrix having 3 rows, we deﬁne I = { 1 } , b = 3 and J { 1 } , 3 = (cid:18) 1 00 0(cid:19) .

Original: If |G| > s , at least one strategy with minimum probability is pruned from G , similarly for D (lines 3-9).
Revised: If |G| > s , at least one strategy with minimum probability is pruned from G , similarly for D (lines 3-9).

Original: Finally, we prune the meta-matrix using matrix multiplication (line 10).
Revised: Finally, we prune the meta-matrix using matrix multiplication (line 10).

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We conduct our experiments on a machine with Xeon(R) CPU E5-2683 v3@2.00GHz and 4 × Tesla v100-PCIE-16GB running Ubuntu operating system.
Revised: We conduct our experiments on a machine with Xeon(R) CPU E5-2683 v3@2.00GHz and 4 × Tesla v100-PCIE-16GB running Ubuntu operating system.

Original: We evaluate the double oracle framework for some established GAN architectures such as vanilla GAN (Goodfellow et al., 2014), DCGAN (Radford et al., 2015), SNGAN (Miyato et al., 2018a) and SGAN (Huang et al., 2017).
Revised: We evaluate the double oracle framework for some established GAN architectures such as vanilla GAN (Goodfellow et al., 2014), DCGAN (Radford et al., 2015), SNGAN (Miyato et al., 2018a) and SGAN (Huang et al., 2017).

Original: We adopt the parameter settings and criterion of the GAN architectures as published.
Revised: We adopt the parameter settings and criterion of the GAN architectures as published.

Original: We set s = 10 unless mentioned otherwise.
Revised: We set s = 10 unless mentioned otherwise.

Original: We compute the mixed NE of the meta-matrix game with Nashpy 1 .
Revised: We compute the mixed NE of the meta-matrix game with Nashpy 1 .

Original: The evaluation details are shown in Appendix B.
Revised: The evaluation details are shown in Appendix B.

Original:  E VALUATION ON S YNTHETIC 2D G AUSSIAN M IXTURE D ATASET
Revised: 5. E VALUATION ON S YNTHETIC 2D G AUSSIAN M IXTURE D ATASET

Original: To illustrate the effectiveness of the architecture, we train a double oracle framework with the simple vanilla GAN architecture on a 2D mixture of 8 Gaussian mixture components with cluster standard deviation 0 .
Revised: To illustrate the effectiveness of the architecture, we train a double oracle framework with the simple vanilla GAN architecture on a 2D mixture of 8 Gaussian mixture components with cluster standard deviation 0 .

Original: 1 which follows the experiment by (Metz et al., 2017).
Revised: 1 which follows the experiment by (Metz et al., 2017).

Original: Figure 2 shows the evolution of 512 samples generated by GAN and DO-GAN through 20000 epochs.
Revised: Figure 2 shows the evolution of 512 samples generated by GAN and DO-GAN through 20000 epochs.

Original: The goal of GAN and
Revised: The goal of GAN and

Original: DO-GAN is to correctly generate samples at 8 modes as shown in the target.
Revised: DO-GAN is to correctly generate samples at 8 modes as shown in the target.

Original: The results show that GAN can only identify 6 out of 8 modes of the synthetic Gaussian data distribution, while the
Revised: The results show that GAN can only identify 6 out of 8 modes of the synthetic Gaussian data distribution, while the

Original: DO-GAN can obtain all the 8 modes of the distribution.
Revised: DO-GAN can obtain all the 8 modes of the distribution.

Original: Furthermore, DO-GAN takes shorter time (less than 5000 epochs) to identify all 8 modes of the data distribution.
Revised: Furthermore, DO-GAN takes shorter time (less than 5000 epochs) to identify all 8 modes of the data distribution.

Original: We present a more detailed evolution of data samples through the training process on 2D Gaussian Mixtures in Appendix C.
Revised: We present a more detailed evolution of data samples through the training process on 2D Gaussian Mixtures in Appendix C.

Original: Ablations.
Revised: Ablations.

Original: We also varied the support set size of the training s = 5 , 10 , 15 and recorded the computation time as discussed in Appendix D.
Revised: We also varied the support set size of the training s = 5 , 10 , 15 and recorded the computation time as discussed in Appendix D.

Original: We found that the training cannot converge when s = 5 and takes a long time when s = 15 .
Revised: We found that the training cannot converge when s = 5 and takes a long time when s = 15 .

Original: Thus, we chose s = 10 for the training process.
Revised: Thus, we chose s = 10 for the training process.

Original: 5. E VALUATION ON R EAL - WORLD D ATASETS
Revised: 5. E VALUATION ON R EAL - WORLD D ATASETS

Original: We evaluate the performance of the double oracle framework which takes several established GAN architectures as the backbone as discussed in Appendix G, i.e., GAN (Goodfellow et al., 2014),
Revised: We evaluate the performance of the double oracle framework which takes several established GAN architectures as the backbone as discussed in Appendix G, i.e., GAN (Goodfellow et al., 2014),

Original: DCGAN (Radford et al., 2015) and SGAN (Huang et al., 2017) with convolutional layers for the deep neural networks of GAN as well as SNGAN (Miyato et al., 2018a) which uses normalization techniques.
Revised: DCGAN (Radford et al., 2015) and SGAN (Huang et al., 2017) with convolutional layers for the deep neural networks of GAN as well as SNGAN (Miyato et al., 2018a) which uses normalization techniques.

Original: We run experiments on MNIST (LeCun & Cortes, 2010), CIFAR-10 (Krizhevsky et al., 2009) and CelebA (Liu et al., 2015) datasets.
Revised: We run experiments on MNIST (LeCun & Cortes, 2010), CIFAR-10 (Krizhevsky et al., 2009) and CelebA (Liu et al., 2015) datasets.

Original: MNIST contains 60,000 samples of handwritten digits with images of 28 × 28 .
Revised: MNIST contains 60,000 samples of handwritten digits with images of 28 × 28 .

Original: CIFAR-10 contains 50 , 000 training images of 32 × 32 of 10 classes.
Revised: CIFAR-10 contains 50 , 000 training images of 32 × 32 of 10 classes.

Original: CelebA is a large-scaled face dataset with more than 200 K images of size 128 × 128 .[Figure]
Revised: CelebA is a large-scaled face dataset with more than 200 K images of size 128 × 128 .

Original: 5.2. Q UALITATIVE E VALUATION
Revised: 5.2. Q UALITATIVE E VALUATION

Original: We choose the CelebA dataset for the qualitative evaluation since the training images contain noticeable artifacts (aliasing, compression, blur) that make the generator difﬁcult to produce perfect and faithful images.
Revised: We choose the CelebA dataset for the qualitative evaluation since the training images contain noticeable artifacts (aliasing, compression, blur) that make the generator difﬁcult to produce perfect and faithful images.

Original: We compare the performance of DO-DCGAN and DO-SGAN with their counterparts 2 .
Revised: We compare the performance of DO-DCGAN, DO-SNGAN and DO-SGAN with their counterparts 2 .

Revised: SNGAN which is trained for 40 epochs with termination (cid:15) of 5 × 10 − 5 for

Original: Each architecture is trained for 25 epochs with termination (cid:15) of 5 × 10 − 5 for the double oracle variants.
Revised: DO-SNGAN where other architectureas are trained for 25 epochs with termination (cid:15) of 5 × 10 − 5 for the double oracle variants.

Original: The generated CelebA images of DCGAN and DO-DCGAN are shown in
Revised: The generated CelebA images of DCGAN and DO-DCGAN are shown in

Original: Figure 3, where we ﬁnd that DCGAN suffers mode-collapse, while DO-DCGAN does not.
Revised: Figure 3, where we ﬁnd that DCGAN suffers mode-collapse, while DO-DCGAN does not.

Original: We also present the generated images of SGAN and  DO-SGAN using ﬁxed noise at different training epochs in Figure 4.
Revised: We also present the generated images of SNGAN vs DO-SNGAN and SGAN vs DO-SGAN using ﬁxed noise at different training epochs in Figure 4 and 5.

Original: From the results, we can see that both SGAN and DO-SGAN are able to generate various faces, i.e., no mode-collapse.
Revised: From the results, we can see that SNGAN, SGAN, DO-SNGAN and DO-SGAN are able to generate various faces, i.e., no mode-collapse.

Original: Judging from subjective visual quality, we ﬁnd that  DO-SGAN is able to generate plausible images faster than  SGAN during training, i.e., 17 epochs for DO-SGAN and 20 epochs for SGAN.
Revised: Judging from subjective visual quality, we ﬁnd that DO-SNGAN and DO-SGAN are able to generate plausible images faster than SNGAN and SGAN during training, i.e., 17 epochs for DO-SGAN and 20 epochs for SGAN.

Original: More experiment results on CIFAR-10as well as SNGAN, DO-SNGAN on CelebA datasets can be found in Appendix E.
Revised: More experiment results on CIFAR-10 can be found in Appendix E.

Original: 5.2. Q UANTITATIVE E VALUATION
Revised: 5.2. Q UANTITATIVE E VALUATION

Original: In this section, we evaluate the performance of various architectures by quantitative metrics.
Revised: In this section, we evaluate the performance of various architectures by quantitative metrics.

Original: Inception Score.
Revised: Inception Score.

Original: We ﬁrst leverage the Inception Score (IS) (Salimans et al., 2016) by using
Revised: We ﬁrst leverage the Inception Score (IS) (Salimans et al., 2016) by using

Original: Inception_v3 (Szegedy et al., 2016) as the inception model.
Revised: Inception_v3 (Szegedy et al., 2016) as the inception model.

Original: To compute the inception score, we ﬁrst compute the Kullback-Leibler (KL) divergence for all generated images and use the equation
Revised: To compute the inception score, we ﬁrst compute the Kullback-Leibler (KL) divergence for all generated images and use the equation

Original: IS =
Revised: IS =

Original: exp( E x [ KL ( D ( p ( y | x ) (cid:107) p ( y )))]) where p ( y ) is the conditional label distributions for the images in the split and p ( y | x ) is that of the image x estimated by the reference inception model.
Revised: exp( E x [ KL ( D ( p ( y | x ) (cid:107) p ( y )))]) where p ( y ) is the conditional label distributions for the images in the split and p ( y | x ) is that of the image x estimated by the reference inception model.

Original: Inception score evaluates the quality and diversity of all generated images rather than the similarity to the real data from the test set.
Revised: Inception score evaluates the quality and diversity of all generated images rather than the similarity to the real data from the test set.

Original: FID Score.
Revised: FID Score.

Original: Fréchet Inception Distance (FID) measures the distance between the feature vectors of real and generated images using Inception_v3 model (Heusel et al., 2017).
Revised: Fréchet Inception Distance (FID) measures the distance between the feature vectors of real and generated images using Inception_v3 model (Heusel et al., 2017).

Original: Here, we let p and q be the distributions of the representations obtained by projecting real and generated samples to the last hidden layer of Inception model.
Revised: Here, we let p and q be the distributions of the representations obtained by projecting real and generated samples to the last hidden layer of Inception model.

Original: Assuming that p and q are the multivariate Gaussian distributions,
Revised: Assuming that p and q are the multivariate Gaussian distributions,

Original: FID measures the 2-Wasserstein distance between the two distributions.
Revised: FID measures the 2-Wasserstein distance between the two distributions.

Original: Hence, FID Score can capture the similarity of generated images to real ones better than the Inception score.
Revised: Hence, FID Score can capture the similarity of generated images to real ones better than the Inception score.

Original: [Table]
Revised: [Table]

Original: Results.
Revised: Results.

Original: The results are shown in Table 1.
Revised: The results are shown in Table 2.

Original: In CIFAR-10 dataset, DO-GAN, DO-DCGAN and
Revised: In CIFAR-10 dataset, DO-GAN, DO-DCGAN and

Original: DO-SNGAN obtain much better results ( 7 . 2 ± 0 .
Revised: DO-SNGAN obtain much better results ( 7 . 2 ± 0 .

Original: 16 , 7 . 86 ± 0 .
Revised: 16 , 7 . 86 ± 0 .

Original: 14 and 8 .
Revised: 14 and 8 .

Original: 55 ± 0 . 08 ) than GAN, DCGAN and SNGAN ( 3 . 84 ± 0 .
Revised: 55 ± 0 . 08 ) than GAN, DCGAN and SNGAN ( 3 . 84 ± 0 .

Original: 32 ± 0 . 05 and 7 .
Revised: 32 ± 0 . 05 and 7 .

Original: 58 ± 0 . 12 ).
Revised: 58 ± 0 . 12 ).

Original: However, we do not see a signiﬁcant improvement in DO-SGAN compared to SGAN 8 .
Revised: However, we do not see a signiﬁcant improvement in DO-SGAN compared to SGAN 8 .

Original: 62 ± 0 .
Revised: 62 ± 0 .

Original: 12 and 8 .
Revised: 12 and 8 .

Original: 69 ± 0 .
Revised: 69 ± 0 .

Original: 10 since SGAN already can generate diverse images.
Revised: 10 since SGAN already can generate diverse images.

Original: We did not include IS for CelebA dataset as IS cannot reﬂect the real image quality for the CelebA, as observed in (Heusel et al., 2017).
Revised: We did not include IS for CelebA dataset as IS cannot reﬂect the real image quality for the CelebA, as observed in (Heusel et al., 2017).

Original: In CIFAR-10 dataset, DO-GAN,
Revised: In CIFAR-10 dataset, DO-GAN,

Original: DO-DCGAN, DO-SNGAN and DO-SGAN obtain much higher FID scores ( 31 . 44 , 22 . 25 , 16 . 56 , 18 . 20 ) respectively.
Revised: DO-DCGAN, DO-SNGAN and DO-SGAN obtain much lower FID scores ( 31 . 44 , 22 . 25 , 16 . 56 , 18 . 20 ) respectively.

Original: The trend follows in CelebA obtaining 7 . 11 for DO-DCGAN while 10 . 92 for
Revised: The trend follows in CelebA obtaining 7 . 11 for DO-DCGAN while 10 . 92 for

Original: DCGAN, 7 . 62 for SNGAN while 6 . 92 for DO-SNGAN, 6 . 98 for SGAN and 6 .
Revised: DCGAN, 7 . 62 for SNGAN while 6 . 92 for DO-SNGAN, 6 . 98 for SGAN and 6 .

Original: 32 for DO-SGAN respectively.
Revised: 32 for DO-SGAN respectively.

Original: Although we see a signiﬁcant improvement in the quality of DO-SGAN images, FID score for DO-SGAN is affected by the distortions.
Revised: Although we see a signiﬁcant improvement in the quality of DO-SGAN images, FID score for DO-SGAN is affected by the distortions.

Original: According to the results, we can see that DO framework performs better than each of their original counterpart architectures.
Revised: According to the results, we can see that DO framework performs better than each of their original counterpart architectures.

Original: More details can be found in Appendix F.
Revised: More details can be found in Appendix F.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We propose a novel double oracle framework to GANs, which starts with a restricted game and incrementally adds the best responses of the generator and the discriminator to compute the mixed NE.
Revised: We propose a novel double oracle framework to GANs, which starts with a restricted game and incrementally adds the best responses of the generator and the discriminator to compute the mixed NE.

Original: We then compute the players’ meta-strategies by using a linear program.
Revised: We then compute the players’ meta-strategies by using a linear program.

Original: We also prune the support strategy set of players.
Revised: We also prune the support strategy set of players.

Original: We apply DO-GAN approach to established GAN architectures such as vanilla
Revised: We apply DO-GAN approach to established GAN architectures such as vanilla

Original: GAN, DCGAN, SNGAN and SGAN.
Revised: GAN, DCGAN, SNGAN and SGAN.

Original: Extensive experiments with the 2D Gaussian synthetic data set as well as real-world datasets such as MNIST, CIFAR-10 and CelebA show that DO-GAN variants have signiﬁcant improvements in comparison to their respective GAN architectures both in terms of subjective image quality as well as in terms ofquantitative metrics.
Revised: Extensive experiments with the 2D Gaussian synthetic data set as well as real-world datasets such as MNIST, CIFAR-10 and CelebA show that DO-GAN variants have signiﬁcant improvements in comparison to their respective GAN architectures both in terms of subjective image quality as well as in terms of

Original: A F ULL A LGORITHM OF DO-GAN
Revised: A F ULL A LGORITHM OF DO-GAN

Original: [Equation] We train the oracles for some iterations which we denote as k 0 , 1 , 2 ,... .
Revised: We train the oracles for some iterations which we denote as k 0 , 1 , 2 ,... .

Original: For experiments, we train each oracle for an epoch for the real-world datasets and 50 iterations for the 2D Synthetic Gaussian
Revised: For experiments, we train each oracle for an epoch for the real-world datasets and 50 iterations for the 2D Synthetic Gaussian

Original: Dataset.
Revised: Dataset.

Original: At each iteration t , we sample the generators from the support set G with the meta-strategy σ t ∗ g to generate the images for evaluation.
Revised: At each iteration t , we sample the generators from the support set G with the meta-strategy σ t ∗ g to generate the images for evaluation.

Original: Similarly, we conduct the performance evaluation with the generators sampled from G with the ﬁnal σ ∗ g at termination.
Revised: Similarly, we conduct the performance evaluation with the generators sampled from G with the ﬁnal σ ∗ g at termination.

Original: SGAN consists of a top-down stack of
Revised: SGAN consists of a top-down stack of

Original: GANs, e.g, for a stack of 2, Generator 1 is the ﬁrst layer stacked on Generator 0 with each of them connected to Discriminator 1 and 0 respectively.
Revised: GANs, e.g, for a stack of 2, Generator 1 is the ﬁrst layer stacked on Generator 0 with each of them connected to Discriminator 1 and 0 respectively.

Original: Hence, in DO-SGAN, we store the meta-strategies for the Generator 0 and 1 in σ t ∗ g and the Discriminator 1 and 0 for σ t ∗ d .
Revised: Hence, in DO-SGAN, we store the meta-strategies for the Generator 0 and 1 in σ t ∗ g and the Discriminator 1 and 0 for σ t ∗ d .

Original: In GeneratorOracle () , we ﬁrst sample Discriminator 1 and 0 from discriminator distribution σ t ∗ d and train Generator 1 ﬁrst then followed by calculating loss with Discriminator 1 and train Generator 0 subsequently, and ﬁnally calculate ﬁnal loss with Discriminator 0 and train the whole model end to end.
Revised: In GeneratorOracle () , we ﬁrst sample Discriminator 1 and 0 from discriminator distribution σ t ∗ d and train Generator 1 ﬁrst then followed by calculating loss with Discriminator 1 and train Generator 0 subsequently, and ﬁnally calculate ﬁnal loss with Discriminator 0 and train the whole model end to end.

Original: We perform the same process for DisciminatorOracle () .
Revised: We perform the same process for DisciminatorOracle () .

Original: B I MPLEMENTATION D ETAILS
Revised: B I MPLEMENTATION D ETAILS

Original: [Table]
Revised: [Table]

Original: We implement our proposed method with Python 3.7, Pytorch=1.4.0 and Torchvision=0.5.0.
Revised: We implement our proposed method with Python 3.7, Pytorch=1.4.0 and Torchvision=0.5.0.

Original: We set the hyperparameters as the original implementations.
Revised: We set the hyperparameters as the original implementations.

Original: We present the hyperparameters set in Table 2.
Revised: We present the hyperparameters set in Table 3.

Original: We use Nashpy to compute the equilibria of the meta-matrix game.
Revised: We use Nashpy to compute the equilibria of the meta-matrix game.

Original: C F ULL T RAINING P ROCESS OF 2D G AUSSIAN D ATASET
Revised: C F ULL T RAINING P ROCESS OF 2D G AUSSIAN D ATASET

Original: [Figure]
Revised: [Figure]

Original: Figure 5 shows the full training process of DO-GAN and GAN on 2D Synthetic Gaussian Dataset.
Revised: Figure 6 shows the full training process of DO-GAN and GAN on 2D Synthetic Gaussian Dataset.

Original: From the results, we ﬁnd that GAN struggles to generate the samples into 8 modes while DO-GAN can generate all the 8 modes of the distribution.
Revised: From the results, we ﬁnd that GAN struggles to generate the samples into 8 modes while DO-GAN can generate all the 8 modes of the distribution.

Original: Furthermore, DO-GAN takes shorter time (less than 5000 iterations) to identify all 8 modes of the data distribution.
Revised: Furthermore, DO-GAN takes shorter time (less than 5000 iterations) to identify all 8 modes of the data distribution.

Original: Moreover, we present the experiment results on 7 mode and 9-mode Gaussian Mixtures in Figure 6 and 7.
Revised: Moreover, we present the experiment results on 7 mode and 9-mode Gaussian Mixtures in Figure 7 and 8.

Original: D I NVESTIGATION OF S UPPORT S ET S IZE
Revised: D I NVESTIGATION OF S UPPORT S ET S IZE

Original: We vary the support set size s to 5 , 10 , 15 and record the training evolution and the running time as presented in Table 3 and Figure 8.
Revised: We vary the support set size s to 5 , 10 , 15 and record the training evolution and the running time as presented in Table 4 and Figure 9.

Original: We ﬁnd that if the support size is too small, e.g., s = 5 , the best responses which are not optimal yet have better utilities than the models in the support set are added and pruned from the meta-matrix repeatedly making the training not able to converge.
Revised: We ﬁnd that if the support size is too small, e.g., s = 5 , the best responses which are not optimal yet have better utilities than the models in the support set are added and pruned from the meta-matrix repeatedly making the training not able to converge.

Original: However, s = 15 takes a signiﬁcantly longer time as the time for the augmenting of meta-matrix becomes exponentially long with the support set size.
Revised: However, s = 15 takes a signiﬁcantly longer time as the time for the augmenting of meta-matrix becomes exponentially long with the support set size.

Original: Hence, we chose s = 10 as our experiment support set size since we observed that there is no signiﬁcant trade-off and shorter runtime.
Revised: Hence, we chose s = 10 as our experiment support set size since we observed that there is no signiﬁcant trade-off and shorter runtime.

Original: [Table]
Revised: [Table]

Original: E G ENERATED IMAGES OF C ELEB A AND CIFAR- 
Revised: E G ENERATED IMAGES OF C ELEB A AND CIFAR-

Original: In this section, we present the training images of CelebA and CIFAR-10 datasets.
Revised: In this section, we present the training images of CelebA and CIFAR-10 datasets.

Original: Figure 9 shows the training samples of DO-DCGAN and DO-DCGAN through the training process.
Revised: Figure 10 shows the training samples of DO-DCGAN and DO-DCGAN through the training process.

Original: Figure 10 also shows those of SNGAN which is trained for 40 epochs with termination (cid:15) of 5 × 10 −for DO-SNGAN.
Revised: Figure 11 also shows those of SNGAN which is trained for 40 epochs with termination (cid:15) of 5 × 10 −for DO-SNGAN.

Original: The results show that DCGAN suffers from mode-collapse, generating similar face while DO-DCGAN can generate more plausible and varying faces.
Revised: The results show that DCGAN suffers from mode-collapse, generating similar face while DO-DCGAN can generate more plausible and varying faces.

Original: We also present the generated images of DCGAN, DO-DCGAN, SNGAN, DO-SNGAN, SGAN and DO-SGAN of CIFARdataset showing that DO-DCGAN, DO-SNGAN and DO-SGAN can generate better and more identiﬁable images than DCGAN, SNGAN and SGAN respectively.
Revised: We also present the generated images of DCGAN, DO-DCGAN, SNGAN, DO-SNGAN, SGAN and DO-SGAN of CIFARdataset showing that DO-DCGAN, DO-SNGAN and DO-SGAN can generate better and more identiﬁable images than DCGAN, SNGAN and SGAN respectively.

Original: We present more of the generated samples from SNGAN, DO-SNGAN, SGAN and DO-SGAN onCelebA dataset in Figure 12.
Revised: We present more of the generated samples from SNGAN, DO-SNGAN, SGAN and DO-SGAN on

Original: [Figure]
Revised: [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: F FID SCORE AGAINST ITERATIONS
Revised: F FID SCORE AGAINST ITERATIONS

Original: To compute FID score, we use Inception_v3 model with max pool of 192 dimensions and the last layer as coding layer as mentioned in (Heusel et al., 2017).
Revised: To compute FID score, we use Inception_v3 model with max pool of 192 dimensions and the last layer as coding layer as mentioned in (Heusel et al., 2017).

Original: We resized MNIST, CIFAR-10 generated and test images to 32 × 32 and CelebA images to 64 × 64 .
Revised: We resized MNIST, CIFAR-10 generated and test images to 32 × 32 and CelebA images to 64 × 64 .

Original: The FID score against training epochs for
Revised: The FID score against training epochs for

Original: CIFAR-10 dataset is as follows:
Revised: CIFAR-10 dataset is as follows:

Original: [Figure]
Revised: [Figure]

Original: Figure 13 presents the FID score against each epoch of training for SGAN and DO-SGAN on CIFAR10.
Revised: Figure 14 presents the FID score against each epoch of training for SGAN and DO-SGAN on CIFAR10.

Original: While both perform relatively well in generating plausible images, we can see that DO-SGAN terminates early at epoch 288 and has a better FID score of 16 .
Revised: While both perform relatively well in generating plausible images, we can see that DO-SGAN terminates early at epoch 288 and has a better FID score of 16 .

Original: 56 compared to 24 .
Revised: 56 compared to 24 .

Original: at 300 epoch until 21 .
Revised: at 300 epoch until 21 .

Original: 284 at 500 epoch for the training of SGAN.
Revised: 284 at 500 epoch for the training of SGAN.

Original: G C HOICE OF GAN A RCHITECTURES FOR E XPERIMENTS
Revised: G C HOICE OF GAN A RCHITECTURES FOR E XPERIMENTS

Original: We carried out experiments with the variants of GANs to evaluate the performance of our DO-GAN framework.
Revised: We carried out experiments with the variants of GANs to evaluate the performance of our DO-GAN framework.

Original: We refer to the taxonomy of GANs (Wang et al., 2019) and choose each architecture from the groups of GANs focused on Network Architecture, Latent Space and Loss: DCGAN, SNGAN and SGAN as shown in Figure 14.
Revised: We refer to the taxonomy of GANs (Wang et al., 2019) and choose each architecture from the groups of GANs focused on Network Architecture, Latent Space and Loss: DCGAN, SNGAN and SGAN as shown in Figure 15.

Original: We have also included comparisons with mixture architectures such as MIXGAN and MGAN.
Revised: We have also included comparisons with mixture architectures such as MIXGAN and MGAN.

Original: H E XAMPLE OF M ETA - MATRIX WITH 5 GENERATORS AND 5 DISCRIMINATORS
Revised: H E XAMPLE OF M ETA - MATRIX WITH 5 GENERATORS AND 5 DISCRIMINATORS

Original: [Table]
Revised: [Table]