CollaGAN : Collaborative GAN for Missing Image Data Imputation

TL;DR

This paper introduces CollaGAN, a novel multi-domain image-to-image translation framework using GANs, which effectively imputes missing image data with higher visual quality than existing methods.

Contribution

The paper presents CollaGAN, a new collaborative GAN architecture that transforms missing image data imputation into a multi-domain translation problem, improving image quality.

Findings

CollaGAN outperforms existing methods in visual quality of imputed images.

The framework successfully handles various image imputation tasks.

It converts the problem into a multi-domain translation, simplifying the process.

Abstract

In many applications requiring multiple inputs to obtain a desired output, if any of the input data is missing, it often introduces large amounts of bias. Although many techniques have been developed for imputing missing data, the image imputation is still difficult due to complicated nature of natural images. To address this problem, here we proposed a novel framework for missing image data imputation, called Collaborative Generative Adversarial Network (CollaGAN). CollaGAN converts an image imputation problem to a multi-domain images-to-image translation task so that a single generator and discriminator network can successfully estimate the missing data using the remaining clean data set. We demonstrate that CollaGAN produces the images with a higher visual quality compared to the existing competing approaches in various image imputation tasks.

Figures

Tables

Table 1. Table 1: MR acquisition parameters for each contrast. T1F, T2w, T2F and T2F* represent MAGiC synthetic T1-FLAIR, MAGiC synthetic T2-weighted, MAGiC synthetic T2-FLAIR and conventional T2-FLAIR, respectively. Four contrasts share the field of view (FOV), acquisition matrix, and slice thickness as shown in the common parameters row.

	TR(ms)	TE(ms)	TI(ms)	FA(deg)
T1F	2500	10	1050	90
T2w	3500	128	-	90
T2F	9000	95	2408	90
T2F*	9000	93	2471	160
Common parameters	FOV:220$\times$220mm, 320$\times$224 matrix, 4.0 mm thickness

Table 2. Table 2: Architecture of the generator used for MR contrast translation. The U-net  [ 28 ] structure was redesigned with the proposed CCNR units which includes instance normalization (N) and leaky-ReLU (L). Conv, P, Cat and T represent convolution, average pooling with strides 2, concatenate, and convolution transpose with strides 2 and kernel size 2 × \times 2, respectively. While k and s refer to the kernel size and the stride, C’ is 1 × \times 1 convolution layer, Conv(k1,s1).

