Predicting Novel Views Using Generative Adversarial Query Network

TL;DR

The paper presents GAQN, a novel framework combining GQN and GANs to improve the quality and speed of novel view synthesis from multiple observations.

Contribution

It introduces an adversarial and feature-matching loss to enhance GQN, resulting in higher quality images and faster training convergence.

Findings

GAQN produces higher quality novel views.

GAQN converges faster than traditional GQN.

Enhanced visual realism in generated images.

Abstract

The problem of predicting a novel view of the scene using an arbitrary number of observations is a challenging problem for computers as well as for humans. This paper introduces the Generative Adversarial Query Network (GAQN), a general learning framework for novel view synthesis that combines Generative Query Network (GQN) and Generative Adversarial Networks (GANs). The conventional GQN encodes input views into a latent representation that is used to generate a new view through a recurrent variational decoder. The proposed GAQN builds on this work by adding two novel aspects: First, we extend the current GQN architecture with an adversarial loss function for improving the visual quality and convergence speed. Second, we introduce a feature-matching loss function for stabilizing the training procedure. The experiments demonstrate that GAQN is able to produce high-quality results and faster convergence compared to the conventional approach.

Tables

Table 1. Table 1: Architecture of our discriminator D 𝐷 D network using 3 residual blocks  [ 13 ] .

Layers	Input size	Output size
conv$2\times 2$, stride = 2, channels = 32, ReLU	$64\times 64\times 3$	$32\times 32\times 32$
ResBlock down 64	$32\times 32\times 32$	$16\times 16\times 64$
ResBlock down 128	$16\times 16\times 64$	$8\times 8\times 128$
ResBlock down 256	$8\times 8\times 128$	$4\times 4\times 256$
ResBlock down 512	$4\times 4\times 256$	$2\times 2\times 512$
conv$1\times 1$, stride = 1, channels = 1024, ReLU	$2\times 2\times 512$	$2\times 2\times 1024$

Table 2. Table 2: Comparison of training, testing loss, KL testing loss and SSIM testing score between our GAQN model (GQN + LSGANs + FM), original GQN and a variant (training GQN with LSGANs loss).

	GQN	GQN + LSGANs	GAQN (ours)
Training loss	7012	6988	6951
Testing loss	7003	6974	6957
KL testing loss	17.59	19.36	22.91
SSIM	0.742	0.815	0.865

Equations

$${\mathcal{L}}_G^{GAN}$$

$${\mathcal{L}}_D^{GAN}$$

$$\mathcal{L}_{GQN}=-\mathbb{E}_{(x,p),z}\bigg{[}-\ln\mathcal{N}(x_{gt}|x^{\prime})+\sum_{n=1}^{M}\Big{[}\mathcal{N}(q_{m},{\pi}_{m})\Big{]}\bigg{]}$$

$${\mathcal{L}}_G^{LSGAN}$$

$${\mathcal{L}}_D^{LSGAN}$$

$${\mathcal{L}}_{FM}=||{\mathbb{E}}_{\mathbf{x}\sim P_{\mathbf{x}}}{f}_D(x_{gt})-{\mathbb{E}}_{\mathbf{z}\sim P_{\mathbf{z}}}{f}_D(x^{\prime })|{|}_2^2$$

$${\mathcal{L}}_G^{GAQN}$$

$${\mathcal{L}}_D^{GAQN}$$

$${\mathcal{L}}_{EG}^{GAQN}$$

Full text

1 Introduction

Humans are easily able to build a mental understanding of the 3D scene based on just 2D images. With such ability, we can effortlessly imagine unseen views of 3D scenes and objects which is currently extremely challenging for computer based systems. Instead of reconstructing the scene as an explicit 3D model, humans can approximate new views by combining images obtained from nearby poses. Such task of predicting an image from a novel view point, given a limited set of other images from the same scene, is referred as a novel view synthesis in computer vision literature.

Novel view synthesis can be considered as a fundamental problem in computer vision and it is still being studied actively by the community. Despite of the tremendous progress obtained during the years, the problem is still far from being solved. There are several reasons making novel view synthesis extremely challenging. First, a perfect solution would require knowledge of the full light field of all visible objects which is usually not possible to obtain due to occlusions and limited number of samples. Second, due to

short distance to the scene geometry, even small changes in the viewpoint may lead to substantial changes in the image appearance. Finally, large parts of the scenes are texture-less and textured areas are typically small. Accurate rendering of novel views can be a useful component for many machine vision applications such as robotics and augmented reality.

