DeepI2I: Enabling Deep Hierarchical Image-to-Image Translation by Transferring from GANs

Image-to-image translation has recently achieved remarkable results. But despite current success, it suffers from inferior performance when translations between classes require large shape changes. We attribute this to the high-resolution bottlenecks which are used by current state-of-the-art image-to-image methods. Therefore, in this work, we propose a novel deep hierarchical Image-to-Image Translation method, called DeepI2I. We learn a model by leveraging hierarchical features: (a) structural information contained in the shallow layers and (b) semantic information extracted from the deep layers. To enable the training of deep I2I models on small datasets, we propose a novel transfer learning method, that transfers knowledge from pre-trained GANs. Specifically, we leverage the discriminator of a pre-trained GANs (i.e. BigGAN or StyleGAN) to initialize both the encoder and the discriminator and the pre-trained generator to initialize the generator of our model. Applying knowledge transfer leads to an alignment problem between the encoder and generator. We introduce an adaptor network to address this. On many-class image-to-image translation on three datasets (Animal faces, Birds, and Foods) we decrease mFID by at least 35% when compared to the state-of-the-art. Furthermore, we qualitatively and quantitatively demonstrate that transfer learning significantly improves the performance of I2I systems, especially for small datasets. Finally, we are the first to perform I2I translations for domains with over 100 classes.


Introduction
Most image-to-image (I2I) networks have a high-resolution bottleneck [10,23,35,37,74,39,40,72,78,79,82]. These methods only apply two down-sampling blocks. Whereas such models are known to be successful for style transfer, it might be difficult to extract abstract semantic information. Therefore, we argue (and experimentally verify) that current I2I architectures have a limited capacity to translate between classes with significant shape changes (e.g. from dog face to meerkat face). To successfully translate between those domains a semantic understanding of the image is required. This information is typically extracted in the deep low-resolution layers of a network.
The loss of spatial resolution, which occurs when adding multiple down-sampling layers, is one of the factors which complicates the usage of deep networks for I2I. For high-quality I2I both low-level style information, as well as high-level semantic information needs to be transferred from the encoder to the generator of the I2I system. Therefore, we propose a deep hierarchical I2I translation framework (see Figure 1 right) that fuses feature representations at various levels of abstraction (depth). Leveraging the hierarchical framework, allows us to perform I2I translation between classes with significant shape changes. The proposed method, DeepI2I, builds upon the state-of-the-art BigGAN model [8], extending it to I2I translation by adding an encoder with the same architecture as the discriminator. An additional advantage of this architecture is that because it applies a latent class embedding, it 34th Conference on Neural Information Processing Systems (NeurIPS 2020), Vancouver, Canada. arXiv:2011.05867v1 [cs.CV] 11 Nov 2020 is scalable to many-class domains. We are the first to perform translations in a single architecture between over 100 classes, while current systems have only considered up to 40 classes maximum 1 .
Another factor, that complicates the extension to deep I2I, is that the increasing amount of network parameters limits its applicability to I2I problems with large datasets. To address this problem we propose a novel knowledge transfer method for I2I translation. Transferring knowledge from pre-trained networks has greatly benefited the discriminative tasks [14], enabling the re-use of highquality networks. However, it is not clear on what dataset a high-quality pre-trained I2I model should be trained, since translations between arbitrary classes might not make sense (e.g. translating from satellite images to dog faces does not make sense, while both classes have been used in separate I2I problems [24]). Instead, we propose to initialize the weights of the I2I model with those of a pre-trained GANs. We leverage the discriminator of a pre-trained BigGAN (Figure 1 left) to initialize both the encoder and the discriminator of I2I translation model, and the pre-trained generator to initialize the generator of our I2I model. To address the misalignment between the different layers of the encoder and generator, we propose a dedicated adaptor network to align both the pre-initialized encoder and generator.
We perform experiments on multiple datasets, including complex datasets which have significant shape changes such as animal faces [41] and foods [33]. We demonstrate the effects of the deep hierarchical I2I translation framework, providing qualitative and quantitative results. We further evaluate the knowledge transfer, which largely accelerates convergence and outperforms DeepI2I trained from scratch. Additionally, leveraging the adaptor is able to tackle the misalignment, consistently improving the performance of I2I translation.

