Original: U-GAT-IT: U NSUPERVISED G ENERATIVE A TTENTIONAL N ETWORKS WITH A DAPTIVE L AYERI NSTANCE N ORMALIZATION FOR I MAGE - TO -I MAGE T RANSLATION
Revised: U-GAT-IT: U NSUPERVISED G ENERATIVE A TTENTIONAL N ETWORKS WITH A DAPTIVE L AYERI NSTANCE N ORMALIZATION FOR I MAGE - TO -I MAGE T RANSLATION

Original: A BSTRACT
Revised: A BSTRACT

Original: We propose a novel method for unsupervised image-to-image translation, which incorporates a new attention module and a new learnable normalization function in an end-to-end manner.
Revised: We propose a novel method for unsupervised image-to-image translation, which incorporates a new attention module and a new learnable normalization function in an end-to-end manner.

Original: The attention module guides our model to focus on more important regions distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.
Revised: The attention module guides our model to focus on more important regions distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.

Original: Unlike previous attention-based method which cannot handle the geometric changes between domains, our model can translate both images requiring holistic changes and images requiring large shape changes.
Revised: Unlike previous attention-based method which cannot handle the geometric changes between domains, our model can translate both images requiring holistic changes and images requiring large shape changes.

Original: Moreover, our new AdaLIN (Adaptive Layer-Instance Normalization) function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture by learned parameters depending on datasets.
Revised: Moreover, our new AdaLIN (Adaptive Layer-Instance Normalization) function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture by learned parameters depending on datasets.

Original: Experimental results show the superiority of the proposed method compared to the existing state-of-the-art models with a ﬁxed network architecture and hyper-parameters.
Revised: Experimental results show the superiority of the proposed method compared to the existing state-of-the-art models with a ﬁxed network architecture and hyper-parameters.

Original: Our code and datasets are available at https://github.com/taki0112/UGATITor https://github.com/znxlwm/UGATITpytorch.
Revised: Our code and datasets are available at https://github.com/taki0112/UGATITor https://github.com/znxlwm/UGATITpytorch.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Image-to-image translation aims to learn a function that maps images within two different domains.
Revised: Image-to-image translation aims to learn a function that maps images within two different domains.

