Title: INSTAGAN: INSTANCE-AWARE IMAGE-TO-IMAGE TRANSLATION

Abstract: Unsupervised image-to-image translation has gained considerable attention due to the recent impressive progress based on generative adversarial networks (GANs). However, previous methods often fail in challenging cases, in particular, when an image has multiple target instances and a translation task involves significant changes in shape, e.g., translating pants to skirts in fashion images. To tackle the issues, we propose a novel method, coined instance-aware GAN (InstaGAN), that incorporates the instance information (e.g., object segmentation masks) and improves multi-instance transfiguration. The proposed method translates both an image and the corresponding set of instance attributes while maintaining the permutation invariance property of the instances. To this end, we introduce a context preserving loss that encourages the network to learn the identity function outside of target instances. We also propose a sequential mini-batch inference/training technique that handles multiple instances with a limited GPU memory and enhances the network to generalize better for multiple instances. Our comparative evaluation demonstrates the effectiveness of the proposed method on different image datasets, in particular, in the aforementioned challenging cases. Code and results are available in https://github.com/sangwoomo/instagan.

1. INTRODUCTION:

Cross-domain generation arises in many machine learning tasks, including neural machine translation (Artetxe et al., 2017; Lample et al., 2017) , image synthesis (Reed et al., 2016; Zhu et al., 2016) , text style transfer (Shen et al., 2017) , and video generation (Bansal et al., 2018; Wang et al., 2018a; Chan et al., 2018) . In particular, the unpaired (or unsupervised) image-to-image translation has achieved an impressive progress based on variants of generative adversarial networks (GANs) (Zhu et al., 2017; Liu et al., 2017; Choi et al., 2017; Almahairi et al., 2018; Huang et al., 2018; Lee et al., 2018) , and has also drawn considerable attention due to its practical applications including colorization (Zhang et al., 2016) , super-resolution (Ledig et al., 2017) , semantic manipulation (Wang et al., 2018b) , and domain adaptation (Bousmalis et al., 2017; Shrivastava et al., 2017; Hoffman et al., 2017) . Previous methods on this line of research, however, often fail on challenging tasks, in particular, when the translation task involves significant changes in shape of instances (Zhu et al., 2017) or the images to translate contains multiple target instances (Gokaslan et al., 2018) . Our goal is to extend image-to-image translation towards such challenging tasks, which can strengthen its applicability up to the next level, e.g., changing pants to skirts in fashion images for a customer to decide which one is better to buy. To this end, we propose a novel method that incorporates the instance information of multiple target objectsin the framework of generative adversarial networks (GAN); hence we called it instance-aware GAN (InstaGAN) . In this work, we use the object segmentation masks for instance information, which may be a good representation for instance shapes, as it contains object boundaries while ignoring other details such as color. Using the information, our method shows impressive results for multi-instance transfiguration tasks, as shown in Figure 1 .

Our main contribution is three-fold: an instance-augmented neural architecture, a context preserving loss, and a sequential mini-batch inference/training technique. First, we propose a neural network architecture that translates both an image and the corresponding set of instance attributes. Our architecture can translate an arbitrary number of instance attributes conditioned by the input, and is designed to be permutation-invariant to the order of instances. Second, we propose a context preserv- 2017)), and our proposed method, InstaGAN. Our method shows better results for multi-instance transfiguration problems.

ing loss that encourages the network to focus on target instances in translation and learn an identity function outside of them. Namely, it aims at preserving the background context while transforming the target instances. Finally, we propose a sequential mini-batch inference/training technique, i.e., translating the mini-batches of instance attributes sequentially, instead of doing the entire set at once. It allows to handle a large number of instance attributes with a limited GPU memory, and thus enhances the network to generalize better for images with many instances. Furthermore, it improves the translation quality of images with even a few instances because it acts as data augmentation during training by producing multiple intermediate samples. All the aforementioned contributions are dedicated to how to incorporates the instance information (e.g., segmentation masks) for image-to-image translation. However, we believe that our approach is applicable to numerous other cross-domain generation tasks where set-structured side information is available.