Related work
Generative adversarial networks. GANs are composed of a generator and a discriminator [19]. The generator aims to synthesize a fake data distribution to fool the discriminator, while the discriminator aims to distinguish the synthesized from the real distribution. Recent works [3,20,44,46,58,77] focus on addressing the mode collapse and training instabilityproblems, which occur normally when training GANs. Besides, several works [8,13,29,30,55] explore constructing effective architectures to synthesize high-quality images. For example, Karras et al. [29][30][31] manage to generate progressively a high-realistic image from low to high resolution. BigGAN [8] successfully synthesizes high-fidelity images on imageNet [12].
Image-to-image translation. Image-to-image translation has been studied widely in computer vision. It has achieved outstanding performance on both paired [18,25,83,70,69] and unpaired image translation [40,35,78,82,65,5,16,66,45,53,64]. These approaches, however, suffer from two main challenges: diversity and scalability. The goal of diversity translation is to synthesize multiple plausible outputs of the target domain from a single input image [23,37,2,56,79]. Scalability [10,79,11,38] refers to translations across several domains using a single model. Several concurrent works [32,76,57,61] also focus on shape translation as well as style. TransGaGa [76] firstly disentangles the input image in the geometry space and style space, then it conducts the translation for each latent space separately. However, none of these approaches addresses the problem of transfer learning for I2I.
Transfer learning for GANs. A series of recent works investigated knowledge transfer on generative models [50,75,71,59] as well as discriminative models [14,52,51,67]. TransferGAN [75] indicates that training GANs on small data benefits from the pre-trained GANs. Noguchi et al. [50] study only updating part of the parameters of the pre-trained generator. Wang et al. [71] propose a minor network to explore the latent space of the pre-trained generator. Several other approaches [49,48,26,17] study pre-trained generators, but do not focus on transferring knowledge. Furthermore, some methods [4,1,81] perform image editing by leveraging the pre-trained GAN. Image2StyleGAN [1] leverages an embedding representation to reconstruct the input sample. To the best of our knowledge, transferring knowledge from pre-trained GANs to I2I translation is not explored yet.  Figure 1: Left: the traditional form of conditional GAN (i.e., BigGAN [8]) which contains the generator Φ and the discriminator Ψ. Right: the proposed DeepI2I method based on conditional GAN (left). Our method consists of four terms: the encoder Υ, the adaptor Λ, the generator Φ and the discriminator Ψ. The encoder Υ is initialized by pre-trained discriminator (left), as well as both the generator Φ and the discriminator Ψ by pre-trained GANs (left). The adaptor Λ aims to align the pre-trained encoder Υ and the pre-trained generator Ψ.