Unit	Layers						nCh
Main		CCNL$\times$2	(skip)	Cat	CCNL$\times$2	C’	16
			(Blck#1)
Blck#1	P	CCNL$\times$2	(skip)	Cat	CCNL$\times$2	T	32
			(Blck#2)
Blck#2	P	CCNL$\times$2	(skip)	Cat	CCNL$\times$2	T	64
			(Blck#3)
Blck#3	P	CCNL$\times$2	(skip)	Cat	CCNL$\times$2	T	128
			(Blck#4)
Blck#4	P		CCNL$\times$2			T	256
CCNL		Conv(k1,s1)	Cat-InstanceNorm-LeakyReLU
		Conv(k3,s1)

Table 3. Table 3: Architecture of the descriminator used for MR contrast translation. k is the kernel size for the convolution and C(n,s) represents the convolution layer with n channels and s strides. Cat, L and FC represent the concatenate layer, the leaky-ReLU layer and the fully-connected layer, respectively.

Order	Layers					k
1a	C(n4,s1)-L	C(n4,s1)-L	C(n4,s1)-L	C(n4,s1)-L	C(n16,s4)-L	4
1b	C(n4,s1)-L	C(n8,s2)-L	C(n8,s1)-L	C(n16,s2)-L	C(n16,s1)-L	4
1c	C(n16,s4)-L	C(n16,s1)-L	C(n16,s1)-L	C(n16,s1)-L	C(n16,s1)-L	4
2	1a	Cat	C(n32,s2)-L	C(n64,s2)-L	C(n128,s2)-L	4
	1b
	1c
3a	C(n1,s1)	Sigmoid ($D_{gan}$)				3
3b	FC(n4)	Softmax ($D_{cls}$)				8

Table 4. Table 4: Architecture of the generator used for illumination translation. Conv, P, Cat and T represent convolution, average pooling with strides 2, concatenate, and convolution transpose with strides 2 and kernel size 2 × \times 2, respectively. k and s refer to the kernel size and the stride. C’ is 1 × \times 1 convolution layer, Conv(k1,s1).

Unit	Layers						nCh
Main	-	CNL$\times$2	(skip)	Cat	CNL$\times$2	C’	64
			(Blck#1)
Blck#1	P	CNL$\times$2	(skip)	Cat	CNL$\times$2	T	128
			(Blck#2)
Blck#2	P	CNL$\times$2	(skip)	Cat	CNL$\times$2	T	256
			(Blck#3)
Blck#3	P	CNL$\times$2	(skip)	Cat	CNL$\times$2	T	512
			(Blck#4)
Blck#4	P	CNL$\times$2				T	1024
CNL		Conv(k3,s1)	Cat-InstanceNorm-LeakyReLU

Table 5. Table 5: Architecture of the generator used for facial expression translation.

Order	Layers
1	C(n64,k4,s2)-L
2	C(n128,k4,s2)-L
3	C(n256,k4,s2)-L
4	C(n512,k4,s2)-L
5	C(n1024,k4,s2)-L
6	C(n2048,k4,s2)-L
7a	C(n1,k3,s1)-Sigmoid ($D_{gan}$)
7b	FC(n5)-Softmax ($D_{cls}$)

Table 6. Table 6: Quantitative results for facial expression imputation. The NMSE/SSIM (lower/upper part for each facial expression, respectively) are calculated from each target domain (A:angry, C:contemptuous, D:disgusted, F:fearful, H:happy, S:surprised, Sad:sad).

	pix2pix	CycleGAN	StarGAN	Proposed
A	0.0247	0.0301	0.0306	\ul0.0197
	0.765	0.732	0.698	\ul0.794
C	0.0283	0.0327	0.0421	\ul0.0105
	0.724	0.0700	0.696	\ul0.840
D	0.0333	0.0362	0.0397	\ul0.0172
	0.716	0.694	0.683	\ul0.802
F	0.0395	0.0329	0.0487	\ul0.0213
	0.677	0.685	0.670	\ul0.761
H	0.0345	0.0350	0.0420	\ul0.0211
	0.697	0.682	0.606	\ul0.778
S	0.0335	0.0268	0.0363	\ul0.0122
	0.697	0.729	0.692	\ul0.803
Sad	0.0349	0.0352	0.0395	\ul0.0204
	0.679	0.6975	0.652	\ul0.776

Table 7. Table 7: Quantitative results for illumination imputation. The NMSE/SSIM (upper/lower part for each row, respectively) are calculated from the target domain.

	pix2pix	CycleGAN	StarGAN	Proposed
$-{90}^{\circ }$	0.0334	0.0777	0.0545	\ul0.0122
	0.799	0.640	0.606	\ul0.876
$-{45}^{\circ }$	0.0181	0.0656	0.0470	\ul0.00873
	0.840	0.688	0.644	\ul0.888
${45}^{\circ }$	0.0151	0.0188	0.0178	\ul0.0150
	0.607	0.734	0.698	\ul0.800
${90}^{\circ }$	0.0680	0.0868	0.0481	\ul0.00839
	0.708	0.665	0.668	\ul0.894

Table 8. Table 8: Qualitative evaluation results using Mechanical Turk experiment. We asked the participants to choose the best image according to the quality of reconstruction image, the similarity to the ground truth, and how well the original facial expression is expressed. Total 1470 answers from 30 participants.

Chosen as the best	pix2pix	CycleGAN	StarGAN	Proposed
	3.8%	17.9%	7.4%	\ul70.8%

Table 9. Table 9: Quantitative results for the ablation study.

(Mean$\pm$std)	$l_1$ w/o $L_{MCC}$	w/o $L_{SSIM}$	Proposed
NMSE	0.0372$\pm$0.00653	0.0200$\pm$0.00391	\ul0.0178$\pm$0.00419
SSIM	0.714$\pm$0.0211	0.779$\pm$0.0243	\ul0.793$\pm$0.0237

Equations

$${\hat{x}}_{\kappa }=G\left(\{x_{\kappa }{\}}^C;\kappa \right)$$

$${\tilde{x}}_{b|a}$$

$${\tilde{x}}_{c|a}$$

$${\tilde{x}}_{d|a}$$

$$\displaystyle\mathcal{L}_{mcc,a}=||x_{b}-\tilde{x}_{b|a}||_{1}+||x_{c}-\tilde{x}_{c|a}||_{1}+||x_{d}-\tilde{x}_{d|a}||_{1}\$$

$${\mathcal{L}}_{mcc,\kappa }=\sum _{{\kappa }^{\prime }\ne \kappa }||x_{{\kappa }^{\prime }}-{\tilde{x}}_{{\kappa }^{\prime }|\kappa }|{|}_1$$

$${\tilde{x}}_{{\kappa }^{\prime }|\kappa }=G\left(\{{\hat{x}}_{\kappa }{\}}^C;{\kappa }^{\prime }\right).$$

$${\mathcal{L}}_{gan}^{dsc}(D_{gan})={\mathbb{E}}_{x_{\kappa }}[(D_{gan}(x_{\kappa })-1{)}^2]+{\mathbb{E}}_{{\tilde{x}}_{\kappa |\kappa }}[(D_{gan}({\tilde{x}}_{\kappa |\kappa }){)}^2],$$

$${\mathcal{L}}_{gan}^{gen}(G)={\mathbb{E}}_{{\tilde{x}}_{\kappa |\kappa }}[(D_{gan}({\tilde{x}}_{\kappa |\kappa })-1{)}^2]$$

$${\mathcal{L}}_{clsf}^{real}(D_{clsf})={\mathbb{E}}_{x_{\kappa }}[-\log (D_{clsf}(\kappa ;x_{\kappa }))]$$

$${\mathcal{L}}_{clsf}^{fake}(G)={\mathbb{E}}_{{\hat{x}}_{\kappa |\kappa }}[-\log (D_{clsf}(\kappa ;{\hat{x}}_{\kappa |\kappa }))]$$

$$\text{SSIM}(p)=\frac{2{\mu }_X{\mu }_Y+C_1}{{\mu }_X^2+{\mu }_Y^2+C_1}\cdot \frac{2{\sigma }_{XY}+C_2}{{\sigma }_X^2+{\sigma }_Y^2+C_2}$$

$${\mathcal{L}}_{\text{SSIM}}(X,Y)=-\log \left(\frac{1}{2|P|}\sum _{p\in P(X,Y)}(1+\text{SSIM}(p))\right)$$

$${\mathcal{L}}_{mcc-\text{SSIM},\kappa }=\sum _{{\kappa }^{\prime }\ne \kappa }{\mathcal{L}}_{\text{SSIM}}\left(x_{{\kappa }^{\prime }},{\tilde{x}}_{{\kappa }^{\prime }|\kappa }\right).$$

Full text

1 Introduction

In many image processing and computer vision applications, multiple set of input images are required to generate the desired output. For example, in brain magnetic resonance imaging (MRI), MR images with T1, T2, or FLAIR (FLuid-Attenuated Inversion Recovery) contrast are all required for accurate diagnosis and segmentation of cancer margin [6]. In generating a 3-D volume from multiple view camera images [5], most algorithms require the pre-defined set of view angles. Unfortunately, the complete set of input data are often difficult to obtain due to the acquisition cost and time, (systematic) errors in the data set, etc. For example, in synthetic MR contrast generation using the Magnetic Resonance Image Compilation (MAGiC, GE Healthcare) sequence, it is often reported that there exists a systematic error in synthetic T2-FLAIR contrast images, which leads to erroneous diagnosis [31]. Missing data can also cause substantial biases, making errorrs in data processing and anlysis and reducing the statistical efficiency [22].

Rather than acquiring all the datasets again in this unexpected situation, which is often not feasible in clinical environment, it is often necessary to replace the missing data with substituted values. This process is often referred to as imputation. Once all missing values have been imputed, the data set can be used as an input for standard techniques designed for the complete data set.

There are several standard methods to impute missing data based on the modeling assumption for the whole set such as mean imputation, regression imputation, stochastic imputation, etc  [2, 9]. Unfortunately, these standard algorithms have limitations for high-dimensional data such as images, since the image imputation requires knowledge of high-dimensional image data manifold.

Similar technical issues exist in image-to-image translation problems, whose goal is to change a particular aspect of a given image to another. The tasks such as super-resolution, denoising, deblurring, style transfer, semantic segmentation, depth prediction, etc can be treated as mapping an image from one domain to a corresponding image in another domain [10, 3, 7, 8]. Here, each domain has a different aspect such as resolution, facial expression, angle of light, etc, and one needs to know the intrinsic manifold structure of the image data set to translate between the domains. Recently, these tasks have been significantly improved thanks to the generative adversarial networks (GANs) [11]. Specifically, CycleGAN [36] or DiscoGAN [18] have been the main workhorse to transfer image between two domains [17, 21]. These approaches are, however, ineffective in generalizing to multiple domain image transfer, since $N$($N$-1) number of generators are required for $N$-domain image transfer (Fig. 1 (a)). To generalize the idea for multi-domain translation, Choi et al [4] proposed a so-called StarGAN which can learn translation mappings among multiple domains by single generator (Fig. 1 (b)). Similar multi-domain transfer network have been proposed recently [34].

These GAN-based image transfer techniques are closely related to image data imputation, since the image translation can be considered as a process of estimating the missing image database by modeling the image manifold structure. However, there are fundamental differences between image imputation and image translation. For example, CycleGAN and StarGAN are interested in transferring one image to another as shown in Fig. 1 (a)(b) without considering the remaining domain data set. However, in image imputation problems, the missing data occurs infrequently, and the goal is to estimate the missing data by utilizing the other clean data set. Therefore, an image imputation problem can be correctly described as in Fig. 1(c), where one generator can estimate the missing data using the remaining clean data set. Since the missing data domain is not difficult to estimate a priori, the imputation algorithm should be designed such that one algorithm can estimate the missing data in any domain by exploiting the data for the rest of the domains.

The proposed image imputation technique called Collaborative Generative Adversarial Network (CollaGAN) offers many advantages over existing methods:

• •

The underlying image manifold can be learned more synergistically from the multiple input data set sharing the same manifold structure, rather than from a single input. Therefore, the estimation of missing data using CollaGAN is more accurate.

• •

CollaGAN still retains the one-generator architecture similar to StarGAN, which is more memory-efficient compared to CycleGAN.

We demonstrate the proposed algorithm shows the best performance among the state-of-the art algorithms for various image imputation tasks.

2 Related Work

2.1 Generative Adversarial Network

Typical GAN framework [11] consists of two neural networks: the generator $G$ and the discriminator $D$. While the discriminator tries to find the features to distinguish between fake/real samples during the train process, the generator learns to eliminate/synthesize the features which the discriminator use to judge fake/real. Thus, GANs could generate more realistic samples which cannot be distinguished by the discriminator between real and fake. GANs have shown remarkable results in various computer vision tasks such as image generation, image translation, etc [16, 21, 18].

2.2 Image-to-image translation

Unlike the original GAN, Conditional GAN (CoGAN) [26] controls the output by adding some information labels as an additional parameter to the generator. Here, instead of generating a generic sample from an unknown noise distribution, the generator learns to produce a fake sample with a specific condition or characteristics (such as a label associated with an image or a more detailed tag). A successful application of conditional GAN is for the image-to-image translation, such as pix2pix [17] for paired data, and CycleGAN for unpaired data [23, 36].

CycleGAN [36] and DiscoGAN [18] attempt to preserve key attributes between the input and the output images by utilizing a cycle consistency loss. However, these frameworks are only able to learn the relationships between two different domains at a time. These approaches have scalability limitations when dealing with multi-domains, since each domain pair needs a separate generator-pair and total $N$($N$-1) number of generators are required to handle the $N$-distinct domains.

StarGAN [4] and Radial GAN [34] are recent frameworks that deal with multiple domains using a single generator. For example, in StarGAN [4], the depth-wise concatenation from input image and the mask vector representing the target domain helps to map the input to reconstructed image in the target domain. Here, the discriminator should be designed to play another role for domain classification. Specifically, the discriminator decides that not only the sample is real or fake, but also the class of the sample.

3 Theory

Here, we explain our Collaborative GAN framework to handle multiple inputs to generate more realistic and more feasible output for image imputation. Compared to StarGAN, which handles single-input and single-output, the multiple-inputs from multiple domains are processed using the proposed method.

3.1 Image imputation using multiple inputs

For ease of explanation, we assume that there are four types ($N=4$) of domains: $a$, $b$, $c$, and $d$. To handle the multiple-inputs using a single generator, we train the generator to synthesize the output image in the target domain, $\hat{x}_{a}$, via a collaborative mapping from the set of the other types of multiple images, $\{x_{a}\}^{C}=\{x_{b},x_{c},x_{d}\}$, where the superscript C denotes the complementary set. This mapping is formally described by

[TABLE]

where $\kappa\in\{a,b,c,d\}$ denotes the target domain index that guides to generate the output for the proper target domain, $\kappa$. As there are $N$ number of combinations for multiple-input and single-output combination, we randomly choose these combination during the training so that the generator learns the various mappings to the multiple target domains.

3.2 Network losses

Multiple cycle consistency loss One of the key concepts for the proposed method is the cycle consistency for multiple inputs. Since the inputs are multiple images, the cycle loss should be redefined. Suppose that the output from the forward generator $G$ is $\hat{x}_{a}$. Then, we could generate $N-1$ number of new combinations as the other inputs for the backward flow of the generator (Fig. 2 middle). For example, when $N=4$, there are three combinations of multi-input and single-output so that we can reconstruct the three images of original domains using backward flow of the generator as:

[TABLE]

Then, the associated multiple cycle consistency loss can be defined as following:

[TABLE]

where $||\cdot||_{1}$ is the $l_{1}$-norm. In general, the cycle consistency loss for the forward generator $\hat{x}_{\kappa}$ can be written by

[TABLE]

where

[TABLE]

Discriminator Loss As mentioned before, the discriminator has two roles: one is to classify the source which is real or fake, and the other is to classify the type of domain which is class $a,b,c$ or $d$. Therefore, the discriminator loss consists of two parts: adversarial loss and domain classification loss. As shown in Fig. 2, this can be realized using a discriminator with two paths $D_{gan}$ and $D_{clsf}$ that share the same neural network weights except the last layers.

Specifically, the adversarial loss is necessary to make the generated images as real as possible. The regular GAN loss might lead to the vanishing gradients problem during the learning process [24, 1]. To overcome such problem and improve the robustness of the training, the adversarial loss of Least Square GAN [24] was utilized instead of the original GAN loss. In particular for the optimization of the discriminator$D_{gan}$, the following loss is minimized:

[TABLE]

whereas the generator is optimized by minimizing the following loss:

[TABLE]

where $\tilde{x}_{\kappa|\kappa}$ is defined in (3).

Next, the domain classification loss consists of two parts: $\mathcal{L}_{clsf}^{real}$ and $\mathcal{L}_{clsf}^{fake}$. They are the cross entropy loss for domain classification from the real images and the fake image, respectively. Recall that the goal of training $G$ is to generate the image properly classified to the target domain. Thus, we first need a best classifier $D_{clsf}$ that should only be trained with the real data to guide the generator properly. Accordingly, we first minimize the loss $\mathcal{L}_{clsf}^{real}$ to train the classifier $D_{clsf}$, then $\mathcal{L}_{clsf}^{fake}$ is minimized by training $G$ with fixing $D_{clsf}$ so that the generator can be trained to generate samples that can be classified correctly.

Specifically, to optimize the $D_{clsf}$, the following $\mathcal{L}_{clsf}^{real}$ should be minimizied with respect to $D_{clsf}$:

[TABLE]

where $D_{clsf}(\kappa;x_{\kappa})$ can be interpreted as the probability to correctly classify the real input $x_{\kappa}$ as the class $\kappa$. On the other hand, the generator $G$ should be trained to generate fake samples which are properly classified by the $D_{clsf}$. Thus, the following loss should be minimized with respect to $G$:

[TABLE]

Structural Similarity Index Loss Structural Similarity Index (SSIM) is one of the state-of-the-art metrics to measure the image quality [33]. The $l_{2}$ loss, which is widely used for the image restoration tasks, has been reported to cause the blurring artifacts on the results [21, 25, 35]. SSIM is one of the perceptual metrics and it is also differentiable, so it can be backpropagated [35]. The SSIM for pixel $p$ is defined as

[TABLE]

where $\mu_{X}$ is an average of $X$, $\sigma_{X}^{2}$ is a variance of $X$ and $\sigma_{XX^{*}}$ is a covariance of $X$ and $X^{*}$. There are two variables to stabilize the division such as $C_{1}=(k_{1}L)^{2}$ and $C_{2}=(k_{2}L)^{2}$. $L$ is a dynamic range of the pixel intensities. $k_{1}$ and $k_{2}$ are constants by default $k_{1}=0.01$ and $k_{2}=0.03$. Since the SSIM is defined between 0 and 1, the loss function for SSIM can be written by:

[TABLE]

where $P$ denotes the pixel location set and $|P|$ is its cardinality. The SSIM loss was applied as an additional multiple cycle consistency loss as follows:

[TABLE]

3.3 Mask vector

To use the single generator, we need to add the target label as a form of mask vector to guide the generator. The mask vector is a binary matrix which has same dimension with the input images to be easily concatenated. The mask vector has $N$ class number of channel dimensions to represent the target domain as one-hot vector along the channel dimension. This is the simplified version of mask vector which was originally introduced in StarGAN [4].

4 Method

4.1 Datasets

MR contrast synthesis Total 280 axis brain images were scanned by multi-dynamic multi-echo sequence and the additional T2 FLAIR (FLuid-Attenuated Inversion Recovery) sequence from 10 subjects. There are four types of MR contrast images in the dataset: T1-FLAIR (T1F), T2-weighted (T2w), T2-FLAIR (T2F), and T2-FLAIR* (T2F*). The first three contrasts were acquired from MAGnetic resonance image Compilation (MAGiC, GE Healthcare) and T2-FLAIR* was acquired by the addtional scan with different MR scan parameter of the third contrast (T2F). The details of MR acquisition parameters are available in Supplementary material.

CMU Multi-PIE For the illumination translation task, the subset of Carnegie Mellon Univesity Multi-Pose Illumination and Expression face database [12] was used. There were 250 participants in the first session and the frontal face of neutral expression were selected with the following five illumination conditions: -90°(right), -45°, 0°(front), 45°and 90°(left). The images were cropped by 240$\times$240 where the faces are centered as shown in Fig. 4.

RaFD The Radboud Faces Database (RaFD) [20] contains eight different facial expressions collected from the 67 participants; neutral, angry, contemptuous, disgusted, fearful, happy, sad, and surprised. Also, there are three different gaze directions and therefore total 1,608 images were divided by subjects for train, validation and test set. We crop the images to 640$\times$640 and resize them to 128$\times$128.

4.2 Network Implementation

The proposed method consists of two networks, the generator and the discriminator (Fig. 2). To achieve the best performance for each task, we redesigned the generators and discriminator to fit for the property of each task, while the general network architecture are similar.

Generators

The generators are based on the U-net [28] structure. U-net consists of the encoder/decoder parts and the each parts between encoder/decoder are connected by contracting paths [28]. The instance normalization [32] and Leaky-ReLU [13] was used instead of batch normalization and ReLU, respectively. We also redesigned the architecture of the networks to fit for each task as described in the followings.

MR contrast translation There are various MR contrasts such as T1 weight contrast, T2 weight contrast, etc. The specific MR contrast scan is determined by the MRI scan parameters such as repetition time (TR), echo time (TE) and so on. The pixel intensities of the MR contrast image are decided based on the physical property of the tissues called MR parameters of the tissues, such as T1, T2, proton density, etc. The MR parameter is the voxel-wise property. This means that for the convolutional neural network, the pixel-by-pixel processing is just as important as processing with the information from neighborhood and/or a large FOV. Thus, instead of using single convolution, the generator uses two convolution branches with 1x1 and 3x3 filters to handle the multi-scale feature information. The two branches of the convolutions are concatenated similar to the inception network [30].

Illumination translation For the illumination translation task, the original U-net structure with instance normalization [32] was used instead of batch normalization.

Facial expression translation For the facial expression translation task, the inputs are multiple facial images with various facial expressions. Since there exists the head movements of the subjects between the facial expressions, the images are not strictly aligned pixel-wise manner. If we use the original U-net for the facial expresion images-to-image task, the generator show poor performance because the informations from the multiple facial expressions are mixed up in the very early stage of the network. From the intuition, the features from the facial expressions should be mixed up in the middle stage of the generator where the features are calculated from the large FOV or already downsampled by pooling layers. Thus, the generators are redesigned with eight branches of encoders for each eight facial expressions and they are concatenated after the encoding process at the middle stage of the generator. The structure of the decoder is similar to decoder parts of U-net except for the use of the residual blocks [14] to add more convolutional layers. The more details about the generator are available in Supplementary material.

Discriminator

The discriminators commonly composed of a series of convolution layer and Leaky-ReLU [13]. As shown in Fig. 2, the discriminator has two output headers: one is the classification header for real or fake and the other is classification header for the domain. PatchGAN [17, 36] was utilized to classify whether local image patches are real or fake. The dropout [15, 29] was very effective to prevent the overfitting of the discriminator. Exceptionally, the discriminator of MR contrast translation has branches for multi-scale processing. The details of the specific discriminator architecture is available in Supplementary Material.

4.3 Network Training

All the models were optimized using Adam [19] with a learning rate of 0.00001, $\beta_{1}=0.9$ and $\beta_{2}=0.999$. As mentioned before, the performance of the classfier should be associated only to real labels which means it should be trained only using the real data. Thus, we first trained the classifier on real images with its corresponding labels for the first 10 epochs, and then we trained the generator and the discriminator simultaneously. Training takes about six hours, half a day, and one day for the MR contrast translation task, illumination translation, and facial expression translation task, respectively, using a single NVIDIA GTX 1080 GPU.

For the illumination translation task, YCbCr color coding was used instead of RGB color coding. YCbCr coding consists of the Y-luminance and CbCr-color space. There are five different illumination images. They almost share the CbCr codings and the only difference is Y-luminance channel. Thus, the only Y-luminance channels were processed for the illumination translation tasks and then the reconstructed images coverted to RGB coded images. We used RGB channels for facial expression translation task, and the MR contrast dataset consists of single-channel images.

5 Experimental Results

For all three image imputation tasks, each datasets were divided into the train, validation and test sets by the subjects. Thus, all our experiments were performed using the unseen images during the training phase. We compared the performance of the proposed method with CycleGAN [36] and StarGAN [4] which are the representative models for image translation tasks.

5.1 Results of MR contrast imputation

First, we trained the models on MR contrast dataset to learn the task of synthesizing the other contrasts. In fact, this was the original motivation of this study that was inspired by the clinical needs. There are four different MR contrasts in the dataset and the generator learns the mapping from one contrast to the other contrast.

As shown in Fig. 3, the proposed method reconstructed the four different MR contrasts, which are very similar to the targets, while StarGAN shows poor results. For the quantitative evaluation, a normalized mean squared error (NMSE) and SSIM were calculated between the reconstruction and the target. Compared to the results of CycleGAN and StarGAN, the four contrast MR images were reconstructed with minimum errors using the proposed method. Since there are so many variables that affect the pixel intensity of MR images, it is necessary to use the pixels from at least three different contrast to accurately estimate the intensity of the other contrast. Thus, there exists a limitation on CycleGAN or StarGAN, since they uses a single input contrast.

For example, consider the reconstruction of T2 weighted image from the T2 FLAIR* input in Fig. 3. The cerebrospinal fluid (CSF) in the T2-weighted image should be bright, while in the T2-FLAIR* it should be dark (yellow and green arrows in Fig. 3). When StarGAN tries to generate the T2 weighted image from the T2 FLAIR*, this should be difficult because the input pixels are close to zero. StarGAN somehow reconstructed the CSF pixels near the gray matter (yellow arrow in Fig. 3) with the help of the neighborhood, but the larger CSF area (green arrow in Fig. 3) cannot be reconstructed because the help of neighborhood pixels is limited. The proposed method, however, utilized the combination of the inputs to accurately reconstruct every pixel.

5.2 Results of illumination imputation

We trained CycleGAN, StarGAN and the proposed method using CMU Multi-PIE dataset for the illumination imputation task. Given five different illumination directions, the input domain for CycleGAN and StarGAN was fixed as the frontal illumination (0°).

As shown in Fig. 4, the proposed method clearly generates the natural illuminations while properly maintaining the color, brightness balance, and textures of the facial images. Compared to the results of CycleGAN and StarGAN, CollaGAN produces the natural illuminations with minimum errors (NMSE/SSIM in Fig. 4). The CycleGAN and StarGAN also generate the four different illumination images from the frontal illumination input. In the result of CycleGAN, however, we can see the emphasis of the red channel and the image looks reddish overall. Also the resulting image looks like a graphic model or a drawing, rather than a photo. The resulting image of StarGAN was only adjusted to the left and right of the illumination smoothly, but did not reflect detailed illumination such as the structure of the face. And unnatural lighting changes were observed on the result of StarGAN.

The proposed method shows the most natural lighting images among the three algorithms. While CycleGAN and StarGAN had simply adjusted the brightness of the left and right sides of the images, the shadow caused by the shape of the nose, the cheek and the jaw is expressed naturally in the proposed method (Fig. 4 yellow arrows).

5.3 Results of facial expression imputation

The eight facial expressions in RaFD were used to train the proposed model for facial expression imputation. The input domain for CycleGAN and StarGAN was defined as a neutral expression among the eight different facial expressions. Different facial expressions were reconstructed naturally using the proposed method as shown in Fig. 5. The CollaGAN produces the most natural images with minimum NMSE and best SSIM scores compared to the CycleGAN and StarGAN as you can see in Fig. 5. Compared with the results of StarGAN, which uses only the single input, the proposed method utilizes as much information as possible from the combinations of facial expressions. As shown in the generated results of CycleGAN and StarGAN (Fig. 5), the generated results of ‘sad’ were very similar to the generated image of ‘neutral’ which was the input of them, while the proposed method expressed the ‘sad’ very well. With a help of multiple cycle consistency, the proposed method clearly generates the natural facial expressions while preserving the identity correctly.

5.4 Effect of incomplete input set

In order to investigate the robustness of the proposed method, we demonstrated CollaGAN results from incomplete input set. If there are two missing facial expressions (eg. ‘happy’ and ‘neutral’) and one is interested in reconstruct the missing image (eg. ‘happy’), one can substitute one image (eg.‘neutral’) from the other subject as one of the input for the CollaGAN. As shown in Fig. 6, the generated image from incomplete input set with the substitute data from others shows similar results compared to the complete input set. CollaGAN utilized the other subject’s facial information (eg. ‘neutral’) to impute the missing facial expression (eg. ‘happy’).

6 Conclusion

In this paper, we presented a novel CollaGAN architecture for missing image data imputation by synergistically combining the information from the available data with the help of a single generator and discriminator. We showed that the proposed method produces images of higher visual quality compared to the existing methods. Therefore, we believe that CollaGAN is a promising algorithm for missing image data imputation in many real world applications.

Acknowledgement. This work was supported by National Research Foundation of Korea under Grant NRF-2016R1A2B3008104 and Institute for Information & Communications Technology Promotion (IITP) grant funded by the Korea government (MSIT) [2016-0-00562(R0124-16-0002), Emotional Intelligence Technology to Infer Human Emotion and Carry on Dialogue Accordingly].

Appendix

7 Collaborative training

This section describes the experiments that further analyze the importance of multi-inputs by providing additional qualitative results.

7.1 Effects of input dropout

The input of the proposed method is much more informative than StarGAN [4]. In other words, there might exist some wasted inputs since there is some redundancy of the inputs. For example on RaFD [20], if ‘Happy’ image plays a major role for reconstructing ‘Angry’ images, the other facial expressions may contribute little on the output, which is not collaborative. To achieve the collaborative learning, it is imporatant to use random nulling on the inputs (control of the number of missing imputs). Thus, the random nulling of the input images helps to increase the contribution of the other facial expressions evenly. It could be treated as a dropout [29] layer on the input images. The contribution of the input dropout is as shown in Fig. 7. The input dropout increases the performance of the reconstruction quality for all ‘Missing $N$’ since the inputs contribute more evenly to the reconstruction.

7.2 Incompelete input datasets

To investigate the effects of the number of inputs, we compared the reconstruction results with the control of the missing number of inputs. Figure. 8 shows the reconstruction results ‘Happy’ and ‘Angry’ using the inputs with different missing values from seven to one. As the amount of input information increased, the reconstruction results improved qualitatively as shown in Fig. 8.

8 Implementation Details

8.1 Details of MR acquisition parameter

Among the four different contrasts, three of them were synthetically generated from the MAGiC sequence (T1F, T2w and T2F) and the other was additionally scanned by conventional T2-FLAIR sequence (T2F*). The MR acquisition parameters are shown in Table. 1.

8.2 Network Implementation

The proposed method consists of two networks, the generator and the discriminator. There are three tasks (MR contrasts imputation, illumination imputation and facial expression imputation) and each task has its own property. Therefore, we redesigned the generators and discriminator for each tasks to achieve the best performance for each task while the general network architecture are similar.

MR contrast translation Instead of using single convolution, the generator uses two convolution branches with 1x1 and 3x3 filters to handle the multi-scale feature information. The two branches of the convolutions are concatenated similar to the inception network [30]. We called this series of two convolution, concatenation, instance normalization [32] and leaky-ReLU [13], CCNR unit, as shown in Table. 2. These CCNR units help the pixel-by-pixel processing of the CNN as well as the processing with a large FOV. The architecture of the generator describes in Table. 2 and Fig. 9.

To classify the MR contrast, multi-scale (multi-resolution) processing is important. The discriminator has three branches that each has different scales as shown in Table. 3. A branch handles the feature on the original resolution. Another branch process the features on the quater-resolution scales ($height/4,width/4$). The other one sequentially reduces the scales for extract features. Three branches are concatenated to process multi-scale features. Similar architecture with this kind of multi-scale approach works well to classify the MR contrast [27].

Illumination translation Architecture of the generator used for illumination translation. It is similar to original U-net structure with instance normalization (N) and leaky-ReLU (L) instead of batch normalization and ReLU, respectively, as shown in Table. 4 and Fig. 10.

The discriminator is consists of convolutions with strides 2 and instance normalization. At the end of the discriminator, there are two branch [4]: one for discriminating real/fake and the other for the domain classification. Here, patchGAN [17, 36] was utilized to classify the source (real/fake).

Facial expression translation For the generator of facial expression translation, we designed a multi-branched U-net which has individual encoder for each input images (Fig. 11). The default architecture is based on U-net structure. The generator consists of two part: encoder and decoder. In the encoding step, each image are encoded separately by eight branches. Here, the mask vector is concatenated to every input images to extract the feature for the target domain. Then, the encoded features are concatenated in the decoder and the decoder shares the structure of the modified U-net as explained in Table. 4. The discriminator shares the architecture with the one used for the illumination translation task (Table. 5) except fot the last fully-connected layer has eight channels for eigth facial expression classification.

9 Additional evaluation results

Quantitative evaluation: The results of the facial expression and illumination need to be evaluated based on the realistic image quality and the classification performance by the domain classifier. In the following, however, quantitative evaluation for facial expression and illumination imputation is provided in the form of a table in terms of NMSE (normalized mean squared error) and SSIM (structural similarity index).

Additionally, we also presented the results of pix2pix [17] which is a single-pair supervised method, to understand whether the proposed multiple cycle consistency losses actually allow for even better performance.

Table 6 & 7 show the additional quantitative evaluation result showing that CollaGAN is better compared to the other algorithms. Here, pix2pix[17], which directly imposes the loss between the generator output and the target data, was also used for the comparison. While pix2pix[17] shows better reconstruction performance compared to CycleGAN and StarGAN, the proposed method shows the best performance as shown in Table 6 & 7 even for paired dataset.

Additional qualitative evaluation : We performed an additional quality assessment by Mechanical Turk experiment for more elaborate qualitative evaluation on the reconstruction results (Table. 8). We asked 30 participants to select the best image according to the image quality and how well the result represents the facial expression of the target domain. 70.8% of the reconstruction results from CollaGAN was chosen as the best reconstruction.

10 Ablation study

To verify the advantage of the proposed multiple-cycle consistency (MCC) loss and SSIM loss, ablation studies were performed using RaFD dataset, and the results are presented in Table 9.

When multiple cycle consistency loss was replaced with $l_{1}$ loss (i.e. direct regression from multiple inputs to the single target), the results showed inferior performance compared to the proposed method. Also, we found that $L_{SSIM}$ improved the reconstruction performance in terms of NMSE and SSIM (Table 9).

10.1 Additional Qualitative Results