The outline of this paper is as follows. In Section 2, we present works related to novel view synthesis methods. A brief background of two previous works that inspired our method is presented in Section 3. In Section 4.1 and Section 4.2, we introduce our Generative Adversarial Query Network with feature matching loss. In Section 5, we show our experimental results and discuss the effectiveness of adversarial training and feature matching loss to the previously proposed methods. Finally, we conclude our research in Section 6.

2 Related work

In this paper, we propose a solution to the task of novel view synthesis when multiple source images are given. Early works on this domain manage to cope with small viewing angle changes by interpolation [5], warping [27] or stereo reconstruction [26]. When the input cameras are further separated from each others, these methods do not perform well due to the sparsity of sampled plenoptic function. Traditional structure-from-motion, structure-from-depth and multi-view geometry methods [4, 16, 31, 34] predict novel views through the estimated 3D structure (point clouds, mesh clouds or a collection of predefined primitives) of the environment. Although, these methods show good results on abundant source data, they are unable to recover the desired target views with a limited number of input images due to the ambiguity of 3D environments. Moreover, estimating the full 3D scene structure may be more challenging problem than that of synthesizing novel images from new viewpoints.

Recent works on deep generative model such as Variational Auto Encoder (VAE) [19], Generative Adversarial Network (GAN) [9] and their variants [1, 17, 20, 33] have demonstrated remarkable results in generating highly photo-realistic novel images. Based on these results, one could expect that similar architectures would be applicable to predict 3D structure of the environment. However, the results demonstrated so far, are far from the desired quality. For instance, the viewpoint transformation networks explicitly learn the relationship between input views of the same 3D scene, but the result is limited in scale such as predicting novel views of an individual rotated objects [6, 12, 28, 29, 32, 36] or predicting a small displacement between stereo camera views [8, 35].

A recent generative model that has shown promises in learning representation for 3D scenes structure is Generative Query Network (GQN) [7]. GQN makes use of an iterative latent variable density model [10] to generate images of the 3D scene. Using multiple source images as input, GQN presents an end-to-end learning framework that generates the novel view from the queried pose by leveraging learned knowledge of the 3D scene representation. However, GQN is known for large memory consumption and the predicted novel views are sometimes blurry.

3 Background

In this section, we provide the reader with a brief background of Generative Adversarial Networks (GANs) [9] and Generative Query Network (GQN) [7]. Figure 1 shows the overall structure of our method and compares it to the previously proposed GANs and GQN.

3.1 Generative Adversarial Networks (GANs)

Generative Adversarial Networks (GANs) [9] consist of two competing architectures referred as a generator (G) and a discriminator (D) (see Figure 1(a)). The generator G maps a given latent representation $z$ (possibly a vector with random values) into a novel image $x^{\prime}=G(z)$ that is then passed to the discriminator network D. The discriminator aims to determine if the given sample is produced by the generator, or if it is a real image taken from the training set. Denoting the real training samples as $x$, the conventional generator loss $\mathcal{L}_{G}^{GAN}$ and discriminator loss $\mathcal{L}_{D}^{GAN}$ are defined as:

[TABLE]

Both networks are trained simultaneously in an alternating fashion. In the ideal case, the procedure guides the generator to produce images that are indistinguishable from the training image distribution. However, in practice the training procedure is challenging due to various problems such as mode collapses [21].

3.2 Generative Query Network (GQN)

Generative Query Network (GQN) [7] is a deep generative model that learns the scene representation to perform novel view synthesis. Using an arbitrary number of observations, GQN can be trained to generate new views from the same environment. A GQN network includes a scene encoder(Enc) and a decoder(Dec) as can be seen in Figure 1(b).

First, the Enc network tries to compress all of the 3D scene information into a latent representation $z$ from multiple pairs of input views $x$ and their camera poses $p$. The Enc network processes each pair of input views and camera poses by using a feed-forward deep convolutional neural network. Each camera pose $p$ is represented by a 7 dimensional vector of $x_{t}$, $y_{t}$, $z_{t}$, $sin(yaw)$, $cos(yaw)$, $sin(pitch)$ and $cos(pitch)$ where $x_{t}$, $y_{t}$, $z_{t}$ are 3D translation, and $yaw$ and $pitch$ are parameters of the 3D rotation matrix. The latent scene information $z$ is the summation of all output pairs from the Enc network.