Deep Hierarchical Image-to-Image Translation
We hypothesise that current I2I translations are limited due to their high-resolution bottleneck architectures. As a consequence, these methods cannot handle translations between classes with large shape changes. Low-level information, extracted in the initial layers, is not adequate for these translations, and high-level (semantic) information is required for successful translation to the target domain. The bottleneck resolution of architectures can be trivially decreased by adding additional down-sampling layers to the architectures. However, inverting a deep low-resolution bottleneck (latent) representation into a high-fidelity image is challenging [43], since the deep features contain mainly attribute-level information, from which it is difficult to reconstruct realistic images which we expect still closely follow the image structure of the input image [63,15].
Instead, we propose a deep hierarchical I2I translation framework that fuses representations at various levels of abstraction (see Fig. 1 right). The method has a BigGAN architecture as its core, and adapts it to I2I translation by adding an encoder network which follows the same architecture as the BigGAN discriminator. This introduces several novelties to the I2I domain, such as orthogonal regularization to fine control over the trade-off between image quality and variety, and class-conditioning via a class embedding representation which operates at various levels of depth in the network. The latter allows to apply the network to many-class I2I translations. Current architectures [10,79] which concatenate a one-hot label vector to the source image or latent space are not scalable to many-class domains.
Method Overview. Let X , Y = R H×W ×3 be the source and target domains. As illustrated in Figure 1 (right), our framework is composed of four neural networks: encoder Υ, adaptor Λ, generator Φ and discriminator Ψ. We aim to learn a network to map the input source image x ∈ X into a target domain imageŷ ∈ Y conditioned on the target domain label c ∈ {1, . . . , C} and a random noise vector z ∈ R Z , Φ (Λ (Υ (x)) , c, z) →ŷ ∈ Y. We use the latent representation from different layers of encoder Υ to extract structural information (shallow layers) and semantic information (deep layers). Let Υ l (x) be the l-th (l = m, ..., n(n > m)) ResBlock 2 output of the encoder, which is fed into the corresponding adaptor Λ l , from which it continues as input to the corresponding layer of the generator.
As illustrated in Figure 1 (right), we take the input image x as input, and extract the hierarchical The adaptor Λ then takes the output of Υ as input, that is Λ (Υ (x)) = {Λ l }, where (Λ l ) is the output of each adaptor Λ l which is further summed to the activations of the corresponding layer of the generator Φ. We clarify the functioning of the adaptor in the next section on transfer learning, where it is used to align pre-trained representations. In case, we train DeepI2I from scratch the adaptor could be the identity function. The generator takes as input the output of adaptor Λ (Υ (x)), the random noise z and the target label c. The generator Φ outputs aŷ = Φ (Λ (Υ (x)) , z, c) which is supposed to mimic the distribution of the target domain images with label c. Sampling different z leads to diverse output resultsŷ.
The function of the discriminator Ψ is threefold. The first one is to distinguish real target images from generated images. The second one is to guide the generator Φ to synthesize images which belong to the class indicated by c. The last one is to compute the reconstruction loss, which aims to preserve a similar pose in both input source image x and the output Φ (Λ (Υ (x)) , z, c). Inspired by recent work [41], we employ the discriminator as a feature extractor from which the reconstruction loss is computed. The reconstruction is based on the l-th ResBlock of discriminator Ψ, and referred to by {Ψ l (y)}.
Training Losses. The overall loss is a multi-task objective comprising of: (a) a conditional adversarial loss which plays two roles. On the one hand, it optimizes the adversarial game between generator and discriminator, i.e., Ψ seeks to maximize while {Υ, Λ, Φ} seeks to minimize it. On the other hand, it encourages {Υ, Λ, Φ} to generate class-specific images which correspondent to label c. (b) a reconstruction loss guarantees that the synthesized imageŷ = Φ (Λ (Υ (x)) , z, c) preserve the same pose as the input image x.
Conditional adversarial loss. We employ GAN [19] to optimize this problem, which is as following: where p (z) follows the normal distribution , and p (c) is the domain label distribution. In this paper, we leverage a conditional GAN [47]. Note that this conditional GAN [47] contains a trainable class embedding layer, we fuse it into the Φ and Ψ networks. The final loss function is optimized by the mini-max game according to Reconstruction loss. Inspired by the results for photo-realistic image generation [28,27,73,62], we consider the reconstruction loss based on a set of the activations extracted from multiple layers of the discriminator Ψ. We define the loss as: where parameters α l are scalars which balance the terms, are 0.1 except for α 3 = 0.01. Note that this loss is only used to update the encoder Υ, adaptor Λ, and generator Φ.
Full Objective. The full objective function of our model is: min where both λ adv and λ rec are hyper-parameters that balance the importance of each terms.

Knowledge transfer
Transfer learning has contributed to the wide application of deep classification networks [14]. It allows exploiting the knowledge from high-quality pre-trained networks when training networks on datasets with relatively little labeled data. Given the success of knowledge transfer for classification networks, it might be surprising that this technique has not been applied to I2I problems. However, it is unclear what dataset could function as the universal I2I dataset (like imageNet [12] for classification networks). Training an I2I network on imageNet is unsound since many translations would be meaningless (translating 'cars' to 'houses', or 'red' to 'crowd'). Instead, we argue that the knowledge required by the encoder, generator, and discriminator of the I2I system can be transferred from high-quality pre-trained GANs.
We propose to initialize the DeepI2I network from a pre-trained high-quality BigGAN (Figure 1 left). We leverage the pre-trained discriminator Ψ to initialize the discriminator Ψ of the proposed model, and we use the pre-trained generator Φ to initialize the deepI2I generator Φ. This would leave the encoder Υ still uninitialized. However, we propose to use the pre-trained discriminator Ψ to also initialize the encoder Υ. This makes sense, since the discriminator of the BigGAN has the ability to correctly classify the input images on imageNet [12], which optimizes it to be an effective feature extractor.
Our architecture introduces connections between the various layers of the encoder and the generator. This allows transferring representations of various resolutions (and abstraction) between the encoder Υ and the generator Φ. The combination is done with a dedicated adaptor network, and combined with a summation: DeepI2I 80 where Φ l is the output of the corresponding layer which has same resolution to Λ l . The hyperparameters w l are used to balance the two terms (in this work we set w l is 0.1). When we use the pretrained encoder and decoder the representations are not aligned, i.e., the feature layer corresponding to the recognition of eyes in the encoder is not the same feature layer which will encourages the generator to generate eyes, since there is no connection between both when training the BigGAN. The task of the adaptor network is to align the two representations. The adaptors are multi-layer CNNs (see Suppl. Mat. Sec. A for details).
We train deepI2I in two phases. In the first phase, we only train the adaptors and discriminator, keeping the encoder and generator fixed. In the second phase we train the whole system except for the encoder, which we keep fixed. We empirically found that a frozen encoder results in slightly better performance.