Original: This topic has gained a lot of attention from researchers in the ﬁelds of machine learning and computer vision because of its wide range of applications including image inpainting (Pathak et al.
Revised: This topic has gained a lot of attention from researchers in the ﬁelds of machine learning and computer vision because of its wide range of applications including image inpainting (Pathak et al.

Original: (2014); Iizuka et al.
Revised: (2014); Iizuka et al.

Original: , super resolution (Dong et al.
Revised: , super resolution (Dong et al.

Original: ; Kim et al.
Revised: ; Kim et al.

Original: , colorization (Zhang et al.
Revised: , colorization (Zhang et al.

Original: and style transfer (Gatys et al.
Revised: and style transfer (Gatys et al.

Original: ; Huang & Belongie (2017)).
Revised: ; Huang & Belongie (2017)).

Original: When paired samples are given, the mapping model can be trained in a supervised manner using a conditional generative model (Isola et al.
Revised: When paired samples are given, the mapping model can be trained in a supervised manner using a conditional generative model (Isola et al.

Original: ; Li et al.
Revised: ; Li et al.

Original: (2017a)
Revised: (2017a)

Original: ; Wang et al.
Revised: ; Wang et al.

Original: (2018)) or a simple regression model (Larsson et al.
Revised: (2018)) or a simple regression model (Larsson et al.

Original: ; Long et al. (2015); Zhang et al. (2016)).
Revised: ; Long et al. (2015); Zhang et al. (2016)).

Original: In unsupervised settings where no paired data is available, multiple works (Anoosheh et al.
Revised: In unsupervised settings where no paired data is available, multiple works (Anoosheh et al.

Original: ; Choi et al.
Revised: ; Choi et al.

Original: Huang et al.
Revised: Huang et al.

Original: ; Kim et al.
Revised: ; Kim et al.

Original: ; Liu et al.
Revised: ; Liu et al.

Original: Royer et al.
Revised: Royer et al.

Original: ; Taigman et al.
Revised: ; Taigman et al.

Original: Yi et al.
Revised: Yi et al.

Original: ; Zhu et al.
Revised: ; Zhu et al.

Original: (2017)) successfully have translated images using shared latent space (Liu et al.
Revised: (2017)) successfully have translated images using shared latent space (Liu et al.

Original: and cycle consistency assumptions (Kim et al.
Revised: and cycle consistency assumptions (Kim et al.

Original: ; Zhu et al.
Revised: ; Zhu et al.

Original: These works have been further developed to handle the multi-modality of the task (Huang et al.
Revised: These works have been further developed to handle the multi-modality of the task (Huang et al.

Original: Despite these advances, previous methods show performance differences depending on the amount of change in both shape and texture between domains.
Revised: Despite these advances, previous methods show performance differences depending on the amount of change in both shape and texture between domains.

Original: For example, they are successful for the style transfer tasks mapping local texture (e.g., photo2vangogh and photo2portrait) but are typically unsuccessful for image translation tasks with larger shape change (e.g., selﬁe2anime and cat2dog) in wild images.
Revised: For example, they are successful for the style transfer tasks mapping local texture (e.g., photo2vangogh and photo2portrait) but are typically unsuccessful for image translation tasks with larger shape change (e.g., selﬁe2anime and cat2dog) in wild images.

Original: Therefore, the pre-processing steps such as image cropping and alignment are often required to avoid these problems by limiting the complexity of the data distributions (Huang et al.
Revised: Therefore, the pre-processing steps such as image cropping and alignment are often required to avoid these problems by limiting the complexity of the data distributions (Huang et al.

Original: Liu et al.
Revised: Liu et al.

Original: In addition, existing methods such as DRIT (Lee et al.
Revised: In addition, existing methods such as DRIT (Lee et al.

Original: (2018)) cannot acquire the desired results for both image translation preserving the shape (e.g., horse2zebra) and image translation changing the shape (e.g., cat2dog) with the ﬁxed network architecture and hyperparameters.
Revised: (2018)) cannot acquire the desired results for both image translation preserving the shape (e.g., horse2zebra) and image translation changing the shape (e.g., cat2dog) with the ﬁxed network architecture and hyperparameters.

Original: The network structure or hyper-parameter setting needs to be adjusted for the speciﬁc dataset.
Revised: The network structure or hyper-parameter setting needs to be adjusted for the speciﬁc dataset.

Original: In this work, we propose a novel method for unsupervised image-to-image translation, which incorporates a new attention module and a new learnable normalization function in an end-to-end manner.
Revised: In this work, we propose a novel method for unsupervised image-to-image translation, which incorporates a new attention module and a new learnable normalization function in an end-to-end manner.

Original: Our model guides the translation to focus on more important regions and ignore minor regions by distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.
Revised: Our model guides the translation to focus on more important regions and ignore minor regions by distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.

Original: These attention maps are embedded into the generator and discriminator to focus on semantically important areas, thus facilitating the shape transformation.
Revised: These attention maps are embedded into the generator and discriminator to focus on semantically important areas, thus facilitating the shape transformation.

Original: While the attention map in the generator induces the focus on areas that speciﬁcally distinguish between the two domains, the attention map in the discriminator helps ﬁne-tuning by focusing on the difference between real image and fake image in target domain.
Revised: While the attention map in the generator induces the focus on areas that speciﬁcally distinguish between the two domains, the attention map in the discriminator helps ﬁne-tuning by focusing on the difference between real image and fake image in target domain.

Original: In addition to the attentional mechanism, we have found that the choice of the normalization function has a signiﬁcant impact on the quality of the transformed results for various datasets with different amounts of change in shape and texture.
Revised: In addition to the attentional mechanism, we have found that the choice of the normalization function has a signiﬁcant impact on the quality of the transformed results for various datasets with different amounts of change in shape and texture.

Original: Inspired by Batch-Instance Normalization(BIN)
Revised: Inspired by Batch-Instance Normalization(BIN)

Original: (Nam & Kim (2018)), we propose Adaptive LayerInstance Normalization (AdaLIN), whose parameters are learned from datasets during training time by adaptively selecting a proper ratio between Instance normalization (IN) and Layer Normalization (LN).
Revised: (Nam & Kim (2018)), we propose Adaptive LayerInstance Normalization (AdaLIN), whose parameters are learned from datasets during training time by adaptively selecting a proper ratio between Instance normalization (IN) and Layer Normalization (LN).

Original: The AdaLIN function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture.
Revised: The AdaLIN function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture.

Original: As a result, our model, without modifying the model architecture or the hyper-parameters, can perform image translation tasks not only requiring holistic changes but also requiring large shape changes.
Revised: As a result, our model, without modifying the model architecture or the hyper-parameters, can perform image translation tasks not only requiring holistic changes but also requiring large shape changes.

Original: In the experiments, we show the superiority of the proposed method compared to the existing state-of-the-art models on not only style transfer but also object transﬁguration.
Revised: In the experiments, we show the superiority of the proposed method compared to the existing state-of-the-art models on not only style transfer but also object transﬁguration.

Original: The main contribution of the proposed work can be summarized as follows:
Revised: The main contribution of the proposed work can be summarized as follows:

Original: • We propose a novel method for unsupervised image-to-image translation with a new attention module and a new normalization function, AdaLIN.
Revised: • We propose a novel method for unsupervised image-to-image translation with a new attention module and a new normalization function, AdaLIN.

Original: • Our attention module helps the model to know where to transform intensively by distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.
Revised: • Our attention module helps the model to know where to transform intensively by distinguishing between source and target domains based on the attention map obtained by the auxiliary classiﬁer.

Original: • AdaLIN function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture without modifying the model architecture or the hyper-parameters.
Revised: • AdaLIN function helps our attention-guided model to ﬂexibly control the amount of change in shape and texture without modifying the model architecture or the hyper-parameters.

Original:  U NSUPERVISED G ENERATIVE A TTENTIONAL N ETWORKS WITH A DAPTIVE L AYER -I NSTANCE N ORMALIZATION
Revised:  U NSUPERVISED G ENERATIVE A TTENTIONAL N ETWORKS WITH A DAPTIVE L AYER -I NSTANCE N ORMALIZATION

Original: Our goal is to train a function G s → t that maps images from a source domain X s to a target domain
Revised: Our goal is to train a function G s → t that maps images from a source domain X s to a target domain

Original: X t using only unpaired samples drawn from each domain.
Revised: X t using only unpaired samples drawn from each domain.

Original: Our framework consists of two generators
Revised: Our framework consists of two generators

Original: G s → t and G t → s and two discriminators D s and D t .
Revised: G s → t and G t → s and two discriminators D s and D t .

Original: We integrate the attention module into both generator and discriminator.
Revised: We integrate the attention module into both generator and discriminator.

Original: The attention module in the discriminator guides the generator to focus on regions that are critical to generate a realistic image.
Revised: The attention module in the discriminator guides the generator to focus on regions that are critical to generate a realistic image.

Original: The attention module in the generator gives attention to the region distinguished from the other domain.
Revised: The attention module in the generator gives attention to the region distinguished from the other domain.

Original: Here, we only explain G s → t and D t (See Fig 1) as the vice versa should be straight-forward.
Revised: Here, we only explain G s → t and D t (See Fig 1) as the vice versa should be straight-forward.

Original: 2. M ODEL 2.1. G ENERATOR
Revised: 2. M ODEL 2.1. G ENERATOR

Original: Let x ∈ { X s , X t } represent a sample from the source and the target domain.
Revised: Let x ∈ { X s , X t } represent a sample from the source and the target domain.

Original: Our translation model
Revised: Our translation model

Original: G s → t consists of an encoder E s , a decoder G t , and an auxiliary classiﬁer η s , where η s ( x ) represents the probability that x comes from X s .
Revised: G s → t consists of an encoder E s , a decoder G t , and an auxiliary classiﬁer η s , where η s ( x ) represents the probability that x comes from X s .

Original: Let E ks ( x ) be the k -th activation map of the encoder and
Revised: Let E ks ( x ) be the k -th activation map of the encoder and

Original: E k ij s ( x ) be the value at ( i, j ) .
Revised: E k ij s ( x ) be the value at ( i, j ) .

Original: Inspired by CAM (Zhou et al.
Revised: Inspired by CAM (Zhou et al.

Original: , the auxiliary classiﬁer is trained to learn the weight of the k -th feature map for the source domain, w ks , by using the global average pooling and global max pooling, i.e., η s ( x ) =
Revised: , the auxiliary classiﬁer is trained to learn the weight of the k -th feature map for the source domain, w ks , by using the global average pooling and global max pooling, i.e., η s ( x ) =

Original: σ (Σ k w ks Σ ij E k ij s ( x )) .
Revised: σ (Σ k w ks Σ ij E k ij s ( x )) .

Original: By exploiting w ks , we can calculate a set of domain speciﬁc attention feature map a s ( x ) =
Revised: By exploiting w ks , we can calculate a set of domain speciﬁc attention feature map a s ( x ) =

Original: w s ∗ E s ( x )
Revised: w s ∗ E s ( x )

Original: = { w ks ∗
Revised: = { w ks ∗

Original: E ks ( x ) | 1 ≤ k ≤ n } , where n is the number of encoded feature maps.
Revised: E ks ( x ) | 1 ≤ k ≤ n } , where n is the number of encoded feature maps.

Original: Then, our translation model G s → t becomes equal to G t ( a s ( x )) .
Revised: Then, our translation model G s → t becomes equal to G t ( a s ( x )) .

Original: Inspired by recent works that use afﬁne transformation parameters in normalization layers and combine normalization functions (Huang & Belongie (2017); Nam & Kim (2018)), we equip the residual blocks with AdaLIN whose parameters, γ and β are dynamically computed by a fully connected layer from the attention map.
Revised: Inspired by recent works that use afﬁne transformation parameters in normalization layers and combine normalization functions (Huang & Belongie (2017); Nam & Kim (2018)), we equip the residual blocks with AdaLIN whose parameters, γ and β are dynamically computed by a fully connected layer from the attention map.

Original: [Equation]
Revised: [Equation]

Original: where µ I , µ L and σ I , σ L are channel-wise, layer-wise mean and standard deviation respectively, γ and β are parameters generated by the fully connected layer, τ is the learning rate and ∆ ρ indicates the parameter update vector (e.g., the gradient) determined by the optimizer.
Revised: where µ I , µ L and σ I , σ L are channel-wise, layer-wise mean and standard deviation respectively, γ and β are parameters generated by the fully connected layer, τ is the learning rate and ∆ ρ indicates the parameter update vector (e.g., the gradient) determined by the optimizer.

Original: The values of ρ are constrained to the range of [0, 1] simply by imposing bounds at the parameter update step.
Revised: The values of ρ are constrained to the range of [0, 1] simply by imposing bounds at the parameter update step.

Original: Generator adjusts the value so that the value of ρ is close to 1 in the task where the instance normalization is important and the value of ρ is close to 0 in the task where the LN is important.
Revised: Generator adjusts the value so that the value of ρ is close to 1 in the task where the instance normalization is important and the value of ρ is close to 0 in the task where the LN is important.

Original: The value of ρ is initialized to 1 in the residual blocks of the decoder and 0 in the up-sampling blocks of the decoder.
Revised: The value of ρ is initialized to 1 in the residual blocks of the decoder and 0 in the up-sampling blocks of the decoder.

Original: An optimal method to transfer the content features onto the style features is to apply Whitening and Coloring Transform (WCT) (Li et al.
Revised: An optimal method to transfer the content features onto the style features is to apply Whitening and Coloring Transform (WCT) (Li et al.

Original: (2017b))
Revised: (2017b))

Original: , but the computational cost is high due to the calculation of the covariance matrix and matrix inverse.
Revised: , but the computational cost is high due to the calculation of the covariance matrix and matrix inverse.

Original: Although, the AdaIN (Huang & Belongie (2017)) is much faster than the WCT, it is sub-optimal to WCT as it assumes uncorrelation between feature channels.
Revised: Although, the AdaIN (Huang & Belongie (2017)) is much faster than the WCT, it is sub-optimal to WCT as it assumes uncorrelation between feature channels.

Original: Thus the transferred features contain slightly more patterns of the content.
Revised: Thus the transferred features contain slightly more patterns of the content.

Original: On the other hand, the LN (Ba et al.
Revised: On the other hand, the LN (Ba et al.

Original: (2016)) does not assume uncorrelation between channels, but sometimes it does not keep the content structure of the original domain well because it considers global statistics only for the feature maps.
Revised: (2016)) does not assume uncorrelation between channels, but sometimes it does not keep the content structure of the original domain well because it considers global statistics only for the feature maps.

Original: To overcome this, our proposed normalization technique
Revised: To overcome this, our proposed normalization technique

Original: AdaLIN combines the advantages of AdaIN and LN by selectively keeping or changing the content information, which helps to solve a wide range of image-to-image translation problems.
Revised: AdaLIN combines the advantages of AdaIN and LN by selectively keeping or changing the content information, which helps to solve a wide range of image-to-image translation problems.

Original: 2.1. D ISCRIMINATOR
Revised: 2.1. D ISCRIMINATOR

Original: Let x ∈ { X t , G s → t ( X s ) } represent a sample from the target domain and the translated source domain.
Revised: Let x ∈ { X t , G s → t ( X s ) } represent a sample from the target domain and the translated source domain.

Original: Similar to other translation models, the discriminator D t which is a multi-scale model consists of an encoder E D t , a classiﬁer C D t , and an auxiliary classiﬁer η D t .
Revised: Similar to other translation models, the discriminator D t which is a multi-scale model consists of an encoder E D t , a classiﬁer C D t , and an auxiliary classiﬁer η D t .

Original: Unlike the other translation models, both η D t ( x ) and D t ( x ) are trained to discriminate whether x comes from X t or
Revised: Unlike the other translation models, both η D t ( x ) and D t ( x ) are trained to discriminate whether x comes from X t or

Original: G s → t ( X s ) .
Revised: G s → t ( X s ) .

Original: Given a sample x , D t ( x ) exploits the attention feature maps a D t ( x ) =
Revised: Given a sample x , D t ( x ) exploits the attention feature maps a D t ( x ) =

Original: w D t ∗ E D t ( x ) using w D t on the encoded feature maps E D t ( x ) that is trained by η D t ( x ) .
Revised: w D t ∗ E D t ( x ) using w D t on the encoded feature maps E D t ( x ) that is trained by η D t ( x ) .

Original: Then, our discriminator
Revised: Then, our discriminator

Original: D t ( x ) becomes equal to C D t ( a D t ( x )) .
Revised: D t ( x ) becomes equal to C D t ( a D t ( x )) .

Original: 2. L OSS FUNCTION
Revised: 2. L OSS FUNCTION

Original: The full objective of our model comprises four loss functions.
Revised: The full objective of our model comprises four loss functions.

Original: Here, instead of using the vanilla
Revised: Here, instead of using the vanilla

Original: GAN objective, we used the Least Squares GAN (Mao et al.
Revised: GAN objective, we used the Least Squares GAN (Mao et al.

Original: (2017)) objective for stable training.
Revised: (2017)) objective for stable training.

Original: Adversarial loss An adversarial loss is employed to match the distribution of the translated images to the target image distribution:
Revised: Adversarial loss An adversarial loss is employed to match the distribution of the translated images to the target image distribution:

Original: [Equation]
Revised: [Equation]

Original: Cycle loss To alleviate the mode collapse problem, we apply a cycle consistency constraint to the generator.
Revised: Cycle loss To alleviate the mode collapse problem, we apply a cycle consistency constraint to the generator.

Original: Given an image x ∈ X s , after the sequential translations of x from X s to X t and from
Revised: Given an image x ∈ X s , after the sequential translations of x from X s to X t and from

Original: X t to X s , the image should be successfully translated back to the original domain:
Revised: X t to X s , the image should be successfully translated back to the original domain:

Original: [Equation]
Revised: [Equation]

Original: Identity loss To ensure that the color distributions of input image and output image are similar, we apply an identity consistency constraint to the generator.
Revised: Identity loss To ensure that the color distributions of input image and output image are similar, we apply an identity consistency constraint to the generator.

Original: Given an image x ∈ X t , after the translation of x using G s → t , the image should not change.
Revised: Given an image x ∈ X t , after the translation of x using G s → t , the image should not change.

Original: [Equation]
Revised: [Equation]

Original: CAM loss By exploiting the information from the auxiliary classiﬁers η s and η D t , given an image x ∈ { X s , X t } .
Revised: CAM loss By exploiting the information from the auxiliary classiﬁers η s and η D t , given an image x ∈ { X s , X t } .

Original: G s → t and D t get to know where they need to improve or what makes the most difference between two domains in the current state:
Revised: G s → t and D t get to know where they need to improve or what makes the most difference between two domains in the current state:

Original: [Equation]
Revised: [Equation]

Original: Full objective Finally, we jointly train the encoders, decoders, discriminators, and auxiliary classiﬁers to optimize the ﬁnal objective:
Revised: Full objective Finally, we jointly train the encoders, decoders, discriminators, and auxiliary classiﬁers to optimize the ﬁnal objective:

Original: [Equation]
Revised: [Equation]

Original: where λ 1 = 1 , λ 2 = 10 , λ 3 = 10 , λ 4 = 1000 .
Revised: where λ 1 = 1 , λ 2 = 10 , λ 3 = 10 , λ 4 = 1000 .

Original: Here, L lsgan =
Revised: Here, L lsgan =

Original: L s → t lsgan + L t → s lsgan and the other losses are deﬁned in the similar way ( L cycle , L identity , and L cam )
Revised: L s → t lsgan + L t → s lsgan and the other losses are deﬁned in the similar way ( L cycle , L identity , and L cam )

Original: [Figure]
Revised: [Figure]

Original:  E XPERIMENTS 3. B ASELINE MODEL
Revised:  E XPERIMENTS 3. B ASELINE MODEL

Original: We have compared our method with various models including CycleGAN (Zhu et al.
Revised: We have compared our method with various models including CycleGAN (Zhu et al.

Original: , UNIT (Liu et al.
Revised: , UNIT (Liu et al.

Original: (2017)), MUNIT (Huang et al.
Revised: (2017)), MUNIT (Huang et al.

Original: (2018)), DRIT (Lee et al.
Revised: (2018)), DRIT (Lee et al.

Original: , AGGAN (Mejjati et al.
Revised: , AGGAN (Mejjati et al.

Original: (2018)), and CartoonGAN (Chen et al.
Revised: (2018)), and CartoonGAN (Chen et al.

Original: All the baseline methods are implemented using the author’s code.
Revised: All the baseline methods are implemented using the author’s code.

Original: 3. D ATASET
Revised: 3. D ATASET

Original: We have evaluated the performance of each method with ﬁve unpaired image datasets including four representative image translation datasets and a newly created dataset consisting of real photos and animation artworks, i.e., selﬁe2anime.
Revised: We have evaluated the performance of each method with ﬁve unpaired image datasets including four representative image translation datasets and a newly created dataset consisting of real photos and animation artworks, i.e., selﬁe2anime.

Original: All images are resized to 256 x 256 for training.
Revised: All images are resized to 256 x 256 for training.

Original: See
Revised: See

Original: Appendix C for each dataset for our experiments.
Revised: Appendix C for each dataset for our experiments.

Original: 3. E XPERIMENT RESULTS
Revised: 3. E XPERIMENT RESULTS

Original: We ﬁrst analyze the effects of attention module and AdaLIN in the proposed model.
Revised: We ﬁrst analyze the effects of attention module and AdaLIN in the proposed model.

Original: We then compare the performance of our model against the other unsupervised image translation models listed in the previous section.
Revised: We then compare the performance of our model against the other unsupervised image translation models listed in the previous section.

Original: To evaluate, the visual quality of translated images, we have conducted a user study.
Revised: To evaluate, the visual quality of translated images, we have conducted a user study.

Original: Users are asked to select the best image among the images generated from ﬁve different methods.
Revised: Users are asked to select the best image among the images generated from ﬁve different methods.

Original: More examples of the results comparing our model with other models are included in the supplementary materials.
Revised: More examples of the results comparing our model with other models are included in the supplementary materials.

Original: 3.3. CAM ANALYSIS
Revised: 3.3. CAM ANALYSIS

Original: First, we conduct an ablation study to conﬁrm the beneﬁt from the attention modules used in both generator and discriminator.
Revised: First, we conduct an ablation study to conﬁrm the beneﬁt from the attention modules used in both generator and discriminator.

Original: As shown in Fig 2 (b), the attention feature map helps the generator to focus on the source image regions that are more discriminative from the target domain, such as eyes and mouth.
Revised: As shown in Fig 2 (b), the attention feature map helps the generator to focus on the source image regions that are more discriminative from the target domain, such as eyes and mouth.

Original: Meanwhile, we can see the regions where the discriminator concentrates its attention to determine whether the target image is real or fake by visualizing local and global attention maps of
Revised: Meanwhile, we can see the regions where the discriminator concentrates its attention to determine whether the target image is real or fake by visualizing local and global attention maps of

Original: [Figure]
Revised: [Figure]

Original: the discriminator as shown in Fig 2 (c) and (d), respectively.
Revised: the discriminator as shown in Fig 2 (c) and (d), respectively.

Original: The generator can ﬁne-tune the area where the discriminator focuses on with those attention maps.
Revised: The generator can ﬁne-tune the area where the discriminator focuses on with those attention maps.

Original: Note that we incorporate both global and local attention maps from two discriminators having different size of receptive ﬁeld.
Revised: Note that we incorporate both global and local attention maps from two discriminators having different size of receptive ﬁeld.

Original: Those maps can help the generator to capture the global structure (e.g., face area and near of eyes) as well as the local regions.
Revised: Those maps can help the generator to capture the global structure (e.g., face area and near of eyes) as well as the local regions.

Original: With this information some regions are translated with more care.
Revised: With this information some regions are translated with more care.

Original: The results with the attention module shown in Fig 2 (e) verify the advantageous effect of exploiting attention feature map in an image translation task.
Revised: The results with the attention module shown in Fig 2 (e) verify the advantageous effect of exploiting attention feature map in an image translation task.

Original: On the other hand, one can see that the eyes are misaligned, or the translation is not done at all in the results without using attention module as shown in Fig(f).
Revised: On the other hand, one can see that the eyes are misaligned, or the translation is not done at all in the results without using attention module as shown in Fig(f).

Original: 3.3. A DA LIN ANALYSIS
Revised: 3.3. A DA LIN ANALYSIS

Original: As described in Appendix B, we have applied the AdaLIN only to the decoder of the generator.
Revised: As described in Appendix B, we have applied the AdaLIN only to the decoder of the generator.

Original: The role of the residual blocks in the decoder is to embed features, and the role of the up-sampling convolution blocks in the decoder is to generate target domain images from the embedded features.
Revised: The role of the residual blocks in the decoder is to embed features, and the role of the up-sampling convolution blocks in the decoder is to generate target domain images from the embedded features.

Original: If the learned value of the gate parameter ρ is closer to 1, it means that the corresponding layers rely more on IN than LN.
Revised: If the learned value of the gate parameter ρ is closer to 1, it means that the corresponding layers rely more on IN than LN.

Original: Likewise, if the learned value of ρ is closer to 0, it means that the corresponding layers rely more on LN than IN.
Revised: Likewise, if the learned value of ρ is closer to 0, it means that the corresponding layers rely more on LN than IN.

Original: As shown in Fig 3 (c), in the case of using only IN in the decoder, the features of the source domain (e.g., earrings and shades around cheekbones) are well preserved due to channel-wise normalized feature statistics used in the residual blocks.
Revised: As shown in Fig 3 (c), in the case of using only IN in the decoder, the features of the source domain (e.g., earrings and shades around cheekbones) are well preserved due to channel-wise normalized feature statistics used in the residual blocks.

Original: However, the amount of translation to target domain style is somewhat insufﬁcient since the global style cannot be captured by IN of the up-sampling convolution blocks.
Revised: However, the amount of translation to target domain style is somewhat insufﬁcient since the global style cannot be captured by IN of the up-sampling convolution blocks.

Original: On the other hand, As shown in Fig 3 (d), if we use only LN in the decoder, target domain style can be transferred sufﬁciently by virtue of layerwise normalized feature statistics used in the up-sampling convolution.
Revised: On the other hand, As shown in Fig 3 (d), if we use only LN in the decoder, target domain style can be transferred sufﬁciently by virtue of layerwise normalized feature statistics used in the up-sampling convolution.

Original: But the features of the source domain image are less preserved by using LN in the residual blocks.
Revised: But the features of the source domain image are less preserved by using LN in the residual blocks.

Original: This analysis of two extreme cases tells us that it is beneﬁcial to rely more on IN than LN in the feature representation layers to preserve semantic characteristics of source domain, and the opposite is true for the upsampling layers that actually generate images from the feature embedding.
Revised: This analysis of two extreme cases tells us that it is beneﬁcial to rely more on IN than LN in the feature representation layers to preserve semantic characteristics of source domain, and the opposite is true for the upsampling layers that actually generate images from the feature embedding.

Original: Therefore, the proposed
Revised: Therefore, the proposed

Original: AdaLIN which adjusts the ratio of IN and LN in the decoder according to source and target domain distributions is more preferable in unsupervised image-to-image translation tasks.
Revised: AdaLIN which adjusts the ratio of IN and LN in the decoder according to source and target domain distributions is more preferable in unsupervised image-to-image translation tasks.

Original: Additionally, the
Revised: Additionally, the

Original: Fig 3 (e), (f) are the results of using the AdaIN and Group Normalization (GN) (Wu & He (2018)) respectively, and our methods are showing better results compared to these.
Revised: Fig 3 (e), (f) are the results of using the AdaIN and Group Normalization (GN) (Wu & He (2018)) respectively, and our methods are showing better results compared to these.

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

Original: [Table]
Revised: [Table]

Original: Also, as shown in Table
Revised: Also, as shown in Table

Original: [Table]
Revised: [Table]

Original: we demonstrate the performance of the attention module and AdaLIN in the selﬁe2anime dataset through an ablation study using Kernel Inception Distance (KID) (Bi´nkowski et al.
Revised: we demonstrate the performance of the attention module and AdaLIN in the selﬁe2anime dataset through an ablation study using Kernel Inception Distance (KID) (Bi´nkowski et al.

Original: Our model achieves the lowest KID values.
Revised: Our model achieves the lowest KID values.

Original: Even if the attention module and AdaLIN are used separately, we can see that our models perform better than the others.
Revised: Even if the attention module and AdaLIN are used separately, we can see that our models perform better than the others.

Original: However, when used together, the performance is even better.
Revised: However, when used together, the performance is even better.

Original: 3.3. Q UALITATIVE EVALUATION
Revised: 3.3. Q UALITATIVE EVALUATION

Original: For qualitative evaluation, we have also conducted a perceptual study.
Revised: For qualitative evaluation, we have also conducted a perceptual study.

Original: 135 participants are shown translated results from different methods including the proposed method with source image, and asked to select the best translated image to target domain.
Revised: 135 participants are shown translated results from different methods including the proposed method with source image, and asked to select the best translated image to target domain.

Original: We inform only the name of target domain, i.e., animation, dog, and zebra to the participants.
Revised: We inform only the name of target domain, i.e., animation, dog, and zebra to the participants.

Original: But, some example images of target domain are provided for the portrait and Van Gogh datasets as minimum information to ensure proper judgments.
Revised: But, some example images of target domain are provided for the portrait and Van Gogh datasets as minimum information to ensure proper judgments.

Original: Table 2 shows that the proposed method achieved signiﬁcantly higher score except for photo2vangogh but comparable in human perceptual study compared to other methods.
Revised: Table 2 shows that the proposed method achieved signiﬁcantly higher score except for photo2vangogh but comparable in human perceptual study compared to other methods.

Original: In Fig 4, we present the image translation results from each method for performance comparisons.
Revised: In Fig 4, we present the image translation results from each method for performance comparisons.

Original: U-GAT-IT can generate undistorted image by focusing more on the distinct regions between source
Revised: U-GAT-IT can generate undistorted image by focusing more on the distinct regions between source

Original: [Table] [Table]
Revised: [Table] [Table]

Original: and target domain by exploiting the attention modules.
Revised: and target domain by exploiting the attention modules.

Original: Note that the regions around heads of two zebras or eyes of dog are distorted in the results from CycleGAN.
Revised: Note that the regions around heads of two zebras or eyes of dog are distorted in the results from CycleGAN.

Original: Moreover, translated results using U-GAT-IT are visually superior to other methods while preserving semantic features of source domain.
Revised: Moreover, translated results using U-GAT-IT are visually superior to other methods while preserving semantic features of source domain.

Original: It is worth noting that the results from MUNIT and DRIT are much dissimilar to the source images since they generate images with random style codes for diversity.
Revised: It is worth noting that the results from MUNIT and DRIT are much dissimilar to the source images since they generate images with random style codes for diversity.

Original: Furthermore, it should be emphasized that U-GAT-IT have applied with the same network architecture and hyper-parameters for all of the ﬁve different datasets, while the other algorithms are trained with preset networks or hyper-parameters.
Revised: Furthermore, it should be emphasized that U-GAT-IT have applied with the same network architecture and hyper-parameters for all of the ﬁve different datasets, while the other algorithms are trained with preset networks or hyper-parameters.

Original: Through the results of user study, we show that the combination of our attention module and AdaLIN makes our model more ﬂexible.
Revised: Through the results of user study, we show that the combination of our attention module and AdaLIN makes our model more ﬂexible.

Original: 3.3. Q UANTITATIVE EVALUATION
Revised: 3.3. Q UANTITATIVE EVALUATION

Original: For quantitative evaluation, we use the recently proposed KID, which computes the squared Maximum Mean Discrepancy between the feature representations of real and generated images.
Revised: For quantitative evaluation, we use the recently proposed KID, which computes the squared Maximum Mean Discrepancy between the feature representations of real and generated images.

Original: The feature representations are extracted from the Inception network (Szegedy et al.
Revised: The feature representations are extracted from the Inception network (Szegedy et al.

Original: In contrast to the Fr´echet Inception Distance (Heusel et al.
Revised: In contrast to the Fr´echet Inception Distance (Heusel et al.

Original: , KID has an unbiased estimator, which makes it more reliable, especially when there are fewer test images than the dimensionality of the inception features.
Revised: , KID has an unbiased estimator, which makes it more reliable, especially when there are fewer test images than the dimensionality of the inception features.

Original: The lower KID indicates that the more shared visual similarities between real and generated images (Mejjati et al.
Revised: The lower KID indicates that the more shared visual similarities between real and generated images (Mejjati et al.

Original: Therefore, if well translated, the KID will have a small value in several datasets.
Revised: Therefore, if well translated, the KID will have a small value in several datasets.

Original: Table 3 shows that the proposed method achieved the lowest KID scores except for the style transfer tasks like photo2vangogh and photo2portrait.
Revised: Table 3 shows that the proposed method achieved the lowest KID scores except for the style transfer tasks like photo2vangogh and photo2portrait.

Original: However, there is no big difference from the lowest score.
Revised: However, there is no big difference from the lowest score.

Original: Also, unlike UNIT and MUNIT, we can see that the source → target, target → source translations are both stable.
Revised: Also, unlike UNIT and MUNIT, we can see that the source → target, target → source translations are both stable.

Original: U-GAT-IT shows even lower KID than the recent attention-based method, AGGAN.
Revised: U-GAT-IT shows even lower KID than the recent attention-based method, AGGAN.

Original: AGGAN yields poor performance for the transformation with shape change such as dog2cat and anime2selﬁe unlike the U-GAT-IT, the attention module of which focuses on distinguishing not between background and foreground but differences between two domains.
Revised: AGGAN yields poor performance for the transformation with shape change such as dog2cat and anime2selﬁe unlike the U-GAT-IT, the attention module of which focuses on distinguishing not between background and foreground but differences between two domains.

Original: CartoonGAN, as shown in the supplementary materials, has only changed the overall color of the image to an animated style, but compared to selﬁe, the eye, which is the biggest characteristic of animation, has not changed at all.
Revised: CartoonGAN, as shown in the supplementary materials, has only changed the overall color of the image to an animated style, but compared to selﬁe, the eye, which is the biggest characteristic of animation, has not changed at all.

Original: Therefore, CartoonGAN has the higher KID.
Revised: Therefore, CartoonGAN has the higher KID.

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: In this paper we have proposed unsupervised image-to-image translation (U-GAT-IT), with the attention module and AdaLIN which can produce more visually pleasing results in various datasets with a ﬁxed network architecture and hyper-parameter.
Revised: In this paper we have proposed unsupervised image-to-image translation (U-GAT-IT), with the attention module and AdaLIN which can produce more visually pleasing results in various datasets with a ﬁxed network architecture and hyper-parameter.

Original: Detailed analysis of various experimental results supports our assumption that attention maps obtained by an auxiliary classiﬁer can guide generator to focus more on distinct regions between source and target domain.
Revised: Detailed analysis of various experimental results supports our assumption that attention maps obtained by an auxiliary classiﬁer can guide generator to focus more on distinct regions between source and target domain.

Original: In addition, we have found that the Adaptive Layer-Instance Normalization (AdaLIN) is essential for translating various datasets that contains different amount of geometry and style changes.
Revised: In addition, we have found that the Adaptive Layer-Instance Normalization (AdaLIN) is essential for translating various datasets that contains different amount of geometry and style changes.

Original: Through experiments, we have shown that the superiority of the proposed method compared to the existing state-of-the-art
Revised: Through experiments, we have shown that the superiority of the proposed method compared to the existing state-of-the-art

Original: GAN-based models for unsupervised image-to-image translation tasks.
Revised: GAN-based models for unsupervised image-to-image translation tasks.

Original: A R ELATED WORKS A. G ENERATIVE A DVERSARIAL N ETWORKS
Revised: A R ELATED WORKS A. G ENERATIVE A DVERSARIAL N ETWORKS

Original: Generative Adversarial Networks (GAN) Goodfellow et al.
Revised: Generative Adversarial Networks (GAN)(Goodfellow et al.

Original: (2014) have achieved impressive results on a wide variety of image generation Arjovsky et al.
Revised: (2014)) have achieved impressive results on a wide variety of image generation(Arjovsky et al.

Original: ; Berthelot et al.
Revised: ; Berthelot et al.

Original: Karras et al.
Revised: Karras et al.

Original: ; Zhao et al.
Revised: ; Zhao et al.

Original: (2017), image inpainting Iizuka et al.  image translation Choi et al.
Revised: , image inpainting(Iizuka et al. (2017)), image translation(Choi et al.

Original: ; Huang et al.
Revised: ; Huang et al.

Original: ; Isola et al.
Revised: ; Isola et al.

Original: ; Liu et al.
Revised: ; Liu et al.

Original: ; Wang et al.
Revised: ; Wang et al.

Original: Zhu et al.
Revised: Zhu et al.

Original: (2017) tasks.
Revised: (2017)) tasks.

Original: In training, a generator aims to generate realistic images to fool a discriminator while the discriminator tries to distinguish the generated images from real images.
Revised: In training, a generator aims to generate realistic images to fool a discriminator while the discriminator tries to distinguish the generated images from real images.

Original: Various multi-stage generative models Karras et al.
Revised: Various multi-stage generative models(Karras et al.

Original: ; Wang et al.
Revised: ; Wang et al.

Original: (2018) and better training objectives Arjovsky et al.
Revised: (2018)) and better training objectives(Arjovsky et al.

Original: ; Berthelot et al.
Revised: ; Berthelot et al.

Original: ; Mao et al.
Revised: ; Mao et al.

Original: ; Zhao et al.
Revised: ; Zhao et al.

Original: (2017) have been proposed to generate more realistic images.
Revised: (2017)) have been proposed to generate more realistic images.

Original: In this paper, our model uses GAN to learn the transformation from a source domain to a signiﬁcantly different target domain, given unpaired training data.
Revised: In this paper, our model uses GAN to learn the transformation from a source domain to a signiﬁcantly different target domain, given unpaired training data.

Original: A. I MAGE - TO - IMAGE TRANSLATION
Revised: A. I MAGE - TO - IMAGE TRANSLATION

Original: Isola et
Revised: Isola et

Original: al.(Isola et al.
Revised: al.(Isola et al.

Original: (2017)) have proposed a conditional GAN-based uniﬁed framework for image-to-image translation.
Revised: (2017)) have proposed a conditional GAN-based uniﬁed framework for image-to-image translation.

Original: High-resolution version of the pix2pix have been proposed by Wang et al.(Wang et al.
Revised: High-resolution version of the pix2pix have been proposed by Wang et al.(Wang et al.

Original: Recently, there have been various attempts (Huang et al.
Revised: Recently, there have been various attempts (Huang et al.

Original: ; Kim et al.
Revised: ; Kim et al.

Original: Liu et al.
Revised: Liu et al.

Original: ; Taigman et al.
Revised: ; Taigman et al.

Original: ; Zhu et al.
Revised: ; Zhu et al.

Original: to learn image translation from an unpaired dataset.
Revised: to learn image translation from an unpaired dataset.

Original: CycleGAN (Zhu et al.
Revised: CycleGAN (Zhu et al.

Original: (2017)) have proposed a cyclic consistence loss for the ﬁrst time to enforce one-to-one mapping.
Revised: (2017)) have proposed a cyclic consistence loss for the ﬁrst time to enforce one-to-one mapping.

Original: UNIT (Liu et al.
Revised: UNIT (Liu et al.

Original: (2017)) assumed a shared-latent space to tackle unsupervised image translation.
Revised: (2017)) assumed a shared-latent space to tackle unsupervised image translation.

Original: However, this approach performs well only when the two domains have similar patterns.
Revised: However, this approach performs well only when the two domains have similar patterns.

Original: MUNIT (Huang et al.
Revised: MUNIT (Huang et al.

Original: (2018)) makes it possible to extend to manyto-many mapping by decomposing the image into content code that is domain-invariant and a style code that captures domain-speciﬁc properties.
Revised: (2018)) makes it possible to extend to manyto-many mapping by decomposing the image into content code that is domain-invariant and a style code that captures domain-speciﬁc properties.

Original: MUNIT synthesizes the separated content and style to generate the ﬁnal image, where the image quality is improved by using adaptive instance normalization (Huang & Belongie (2017)).
Revised: MUNIT synthesizes the separated content and style to generate the ﬁnal image, where the image quality is improved by using adaptive instance normalization (Huang & Belongie (2017)).

Original: With the same purpose as MUNIT, DRIT (Lee et al.
Revised: With the same purpose as MUNIT, DRIT (Lee et al.

Original: (2018)) decomposes images into content and style, so that many-to-many mapping is possible.
Revised: (2018)) decomposes images into content and style, so that many-to-many mapping is possible.

Original: The only difference is that content space is shared between the two domains using the weight sharing and content discriminator which is auxiliary classiﬁer.
Revised: The only difference is that content space is shared between the two domains using the weight sharing and content discriminator which is auxiliary classiﬁer.

Original: Nevertheless, the performance of these methods (Huang et al.
Revised: Nevertheless, the performance of these methods (Huang et al.

Original: Liu et al.
Revised: Liu et al.

Original: ; Lee et al.
Revised: ; Lee et al.

Original: (2018)) are limited to the dataset that contains well-aligned images between source and target domains.
Revised: (2018)) are limited to the dataset that contains well-aligned images between source and target domains.

Original: In addition, AGGAN (Mejjati et al.
Revised: In addition, AGGAN (Mejjati et al.

Original: (2018)) improved the performance of image translation by using attention mechanism to distinguish between foreground and background.
Revised: (2018)) improved the performance of image translation by using attention mechanism to distinguish between foreground and background.

Original: However, the attention module in AGGAN cannot help to transform the object’s shape in the image.
Revised: However, the attention module in AGGAN cannot help to transform the object’s shape in the image.

Original: Although, CartoonGAN (Chen et al.
Revised: Although, CartoonGAN (Chen et al.

Original: (2018)) shows good performance for animation style translation, it changes only the color, tone, and thickness of line in the image.
Revised: (2018)) shows good performance for animation style translation, it changes only the color, tone, and thickness of line in the image.

Original: Therefore it is not suitable for the shape change in the image.
Revised: Therefore it is not suitable for the shape change in the image.

Original: A. C LASS A CTIVATION M AP
Revised: A. C LASS A CTIVATION M AP

Original: Zhou et al.
Revised: Zhou et al.

Original: (Zhou et al.
Revised: (Zhou et al.

Original: (2016)) have proposed Class Activation Map (CAM) using global average pooling in a CNN.
Revised: (2016)) have proposed Class Activation Map (CAM) using global average pooling in a CNN.

Original: The CAM for a particular class shows the discriminative image regions by the
Revised: The CAM for a particular class shows the discriminative image regions by the

Original: CNN to determine that class.
Revised: CNN to determine that class.

Original: In this work, our model leads to intensively change discriminative image regions provided by distinguishing two domains using the CAM approach.
Revised: In this work, our model leads to intensively change discriminative image regions provided by distinguishing two domains using the CAM approach.

Original: However, not only global average pooling is used, but global max pooling is also used to make the results better.
Revised: However, not only global average pooling is used, but global max pooling is also used to make the results better.

Original: A. N ORMALIZATION
Revised: A. N ORMALIZATION

Original: Recent neural style transfer researches have shown that CNN feature statistics (e.g., Gram matrix (Gatys et al.
Revised: Recent neural style transfer researches have shown that CNN feature statistics (e.g., Gram matrix (Gatys et al.

Original: (2016)), mean and variance (Huang & Belongie (2017)) can be used as direct descriptors for image styles.
Revised: (2016)), mean and variance (Huang & Belongie (2017)) can be used as direct descriptors for image styles.

Original: In particular, Instance Normalization (IN) has the effect of removing the style variation by directly normalizing the feature statistics of the image and is used more often than Batch
Revised: In particular, Instance Normalization (IN) has the effect of removing the style variation by directly normalizing the feature statistics of the image and is used more often than Batch

Original: Normalization (BN) or Layer Normalization (LN) in style transfer.
Revised: Normalization (BN) or Layer Normalization (LN) in style transfer.

Original: However, when normalizing images, recent studies use Adaptive Instance Normalization (AdaIN) (Huang & Belongie (2017)),
Revised: However, when normalizing images, recent studies use Adaptive Instance Normalization (AdaIN) (Huang & Belongie (2017)),

Original: Conditional Instance Normalization (CIN)
Revised: Conditional Instance Normalization (CIN)

Original: (Dumoulin et al.
Revised: (Dumoulin et al.

Original: (2017)), and Batch-Instance Normalization (BIN)
Revised: (2017)), and Batch-Instance Normalization (BIN)

Original: (Nam & Kim (2018)) instead of using IN alone.
Revised: (Nam & Kim (2018)) instead of using IN alone.

Original: In our work, we propose an Adaptive
Revised: In our work, we propose an Adaptive

Original: Layer-Instance Normalization (AdaLIN) function to adaptively select a proper ratio between IN and
Revised: Layer-Instance Normalization (AdaLIN) function to adaptively select a proper ratio between IN and

Original: LN.
Revised: LN.

Original: Through the AdaLIN, our attention-guided model can ﬂexibly control the amount of change in shape and texture.
Revised: Through the AdaLIN, our attention-guided model can ﬂexibly control the amount of change in shape and texture.

Original: B I MPLEMENTATION D ETAILS B. N ETWORK ARCHITECTURE
Revised: B I MPLEMENTATION D ETAILS B. N ETWORK ARCHITECTURE

Original: The network architectures of U-GAT-IT are shown in Table 4, 5, and 6.
Revised: The network architectures of U-GAT-IT are shown in Table 4, 5, and 6.

Original: The encoder of the generator is composed of two convolution layers with the stride size of two for down-sampling and four residual blocks.
Revised: The encoder of the generator is composed of two convolution layers with the stride size of two for down-sampling and four residual blocks.

Original: The decoder of the generator consists of four residual blocks and two up-sampling convolution layers with the stride size of one.
Revised: The decoder of the generator consists of four residual blocks and two up-sampling convolution layers with the stride size of one.

Original: Note that we use the instance normalization for the encoder and AdaLIN for the decoder, respectively.
Revised: Note that we use the instance normalization for the encoder and AdaLIN for the decoder, respectively.

Original: In general, LN does not perform better than batch normalization in classiﬁcation problems (Wu & He (2018)).
Revised: In general, LN does not perform better than batch normalization in classiﬁcation problems (Wu & He (2018)).

Original: Since the auxiliary classiﬁer is connected from the encoder in the generator, to increase the accuracy of the auxiliary classiﬁer we use the instance normalization(batch normalization with a mini-batch size of 1) instead of the AdaLIN.
Revised: Since the auxiliary classiﬁer is connected from the encoder in the generator, to increase the accuracy of the auxiliary classiﬁer we use the instance normalization(batch normalization with a mini-batch size of 1) instead of the AdaLIN.

Original: Spectral normalization (Miyato et al.
Revised: Spectral normalization (Miyato et al.

Original: (2018)) is used for the discriminator.
Revised: (2018)) is used for the discriminator.

Original: We employ two different scales of PatchGAN (Isola et al.
Revised: We employ two different scales of PatchGAN (Isola et al.

Original: for the discriminator network, which classiﬁes whether local (70 x 70) and global (286 x 286) image patches are real or fake.
Revised: for the discriminator network, which classiﬁes whether local (70 x 70) and global (286 x 286) image patches are real or fake.

Original: For the activation function, we use ReLU in the generator and leaky-ReLU with a slope of 0.2 in the discriminator.
Revised: For the activation function, we use ReLU in the generator and leaky-ReLU with a slope of 0.2 in the discriminator.

Original: B. T RAINING
Revised: B. T RAINING

Original: All models are trained using Adam (Kingma & Ba (2015)) with β 1 =0.5 and β 2 =0.999.
Revised: All models are trained using Adam (Kingma & Ba (2015)) with β 1 =0.5 and β 2 =0.999.

Original: For data augmentation, we ﬂipped the images horizontally with a probability of 0.5, resized them to 286 x 286, and random cropped them to 256 x 256.
Revised: For data augmentation, we ﬂipped the images horizontally with a probability of 0.5, resized them to 286 x 286, and random cropped them to 256 x 256.

Original: The batch size is set to one for all experiments.
Revised: The batch size is set to one for all experiments.

Original: We train all models with a ﬁxed learning rate of 0.0001 until 500,000 iterations and linearly decayed up to 1,000,000 iterations.
Revised: We train all models with a ﬁxed learning rate of 0.0001 until 500,000 iterations and linearly decayed up to 1,000,000 iterations.

Original: We also use a weight decay at rate of 0.0001.
Revised: We also use a weight decay at rate of 0.0001.

Original: The weights are initialized from a zero-centered normal distribution with a standard deviation of 0.02.
Revised: The weights are initialized from a zero-centered normal distribution with a standard deviation of 0.02.

Original: C D ATASET D ETAILS selﬁe2anime
Revised: C D ATASET D ETAILS selﬁe2anime

Original: The selﬁe dataset contains 46,836 selﬁe images annotated with 36 different attributes.
Revised: The selﬁe dataset contains 46,836 selﬁe images annotated with 36 different attributes.

Original: We only use photos of females as training data and test data.
Revised: We only use photos of females as training data and test data.

Original: The size of the training dataset is 3400, and that of the test dataset is 100, with the image size of 256 x 256.
Revised: The size of the training dataset is 3400, and that of the test dataset is 100, with the image size of 256 x 256.

Original: For the anime dataset, we have ﬁrstly retrieved 69,926 animation character images from Anime-Planet 1 .
Revised: For the anime dataset, we have ﬁrstly retrieved 69,926 animation character images from Anime-Planet 1 .

Original: Among those images, 27,023 face images are extracted by using an anime-face detector 2 .
Revised: Among those images, 27,023 face images are extracted by using an anime-face detector 2 .

Original: After selecting only female character images and removing monochrome images manually, we have collected two datasets of female anime face images, with the sizes of 3400 and 100 for training and test data respectively, which is the same numbers as the selﬁe dataset.
Revised: After selecting only female character images and removing monochrome images manually, we have collected two datasets of female anime face images, with the sizes of 3400 and 100 for training and test data respectively, which is the same numbers as the selﬁe dataset.

Original: Finally, all anime face images are resized to 256 x 256 by applying a CNN-based image super-resolution algorithm 3 .
Revised: Finally, all anime face images are resized to 256 x 256 by applying a CNN-based image super-resolution algorithm 3 .

Original: horse2zebra and photo2vangogh These datasets are used in CycleGAN (Zhu et al.
Revised: horse2zebra and photo2vangogh These datasets are used in CycleGAN (Zhu et al.

Original: The training dataset size of each class: 1,067 (horse), 1,334 (zebra), 6,287 (photo), and 400 (vangogh).
Revised: The training dataset size of each class: 1,067 (horse), 1,334 (zebra), 6,287 (photo), and 400 (vangogh).

Original: The test datasets consist of 120 (horse), 140 (zebra), 751 (photo), and 400 (vangogh).
Revised: The test datasets consist of 120 (horse), 140 (zebra), 751 (photo), and 400 (vangogh).

Original: Note that the training data and the test data of vangogh class are the same.
Revised: Note that the training data and the test data of vangogh class are the same.

Original: cat2dog and photo2portrait
Revised: cat2dog and photo2portrait

Original: These datasets are used in DRIT (Lee et al.
Revised: These datasets are used in DRIT (Lee et al.

Original: The numbers of data for each class are 871 (cat), 1,364 (zebra), 6,452 (photo), and 1,811 (vangogh).
Revised: The numbers of data for each class are 871 (cat), 1,364 (zebra), 6,452 (photo), and 1,811 (vangogh).

Original: We use 120 (horse), 140 (zebra), 751 (photo), and 400 (vangogh) randomly selected images as test data, respectively.
Revised: We use 120 (horse), 140 (zebra), 751 (photo), and 400 (vangogh) randomly selected images as test data, respectively.

Original: D A DDITIONAL EXPERIMENTAL RESULTS
Revised: D A DDITIONAL EXPERIMENTAL RESULTS

Original: In addition to the results presented in the paper, we show supplement generation results for the ﬁve datasets in Figs 5, 6, 7, 8, 9, 10,
Revised: In addition to the results presented in the paper, we show supplement generation results for the ﬁve datasets in Figs 5, 6, 7, 8, 9, 10,

Original: [Table]
Revised: [Table]

Original: and 12.
Revised: and 12.

Original: [Table]
Revised: [Table]

Original: (1, 1, 256) → (1, 1, 256)
Revised: (1, 1, 256) → (1, 1, 256)

Original: MLP-(N256), ReLU (1, 1, 256) → (1, 1, 256)
Revised: MLP-(N256), ReLU (1, 1, 256) → (1, 1, 256)

Original: MLP-(N256), ReLU
Revised: MLP-(N256), ReLU

Original: Decoder Bottleneck ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)
Revised: Decoder Bottleneck ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)

Original: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256) AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)
Revised: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256) AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)

Original: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)
Revised: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU ( h 4 , w 4 , 256) → ( h 4 , w 4 , 256)

Original: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU
Revised: AdaResBlock-(N256, K3, S1, P1), AdaILN, ReLU

Original: Decoder Up-sampling ( h 4 , w 4 , 256) → ( h 2 , w 2 , 128)
Revised: Decoder Up-sampling ( h 4 , w 4 , 256) → ( h 2 , w 2 , 128)

Original: Up-CONV-(N128, K3, S1, P1), LIN, ReLU ( h 2 , w 2 , 128) → (h, w, 64)
Revised: Up-CONV-(N128, K3, S1, P1), LIN, ReLU ( h 2 , w 2 , 128) → (h, w, 64)

Original: Up-CONV-(N64, K3, S1, P1), LIN, ReLU (h, w, 64) → (h, w, 3)
Revised: Up-CONV-(N64, K3, S1, P1), LIN, ReLU (h, w, 64) → (h, w, 3)

Original: CONV-(N3, K7, S1, P3), Tanh
Revised: CONV-(N3, K7, S1, P3), Tanh

Original: [Table]
Revised: [Table]

Original: CONV-(N256, K4, S2, P1), SN, Leaky-ReLU ( h 8 ,
Revised: CONV-(N256, K4, S2, P1), SN, Leaky-ReLU ( h 8 ,

Original: [Table]
Revised: [Table]

Original: → (
Revised: → (

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: CONV-(N512, K4, S1, P1), SN, Leaky-ReLU
Revised: CONV-(N512, K4, S1, P1), SN, Leaky-ReLU

Original: [Table]
Revised: [Table]

Original: ( h 8 , w 8 , 512)
Revised: ( h 8 , w 8 , 512)

Original: → ( h 8 , w 8 , 1024)
Revised: → ( h 8 , w 8 , 1024)

Original: Global Average & Max Pooling,
Revised: Global Average & Max Pooling,

Original: MLP-(N1),
Revised: MLP-(N1),

Original: Multiply the weights of MLP ( h 8 , w 8 , 1024)
Revised: Multiply the weights of MLP ( h 8 , w 8 , 1024)

Original: → (
Revised: → (

Original: [Table] [Table]
Revised: [Table] [Table]

Original: CONV-(N512, K1, S1), Leaky-ReLU
Revised: CONV-(N512, K1, S1), Leaky-ReLU

Original: Classiﬁer ( h 8 ,
Revised: Classiﬁer ( h 8 ,

Original: [Table]
Revised: [Table]

Original: → (
Revised: → (

Original: [Table] [Table]
Revised: [Table] [Table]

Original: CONV-(N1, K4, S1, P1), SN
Revised: CONV-(N1, K4, S1, P1), SN

Original: [Table]
Revised: [Table]

Original: (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) (k)
Revised: (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) (k)

Original: [Figure]
Revised: [Figure]

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

Original: [Figure]
Revised: [Figure]

Original: (d) (e) (f) (g) (h) (
Revised: (d) (e) (f) (g) (h) (

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

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

Original: [Figure]
Revised: [Figure]

Original: ) (e) (f) (g) (h) (i) (j)
Revised: ) (e) (f) (g) (h) (i) (j)

Original: (a) (b) (c) (d) (e) (f) (g) (h) (i) (j)
Revised: (a) (b) (c) (d) (e) (f) (g) (h) (i) (j)

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

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

Original: (a
Revised: (a

Original: [Figure]
Revised: [Figure]

Original: (b) (c) (d) (e) (f) (g) (h) (i) (j)
Revised: (b) (c) (d) (e) (f) (g) (h) (i) (j)