The goal of the GQN is to predict novel views by using the queried pose $p_{q}$. Therefore, $p_{q}$ and $z$ are input to the Dec network to generate the new view $x^{\prime}$. The Dec network is a conditional latent variable model DRAW [11] which includes $M$ pairs of Inference and Generation recurrent sub network [10]. In the language of GANs, the term of decoder Dec and generator G have many similarities since they both synthesize data from the latent vector $z$ (could be also random vector). Both Enc and Dec are trained jointly to minimize the evidence lower bound (ELBO) loss $\mathcal{L}_{GQN}$ :

[TABLE]

The GQN training loss $\mathcal{L}_{GQN}$ is the expected value over the negative log-likelihood of the target image $x_{gt}$ given the target distribution regularized by the cumulative Kullback Leibler divergence between obtained posterior $q_{m}$ and prior $\pi_{m}$ distributions from $m^{th}$ generation step.

4 Generative Adversarial Query Network

The proposed Generative Adversarial Query Network (GAQN) builds on the GQN architecture by introducing two novel contributions. We will explain both of these in the following subsections. The corresponding experimental results are presented in Section 5. Figure 1(c) shows the overall architecture of our method.

4.1 Adversarial loss

As illustrated in Figure 1(c), the proposed GAQN consists of three components: an encoder network Enc, a decoder network Dec, and a discriminator network D. The GAQN utilities the same Enc and Dec architecture as standard GQN to generate a novel view $x^{\prime}=Dec(Enc(x,p),p_{q})$. However, inspired by the recent advancement of GANs, we include an additional discriminator network D to distinguish between the generated fake images from the GQN and the ground truth view in the training data. In this way, the discriminator acts as a learn-able loss function that boosts the learning process of GQN.

Numerous works [1, 21, 24, 25] have shown that the training of the GAN may be unstable due to the vanishing gradients problem caused by the binary cross entropy loss as defined in Equation (1) and (2). In this paper, we avoid the above problem by adopting the least-square loss function from the previously proposed Least Squares Generative Adversarial Networks (LSGANs) [20]. The idea of LSGANs has been proved to be effective since it tries to pull the fake samples closer to the decision boundary of the least-square loss function. Based on the distance between the sampled data and the decision boundary, LSGANs manages to generate better gradients to update its generator. Furthermore, LSGANs also proves to exhibit less mode-seeking behaviour [3] which also stabilize the training process. Equation (4) and (5) provide the generator and discriminator loss of LSGANs that we use to train the GQN decoder and our proposed discriminator, respectively.

[TABLE]

Inspired by recent works [33, 22] on GANs, our proposed Discriminator $D$ network adopts the residual blocks architecture [13]. Instead of directly classifying the generated image as real or fake, we follow the patch-based discriminator [15] to restrict the attention to the structure in the local patches. Table 1 shows the design of our discriminator network.

The original GQN includes per-pixel variance annealing technique [7] that is aimed to focus the learning for the scene environment (wall, floor and sky), location and color of objects at the early stage of the training and enhance the low level details later. Even though the annealing strategy was shown to work, we argue that the adversarial loss is able to further speed up the learning and to generate sharper object details at the early stages of the training. Therefore, our GAQN can achieve better visualized novel view earlier than GQN.

Figure 2 illustrates the predicted novel view using the plain GQN architecture and the proposed GAQN architecture. Although the obtained GQN model successfully predicts the correct location and color of three objects in the 3D scene, their edges are blurry. Meanwhile our proposed method manages to produce sharper object edges, especially, to the middle green icosahedron. Further results and implementation details are provided in Section 5.

4.2 Feature-matching loss

Inspired by the recent works [2, 25, 30] on improving the stability of the GAN training, we add an extra feature matching loss to train the generator network. The main idea of this feature matching loss is to use the discriminator network as a feature extractor and guide the generator to generate data that matches the feature statistics of the real data. There are several approaches on exploiting the feature matching loss in training the generator.

Specifically, the common GAN generator loss as shown in Equation (1) is being replaced by a mean feature matching loss. It has been argued that this mean feature matching loss helps preventing the gradient vanishing problem during the training. In our research, we have already adopted the least square loss to address the above problem (Section 4.1) but there is no guarantee that the problem is completely solved. Therefore, we train our GAQN generator network using a unified loss function $\mathcal{L}_{G}^{GAQN}$ as the combination of LSGANs generator loss $\mathcal{L}_{G}^{LSGAN}$ and mean feature matching loss $\mathcal{L}_{FM}$. Let $f_{D}()$ be the mean of the output feature maps from the 3rd layer (ResBlock down 128 in Table 1) of the discriminator network, the mean feature matching loss is define as follow:

[TABLE]

In this paper, we jointly train GAQN Enc and G by using $\mathcal{L}_{EG}^{GAQN}$ which is the conventional GQN ELBO loss (Equation (3)). The D parameters are being updated by the least squares loss (Equation (5)) from LSGANs, and we adopt the mean feature matching loss (Equation (6)) to update G. Finally, Equations (7), (8) and (9) show all the loss functions we have used to train our GAQN model.

[TABLE]

5 Experiments

5.1 Experimental settings

We evaluate our method using the rooms ring camera dataset that was provided and used by Eslami et al. in [7]. The dataset contains various rendered 3D square rooms that contain random objects of various shapes, colors and locations. Moreover, the scene textures, walls and lights are also randomly generated. Therefore, the task of predicting the novel views on this data-set is a relatively challenging problem.

The original GQN construction proposed in [7] consumes a large amount of computing and memory resources. Due to computational restrictions, we demonstrate the advantages of the proposed architectural changes using a smaller version of the basic GQN network and a subset of the training data. Originally, training a 12 generative-layers GQN model with batch size of 36 requires 4 NVIDIA K80 GPUs as shown in [7]. In this paper, we use a single NVIDIA Tesla P100 GPU to train our GAQN model which has 8 generative layers and batch size is 20. As far as we experimented, this change would not affect the quality of results. Despite of the smaller network size, our method is able to produce results (see figures 2 and 4) that are very close to those presented in the original work [7] that uses clearly larger network and training set. This further, emphasized the benefits of the proposed architectural modifications. Moreover, we only use the first halve of the original GQN’s training and testing data for faster training procedure.

We implement our model on PyTorch [23] and our GAQN model is trained end-to-end using ADAM optimization [18] with hyper-parameter $\beta_{1}=0.9$ and $\beta_{2}=0.999$. The generator network is trained using the learning rate of $10^{-4}$ and the discriminator is trained using a learning rate of $4\times 10^{-4}$. Recent work by Heusel et al. [14] shows that if we update the generator slower than the discriminator then it helps to reach the convergence easier.

5.2 Results

Our approach relies on two new components, namely, an adversarial training pipeline using the least-square GANs loss and the discriminator feature matching loss functions to enhance the previously proposed GQN model. In this section, we will experimentally investigate the impact of the both components. The results corresponding to only GQN and adversarial loss are denoted as (GQN + LSGANs), whereas the results with the proposed full model are denoted as GAQN. We train the above methods using the same hyper-parameters (reported in Section 5.1) and record their training and testing loss for evaluation purposes. We also use the structure similarity index (SSIM) to assess on the quality of the target image and the predicted novel on a held-out test set.

Table 2 contains the obtained results. The proposed full GAQN method has clearly the smallest training and testing loss and the largest Kullback–Leibler (KL) testing loss. The KL loss represents the distance between the estimated and true distribution produced by GQN’s generation network and this KL loss is the second term in the ELBO loss (Equation (3)). If the model manages to produce high KL loss then the predicted novel view tends to be close to the ground-truth data. It is also evident that the adversarial loss is able to improve the results compared to the plain GQN architecture. However, the largest gain is obtained by combining both of the proposed contributions.

In Figure 4, we show qualitative examples of the generated novel views produced by different versions of the proposed GAQN method and the baseline. Although the baseline manages to correctly generate the colors and positions of objects in most cases, theirs edges are blurry. Based on the SSIM, our GAQN model achieves highest score and produce sharper edges on predicted images.

Finally, we illustrate how the least squares loss of LSGANs and discriminator feature matching loss affect the training procedure of the method. In this experiment, we compare the generator and discriminator training loss of our proposed GAQN and GQN + GAN. As can be seen in Figure 3 (b), the training procedure of GQN + GAN is highly unstable due to mode collapsing and diminishing gradients. Our GAQN model eliminates both problems by using the least-squares loss and the discriminator mean feature loss as shown in Figure 3 (a).

6 Conclusion

We have introduced an novel adversarial training pipeline to improve the previously proposed GQN network architecture. Our experimental results demonstrate that training an additional discriminator network encourages the GQN model to predict more accurate novel views. Moreover, using the combination of least square loss and the feature matching loss helps stabilizing both generator and discriminator training process. In our future work, we will explore how to generate novel views in the bigger scale of indoor scenes where there are more objects and different lighting conditions.