To the best of our knowledge, we are the first to report image-to-image translation results for multiinstance transfiguration tasks. A few number of recent methods (Kim et al., 2017; Liu et al., 2017; Gokaslan et al., 2018) show some transfiguration results but only for images with a single instance often in a clear background. Unlike the previous results in a simple setting, our focus is on the harmony of instances naturally rendered with the background. On the other hand, CycleGAN (Zhu et al., 2017) show some results for multi-instance cases, but report only a limited performance for transfiguration tasks. At a high level, the significance of our work is also on discovering that the instance information is effective for shape-transforming image-to-image translation, which we think would be influential to other related research in the future. Mask contrast-GAN (Liang et al., 2017) and Attention-GAN (Mejjati et al., 2018) use segmentation masks or predicted attentions, but only to attach the background to the (translated) cropped instances. They do not allow to transform the shapes of the instances. To the contrary, our method learns how to preserve the background by optimizing the context preserving loss, thus facilitating the shape transformation.

2. INSTAGAN: INSTANCE-AWARE IMAGE-TO-IMAGE TRANSLATION:

Given two image domains X and Y, the problem of image-to-image translation aims to learn mappings across different image domains, G XY : X → Y or/and G YX : Y → X , i.e., transforming target scene elements while preserving the original contexts. This can also be formulated as a conditional generative modeling task where we estimate the conditionals p(y|x) or/and p(x|y). The goal of unsupervised translation we tackle is to recover such mappings only using unpaired samples from marginal distributions of original data, p data (x) and p data (y) of two image domains.

The main and unique idea of our approach is to incorporate the additional instance information, i.e., augment a space of set of instance attributes A to the original image space X , to improve the image-to-image translation. The set of instance attributes a ∈ A comprises all individual attributes of N target instances: a = {a i } N i=1 . In this work, we use an instance segmentation mask only, but we remark that any useful type of instance information can be incorporated for the attributes. Our approach then can be described as learning joint-mappings between attribute-augmented spaces X ×A and Y ×B. This leads to disentangle different instances in the image and allows the generator to perform an accurate and detailed translation. We learn our attribute-augmented mapping in the framework of generative adversarial networks (GANs) (Goodfellow et al., 2014) , hence, we call it instance-aware GAN (InstaGAN). We present details of our approach in the following subsections.

2.1. INSTAGAN ARCHITECTURE:

Recent GAN-based methods (Zhu et al., 2017; Liu et al., 2017) have achieved impressive performance in the unsupervised translation by jointly training two coupled mappings G XY and G YX with To achieve properties, we sum features of all set elements for invariance, and then concatenate it with the identity mapping for equivariance.

a cycle-consistency loss that encourages G YX (G XY (x)) ≈ x and G XY (G YX (y)) ≈ y. Namely, we choose to leverage the CycleGAN approach (Zhu et al., 2017) to build our InstaGAN. However, we remark that training two coupled mappings is not essential for our method, and one can also design a single mapping following other approaches (Benaim & Wolf, 2017; Galanti et al., 2018) . Figure 2 illustrates the overall architecture of our model. We train two coupled generators Our generator G encodes both x and a, and translates them into y and b . Notably, the order of the instance attributes in the set a should not affect the translated image y , and each instance attribute in the set a should be translated to the corresponding one in b . In other words, y is permutation-invariant with respect to the instances in a, and b is permutation-equivariant with respect to them. These properties can be implemented by introducing proper operators in feature encoding (Zaheer et al., 2017) . We first extract individual features from image and attributes using image feature extractor f GX and attribute feature extractor f GA , respectively. The attribute features individually extracted using f GA are then aggregated into a permutation-invariant set feature via summation:

G XY : X × A → Y × B and G YX : Y × B → X × A,

N i=1 f GA (a i ).

As illustrated in Figure 2b , we concatenate some of image and attribute features with the set feature, and feed them to image and attribute generators. Formally, the image representation h GX and the n-th attribute representation h n GA in generator G can be formulated as:

EQUATION

where each attribute encoding h n GA process features of all attributes as a contextual feature. Finally, h GX is fed to the image generator g GX , and h n GA (n = 1, . . . , N ) are to the attribute generator g GA . On the other hand, our discriminator D encodes both x and a (or x and a ), and determines whether the pair is from the domain or not. Here, the order of the instance attributes in the set a should not affect the output. In a similar manner above, our representation in discriminator D, which is permutation-invariant to the instances, is formulated as:

EQUATION

which is fed to an adversarial discriminator g DX .

We emphasize that the joint encoding of both image x and instance attributes a for each neural component is crucial because it allows the network to learn the relation between x and a. For example, if two separate encodings and discriminators are used for x and a, the generator may be misled to produce image and instance masks that do not match with each other. By using the joint encoding and discriminator, our generator can produce an image of instances properly depicted on the area consistent with its segmentation masks. As will be seen in Section 3, our approach can disentangle output instances considering their original layouts. Note that any types of neural networks may be used for sub-network architectures mentioned above such as f GX , f GA , f DX , f DA , g GX , g GA , and g DX . We describe the detailed architectures used in our experiments in Appendix A.

2.2. TRAINING LOSS:

Remind that an image-to-image translation model aims to translate a domain while keeping the original contexts (e.g., background or instances' domain-independent characteristics such as the looking direction). To this end, we both consider the domain loss, which makes the generated outputs to follow the style of a target domain, and the content loss, which makes the outputs to keep the original contents. Following our baseline model, CycleGAN (Zhu et al., 2017) , we use the GAN loss for the domain loss, and consider both the cycle-consistency loss (Kim et al., 2017; Yi et al., 2017) and the identity mapping loss (Taigman et al., 2016) for the content losses. 1 In addition, we also propose a new content loss, coined context preserving loss, using the original and predicted segmentation information. In what follows, we formally define our training loss in detail.

For simplicity, we denote our loss function as a function of a single training sample (x, a) ∈ X × A and (y, b) ∈ Y × B, while one has to minimize its empirical means in training.

The GAN loss is originally proposed by Goodfellow et al. (2014) for generative modeling via alternately training generator G and discriminator D. Here, D determines if the data is a real one of a fake/generated/translated one made by G. There are numerous variants of the GAN loss (Nowozin et al., 2016; Arjovsky et al., 2017; Li et al., 2017; Mroueh et al., 2017) , and we follow the LSGAN scheme (Mao et al., 2017) , which is empirically known to show a stably good performance:

L LSGAN = (D X (x, a) -1) 2 + D X (G YX (y, b)) 2 + (D Y (y, b) -1) 2 + D Y (G XY (x, a)) 2 . (3)

For keeping the original content, the cycle-consistency loss L cyc and the identity mapping loss L idt enforce samples not to lose the original information after translating twice and once, respectively:

L cyc = G YX (G XY (x, a)) -(x, a) 1 + G XY (G YX (y, b)) -(y, b) 1 , (4) L idt = G XY (y, b) -(y, b) 1 + G YX (x, a) -(x, a) 1 .

(5)

Finally, our newly proposed context preserving loss L ctx enforces to translate instances only, while keeping outside of them, i.e., background. Formally, it is a pixel-wise weighted 1 -loss where the weight is 1 for background and 0 for instances. Here, note that backgrounds for two domains become different in transfiguration-type translation involving significant shape changes. Hence, we consider the non-zero weight only if a pixel is in background in both original and translated ones. Namely, for the original samples (x, a), (y, b) and the translated one (y , b ), (x , a ), we let the weight w(a, b ), w(b, a ) be one minus the element-wise minimum of binary represented instance masks, and we propose

L ctx = w(a, b ) (x -y ) 1 ] + w(b, a ) (y -x ) 1 (6)

where is the element-wise product. In our experiments, we found that the context preserving loss not only keeps the background better, but also improves the quality of generated instance segmentations. Finally, the total loss of InstaGAN is

EQUATION

where λ cyc , λ idt , λ ctx > 0 are some hyper-parameters balancing the losses.

2.3. SEQUENTIAL MINI-BATCH TRANSLATION:

While the proposed architecture is able to translate an arbitrary number of instances in principle, the GPU memory required linearly increases with the number of instances. For example, in our experiments, a machine was able to forward only a small number (say, 2) of instance attributes Given an input (x, a), we first divide the set of instance masks a into mini-batches a 1 , . . . , a M , i.e., a = i a i and a i ∩ a j = ∅ for i = j. Then, at the m-th iteration for m = 1, 2, . . . , M , we translate the image-mask pair (x m , a m ), where x m is the translated image y m-1 from the previous iteration, and x 1 = x. In this sequential scheme, at each iteration, the generator G outputs an intermediate translated image y m , which accumulates all mini-batch translations up to the current iteration, and a translated mini-batch of instance masks b m :

