S TOCHASTIC C ONDITIONAL G ENERATIVE N ETWORKS WITH B ASIS D ECOMPOSITION
Anonymous authors
Paper under double-blind review
A BSTRACT
While generative adversarial networks (GANs) have revolutionized machine learning, a number of open questions remain to fully understand them and exploit their power.
One of these questions is how to efﬁciently achieve proper diversity and sampling of the multi-mode data space.
To address this, we introduce BasisGAN, a stochastic conditional multi-mode image generator.
By exploiting the observation that a convolutional ﬁlter can be well approximated as a linear combination of a small set of basis elements, we learn a plug-and-played basis generator to stochastically generate basis elements, with just a few hundred of parameters, to fully embed stochasticity into convolutional ﬁlters.
By sampling basis elements instead of ﬁlters, we dramatically reduce the cost of modeling the parameter space with no sacriﬁce on either image diversity or ﬁdelity.
To illustrate this proposed plug-and-play framework, we construct variants of BasisGAN based on state-ofthe-art conditional image generation networks, and train the networks by simply plugging in a basis generator, without additional auxiliary components, hyperparameters, or training objectives.
The experimental success is complemented with theoretical results indicating how the perturbations introduced by the proposed sampling of basis elements can propagate to the appearance of generated images.
I NTRODUCTION
Conditional image generation networks learn mappings from the condition domain to the image domain by training on massive samples from both domains.
The mapping from a condition, e.g., a map, to an image, e.g., a satellite image, is essentially one-to-many as illustrated in Figure 1.
In other words, there exists many plausible output images that satisfy a given input condition, which motivates us to explore multi-mode conditional image generation that produces diverse images conditioned on one single input condition.
One technique to improve image generation diversity is to feed the image generator with an additional latent code in the hope that such code can carry information that is not covered by the input condition, so that diverse output images are achieved by decoding the missing information conveyed through different latent codes.
However, as illustrated in the seminal work Isola et al.
(2017), encoding the diversity with an input latent code can lead to unsatisfactory performance for the following reasons.
While training using objectives like GAN loss Goodfellow et al.
(2014), regularizations like L1 loss Isola et al.
and perceptual loss Wang et al.
(2018) are imposed to improve both visual ﬁdelity and correspondence to the input condition.
However, no similar regularization is imposed to enforce the correspondence between outputs and latent codes, so that the network is prone to ignore input latent codes in training, and produce identical images from an input condition even with different latent codes.
Several methods are proposed to explicitly encourage the network to take into account input latent codes to encode diversity.
For example, Mao et al.
(2019) explicitly maximizes the ratio of the distance between generated images with respect to the corresponding latent codes; while Zhu et al.
(2017b) applies an auxiliary network for decoding the latent codes from the generative images.
Although the diversity of the generative images is signiﬁcantly improved, these methods experience drawbacks.
In Mao et al.
(2019), at least two samples generated from the same condition are needed for calculating the regularization term, which multiplies the memory footprint while training each mini-batch.
Auxiliary network structures and training objectives in Zhu et al.
(2017b) unavoidably increase training difﬁculty and memory footprint.
These previously proposed methods usually require considerable modiﬁcations to the underlying framework.
z
SampledBases " L × L × K (cid:1) K
C C ′ B
a s
i s
G e n e r a t o r
F ilt e r
R ec on s t r u c ti on
BasisGenerator a # $
D e t e r m i n i s ti c
S ub - m od e l
S t o c h
a s ti c
S ub - m od e l
GeneratedImageswithDifferentFilters
InputCondition w
Convolve
Convolve wz
SampledBases " L × L × K (cid:1) K
C C ′ B
a s
i s
G e n e r a t o r
F ilt e r
R ec on s t r u c ti on
BasisGenerator a # $
Ground Truth
In this paper, we propose a stochastic model, BasisGAN , that directly maps an input condition to diverse output images, aiming at building networks that model the multi-mode intrinsically.
The proposed method exploits a known observation that a well-trained deep network can converge to signiﬁcantly different sets of parameters across multiple trainings, due to factors such as different parameter initializations and different choices of mini-batches.
Therefore, instead of treating a conditional image generation network as a deterministic function with ﬁxed parameters, we propose modeling the ﬁlter in each convolutional layer as a sample from ﬁlter space, and learning the corresponding ﬁlter space using a tiny network for efﬁcient and diverse ﬁlter sampling.
In Ghosh et al.
(2018), parameter non-uniqueness is used for multi-mode image generation by training several generators with different parameters simultaneously as a multi-agent solution.
However, the maximum modes of Ghosh et al.
(2018) are restricted by the number of agents, and the replication increases memory as well as computational cost.
Based on the above parameters non-uniqueness property, we introduce into a deep network stochastic convolutional layers, where ﬁlters are sampled from learned ﬁlter spaces.
Speciﬁcally, we learn the mapping from a simple prior to the ﬁlter space using neural networks, here referred to as ﬁlter generators .
To empower a deterministic network with multi-mode image generation, we divide the network into a deterministic sub-model and a stochastic sub-model as shown in Figure 1, where standard convolutional layers and stochastic convolutional layers with ﬁlter generators are deployed, respectively.
By optimizing an adversarial loss, ﬁlter generators can be jointly trained with a conditional image generation network.
In each forward pass, ﬁlters at stochastic layers are sampled by ﬁlter generators.
Highly diverse images conditioned on the same input are achieved by jointly sampling of ﬁlters in multiple stochastic convolutional layers.
However, ﬁlters of a convolutional layer are usually high-dimensional while being together written as one vector, which makes the modeling and sampling of a ﬁlter space highly costly in practice in terms of training time, sampling time, and ﬁlter generator memory footprint.
Based on the low-rank property observed from sampled ﬁlters, we decompose each ﬁlter as a linear combination of a small set of basis elements Qiu et al.
(2018), and propose to only sample low-dimensional spatial basis elements instead of ﬁlters.
By replacing ﬁlter generators with basis generators , the proposed method becomes highly efﬁcient and practical.
Theoretical arguments are provided on how perturbations introduced by sampling basis elements can propagate to the appearance of generated images.
The proposed BasisGAN introduces a generalizable concept to promote diverse modes in the conditional image generation.
As basis generators act as plug-and-play modules, variants of BasisGAN can be easily constructed by replacing in various state-of-the-art conditional image generation networks the standard convolutional layers by stochastic layers with basis generators.
Then, we directly train them without additional auxiliary components, hyperparameters, or training objectives on top of the underlying models.
Experimental results consistently show that the proposed BasisGAN is a simple yet effective solution to multi-mode conditional image generation.
We further empirically show that the inherent stochasticity introduced by our method allows training without paired sam- ples, and the one-to-many image-to-image translation is achieved using a stochastic auto-encoder where stochasticity prevents the network from learning a trivial identity mapping.
Our contributions are summarized as follows:
• We propose a plug-and-played basis generator to stochastically generate basis elements, with just a few hundred of parameters, to fully embed stochasticity into network ﬁlters.
• Theoretic arguments are provided to support the simpliﬁcation of replacing stochastic ﬁlter generation with basis generation.
• Both the generation ﬁdelity and diversity of the proposed BasisGAN with basis generators are validated extensively, and state-of-the-art performances are consistently observed.
R ELATED W ORK
Conditional image generation.
Parametric modeling of the natural image distribution has been studied for years, from restricted Boltzmann machines Smolensky (1986) to variational autoencoders Kingma & Welling (2013); in particular variants with conditions Oord et al.
; Sohn et al.
; Van den Oord et al.
(2016) show promising results.
With the great power of GANs
Goodfellow et al.
(2014), conditional generative adversarial networks (cGANs) Isola et
al.
Pathak et al.
; Sangkloy et al.
; Wang et al.
; Xian et al.
Zhu et al.
(2017a) achieve great progress on visually appealing images given conditions.
However, the quality of images and the loyalty to input conditions come with sacriﬁce on image diversity as discussed in Zhu et al.
(2017b), which is addressed by the proposed BasisGAN.
Multi-mode conditional image generation.
To enable the cGANs with multi-mode image generation, pioneer works like infoGAN Chen et al.
and pix2pix Isola et al.
(2017) propose to encode the diversity in an input latent code.
To enforce the networks to take into account input latent codes, Zhu et al. (2017b) deploys auxiliary networks and training objectives to impose the recovery of the input latent code from the generated images.
MSGAN Mao et al.
(2019) and DSGAN Yang et al.
(2019) propose regularization terms for diversity that enforces a larger distance between generated images with respect to different input latent codes given one input condition.
These methods require considerable modiﬁcations to the underlying original framework.
Neural network parameters generating and uncertainty.
Extensive studies have been conducted for generating network parameters using another network since Hypernetworks Ha et al.
As a seminal work on network parameter modeling, Hypernetworks successfully reduce learnable parameters by relaxing weight-sharing across layers.
Followup works like Bayesian Hypernetworks Krueger et al.
(2017) further introduce uncertainty to the generated parameters.
Variational inference based methods like Bayes by Backprop Blundell et al.
(2015) solve the intractable posterior distribution of parameters by assuming a prior (usually Gaussian).
However, the assumed prior unavoidably degrades the expressiveness of the learned distribution.
The parameter prediction of neural network is intensively studied under the context of few shot learning Bertinetto et al.
; Qiao et al.
; Wang et al.
(2019), which aims to customize a network to a new task adaptively and efﬁciently in a data-driven way.
Apart from few shot learning, Denil et al.
(2013) suggests parameter prediction as a way to study the redundancy in neural networks.
While studying the representation power of random weights, Saxe et al.
(2011) also suggests the uncertainty and non-uniqueness of network parameters.
Another family of network with uncertainty is based on variational inference Blundell et al.
(2015), where an assumption of the distribution on network weights is imposed for a tractable learning on the distribution of weights.
Works on studying the relationship between local and global minima of deep networks Haeffele & Vidal (2015); Vidal et al.
(2017) also suggest the non-uniqueness of optimal parameters of a deep network.
S TOCHASTIC F ILTER G ENERATION
A conditional generative network (cGAN) Mirza & Osindero (2014) learns the mapping from input condition domain A to output image domain B using a deep neural network.
The conditional image generation is essentially a one-to-many mapping as there could be multiple plausible instances
B ∈ B that map to a condition
A ∈
A Zhu et al.
(2017b),
corresponding to a distribution p ( B | A ) .
However, the naive mapping of the generator formulated by a neural network G : A → B is deterministic, and is incapable of covering the distribution p ( B | A ) .
We exploit the non-uniqueness of network parameters as discussed above, and introduce stochasticity into convolutional ﬁlters through plug-and-play ﬁlter generators .
To achieve this, we divide a network into two sub-models:
• A deterministic sub-model with convolutional ﬁlters φ that remain ﬁxed after training; • A stochastic sub-model whose convolutional ﬁlters w are sampled from parameter spaces modeled by neural networks T , referred to as ﬁlter generators, parametrized by θ with inputs z from a prior distribution, e.g., N (0 , I ) for all experiments in this paper.
Note that ﬁlters in each stochastic layer are modeled with a separate neural network, which is not explicitly shown in the formulation for notation brevity.
With this formulation, the conditional image generation becomes G φ,θ : A → B , with stochasticity achieved by sampling ﬁlters w = T θ ( z ) for the stochastic sub-model in each forward pass.
The conditional GAN loss Goodfellow et al.
Mirza & Osindero (2014) then becomes
[Equation]
where D denotes a standard discriminator.
Note that we represent the generator here as
G φ,θ ( A ; T θ ( z )) to emphasize that the generator uses stochastic ﬁlters w = T θ ( z ) .
Given a stochastic generative network parametrized by φ and θ , and input condition A , the generated images form a conditional probability q φ,θ ( B | A ) , so that (1) can be simpliﬁed as
[Equation]
When the optimal discriminator is achieved, (2) can be reformulated as
[Equation]
where JSD is the Jensen-Shannon divergence (the proof is provided in the supplementary material).
The global minimum of (3) is achieved when given every sampled condition A , the generator perfectly replicates the true distribution p ( B | A ) , which indicates that by directly optimizing the loss in (1), conditional image generation with diversity is achieved with the proposed stochasticity in the convolutional ﬁlters.
To optimize (1), we train D as in Goodfellow et al.
(2014) to maximize the probability of assigning the correct label to both training examples and samples from G φ,θ .
Simultaneously, we train G φ,θ to minimize the following loss, where ﬁlter generators T θ are jointly optimized to bring stochasticity:
[Equation]
We describe in detail the optimization of the generator parameters { φ, θ } in supplementary material Algorithm 1.
Discussions on diversity modeling in cGANs.
The goal of cGAN is to model the conditional probability p
( B | A ) .
Previous cGAN models Mao et al.
; Mirza & Osindero (2014);
Zhu et al.
(2017b) typically incorporate randomness in the generator by setting B =
G ( A , z ) , z ∼ p ( z ) , where G is a deep network with deterministic parametrization and the randomness is introduced via z , e.g., a latent code, as an extra input .
This formulation implicitly makes the following two assumptions: (A1)
The randomness of the generator is independent from that of p ( A ) ; (A2) Each realization B ( ω ) conditional on A can be modeled by a CNN, i.e., B = G ω
( A ) , where G ω is a draw from an ensemble of CNNs, ω being the random event.
(A1) is reasonable as long as the source of variation to be modeled by cGAN is independent from that contained in A , and the rational of (A2) lies in the expressive power of CNNs for image to image translation.
The previous model adopts a speciﬁc form of G ω ( A ) via feeding random input z ( ω ) to G , yet one may observe that the most general formulation under (A1), (A2) would be to sample the generator itself from certain distribution p ( G ) , which is independent from p ( A ) .
Since generative CNNs are parametrized by convolutional ﬁlters, this would be equivalent to set B = G
( A ; w ) , w ∼ p ( w ) , where we use “;” in the parentheses to emphasize that what after is parametrization of the generator.
The proposed cGAN model in the current paper indeed takes such an approach, where we model p ( w ) by a separate ﬁlter generator network.
S TOCHASTIC B ASIS G ENERATION
Using the method above, ﬁlters of each stochastic layer w are generated in the form of a highdimensional vector of size L × L × C (cid:48) × C , where L , C (cid:48) , and C correspond to the kernel size, numbers of input and output channels, respectively.
Although directly generating such high-dimensional vectors is feasible, it can be highly costly in terms of training time, sampling time, and memory footprint when the network scale grows.
We present a throughout comparison in terms of generated quality and sample ﬁlter size in supplementary material Figure A.1, where it is clearly shown that ﬁlter generation is too costly to afford.
In this section, we propose to replace ﬁlter generation with basis generation to achieve a quality/cost effect shown by the red dot in Figure A.1.
Details on the memory, parameter number, and computational cost are also provided at the end of the supplementary material, Section G.
For convolutional ﬁlters, the weights w is a 3-way tensor involving a spatial index and two channel indices for input and output channel respectively.
Tensor low-rank decomposition cannot be deﬁned in a unique way.
For convolutional ﬁlters, a natural solution then is to separate out the spatial index, which leads to depth-separable network architectures Chollet (2017).
Among other studies of lowrank factorization of convolutional layers, Qiu et al.
(2018) proposes to approximate a convolutional ﬁlter using a set of preﬁxed basis element linearly combined by learned reconstruction coefﬁcients.
Given that the weights in convolutional layers may have a low-rank structure, we collect a large amount of generated ﬁlters and reshape the stack of N sampled ﬁlters to a 2-dimensional matrix F with size of J × J (cid:48) , where J = N × L × L and J (cid:48)
= C (cid:48) × C .
We consistently observe that F is always of low effective rank, regardless the network scales we use to estimate the ﬁlter distribution.
If we assume that a collection of generated ﬁlters observe such a low-rank structure, the following theorem proves that it sufﬁces to generate bases in order to generate the desired distribution of ﬁlters.
Theorem 1.
Let (Ω , P ) be probability space and F : Ω → R L 2 × C (cid:48)
× C a 3-way random tensor, where F maps each event ω to F ω ( u, λ (cid:48) , λ ) , u ∈ [ L ] ×
[ L ] , λ (cid:48) ∈ [ C (cid:48) ] , λ ∈
[ C ] .
For each ﬁxed ω and u , F ω ( u ) := { F ω ( u, λ (cid:48) , λ ) } λ (cid:48) ,λ ∈ L ( R C (cid:48) , R C ) .
If there exists a set of deterministic linear transforms a k , k = 1 , · · · , K in L ( R C (cid:48) , R C ) s.t. F ω ( u ) ∈
Span { a k } Kk =1 for any ω and u , then there exists K random vectors
b k : Ω → R L 2 , k
= 1 , · · · , K , s.t. F ( u, λ (cid:48) , λ ) =
(cid:80)
Kk =
b k ( u ) a k ( λ (cid:48) , λ ) in distribution.
If F has a probability density, then so do { b k } Kk =1 .
The proof of the theorem is provided in the supplementary material.
We simplify the expensive ﬁlter generation problem by decomposing each ﬁlter as a linear combination of a small set of basis elements, and then sampling basis elements instead of ﬁlters directly.
In our method, we assume that the diverse modes of conditional image generations are essentially caused by the spatial perturbations, thus we propose to introduce stochasticity to the spatial basis elements.
Speciﬁcally, we apply convolutional ﬁler decomposition as in Qiu et al.
(2018) to write w = ψ a , ψ ∈ R L × L × K , where ψ are basis elements, a are decomposition coefﬁcients, and K is a pre-deﬁned small value, e.g., K = 7 .
We keep the decomposition coefﬁcients a deterministic and learned directly from training samples.
Instead of using predeﬁned basis elements as in Qiu et al.
(2018), we adopt a basis generator network T ( θ, z ) parametrized by θ , that learns the mapping from random latent vectors z to basis elements ψ with stochasticity.
The basis generator networks are jointly trained with the main conditional image generation network in an end-to-end manner. Note that we inherit term ‘basis’ from DCFNet Qiu et al. (2018) for the intuition behind the proposed framework, and we do not impose additional constrains such as orthogonality or linear independence to the generated elements.
Sampling the basis elements ψ using basis generators dramatically reduces the difﬁculty on modeling the corresponding probability distribution.
The costly ﬁlter generators in Section 3 is now replaced by much more efﬁcient basis generators, and stochastic ﬁlters are then constructed by linearly combining sampled basis elements with the deterministic coefﬁcients, w = ψ a = T ( θ, z ) a .
The illustration on the convolution ﬁlter reconstruction is shown as a part of Figure 1.
As illustrated in this ﬁgure, BasisGAN is constructed by replacing convolutional layers with the proposed stochastic convolutional layers with basis generators, and the network parameters can be learned without additional auxiliary training objective or regularization.
E XPERIMENTS
In this section, we conduct experiments on multiple conditional generation task.
Our preliminary objective is to show that thanks to the inherent stochasticity of the proposed BasisGAN, multi-mode conditional image generation can be learned without any additional regularizations that explicitly promote diversity.
The effectiveness of the proposed BasisGAN is demonstrated by quantitative and qualitative results on multiple tasks and underlying models.
We start with a stochastic auto-encoder example to demonstrate the inherent stochasticity brought by basis generator.
Then we proceed to image to image translation tasks, and compare the proposed method with: regularization based methods DSGAN Yang et al.
(2019) and MSGAN Mao et al.
(2019) that adopt explicit regularization terms that encourages higher distance between output images with different latent code; the model based method MUNIT Huang et al.
(2018) that explicitly decouples appearance with content and achieves diverse image generation by manipulating appearance code; and BicycleGAN Zhu et al.
(2017b) that uses auxiliary networks to encourage the diversity of the generated images with respect to the input latent code.
We further demonstrate that as an essential way to inject randomness to conditional image generation, our method is compatible with existing regularization based methods, which can be adopted together with our proposed method for further performance improvements.
Finally, ablation studies on the size of basis generators and the effect of K are provided in the supplementary material, Section E.
5. S TOCHASTIC A UTO - ENCODER
The inherent stochasticity of the proposed BasisGAN allows learning conditional one-to-many mapping even without paired samples for training.
We validate this by a variant of BasisGAN referred as stochastic auto-encoder, which is trained to do simple self-reconstructions with real-world images as inputs.
Only L1 loss and GAN loss are imposed to promote ﬁdelity and correspondence.
However, thanks to the inherent stochasticity of BasisGAN, we observe that the network does not collapse to a trivial identity mapping, and diverse outputs with strong correspondence to the input images are generated with appealing ﬁdelity.
Some illustrative results are shown in Figure 2.
[Figure]
Stochastic auto-encoder one-to-many conditional image generation without paired sample. The network is trained directly to reconstruct the input real-world images, and the inherent stochasticity of the proposed method successfully promotes diverse output appearances with
strong ﬁdelity and correspondence to the inputs.
5. I MAGE TO I MAGE T RANSLATION
To faithfully validate the ﬁdelity and diversity of generated images, we follow Mao et al.
(2019) to evaluate the performance quantitatively using the following metrics:
LPIPS.
The diversity of generated images are measured using LPIPS Mao et al.
LPIPS computes the distance of images in the feature space.
Generated images with higher diversity give higher LPIPS scores, which are more favourable in conditional image generation.
FID.
FID Heusel et al.
(2017) is used to measure the ﬁdelity of the generated images.
It computes the distance between the distribution of the generated images and the true images.
Since the entire GAN family is to faithfully model true data distribution parametrically, lower FID is favourable in our case since it reﬂects a closer ﬁt to the desired distribution.
Pix2Pix → BasisGAN.
As one of the most prevalent conditional image generation network,
Pix2Pix Isola et al.
(2017) serves as a solid baseline for many multi-mode conditional image generation methods.
It achieves conditional image generation by feeding the generator a conditional image, and training the generator to synthesize image with both GAN loss and L1 loss to the ground truth image.
Typical applications for Pix2Pix include edge maps → shoes or handbags, maps → satellites, [Figure] [Table]
and so on. We adopt the ResNet based Pix2Pix model, and impose the proposed stochasticity in the successive residual blocks, where regular convolutional layers and convolutional layers with basis generators convolve alternatively with the feature maps.
The network is re-trained from scratch directly without any extra loss functions or regularizations.
Some samples are visualized in Figure 3.
For a fair comparison with previous works Isola et al.
; Mao et al.
Zhu et al.
(2017b);
Yang et al.
; Huang et al.
(2018), we perform the quantitative evaluations on image to image translation tasks and the results are presented in Table 1.
Qualitative comparisons are presented in
Figure A.3.
As discussed, all the state-of-the-art methods require considerable modiﬁcations to the underlying framework.
By simply using the proposed stochastic basis generators as plug-and-play modules to the Pix2Pix model, the BasisGAN generates signiﬁcantly more diverse images but still at comparable quality with other state-of-the-art methods.
Moreover, as shown in Table A.3, BasisGAN reduces the number of trainable parameters comparing to the underlying methods thanks to the small number of basis elements and the tiny basis generator structures.
While regularization based methods like Mao et al.
; Yang et al.
(2019) maintain the parameter numbers of the underlying network models.
Pix2PixHD → BasisGAN.
In this experiment, we report results on high-resolution scenarios, which particularly demand efﬁciency and have not been previously studied by other conditional image generation methods. [Figure] image translation.
Diversity and ﬁdelity are measured using LPIPS
[Table]
[Table]
We conduct high resolution image synthesis on Pix2PixHD Wang et al.
(2018), which is proposed to conditionally generate images with resolution up to 2048 × 1024 .
The importance of this experiment arises from the fact that existing methods Mao et al.
Zhu et al.
(2017b) require considerable modiﬁcations to the underlying networks, which in this case, are difﬁcult to be scaled to very high resolution image synthesis due to the memory limit of modern hardware.
Our method requires no auxiliary networks structures or special batch formulation, thus is easy to be scaled to large scale scenarios.
Some generated samples are visualized in Figure 4.
Quantitative results and comparisons against DSGAN Yang et al.
(2019) are reported in Table 2.
BasisGAN signiﬁcantly improves both diversity and ﬁdelity with little overheads in terms of training time, testing time, and memory.
Image inpainting.
We conduct one-to-many image inpainting experiments on face images.
Following Yang et al.
(2019), centered face images in the celebA dataset are adopted and parts of the faces are discarded by removing the center pixels.
We adopt the exact same network used in Yang et al.
and replace the convolutional layers by layers with basis generators.
To show the plugand-play compatibility of the proposed BasisGAN, we conduct experiments by both training BasisGAN alone and combining BasisGAN with regularization based methods DSGAN (BasisGAN +
DSGAN).
When combining BasisGAN with DSGAN, we feed all the basis generator in BasisGAN with the same latent code and use the distance between the latent codes and the distance between generated samples to compute the regularization term proposed in Yang et al.
Quantitative results and qualitative results are in Table 3 and Figure 5, respectively.
BasisGAN delivers good balance between diversity and ﬁdelity, while combining BasisGAN with regularization based DSGAN further improves the performance.
[Figure]
C ONCLUSION
In this paper, we proposed BasisGAN to model the multi-mode for conditional image generation in an intrinsic way.
We formulated BasisGAN as a stochastic model to allow convolutional ﬁlters to be sampled from a ﬁlter space learned by a neural network instead of being deterministic.
To signiﬁcantly reduce the cost of sampling high-dimensional ﬁlters, we adopt parameter reduction using ﬁlter decomposition, and sample low-dimensional basis elements, as supported by the theoretical results here presented.
Stochasticity is introduced by replacing deterministic convolution layers with stochastic layers with basis generators.
BasisGAN with basis generators achieves high-ﬁdelity and high-diversity, state-of-the-art conditional image generation, without any auxiliary training objectives or regularizations.
Extensive experiments with multiple underlying models demonstrate the effectiveness and extensibility of the proposed method.
A P ROOF OF E QUATION (3)
Proof.
Given (2) in Section
[Equation]
the minimax game of adversarial training is expressed as:
[Equation]
By ﬁxing A and only consider:
[Equation]
The optimal discriminator D ∗ in (A.2) is achieved when
[Equation]
Given the optimal discriminator D ∗
[Equation]
(A.2) is expressed as:
[Equation]
where KL is the Kullback-Leibler divergence.
The minimum of V (cid:48) is achieved iff the JensenShannon divergence is 0 and p ( B | A ) =
q φ,θ ( B | A ) .
And the global minimum of (A.1) is achieved when given every sampled A , the generator perfectly replicate the conditional distribution p ( B | A ) .
B P ROOF OF T HEOREM 4.
Proof.
We ﬁrst consider the case when { a k } Kk =1 is a linearly independent set in the space of
L ( R C (cid:48) , R C ) , which is ﬁnite dimensional (the space of C (cid:48) -by- C matrices).
Then F ω ( u ) is in the span of { a k } k for any ω, u means that there are unique coefﬁcients b ( k ; ω, u ) s.t.
[Equation]
and the vector { b ( k ; ω, u ) } k ∈ R k can be determined from F ω ( u ) by a (deterministic) linear transform.
Since each entry F ( u, λ (cid:48) , λ ) is a random variable, i.e. measurable function on (Ω , P ) , then so is b ( k ; · , u ) viewed as a mapping from Ω to R , for each k and u , due to that linear transform between ﬁnite dimensional spaces preserves measurability.
For same reason, if F ( u, λ (cid:48) , λ ) has probability density, then so does each b ( k ; · , u ) .
Letting { b ( k ; · , u ) } u ∈
[ L ] ×
[ L ] be the random vectors b k proves the statement.
When { a k } Kk =1 are linearly dependent, the dimensionality of the subspace where F ω ( u ) lie in is ˜ K < K .
Suppose { ˜ a k } ˜
Kk =1 is a linearly independent set which spans the subspace, and T : R ˜ K →
R K is the linear transform to map to a k ’s from ˜ a k ’s. Using the argument above, there exist random vectors ˜
b k s.t. F = (cid:80) ˜
K k =1 ˜ b k ˜ a k , and using the pseudo-inverse of T to construct random vectors { b k } Kk =
we have that F = (cid:80)
Kk [-=
-]=
1 b k a k .
This proves the existence of the K random vectors b k .
C P ARAMETER O PTIMIZATION IN F ILTER G ENERATION
The optimization of the parameters { φ, θ } in ﬁlter generation is presented in Algorithm 1.
[Equation]
[Figure]
The quality metrics are introduced in Section 5.
D C OMPUTATION C OMPARISON
We present a throughout comparison in terms of generated quality and sample ﬁlter size in Figure A.1, where it is clearly shown that ﬁlter generation is too costly to afford, and basis generation achieves a signiﬁcantly better quality/cost effect shown by the red dot in Figure A.1.
E A BLATION S TUDIES
In this section, we perform ablation studies on the proposed BasisGAN, and evaluate multiple factors that can affect generation results.
We perform ablation studies on BasisGAN adapted from the
Pix2Pix model with the maps → satellite dataset.
Size of basis generators.
We model a basis generator using a small neural network, which consists of several hidden layers and inputs a latent code sampled from a prior distribution.
We consistently observe that a basis generator with a single hidden layer achieves the best performance while maintains fast basis generation speed.
Here we perform further experiments on the size of intermediate layers and input latent code size, and the results are presented in Table A.1.
It is observed that the size of a basis generator does not signiﬁcantly effect the ﬁnal performance, and we use the 64 +setting in all the experiments for a good balance between performances and costs.
Number of basis elements K.
By empirically observing the low rank of generated ﬁlters, we use
K = 7 in all the aforementioned experiments.
We conduct further experiments to show the performances with larger K and show the results in Table A.2.
It is clearly shown that by increasing K , the quality of the generated images do not increase.
And when K gets larger, e.g, K = 128 , even signiﬁcantly degrades the diversity of the generated images.
[Table]
[Table]
F Q UALITATIVE R ESULTS F. P IX 2P IX → B ASIS GAN
Additional qualitative results for Pix2Pix → BasisGAN are presented in Figure A.2.
Qualitative comparisons against MSGAN Mao et al.
(2019) and DSGAN Yang et al.
(2019) are presented in
Figure A.3.
We directly use the ofﬁcial implementation and the pretrained models provided by the authors.
For each example, the ﬁrst 5 generated samples are presented without any selection.
For the satellite → map comparison, we often observe missing correspondence in the samples generated by
DSGAN.
BasisGAN consistently provides samples with diverse details and strong correspondence to the input conditions.
[Equation]
Additional qualitative results for Pix2PixHD → BasisGAN are presented in Figure A.4.
G S PEED , P ARAMETER , AND M EMORY
We use PyTorch for the implementation of all the experiments.
The training and testing are performed on a single NVIDIA 1080Ti graphic card with 11GB memory.
The comparisons on testing speed, parameter number, and training memory are presented in Table A.3.
The training memory is measured under standard setting with resolution of 256 × 256 for Pix2Pix, and 1024 × 512 for Pix2PixHD.
Since we are using small number of basis elements (typically 7), and tiny basis generators, the overall trainable parameter number of the networks are reduced.
Note that we only compute the parameter number of the generator networks since we do not adopt any change to the discriminators.
[Table]
[Figure]
[Figure] [Figure]