Experiments
In this section, we will first evaluate our model on the more challenging setting, many-class I2I translation, which is rarely explored in the previous works. Next, we perform two-class I2I translation which allows us to compare to unconditional I2I methods [9,23,34,37,40,82].

Experiment setting
The training details for all models are in included Suppl. Mat. Sec. A. Throughout this section, we will use deepI2I to refer to our method when using the initialization from BigGAN, and we use deepI2I (scratch) when we train the network from scratch.
Evaluation metrics. We report results on four evaluation metrics. Fréchet Inception Distance (FID) [22] measures the similarity between two sets in the embedding space given by the features of a convolutional neural network. Kernel Inception Distance (KID) [6] calculates the squared maximum mean discrepancy to indicate the visual similarity between real and synthesized images. We calculate the mean values of all categories in terms of FID and KID, denoted as mFID and mKID. We further evaluate on two metrics of translation accuracy to show the ability of the learned model to synthesizing the correct class-specific images, called real classifier (RC) and fake classifier (FC) [ respectively. The former is trained on real data and evaluated on the generated data, while the latter is trained on the generated samples and evaluated on the real data.
Datasets. We present our results on four datasets, namely Animal faces [41], Birds [68], Foods [33] and cat2dog [37]. Animal faces dataset contains 117,574 images and 149 classes in total, Birds has 48,527 images and 555 classes in total, Foods consists of 31,395 images and 256 classes in total, and cat2dog composes of 2235 images and 2 classes in total. We resized all images to 128 × 128, and split each data into training set (90 %) and test set (10 %).
The baselines for many-class I2I. We compare to StarGAN [10], SDIT [72] and DMIT [79], all of which performs image-to-image translation between many-class domains. StarGAN [10] performs scalable image translation for all classes by inputting the label to the generator. SDIT [72] obtains scability and diversity in a single model by conditioning on the class label and random noise. DMIT [79] concatenates the class label and the random noise, and maps them into the latent representation. All these architectures are based on high-resolution bottleneck architectures.
The baselines for two-class I2I. We also adopt six baselines for this setting. CycleGAN [82] used a cycle consistency loss to reconstruct the input image, avoiding the requirement of paired data. UNIT [40] presented an unsupervised I2I translation method under the shared-latent space assumption. A set of methods, including MUNIT [23], DRIT [37], DRIT++ [38] and StarGANv2 [11], disentangle the latent distribution into the content space which is shared between two domains, and the style space which is domain-specific and aligned with a Gaussian distribution. NICEGAN [9] investigated sharing weights of the encoder and discriminator. UGATIT [34] studied an attention module and a new learnable normalization function, which is able to handle the geometric changes.

Many-class image-to-image translation
Ablation study We conduct ablation studies to isolate the validity of the key components of our method: transfer learning technique and the adaptor.
Transfer learning. Figure 2 shows the visualization (Figure 2 (a)) and the evolution of mFID (Figure 2 (b)) during the training process without and with knowledge transfer. As shown in Figure 2 (a), the proposed method (DeepI2I) adapted from a pre-trained model is able to synthesize the shape information of class-specific images in significantly fewer iterations than the model trained from scratch (DeepI2I (scratch)) at the early training stage. And the translated images from DeepI2I are observed to have higher quality and more authentic details than DeepI2I (scratch). Figure 2 (b) also supports the conclusion: DeepI2I converges much faster than DeepI2I (scratch) in terms of mFID, though the gap is reduced over time.
We perform an additional ablation of partial transfer learning on the Animal faces dataset in Fig. 6 (left). Instead of using the pre-trained GAN to initialize all three networks of the I2I system, we consider only initializing some of the networks with the pre-trained GAN and randomly initializing the remaining ones. As can be seen, the network does only successfully converge when we initialize all three networks with the pre-trained GAN.
Adaptor. We explore a wide variety of configurations for our approach by applying adaptors on several layers between encoder and generator. These results are based on DeepI2I initialized with the pre-trained GAN. Here we evaluate the effect of each adaptor on these four evaluation metrics. E.g. DeepI2I (w-3) refers to model with the adaptor Λ 3 and without adaptors Λ l (l = 4, 5, 6). Figure 3 presents a comparison between several variants of the proposed method. Only considering the  single adaptor fails to achieve satisfactory performance, indicating that lacking either the information contained in the lower layer (i.e. the third, fourth, fifth ResBlocks of encoder Υ ) nor the semantic information extracted in deep layers (i.e. the sixth ResBlock), the method cannot conduct effective I2I translation for challenging tasks. Notably, only using the adaptor on the deep feature (i.e. the sixth ResBlock ) obtains the worst performance, since the deep layer contains more attribute information and less structural information, which largely increases the difficulty to generate realistic image [49]. We also remove the adaptor network, and directly sum the extracted feature into the generator, called †DeepI2I. Note we connections at the all four ResBlocks. †DeepI2I obtains better results (e.g., mFID: 92.0) than the case where only one adaptor is considered. But the large gap with DeepI2I (e.g., mFID: 68.4) shows the importance of the adaptor network. The combination of adaptors (DeepI2I) in our proposed method achieves the best accuracy on all of the evaluations.
Number of downsampling layers. In this paper, we propose to use multiple downsampling layers to extract effectively the structure and semantic information. We perform an experiment to evaluate the effective of the number of downsampling layers. As shown in Table 6 (middle), we experimentally find that more downsampling layers results in better performance.
Quantitative results. Table 1 3 reports the quantitative results on the Animal faces [41], Birds [68] and Foods [33] datasets to assess many-class I2I translation. We can see that the proposed method achieves the best performance (denoted as DeepI2I in the table), in terms of four evaluation metrics, indicating that our model produces the most realistic and correct class-specific images among all the methods compared. In addition, we also conduct an experiment without transferring any information from BigGAN (denoted as DeepI2I (scratch)). On animal faces dataset, DeepI2I (scratch) obtains better results than the other baselines, and comparable performance to DeepI2I. However, DeepI2I (scratch) achieves the worst scores on birds and foods datasets. The different score of above metrics is due to the fact that the former has a large number of images per class (animal faces: 710/per class),  while the latter has only limited data (birds: 78/per class; foods: 110/per class) 4 . DeepI2I wins in all metrics, clearly verifying the importance of the hierarchical architecture, combined with knowledge transfer for deep I2I translation.
Finally, we perform a psychophysical experiment with generated images by StarGAN, DMIT and DeepI2I. We conduct a user study and ask subjects to select results that are more realistic given the target label, and have the same pose as the input image. We apply pairwise comparisons (forced choice) with 26 users (30 pairs of images/user). Figure 6(right) shows that DeepI2I considerably outperforms the other methods.
Qualitative results. Figure 4 shows the many-class translation results on animal faces and food dataset. We observe that our method provides a higher visual quality of translation compared to the StarGAN and DMIT models. Taking the animal faces examples, both StarGAN and DMIT barely synthesize a few categories, but fail to generate realistic images for most ones. DeepI2I, however, not only manages to map the input image into class-specific image given the target label, but also guarantees to generate high-resolution realistic images. The visualization of the food dataset also supports our conclusion: DeepI2I can synthesize target images given a target food name.
Scabality and diversity We also explore two significant properties: the scability and the diversity. As shown in Figure 5, DeepI2I successfully translates the input image into class-specific images, clearly indicating that the proposed method provides scability. Given the target attribute (i.e., meerkat), our method generates diverse outputs (the second column). What is more important, we achieve both the scalability and the diversity with one single model.

Two-class image-to-image translation
Here we consider translating images between two categories: cats and dogs, to be able to compare our method with other unconditional I2I methods. Figure 7 (left) compares DeepI2I with six baselines. We can see how DeepI2I clearly generates more realistic target images. Figure 7 (right) reports the metric values. Our method outperforms all the baselines on the evaluation metrics except for KID (dog→cat). This experiment shows that our method still keeps comparable performance even for two-class image-to-image translation.

Unseen image-to-image translation
To illustrate the generalization power of deepI2I, we also perform unseen I2I. Here we provide the network with an input class which was not used during training. We use the network trained on the animal face and provide it with a human face. As illustrated in Figure 8, StarGAN fails to translate the input human face into the class-specific outputs, and the generated images are not satisfactory. DeepI2I, however, manages to generate high-quality images with significant shape changes (consider for example column four of results).

Conclusion
We introduced a new network for many-class image-to-image translation including classes with significant shape changes. We extract the hierarchical representation of an input image, including both structural and semantic information. Hierarchical I2I obtains inferior results on limited datasets.
To mitigate this problem we propose to initialize deepI2I from a pre-trained GAN. As such we are the first to study transfer learning for I2I networks. Naively duplicating the pre-trained GAN suffers from an alignment problem. We address this by introducing a dedicated adaptor network. We qualitatively and quantitatively evaluate our method on several datasets. We optimize the model using Adam [36] with batch size of 32. The learning rate of the generator is 0.0001, and the one of the encoder, adaptor and discriminator is 0.0004 with exponential decay rates of (β 1 , β 2 ) = (0.0, 0.999). We use 4 ×Quadro RTX 6000 GPUs (27G/per) to conduct all our experiments.
Metric Computation For the computation of the metrics, we randomly generate 12,800 images for each target category given the same input images, which are from the test dataset. As the classifier, we use Resent50 [21] as the backbone, followed by one fully connected layer to compute the RC and FC metrics.

B Additional Qualitative Results
We provide additional results for models trained on animal faces, foods, and birds in Figure 11, 12, 13.
We also show results translating an input image into all category on animal faces, foods, and birds in Figure 14, 15, 16.

C Results on Reduced Animal Face Dataset
We also evaluate our method using fewer animal faces. Specifically, we randomly select 10% of data per class. As reported in Table 2 Figure 9: Qualitative results on the cat2dog dataset. The generated images are prone to suffer from artifacts (the red box), which is caused by StyleGAN [30]. Figure 8 reports interpolation by freezing the input images while interpolating the class embedding between two classes. Our model still manages to generate high quantity images even given never seen class embeddings.

E Results on StyleGAN
We also explore the proposed method on StyleGAN [30]. Like the one in the main paper which transfers from BigGAN, we build our model based on the StyleGAN structure, and initialize our Figure 10: Typical failure case of our method. The first column is the input, followed by the output for different target classes in the remaining columns.

Datasets
Animal faces (  model using the pre-trained StyleGAN, which is optimized on HHFQ dataset [30]. We refer readers to StyleGAN paper for more details. As illustrated in Figure 9, DeepI2I manages to translate the input image (dog) into target image (cat). The generated images, however, suffer from the artifacts (the red box in Figure 9), which is a result of both the architecture and the training method of StyleGAN. In the future, we will adapt our method to the latest methods (e.g., StyleGAN2 [31]) to avoid this problem.

F Ablation on Reconstruction loss
The reconstruction loss helps to maintain the structure/poss information of the input sample. We conduct experiment by removing the reconstruction loss during training, and find the structure of both input (Figure 18 first column) and output ( Figure 18 third column) is different. This shows that the structure information will be lost without reconstruction loss. The same is also used in [41,72].

G Impact of transfer learning on translation classic
We also performed an experiment on the classic translation from horses to zebras proposed in [80]. The experiment and visualisation of the results are shown in Figure 17. In terms of FID score the results improve from 77.2 for CycleGAN to 63.2 for DeepI2I.

H T-SNE
We investigate the latent space of the generated images. We randomly sample 1280 images, and translate them into a specific class (Blenheim spaniel). Specifically, given the generated images we firstly perform Principle Component Analysis (PCA) [7] to extracted feature, then conduct the T-SNE [42] to visualize the generated images in a two dimensional space. As illustrated in Figure 19, given the target class (Blenheim spaniel), DeepI2I correctly disentangles the pose information of the input classes.
The T-SNE plot shows that input animals having similar pose are localized close to each other in the T-SNE plot. Furthermore, it shows DeepI2I has the ability of diversity. We also conduct T-SNE for 14,900 generated images across 149 categories ( Figure 20).  Table 3: Ablation study of the variants of our model. * means the encoder of our model is from scratch, while both the generator and the discriminator are from the pre-trained GAN (BigGAN).

I Failure cases
Our method obtains compelling performance for many cases, but suffers from some failures. Figure 10 shows a few failure cases. The input images are different from the normal animal faces. E.g. a side-view of a face, which is rare in the dataset, causes the model to produce unrealistic results.     Note that for each pair image, the left is the input and the right is the output image. Please zoom-in for details.