EQUATION

In order to align the translated image with mini-batches of instance masks, we aggregate all the translated mini-batch and produce a translated sample:

EQUATION

The final output of the proposed sequential inference scheme is (y M , b 1:M ).

We also propose the corresponding sequential training algorithm, as illustrated in Figure 3 . We apply content loss (4-6) to the intermediate samples (y m , b m ) of current mini-batch a m , as it is just a function of inputs and outputs of the generator G.2 In contrast, we apply GAN loss (3) to the samples of aggregated mini-batches (y m , b 1:m ), because the network fails to align images and masks when using only a partial subset of instance masks. We used real/original samples {x} with the full set of instance masks only. Formally, the sequential version of the training loss of InstaGAN is

EQUATION

where

L content = λ cyc L cyc + λ idt L idt + λ ctx L ctx .

We detach every m-th iteration of training, i.e., backpropagating with the mini-batch a m , so that only a fixed GPU memory is required, regardless of the number of training instances.3 Hence, the sequential training allows for training with samples containing many instances, and thus improves the generalization performance. Furthermore, it also improves translation of an image even with a few instances, compared to the one-step approach, due to its data augmentation effect using intermediate samples (x m , a m ). In our experiments, we divided the instances into mini-batches a 1 , . . . , a M according to the decreasing order of the spatial sizes of instances. Interestingly, the decreasing order showed a better performance than the random order. We believe that this is because small instances tend to be occluded by other instances in images, thus often losing their intrinsic shape information.

3. EXPERIMENTAL RESULTS:



3.1. IMAGE-TO-IMAGE TRANSLATION RESULTS:

We first qualitatively evaluate our method on various datasets. We compare our model, InstaGAN, with the baseline model, CycleGAN (Zhu et al., 2017) . For fair comparisons, we doubled the number of parameters of CycleGAN, as InstaGAN uses two networks for image and masks, respectively. We sample two classes from various datasets, including clothing co-parsing (CCP) (Yang et al., Figure 8 : Translation results on CCP dataset, using predicted mask for inference.

2014), multi-human parsing (MHP) (Zhao et al., 2018) , and MS COCO (Lin et al., 2014) datasets, and use them as the two domains for translation. In visualizations, we merge all instance masks into one for the sake of compactness. See Appendix B for detailed settings for our experiments. The translation results for three datasets are presented in Figure 4 , 5, and 6, respectively. While CycleGAN mostly fails, our method generates reasonable shapes of the target instances and keeps the original contexts by focusing on the instances via the context preserving loss. For example, see the results on sheep↔giraffe in Figure 6 . CycleGAN often generates sheep-like instances but loses the original background. InstaGAN not only generates better sheep or giraffes, but also preserves the layout of the original instances, i.e., the looking direction (left, right, front) of sheep and giraffes are consistent after translation. More experimental results are presented in Appendix E. Code and results are available in https://github.com/sangwoomo/instagan.

On the other hand, our method can control the instances to translate by conditioning the input, as shown in Figure 7 . Such a control is impossible under CycleGAN. We also note that we focus on complex (multi-instance transfiguration) tasks to emphasize the advantages of our method. Nevertheless, our method is also attractive to use even for simple tasks (e.g., horse↔zebra) as it reduces false positives/negatives via the context preserving loss and enables to control translation. We finally emphasize that our method showed good results even when we use predicted segmentation for inference, as shown in Figure 8 , and this can reduce the cost of collecting mask labels in practice. 4Finally, we also quantitatively evaluate the translation performance of our method. We measure the classification score, the ratio of images predicted as the target class by a pretrained classifier. Specifically, we fine-tune the final layers of the ImageNet (Deng et al., 2009) pretrained VGG-16 (Simonyan & Zisserman, 2014) network, as a binary classifier for each domain. Table 1 and Table 2 in Appendix D show the classification scores for CCP and COCO datasets, respectively. Our method outperforms CycleGAN in all classification experiments, e.g., ours achieves 23.2% accuracy for the pants→shorts task, while CycleGAN obtains only 8.5%.

3.2. ABLATION STUDY:

We now investigate the effects of each component of our proposed method in Figure 9 . Our method is composed of the InstaGAN architecture, the context preserving loss L ctx , and the sequential minibatch inference/training technique. We progressively add each component to the baseline model, CycleGAN (with doubled parameters). First, we study the effect of our architecture. For fair comparison, we train a CycleGAN model with an additional input channel, which translates the mask-augmented image, hence we call it CycleGAN+Seg. Unlike our architecture which translates the set of instance masks, CycleGAN+Seg translates the union of all masks at once. Due to this, CycleGAN+Seg fails to translate some instances and often merge them. On the other hand, our architecture keeps every instance and disentangles better. Second, we study the effect of the context preserving loss: it not only preserves the background better (row 2), but also improves the translation results as it regularizes the mapping (row 3). Third, we study the effect of our sequential translation: it not only improves the generalization performance (row 2,3) but also improves the translation results on few instances, via data augmentation (row 1).

Finally, Figure 10 reports how much the sequential translation, denoted by "Seq", is effective in inference and training, compared to the one-step approach, denoted by "One". For the one-step training, we consider only two instances, as it is the maximum number affordable for our machines.

On the other hand, for the sequential training, we sequentially train two instances twice, i.e., images of four instances. For the one-step inference, we translate the entire set at once, and for the sequential inference, we sequentially translate two instances at each iteration. We find that our sequential algorithm is effective for both training and inference: (a) training/inference = One/Seq shows blurry results as intermediate data have not shown during training and stacks noise as the iteration goes, and (b) Seq/One shows poor generalization performance for multiple instances as the one-step inference for many instances is not shown in training (due to a limited GPU memory).

4. CONCLUSION:

We have proposed a novel method incorporating the set of instance attributes for image-to-image translation. The experiments on different datasets have shown successful image-to-image translation on the challenging tasks of multi-instance transfiguration, including new tasks, e.g., translating jeans to skirt in fashion images. We remark that our ideas utilizing the set-structured side information have potential to be applied to other cross-domain generations tasks, e.g., neural machine translation or video generation. Investigating new tasks and new information could be an interesting research direction in the future.

D QUANTITATIVE RESULTS:

We evaluated the classification score for CCP and COCO dataset. Unlike CCP dataset, COCO dataset suffers from the false positive problem, that the classifier fails to determine if the generator produced target instances on the right place. To overcome this issue, we measured the masked classification score, where the input images are masked by the corresponding segmentations. We note that CycleGAN and our method showed comparable results for the naïve classification score, but ours outperformed for the masked classification score, as it reduces the false positive problem. 

E MORE TRANSLATION RESULTS:

We present more qualitative results in high resolution images.

Figure 12 : Translation results for images searched from Google to test the generalization performance of our model. We used a pix2pix (Isola et al., 2017) model to predict the segmentation. 

F MORE COMPARISONS WITH CYCLEGAN+SEG:

To demonstrate the effectiveness of our method further, we provide more comparison results with CycleGAN+Seg. Since CycleGAN+Seg translates all instances at once, it often (a) fails to translate instances, or (b) merges multiple instances (see Figure 23 and 25), or (c) generates multiple instances from one instance (see Figure 24 and 26). On the other hand, our method does not have such issues due to its instance-aware nature. In addition, since the unioned mask losses the original shape information, our instance-aware method produces better shape results (e.g., see row 1 of Figure 25 ). 

G GENERALIZATION OF TRANSLATED MASKS:

To show that our model generalizes well, we searched the nearest training neighbors (in L 2 -norm) of translated target masks. As reported in Figure 27 , we observe that the translated masks (col 3,4) are often much different from the nearest neighbors (col 5,6) . This confirms that our model does not simply memorize training instance masks, but learns a mapping that generalizes for target instances. 

H TRANSLATION RESULTS OF CROP & ATTACH BASELINE:

For interested readers, we also present the translation results of the simple crop & attach baseline in Figure 28 , that find the nearest neighbors of the original masks from target masks, and crop & attach the corresponding image to the original image. Here, since the distance in pixel space (e.g., L 2 -norm) obviously does not capture semantics, the cropped instances do not fit with the original contexts as well. 

I VIDEO TRANSLATION RESULTS:

For interested readers, we also present video translation results in Figure 29 . Here, we use a predicted segmentation (generated by a pix2pix (Isola et al., 2017) model as in Figure 8 and Figure 12 ) for each frame. Similar to CycleGAN, our method shows temporally coherent results, even though we did not used any explicit regularization. One might design a more advanced version of our model utilizing temporal patterns e.g., using the idea of Recycle-GAN (Bansal et al., 2018) for video-to-video translation, which we think is an interesting future direction to explore.

Figure 29 : Original images (row 1) and translated results of our method (row 2) on a video searched from YouTube. We present translation results on successive eight frames for visualization.

:

We remark that the identity mapping loss is also used in CycleGAN (see Figure9ofZhu et al. (2017)).

The cycle-consistency loss (4) needs reconstruction sample (x m , a m ). However, it is just a twice translated current mini-batch sample, i.e., for the opposite direction generator G , (x m , a m ) = G (G(xm, am)).

3 We still recommend users to increase the subset size as long as the GPU memory allows. This is because too many sequential steps may hurt the permutation-invariance property of our model.

For the results in Figure8, we trained a pix2pix(Isola et al., 2017) model to predict a single mask from an image, but one can also utilize recent methods to predict instance masks in supervised(He et al., 2017) or weakly-supervised(Zhou et al., 2018) way.

Figures and Tables:

Figure 1: Translation results of the prior work (CycleGAN, Zhu et al. (2017)), and our proposed method, InstaGAN. Our method shows better results for multi-instance transfiguration problems.

Figure 2: (a) Overview of InstaGAN, where generators G XY , G YX and discriminator D X , D Y follows the architectures in (b) and (c), respectively. Each network is designed to encode both an image and set of instance masks. G is permutation equivariant, and D is permutation invariant to the set order.To achieve properties, we sum features of all set elements for invariance, and then concatenate it with the identity mapping for equivariance.

where G XY translates the original data (x, a) to the target domain data (y , b ) (and vice versa for G YX ), with adversarial discriminators D X : X × A → {'X', 'not X'} and D Y : Y × B → {'Y', 'not Y'}, where D X determines if the data (original (x, a) or translated (x , a )) is in the target domain X × A or not (and vice versa for D Y ).

Figure 3: Overview of the sequential mini-batch training with instance subsets (mini-batches) of size 1,2, and 1, as shown in the top right side. The content loss is applied to the intermediate samples of current mini-batch, and GAN loss is applied to the samples of aggregated mini-batches. We detach every iteration in training, in that the real line indicates the backpropagated paths and dashed lines indicates the detached paths. See text for details.

Figure 4: Translation results on clothing co-parsing (CCP) (Yang et al., 2014) dataset.

Figure 5: Translation results on multi-human parsing (MHP) (Zhao et al., 2018) dataset.

Figure 6: Translation results on COCO (Lin et al., 2014) dataset.

Figure 7: Results of InstaGAN varying over different input masks.

Figure 9: Ablation study on the effect of each component of our method: the InstaGAN architecture, the context preserving loss, and the sequential mini-batch inference/training algorithm, which are denoted as InstaGAN, L ctx , and Sequential, respectively.

Figure 10: Ablation study on the effects of the sequential mini-batch inference/training technique. The left and right side of title indicates which method used for training and inference, respectively, where "One" and "Seq" indicate the one-step and sequential schemes, respectively.

Figure 14: More translation results on MHP dataset (skirt→pants).

Figure 15: More translation results on COCO dataset (sheep→giraffe).

Figure 16: More translation results on COCO dataset (giraffe→sheep).

Figure 17: More translation results on COCO dataset (zebra→elephant).

Figure 18: More translation results on COCO dataset (elephant→zebra).

Figure 19: More translation results on COCO dataset (bird→zebra).

Figure 20: More translation results on COCO dataset (zebra→bird).

Figure 21: More translation results on COCO dataset (horse→car).

Figure 22: More translation results on COCO dataset (car→horse).

Figure 23: Comparisons with CycleGAN+Seg on MHP dataset (pants→skirt).

Figure 25: Comparisons with CycleGAN+Seg on COCO dataset (sheep→giraffe).

Figure 26: Comparisons with CycleGAN+Seg on COCO dataset (giraffe→sheep).

Figure 27: Nearest training neighbors of translated masks.

Figure 28: Translation results of crop & attach baseline.

Classification score for CCP dataset.

Table content: <table><tr><td/><td colspan="2">jeans→skirt</td><td colspan="2">skirt→jeans</td><td colspan="4">shorts→pants pants→shorts</td></tr><tr><td/><td>train</td><td>test</td><td>train</td><td>test</td><td>train</td><td>test</td><td>train</td><td>test</td></tr><tr><td>Real</td><td colspan="8">0.970 0.888 0.982 0.946 1.000 0.984 0.990 0.720</td></tr><tr><td>CycleGAN</td><td colspan="8">0.465 0.371 0.561 0.483 0.845 0.524 0.305 0.085</td></tr><tr><td colspan="9">InstaGAN (ours) 0.665 0.600 0.658 0.540 0.898 0.768 0.373 0.232</td></tr></table>

Classification score (masked) for COCO dataset. InstaGAN (ours) 0.406 0.781 0.355 0.642 0.443 0.465 0.322 0.333

Table content: <table><tr><td/><td colspan="4">sheep→giraffe giraffe→sheep</td><td colspan="2">cup→bottle</td><td colspan="2">bottle→cup</td></tr><tr><td/><td>train</td><td>test</td><td>train</td><td>test</td><td>train</td><td>test</td><td>train</td><td>test</td></tr><tr><td>Real</td><td colspan="8">0.891 0.911 0.925 0.930 0.746 0.723 0.622 0.566</td></tr><tr><td>CycleGAN</td><td colspan="8">0.313 0.594 0.291 0.512 0.368 0.403 0.290 0.275</td></tr></table>

Peer review (iclr2019):
 Post rebuttal: I am satisfied by the points mentioned by authors! ---------------------------------------------------------------- Summary: The paper proposes to add instance-aware segmentation masks for the problem of unpaired image-to-image translation. A new formulation is proposed to incorporate instance masks with an input image to generate a new target image and corresponding mask. The authors demonstrate it on multiple tasks, and show nice results for each of them. Pros: 1. The formulation is intuitive and well done! 2. The idea of sequential mini-batch translation connects nicely to the old school of making images by layering. 3. Nice qualitative analysis, and good results in comparison with Cycle-GAN (an obvious baseline for the formulation). I would make an observation that two domains for translation (such as sheep to giraffe, jeans to skirts etc) are thoughtfully selected because Cycle-GAN is somewhat bound to fail on them. There is no way Cycle-GAN can work for jeans to skirts because by design the distribution for images from both set would be mostly similar, and it is way too hard for the discriminator to distinguish between two. This ultimately leads the generator to act as an identity mapping (easily observed in all the qualitative examples). 4. The proposed approach can easily find direct application in places where a user-control is required for image editing or synthesis. 5. The literature review is extensive. Cons: 1. My biggest criticism of this work is the absence of simple baselines. Given the fact that the formulation use an instance segmentation map with the given input, the following obvious baseline need consideration: Suppose the two domains are sheep and giraffe: a. given the input of sheep and its instance mask, find a shape/mask in giraffe from the training images that is closest (it could be same location in image or some other similarity measure). b. mask the input image using the sheep mask. Use giraffe mask and add corresponding RGB components of the masked giraffe (from the training set) to the masked input image. The above step would give a rough image with some holes. c. To remove holes, one can either use an image inpainting pipeline, or can also simply use a CNN with GAN loss. I believe that above pipeline should give competitive (if not better) outputs to the proposed formulation. (Note: the above pipeline could be considered a simpler version of PhotoClipArt from Lalonde et al, 2007). 2. Nearest neighbors on generated instance map needs to be done. This enables to understand if the generated shapes are similar to ones in training set, or there are new shapes/masks being generated. Looking at the current results, I believe that generated masks are very similar to the training instances for that category. And that makes baseline described in (1) even more important. 3. An interesting thing about Cycle-GAN is its ability to give somewhat temporally consistent (if not a lot) -- ex. Horse to Zebra output shown by the authors of Cycle-GAN. I am not sure if the proposed formulation will be able to give temporally consistent output on shorts/skirts to jeans example. It would be important to see how the generated output looks for a given video input containing a person and its segmentation map of jeans to generate a video of same person in shorts?