Unsupervised Creation of Parameterized Avatars

TL;DR

This paper introduces an unsupervised method to generate parameterized avatars from input images using a GAN, enabling automatic avatar creation without supervision and extending domain adaptation and transfer techniques.

Contribution

It proposes a novel unsupervised learning approach with a theoretical generalization bound for creating avatars from images using a GAN.

Findings

Successfully creates avatars that resemble input images

Extends unsupervised domain adaptation and transfer literature

Provides a theoretical bound based on discrepancy

Abstract

We study the problem of mapping an input image to a tied pair consisting of a vector of parameters and an image that is created using a graphical engine from the vector of parameters. The mapping's objective is to have the output image as similar as possible to the input image. During training, no supervision is given in the form of matching inputs and outputs. This learning problem extends two literature problems: unsupervised domain adaptation and cross domain transfer. We define a generalization bound that is based on discrepancy, and employ a GAN to implement a network solution that corresponds to this bound. Experimentally, our method is shown to solve the problem of automatically creating avatars.

Tables

Table 1. Table 1: Comparison of median rank for retrieval out of a set of 100,001 face images for either manually created emoji, or emoji and VR avatars created by DTN or TOS. Results are shown for the “raw” G ​ ( x ) 𝐺 𝑥 G(x) as well as for the configuration compliant e ( . . ( x ) ) e(..(x)) . Since DTN does not produce a configuration-compliant emoji, we obtain the results for the e ( . . ( x ) ) e(..(x)) column by applying to its output a pretrained network c ¯ ¯ 𝑐 \bar{c} that maps emoji to configurations. Also shown are DANN results obtained when training such a mapping c ¯ ¯ 𝑐 \bar{c} that is adapted to the samples in 𝐬 𝐬 \mathbf{s} .

Method	Emoji		Avatars
	$𝐠\left(𝐟\left(𝐱\right)\right)$	$𝐞(..\left(𝐱\right))$	$𝐠\left(𝐟\left(𝐱\right)\right)$	$𝐞(..\left(𝐱\right))$
Manual	NA	16,311	NA	NA
DANN [6]	NA	59,625	NA	52,435
DTN [23]	16	18,079	195	38,805
TOS	30	3,519	758	11,153
TOS fixed $\overline{c}$	26	14,990	253	43,160

Table 2. Table 2: The mathematical notations used in the paper.

Symbol	Meaning
$𝒳$	Input space
$𝒴$	Output space
${𝒴}_1,{𝒴}_2$	Tied output spaces
$D_S$	Source distribution
$D_T$	Target distribution
$D_1$,$D_2$	Input/output or other pairs of distributions
$\ell$	A loss function, typically $\ell :𝒴\times 𝒴\to {ℝ}_{+}$
${\text{disc}}_{𝒞}(D_1,D_2)$	Discrepancy between two distributions $D_1$ and $D_2$, using functions from the hypothesis class $𝒞$
$R_D[c_1,c_2]$	The risk between two functions $c_1$ and $c_2$, i.e.,${𝔼}_{x\sim D}\left[\ell (c_1\left(x\right),c_2\left(x\right))\right]$
$y$	The function from input to output we learn
$y_S,y_T$	In domain adaptation, the source and target functions from input to output
$f$	A pre-trained feature map
$e$	A mapping from configurations (${𝒴}_2$) to parameterized outputs (${𝒴}_1$)
$c\in {\mathscr{H}}_3$	A learned mapping from the space of parameterized outputs (${𝒴}_1$) to configurations (${𝒴}_2$)
$g\in {\mathscr{H}}_2$	A generator function from the feature space (image of $f$) to the output space
$d$	The discriminator of the GAN
$h\in \mathscr{H}$	A mapping from input to output (different to each problem)
$G$	A generator from the input space to the space ${𝒴}_1$
$L_{\text{GAN}}$	The GAN loss term. Used together with Eq. 7
$L_c$	The loss that arises from the mismatch between $G$ and $c$. The specific form used is given in Eq. 5
${\ell }_e$	For a given $x$, the mismatch between $G\left(x\right)$ and $e\circ c$ applied to it
$𝐬$	The training set in $𝒳$
$𝐭$	The training set in ${𝒴}_1$
$L_{\text{CONST}}$	The term that enforces f-constancy
$L_{\text{TID}}$	The term that enforces idempotency for the learned mapping
$L_{\text{TV}}$	Total Variation loss, which encourages smoothness of the output
$\alpha$,$\beta$,$\gamma$,$\delta$	Tradeoff parameters (weights in the loss term the network minimizes)
$p$	The feature map of the DANN algorithm [6]
$l$	The label predictor network of the DANN algorithm [6]

Equations

$$R_{D_1}[h,y]\le$$

$$+{\text{disc}}_{\mathcal{H}}(y\circ D_2,h\circ D_1)+\lambda$$

$$R_{D_1}[e\circ h,e\circ y]\le$$

$$+R_{D_1}[f\circ g\circ f,f]$$

$$+{\text{disc}}_{\mathcal{H}}(e\circ y\circ D_2,g\circ f\circ D_1)+\lambda ,$$

$$R_{D_1}[g\circ f,e\circ y]\le$$

$$+{\text{disc}}_{\mathcal{H}}(e\circ y\circ D_2,g\circ f\circ D_1)+\lambda \text{qed}$$

$$L_c=\underset{c}{\min }{E}_x\ell (G,c,x).$$

$${\ell }_e(G,c,x)=\Vert G(x)-e(c(G(x))){\Vert }^2.$$

$$L_c=\sum _{x\in \mathbf{s}}\Vert g(f(x))-e(c(g(f(x)))){\Vert }^2$$

$$L_{\text{CONST}}=\sum _{x\in \mathbf{s}}\Vert f(x)-f(G(x)){\Vert }^2$$

$$\ell (G,d,x)=\log [1-d(G(x))]+\frac{1}{|\mathbf{t}|}\sum _{x^{\prime }\in \mathbf{t}}\log [d(x^{\prime })].$$

$$L_{\text{TID}}=\sum _{x\in \mathbf{t}}\Vert x-g(f(x)){\Vert }^2$$

$$\underset{x\in X_p}{\mathrm{argmin}}||f(x)-f(e(c(G(x))))||.$$

Full text

This learning problem extends two literature problems: unsupervised domain adaptation and cross domain transfer. We define a generalization bound that is based on discrepancy, and employ a GAN to implement a network solution that corresponds to this bound. Experimentally, our method is shown to solve the problem of automatically creating avatars.

1 Introduction

The artist Hanoch Piven creates caricatures by arranging household items and scrap material in a frame and photographing the result, see Fig. 1(a). How can a computer create such images? Given a training set consisting of Piven’s images, Generative Adversarial Networks (GANs) can be used to create images that are as indistinguishable as possible from the training set. However, common sense tells us that for any reasonably sized training set, without knowledge about the physical world, the generated images would be easily recognized by humans as being synthetic.

As a second motivating example, consider the problem of generating computer avatars based on the user’s appearance. In order to allow the avatars to be easily manipulated, each avatar is represented by a set of “switches” (parameters) that select, for example, the shape of the nose, the color of the eyes and the style of hair, all from a predefined set of options created by artists. Similar to the first example, the visual appearance of the avatar adheres to a set of constraints. Once the set of parameters is set, the avatar can be rendered in many variations (Fig. 1(b)).

The goal of this work is to learn to map an input image to two tied outputs: a vector in some parameter space and the image generated by this vector. While it is sufficient to recover just the vector of parameters and then generate the image, a non-intuitive result of our work is that it is preferable to recover the analog image first. In any case, the mapping between the input image and either of the outputs should be learned in an unsupervised way due to the difficulty of obtaining supervised samples that map input images to parameterized representations. In avatar creation, it is time consuming for humans to select the parameters that represent a user, even after considerable training. The selected parameters are also not guaranteed to be the optimal depiction of that user. Therefore, using unsupervised methods is both more practical and holds the potential to lead to more accurate results.

In addition, humans can learn to create parameterized analogies without using matching samples. Understanding possible computational processes is, therefore, an objective of AI, and is the research question addressed. Our contributions are therefore as follows: (i) we present a highly applicable and, as far as we know, completely unexplored vision problem; (ii) the new problem is placed in the mathematical context of other domain shift problems; (iii) a generalization bound for the new problem is presented; (iv) an algorithm that matches the terms of the generalization bound is introduced; (v) the qualitative and quantitative success of the method further validates the non-intuitive path we take and (vi) the new method is shown to solve the parameterized avatar creation problem.

1.1 Background

Generative Adversarial Networks GAN [8] methods train a generator network $G$ that synthesizes samples from a target distribution, given noise vectors, by jointly training a second network $d$. The specific generative architecture we employ is based on the architecture of [21]. Since the image we create is based on an input and not on random noise, our method is related to Conditional GANs, which employ GANs in order to generate samples from a specific class [18], based on a textual description [22], or to invert mid-level network activations [3]. The CoGAN method [15], like our method, generates a pair of tied outputs. However, this method generates the two based on a random vector and not on an input image. More importantly, the two outputs are assumed to be similar and their generators (and GAN discriminators) share many of the layers. In our case, the two outputs are related in a different way: a vector of parameters and the resulting image. The solutions are also vastly different.

A recent work, which studied the learning of 3D structure from images in an unsupervised manner, shares some of computational characteristics with our problem [11]. The most similar application to ours, involves a parametrization of a 3D computer graphics object with 162 vertices, each moving along a line, a black-box camera projecting from 3D to 2D and a set of 2D images without the corresponding 3D configuration. The system then learns to map 2D images to the set of vertices. This setting shares with us the existence of a fixed mapping from the vector of parameters to the image. In our case, this mapping is given as a neural network that will be termed $e$, in their case, it is given as a black box, which, as discussed in Sec. 5 is a solvable challenge. A more significant difference is that in their case, the images generated by the fixed mapping are in the same domain as the input, while in our case it is from a different domain. The method employed in [11] completely differs from ours and is based on sequential generative models [9].

Distances between distributions In unsupervised learning, where one cannot match between an input sample and its output, many methods rely on measuring distances between distributions. Specifically, GANs were recently shown [6] to implement the theoretical notion of discrepancies.

Definition 1** (Discrepancy distance).**

*Let $\mathcal{C}$ be a class of functions from $A$ to $B$ and let $\ell:B\times B\rightarrow\mathbb{R}_{+}$ be a loss function over $B$. The discrepancy distance $\textnormal{disc}_{\mathcal{C}}$ between two distributions $D_{1}$ and $D_{2}$ over $A$ is defined as \textnormal{disc}_{\mathcal{C}}(D_{1},D_{2})=\sup_{c_{1},c_{2}\in\mathcal{C}}\Big{|}R_{D_{1}}[c_{1},c_{2}]-R_{D_{2}}[c_{1},c_{2}]\Big{|}, where $R_{D}[c_{1},c_{2}]=\mathbb{E}_{x\sim D}\left[\ell(c_{1}(x),c_{2}(x))\right]$. *

Image synthesis with CNNs The supervised network of [4] receives as input a one-hot encoding of the desired model as well as view parameters and a 3D transformation and generates the desired view of a 3D object.

DC-IGN [13] performs a similar task with less direct supervision. The training set of this method is stratified but not necessarily fully labeled and is used to disentangle the image representation in an encoder-decoder framework. Pix2pix [10] maps an image to another domain. This methods is fully supervised and requires pairs of matching samples from the two domains.

Style transfer In these methods [7, 25, 12], new images are synthesized by minimizing the content loss with respect to one input sample and the style loss with respect to one or more input samples. The content loss is typically the encoding of the image by a network training for an image categorization task, similar to our work. The style loss compares the statistics of the activations in various layers of the neural network. We do not employ style losses in our method and more significantly, the problem that we solve differs. This is not only because style transfer methods cannot capture semantics [23], but also because the image we generate has to adhere to specific constraints. Similarly, the work that has been done to automatically generate sketches from images, e.g., [26, 27], does not apply to our problem since it does not produce a parameter vector in a semantic configuration space. The literature of face sketches also typically trains in a supervised manner that requires correspondences between sketches and photographs.

2 Problem Formulation

Problems involving domain shift receive an increasing amount of attention, as the field of machine learning moves its focus away from the vanilla supervised learning scenarios to new combinations of supervised, unsupervised and transfer learning. In this section, we formulate the new computational problem that we pose “Tied Output Synthesis” (TOS) and put it within a theoretical context. In the next section, we redefine the problem as a concrete deep learning problem. In order to maximize clarity, the two sections are kept as independent as possible.

2.1 Related Problems

In the unsupervised domain adaptation problem [2, 17, 1], the algorithm trains a hypothesis on a source domain and the hypothesis is tested on a different target domain. The algorithm is aided with a labeled dataset of the source domain and an unlabeled dataset of the target domain. The conventional approach to dealing with this problem is to learn a feature map that (i) enables accurate classification in the source domain and (ii) captures meaningful invariant relationships between the source and target domains.

Let $\mathcal{X}$ be the input space and $\mathcal{Y}$ be the output space (the mathematical notation is also conveniently tabulated in the appendix). The source domain is a distribution $D_{S}$ over $\mathcal{X}$ along with a function $y_{S}:\mathcal{X}\rightarrow\mathcal{Y}$. Similarly, the target domain is specified by $(D_{T},y_{T})$. Given some loss function $\ell:\mathcal{Y}\times\mathcal{Y}\rightarrow\mathbb{R}_{+}$ The goal is to fit a hypothesis $h$ from some hypothesis space $\mathcal{H}$, which minimizes the Target Generalization Risk, $R_{D_{T}}[h,y_{T}]$. Where a Generalization Risk is defined as

$R_{D}[h_{1},h_{2}]=\mathbb{E}_{x\sim D}\left[\ell(h_{1}(x),h_{2}(x))\right]$.

The distributions $D_{S}$, $D_{T}$ and the target function $y_{T}:\mathcal{X}\rightarrow\mathcal{Y}$ are unknown to the learning algorithm. Instead, the learning algorithm relies on a training set of labeled samples $\{(x,y_{S}(x))\}$, where $x$ is sampled from $D_{S}$ as well as on an unlabeled training set of samples $x\sim D_{T}$, see Fig. 2(a).

In the cross domain transfer problem, the task is to learn a function that maps samples from the input domain $\cal X$ to the output domain $\cal Y$. It was recently presented in [23], where a GAN based solution was able to convincingly transform face images into caricatures from a specific domain.

The training data available to the learning algorithm in the cross domain transfer problem is illustrated in Fig. 2(b). The problem consists of two distributions, $D_{1}$ and $D_{2}$, and a target function, $y$. The algorithm has access to the following two unsupervised datasets: $\{x_{i}{\sim}D_{1}\}^{m}_{i=1}$ and $\{y(x_{j})|x_{j}{\sim}D_{2}\}^{n}_{j=1}$. The goal is to fit a function $h=g\circ f\in\mathcal{H}$ that optimizes $\inf_{h\in\mathcal{H}}R_{D_{1}}[h,y]$.

It is assumed that: (i) $f$ is a fixed pre-trained feature map and, therefore, \mathcal{H}=\left\{g\circ f\big{|}g\in\mathcal{H}_{2}\right\} for some hypothesis class $\mathcal{H}_{2}$; and (ii) $y$ is idempotent, i.e, $y\circ y\equiv y$. For example, in [23], $f$ is the DeepFace representation [24] and $y$ maps face images to emoji caricatures. In addition, applying $y$ on an emoji gives the same emoji. Note that according to the terminology of [23], $D_{1}$ and $D_{2}$ are the source and target distributions respectively. However, the loss $R_{D_{1}}[h,y]$ is measured over $D_{1}$, while in domain adaptation, it is measured over the target distribution.

Recently [5], the cross domain transfer problem was analyzed using the theoretical term of discrepancy. Denoting, for example, $y\circ D$ to be the distribution of the $y$ mappings of samples $x\sim D$, then the following bound is obtained.

Theorem 1** (Domain transfer [5]).**

*If $\ell$ satisfies the triangle inequality111For all $y_{1},y_{2},y_{3}\in\mathcal{Y}$ it holds that $\ell(y_{1},y_{3})\leq\ell(y_{1},y_{2})+\ell(y_{2},y_{3})$. This holds for the absolute loss, and can be relaxed to the square loss, where it holds up to a multiplicative factor of 3. and $\mathcal{H}_{2}$ (the hypothesis class of $g$) is a universal Lipschitz hypothesis class222A function $c\in\mathcal{C}$ is Lipschitz with respect to $\ell$, if there is a constant $L>0$ such that: $\forall a_{1},a_{2}\in A:\ell(c(a_{1}),c(a_{2}))\leq L\cdot\ell(a_{1},a_{2})$. A hypothesis class $\mathcal{C}$ is universal Lipschitz with respect to $\ell$ if all functions $c\in\mathcal{C}$ are Lipschitz with some universal constant $L>0$. This holds, for example, for neural networks with leaky ReLU activations and weight matrices of bounded norms, under the squared or absolute loss., then for all $h=g\circ f\in\mathcal{H}$, *

[TABLE]

Here, $\lambda=\min_{h\in\mathcal{H}}\left\{R_{y\circ D_{2}}[h,\textnormal{Id}]+R_{D_{1}}[h,y]\right\}$ and $h^{*}=g^{*}\circ f$ is the corresponding minimizer.

This theorem matches the method of [23], which is called DTN. It bounds the risk $R_{D_{1}}[h,y]$, i.e., the expected loss (using $\ell$) between the mappings by the ground truth function $y$ and the mapping by the learned function $h$ for samples $x\sim\mathcal{D}_{1}$. The first term in the R.H.S $R_{y\circ D_{2}}[h,\textnormal{Id}]$ is the $L_{\text{TID}}$ part of the DTN loss, which, for the emoji generation application, states that emoji caricatures are mapped to themselves. The second term $R_{D_{1}}[f\circ h,f]$ corresponds to the $L_{\text{CONST}}$ term of DTN, which states that the DeepFace representations of the input face image and the resulting caricature are similar. The theorem shows that his constancy does not need to be assumed and is a result of the idempotency of $y$ and the structure of $h$. The third term $\textnormal{disc}_{\mathcal{H}}(y\circ D_{2},h\circ D_{1})$ is the GAN element of the DTN method, which compares generated caricatures ($h\circ D_{1}$) to the training dataset of the unlabeled emoji ($y\circ D_{2}$). Lastly, the $\lambda$ factor captures the complexity of the hypothesis class $\cal H$, which depends on the chosen architecture of the neural network that instantiates $g$. A similar factor in the generalization bound of the unsupervised domain adaptation problem is presented in [1].

2.2 The Tied Output Synthesis Problem

The problem studied in this paper, is a third flavor of domain shift, which can be seen as a mix of the two problems: unsupervised domain adaptation and the cross domain transfer problem. Similar to the unsupervised domain transfer problem, we are given a set of supervised labeled samples. The samples $c_{j}$ are drawn i.i.d from some distribution $D_{2}$ in the space $\mathcal{Y}_{2}$ and are given together with their mappings $e(c_{j})\in\mathcal{Y}_{1}$. In addition, and similar to the cross domain transfer problem, we are given samples $x_{i}\in\mathcal{X}$ drawn i.i.d from another distribution $D_{1}$. The goal is to learn a mapping $y:\mathcal{X}\rightarrow\mathcal{Y}_{2}$ that satisfies the following condition $y\circ e\circ y=y$. The hypothesis class contains functions $h$ of the form $c\circ g\circ f$ for some known $f$ for $g\in\mathcal{H}_{2}$ and for $c\in\mathcal{H}_{3}$. $f$ is a pre-learned function that maps the input sample in $\mathcal{X}$ to some feature space, $g$ maps from this feature space to the space $\mathcal{Y}_{1}$, and $c$ maps from this space to the space of parameters $\mathcal{Y}_{2}$, see Fig. 2(c) and Fig. 3.

Our approach assumes that $e$ is prelearned from the matching samples $(c_{j},e(c_{j}))$. However, $c$ is learned together with $g$. This makes sense, since while $e$ is a feedforward transformation from a set of parameters to an output, $c$ requires the conversion of an input of the form $g(f(x))$ where $x\sim D_{1}$, which is different from the image of $e$ for inputs in $\mathcal{Y}_{2}$. The theorem below describes our solution.

Theorem 2** (Tied output bound).**

*If $\ell$ satisfies the triangle inequality and $\mathcal{H}_{2}$ is a universal Lipschitz hypothesis class with respect to $\ell$, then for all $h=c\circ g\circ f\in\mathcal{H}$, *

[TABLE]

where $\lambda=\min_{g\in\mathcal{H}_{2}}\left\{R_{e\circ y\circ D_{2}}[g\circ f,\textnormal{Id}]+R_{D_{1}}[g\circ f,e\circ y]\right\}$ and $g^{*}$ is the corresponding minimizer.

Proof.

By the triangle inequality, we obtain:

$R_{D_{1}}[e\circ h,e\circ y]\leq R_{D_{1}}[e\circ h,g\circ f]+R_{D_{1}}[g\circ f,e\circ y]$.

Applying Thm. 1 completes the proof:

[TABLE]

Thm. 2 presents a recursive connection between the tied output synthesis problem and the cross domain transfer problem. This relation can be generalized for tying even more outputs to even more complex relations among parts of the training data. The importance of having a generalization bound to guide our solution stems from the plausibility of many other terms such as $R_{e\circ y\circ D_{2}}[e\circ h,g\circ f]$ or $R_{D_{1}}[f\circ g\circ f,f\circ e\circ h]$.

Comparing to Unsupervised Cross Domain Transfer The tied output problem is a specific case of cross domain transfer with $\mathcal{Y}$ of the latter being $\mathcal{Y}_{1}\times\mathcal{Y}_{2}$ of the former. However, this view makes no use of the network $e$. Comparing Thm. 1 and Tmm. 2, there is an additional term in the second bound: $R_{D_{1}}[e\circ h,g\circ f]$. It expresses the expected loss (over samples from $D_{1}$) when comparing the result of applying the full cycle of encoding by $f$, generating an image by $g$, estimating the parameters in the space $\mathcal{Y}_{2}$ using $c$, and synthesizing the image that corresponds to these parameters using $e$, to the result of applying the subprocess that includes only $f$ and $g$.

Comparing to Unsupervised Domain Adaptation Consider the domain $\mathcal{X}\cup\mathcal{Y}_{1}$ and learn the function $e^{-1}$ from this domain to $\mathcal{Y}_{2}$, using the samples $\{(e(c_{j}),c_{j})|c_{j}\sim D_{2}\}$, adapted to $x_{i}~{}\sim D_{1}$. This is a domain adaptation problem with $D_{S}=e\circ D_{2}$ and $D_{T}=D_{1}$. Our experiments show that applying this reduction leads to suboptimal results. This is expected, since this approach does not make use of the prelearned feature map $f$. This feature map is not to be confused with the feature network learned in [6], which we denote by $p$. The latter is meant to eliminate the differences between $p\circ D_{S}$ and $p\circ D_{T}$. However, the prelearned $f$ leads to easily distinguishable $f\circ D_{S}$ and $f\circ D_{T}$.

The unsupervised domain adaptation and the TOS problem become more similar, if one identifies $p$ with the conditional function that applies $g\circ f$ to samples from $\mathcal{X}$ and the identity to samples from $\mathcal{Y}_{1}$. In this case, the label predictor of [6] is identified with our $c$ and the discrepancy terms (i.e., the GANs) are applied to the same pairs of distributions. However, the two solutions would still differ since (i) our solution minimizes $R_{D_{1}}[e\circ h,g\circ f]$, while in unsupervised domain adaptation, the analog term is minimized over $D_{S}=e\circ D_{2}$ and (ii) the additional non-discrepancy terms would not have analogs in the domain adaptation bounds.

3 The Tied Output Synthesis Network

We next reformulate the problem as a neural network challenge. For clarity, this formulation is purposefully written to be independent of the mathematical presentation above. We study the problem of projecting an image in one domain to an image in another domain, in which the images follow a set of specifications. Given a domain, $\mathcal{X}$, a mapping $e$ and a function $f$, we would like to learn a generative function $G$ such that $f$ is invariant under $G$, i.e., $f\circ G=f$, and that for all samples $x\in\mathcal{X}$, there exists a configuration $u\in\mathcal{Y}_{2}$ such that $G(x)=e(u)$. Other than the functions $f$ and $e$, the training data is unsupervised and consists of a set of samples from the source domain $\mathcal{X}$ and a second set from the target domain of $e$, which we call $\mathcal{Y}_{1}$.

In comparison to the domain transfer method presented in [23], the domain $\mathcal{Y}_{1}$ is constrained to be the image of a mapping $e$. DTN cannot satisfy this requirement, since presenting it with a training set $\mathbf{t}$ of samples generated by $e$ is not a strong enough constraint. Furthermore, the real-world avataring applications require the recovery of the configuration $u$ itself, which allows the synthesis of novel samples using an extended engine $e^{*}$ that generates new poses, expressions in the case of face images, etc.

3.1 The interplay between the trained networks

In a general view of GANs, assume a loss function $\ell(G,d,x)$, for some function $d$ that receives inputs in the domain $\mathcal{Y}_{1}$. $G$, which maps an input $x$ to entities in $\mathcal{Y}_{1}$, minimizes the following loss: ${L_{\text{GAN}}}=\max_{d}-\operatorname{\mathbb{E}}_{x}\ell(G,d,x)$. This optimization is successful, if for every function $d$, the expectation of $\ell(G,d,x)$ is small for the learned $G$. It is done by maximizing this expectation with respect to $d$, and minimizing it with respect to $G$. The two learned networks $d$ and $G$ provide a training signal to each other.

Two networks can also provide a mutual signal by collaborating on a shared task. Consider the case in which $G$ and a second function $c$ work hand-in-hand in order to minimize the expectation of some other loss $\ell(G,c,x)$. In this case, $G$ “relies” on $c$ and minimizes the following expression:

[TABLE]

This optimization succeeds if there exists a function $c$ for which, post-learning, the expectation $\operatorname{\mathbb{E}}_{x}\ell(G,c,x)$ is small.

In the problem of tied output synthesis, the function $e$ maps entities $u$ in some configuration space $\mathcal{Y}_{2}$ to the target space $\mathcal{Y}_{1}$. $c$ maps samples from $\mathcal{Y}_{1}$ to the configuration space, essentially inverting $e$. The suitable loss is:

[TABLE]

For such a problem, the optimal $c$ is given by $c^{*}(z)=\operatorname*{arg\!\min}_{u}\|z-e(u)\|^{2}$. This implicit function is intractable to compute, and $c$ is learned instead as a deep neural network.

3.2 The complete network solution

The learning algorithm is given, in addition to two mappings $e$ and $f$, a training set $\mathbf{s}\subset\mathcal{X}$, and a training set $\mathbf{t}\subset\mathcal{Y}_{1}$. Similar to [23], we define $G$ to be composed out of $f$ and a second function $g$ that maps from the output space of $f$ to $T$, i.e., $G=g\circ f$. The $e$ compliance term ($L_{c}$ of Eq. 3 using $\ell_{e}$ of Eq. 4) becomes:

[TABLE]

In addition, we minimize $L_{\text{CONST}}$, which advocates that for every input $x\in\mathbf{s}$, $f$ remains unchanged as $G$ maps it to $\mathcal{Y}_{1}$:

[TABLE]

A GAN term is added to ensure that the samples generated by $G$ are indistinguishable from the set $\mathbf{t}$. The GAN employs a binary classifier network $d$, and makes use of the training set $\mathbf{t}$. Specifically, the following form of $\ell$ is used in $L_{\text{GAN}}$:

[TABLE]

Like [23], the following term encourages $G$ to be the identity mapping for samples from $\mathbf{t}$.

[TABLE]

Taken together, $d$ maximizes $L_{GAN}$, and both $g$ and $c$ minimize $L_{c}+\alpha L_{\text{GAN}}+\beta L_{\text{CONST}}+\gamma L_{\text{TID}}+\delta L_{\text{TV}}$ for some non-negative weights $\alpha,\beta,\gamma,\delta$, where $L_{\text{TV}}$, is the total variation loss, which smooths the resulting image $z=[z_{ij}]=G(x)$: $L_{TV}(z)=\sum_{i,j}\left(\left(z_{i,j+1}-z_{ij}\right)^{2}+\left(z_{i+1,j}-z_{ij}\right)^{2}\right)^{\frac{1}{2}}$. The method is illustrated in Fig. 4 and laid out in Alg. 1.

In the context of Thm. 2, the term $L_{c}$ corresponds to the risk term $R_{D_{1}}[e\circ h,g\circ f]$ in the theorem and compares samples transformed by the mapping $g\circ f$ to the mapping of the same samples to a configuration in $\mathcal{Y}_{2}$ using $c\circ g\circ f$ and then to $\mathcal{Y}_{1}$ using $e$. The term $L_{\text{TID}}$ corresponds to the risk $R_{e\circ y\circ D_{2}}[g\circ f,\textnormal{Id}]$, which is the expected loss over the distribution from which $\mathbf{t}$ is sampled, when comparing the samples in this training set to the result of mapping these by $g\circ f$. The discrepancy term $\textnormal{disc}_{\mathcal{H}}(e\circ y\circ D_{2},g\circ f\circ D_{1})$ matches the $L_{\text{GAN}}$ term, which as explained above, measures a distance between two distributions, in this case, $e\circ y\circ D_{2}$, which is the distribution from which the training set $\mathbf{t}$ is taken, and the distribution of mappings by $g\circ f$ of the samples $\mathbf{s}$ which are drawn from $D_{1}$.

4 Experiments

The Tied Output Synthesis (TOS) method is evaluated on a toy problem of inverting a polygon synthesizing engine and on avatar generation from a photograph for two different CG engines. The first problem is presented as a mere illustration of the method, while the second is an unsolved real-world challenge.

4.1 Polygons

The first experiment studies TOS in a context that is independent of $f$ constancy. Given a set of images $\mathbf{t}\in\mathcal{Y}_{1}$, and a mapping $e$ from some vector space to $\mathcal{Y}_{1}$, learn a mapping $c$ and a generative function $G$ that creates random images in $\mathcal{Y}_{1}$ that are $e$-compliant (Eq. 4).

We create binary $64\times 64$ images of regular polygons by sampling uniformly three parameters: the number of vertices (3-6), the radius of the enclosing circle (15-30), and a rotation angle in the range $[-10,10]$. Some polygons are shown in Fig. 5(a). 10,000 training images were created and used in order to train a CNN $e$ that maps the three parameters to the output, with very little loss (MSE of 0.1).

A training set $\mathbf{t}$ of a similar size is collected by sampling in the same way. As a baseline method, we employ DCGAN [21], in which the generator function $G$ has four deconvolution layers (the open code of https://github.com/soumith/dcgan.torch is used), and in which the input $x$ is a random vector in $[-1,1]^{100}$. The results are shown in Fig. 5(b). While the generated images are similar to the class of generated polygons, they are not from this class and contain visible artifacts such as curved edges.

A TOS is then trained by minimizing Eq. 4 with the additional GAN constraints. The optimization minimizes $L_{c}+\alpha L_{\text{GAN}}$, for $\alpha=1$ ($L_{CONST}$ and $L_{TID}$ are irrelevant to this experiment), and with the input distribution $D_{1}$ of random vectors sampled uniformly in the $[-1,1]$ hypercube in 100D. The results, as depicted in Fig. 5(c), show that TOS, which enjoys the additional supervision of $e$, produces results that better fit the polygon class.

4.2 Face Emoji

The proposed TOS method is evaluated for the task of generating specification-compliant emoji. In this task, we transfer an “in-the-wild” facial photograph to a set of parameters that defines an emoji. As the unlabeled training data of face images (domain $\mathcal{X}$), we use a set $\mathbf{s}$ of one million random images without identity information. The set $\mathbf{t}$ consists of assorted facial avatars (emoji) created by an online service (bitmoji.com). The emoji images were processed by an automatic process that detects, based on a set of heuristics, the center of the irises and the tip of the nose [23]. Based on these coordinates, the emoji were centered and scaled into $152\times 152$ RGB images.

The emoji engine of the online service is mostly additive. In order to train the TOS, we mimic it and have created a neural network $e$ that maps properties such as gender, length of hair, shape of eyes, etc. into an output image. The architecture is detailed in the appendix.

As the function $f$, we employ the representation layer of the DeepFace network [24]. This representation is 256-dimensional and was trained on a labeled set of four million images that does not intersect the set $\mathbf{s}$. Network $c$ maps a $64\times 64$ emoji to a configuration vector. It contains five convolutional layers, each followed by batch normalization and a leaky ReLU with a leakiness coefficient of 0.2. Network $g$ maps $f$’s representations to $64\times 64$ RGB images. Following [23], this is done through a network with 9 blocks, each consisting of a convolution, batch-normalization and ReLU. The odd blocks 1,3,5,7,9 perform upscaling convolutions. The even ones perform $1\times 1$ convolutions [14]. Network $d$ takes $152\times 152$ RGB images (either natural or scaled-up emoji) and consists of 6 blocks, each containing a convolution with stride 2, batch normalization, and a leaky ReLU. We set $\alpha=0.01$, $\beta=100$, $\gamma=1$, $\delta=0.0005$ as the tradeoff hyperparameters, after eyeballing the results of the first epoch of a very limited set of experiments.

For evaluation purposes only, we employ the benchmark of [23], which contains manually created emoji of $118$ random images from the CelebA dataset [16]. The benchmark was created by a team of professional annotators who used the web service that creates the emoji images. Fig. 7 shows side by side samples of the original image, the human generated emoji, the emoji generated by the generator function of DTN [23], and the emoji generated by both the generator $G=g\circ f$ and the compound generator $e\circ c\circ G$ of our TOS method. As can be seen, the DTN emoji tend to be more informative, albeit less restrictive than the ones created manually. TOS respects the configuration space and creates emoji that are similar to the ones created by the human annotators, but which tend to carry more identity information.

In order to evaluate the identifiability of the resulting emoji, the authors of [23] have collected a second example for each identity in the set of $118$ CelebA images and a set $\mathbf{s}^{\prime}$ of 100,000 random face images (unsupervised, without identity), which were not included in $\mathbf{s}$. The VGG face CNN descriptor [20] is then used in order to perform retrieval as follows. For each image $x$ in the manually annotated set, a gallery $\mathbf{s}^{\prime}\cup x^{\prime}$ is created, where $x^{\prime}$ is the other image of the person in $x$. Retrieval is then performed using VGG faces and either the manually created emoji, $G(x)$, or $e(c(G(x)))$ as the probe.

In these experiments, the VGG network is used in order to avoid a bias that might be caused by using $f$ both for training the DTN and the TOS methods and for evaluation. The results are reported in Tab. 1. As can be seen, the $G(x)$ emoji generated by DTN are extremely discriminative and obtain a median rank of 16 in cross-domain identification out of $10^{5}$ distractors. However, DTNs are not compatible with any configuration vector. In order to demonstrate this, we trained a network $\bar{c}$ that maps emoji images to configurations. When applied to the emoji generated by DTN and transforming the results, using $e$, back to an emoji, the obtained images are less identifiable than the emoji created manually (Tab. 1, under $e(..(x))$). By comparison, the median rank of the emoji created by the configuration vector $c(G(x))$ of TOS is much better than the result obtained by the human annotators. As expected, DTN has more identifiable results than TOS when considering the output of $g(f(x))$ directly, since TOS has additional terms and the role of $L_{\text{CONST}}$ in TOS is naturally reduced.

The need to train $c$ and $G$ jointly, as is done in the TOS framework, is also verified in a second experiment, in which we fixed the network $c$ of TOS to be the pretrained network $\bar{c}$. The results of rendering the configuration vector were also not as good as those obtained by the unmodified TOS framework. As expected, querying by $G(x)$ directly, produces results that are between DTN and TOS.

It should be noted that using the pretrained $\bar{c}$ directly on inputs faces, leads to fixed configurations (modes), since $\bar{c}$ was trained to map from $\mathcal{Y}_{1}$ and not from $\mathcal{X}$. This is also true when performing the prediction based on $f$ mappings of the input and when training a mapping from $\mathcal{X}$ to $\mathcal{Y}_{2}$ under the $f$ distance on the resulting avatar. This situation calls for the use of unsupervised domain adaptation (Sec. 2) to learn a mapping from $\mathcal{X}$ to $\mathcal{Y}_{2}$ by adapting a mapping from $\mathcal{Y}_{1}$. Despite some effort, applying the domain adaptation method of [6] did not result in satisfactory results (Tab. 1 and appendix). The best architecture found for this network follows the framework of domain-adversarial neural networks [6]. Our implementation consists of a feature network $p$ that resembles our network $c$ - with 4 convolution layers, a label predictor $l$ which consists of 3 fully connected layers, and a discriminative network $d$ that consists of 2 fully connected layers. The latter is preceded by a gradient reversal layer to ensure that the feature distributions of both domains are made similar. In both $l$ and $d$, each hidden layer is followed by batch normalization.

Human rating Finally, we asked a group of 20 volunteers to select the better emoji, given a photo from celebA and two matching emoji: one created by the expert annotators and one created by TOS ($e\circ c\circ G$). The raters were told that they are presented with the results of two algorithms for automatically generating emoji and are requested to pick their favorable emoji for each image. The images were presented printed out, in random order, and the raters were given an unlimited amount of time. In 39.53% of the answers, the TOS emoji was selected. This is remarkable considering that in a good portion of the celebA emoji, the TOS created very dark emoji in an unfitting manner (since $f$ is invariant to illumination and since the configuration has many more dark skin tones than lighter ones).

TOS, therefore, not only provides more identifiable emoji, but is also very close to be on par with professional annotators. It is important to note that we did not compare to DTN in this rating, since DTN does not create a configuration vector, which is needed for avatar applications (Fig 1(b)).

Multiple Images Per Person Following [23], we evaluate the results obtained per person and not just per image on the Facescrub dataset [19]. For each person $q$, we considered the set of their images $X_{q}$, and selected the emoji that was most similar to their source image, i.e., the one for which: $\operatorname*{arg\!\min}_{x\in X_{q}}||f(x)-f(e(c(G(x))))||$. The qualitative results are appealing and are shown in Fig. 9.

4.3 VR Avatars

We next apply the proposed TOS method to a commercial avatar generator engine, see Fig. 7(c). We sample random parameterizations and automatically align their frontally-rendered avatars into $64\times 64$ RGB images to form the training set $\mathbf{t}$. We then train a CNN $e$ to mimic this engine and generate such images given their parameterization. Using the same architectures and configurations as in Sec. 4.2, including the same training set $\mathbf{s}$, we train $g$ and $c$ to map natural facial photographs to their engine-compliant set of parameters. We also repeat the same identification experiment and report median rankings of the analog experiments, see Tab. 1(right). The 3D avatar engine is by design not as detailed as the 2D emoji one, with elements such as facial hair still missing and less part shapes available. In addition, the avatar model style is more generic and focused on real time puppeteering and not on cartooning. Therefore, the overall numbers are lower for all methods, as expected. TOS seems to be the only method that is able to produce identifiable configurations, while the other methods lead to ranking that is close to random.

5 Conclusions

With the advent of better computer graphics engines and the plethora of available models, and the ability of neural networks to compare cross-domain entities, the missing element for bridging between computer vision and computer graphics is the ability to link image data to a suitable parametrization. The previously presented DTN method showed a remarkable capability to create analogies without explicit supervision. For example, highly identifiable emoji were generated. However, emoji applications call for parametrized characters, which can then be transformed by artists to other views and new expressions, and the emoji created by DTN cannot be converted to a configuration. The TOS method that we present is able to generate identifiable emoji that are coupled with a valid configuration vector.

While TOS was presented in a way that requires the rendering function $e$ to be differentiable, working with black-box renderers using gradient estimation techniques is a common practice, e.g., in Reinforcement Learning.

Appendix A Summary of Notations

Tab. 2 itemizes the symbols used in this work. Fig. 2,3,4 of the main text illustrate many of these symbols.

Appendix B DANN results

Fig. 8 shows side by side samples of the original image and the emoji generated by the method of [6]. As can be seen, these results do not preserve the identity very well, despite considerable effort invested in finding suitable architectures.

Appendix C Multiple Images Per Person

Following [23], we evaluate the visual quality that is obtained per person and not just per image, by testing TOS on the Facescrub dataset [19]. For each person $p$, we considered the set of their images $X_{p}$, and selected the emoji that was most similar to their source image, i.e., the one for which:

[TABLE]

Fig. 7 depicts the results obtained by this selection method on sample images form the Facescrub dataset (it is an extension of Fig. 7 of the main text). The figure also shows, for comparison, the DTN [23] result for the same image.

Appendix D Detailed Architecture of the Various Networks

In this section we describe the architectures of the networks used in for the emoji and avatar experiments.

D.1 TOS

Network $g$ maps DeepFace’s 256-dimensional representation [24] into $64\times 64$ RGB emoji images. Following [23], this is done through a network with 9 blocks, each consisting of a convolution, batch-normalization and ReLU, except the last layer which employs Tanh activation. The odd blocks 1,3,5,7,9 perform upscaling convolutions with 512-256-128-64-3 filters respectively of spatial size $4\times 4$. The even ones perform $1\times 1$ convolutions [14]. The odd blocks use a stride of 2 and padding of 1, excluding the first one which does not use stride or padding.

Network $e$ maps emoji parameterization into the matching $64\times 64$ RGB emoji. The parameterization is given as binary vectors in $\mathbb{R}^{813}$ for emojis; Avatar parameterization is in $\mathbb{R}^{354}$. While there are dependencies among the various dimensions (an emoji cannot have two hairstyles at once), the binary representation is chosen for its simplicity and generality. $e$ is trained in a fully supervised way, using pairs of matching parameterization vectors and images in a supervised manner.

The architecture of $e$ employs five upscaling convolutions with 512-256-128-64-3 filters respectively, each of spatial size $4\times 4$. All layers except the last one are batch normalized followed by a ReLU activation. The last layer is followed by Tanh activation, generating an RGB image with values in range $[-1,1]$. All the layers use a stride of 2 and padding of 1, excluding the first one which does not use stride or padding.

Network $d$ takes $152\times 152$ RGB images (either natural or scaled-up emoji) and outputs log-probabilities predicting if the image is fake or real. It consists of 6 blocks, each containing a convolution with stride 2, batch normalization, and a leaky ReLU with leakiness coefficient of 0.2. Each block contains 64-128-256-512-512-3 filters respectively. As before, the last layer does not employ batch normalization and ReLU.

Network $c$ maps a $64\times 64$ emoji to parameterization vector. It contains five convolutional layers, each followed by batch normalization and a leaky ReLU with a leakiness coefficient of 0.2. Each layer contains 64-128-256-512-813 filters respectively. The last layer is followed by Tanh activation, generating a parameterization vector with values in range $[-1,1]$.

The networks used for the synthetic polygon experiment are somewhat simpler: $g$ has the same structure of as in the emoji experiment excluding the even convolutions i.e., it does not contain the $1\times 1$ convolutions. The architecture of $d$ is unchanged. Finally, the architectures of $e$ and $c$ are updated to match the synthetic experiment parameterization. $e$ is changed to map a parameterization vectors in $\mathbb{R}^{3}$ to RGB images, and $c$ is trained to predict such a vector.

D.2 DANN

In the domain adaptation experiments, network $p$ extracts 2048-dimensional feature vectors from $64\times 64$ RGB images. It resembles the structure of network $c$ - with 4 convolution layers. Each convolution is with 64-128-256-512 filters respectively. The last convolutional layer employs a stride of 1 instead of 2 and does not use batch-normalized or leaky ReLU. Finally, the network output is flattened to 1-dimensional feature vector.

The label prediction network $l$ accepts as input feature vectors generated by $p$ and outputs emoji parameterization vectors matching the input image. It consists of 3 fully connected layers. Each hidden layer is followed by batch-normalization and leaky ReLU activation. The last layer is followed by Tanh activation. The hidden layers contain 1024 and 512 units respectively.

The discriminator $d$ predicts the input image domain given its feature vector. It consists of two fully connected layers with 512 hidden units. The hidden layer is followed by batch normalization and leaky ReLU activations. It is preceded by a gradient reversal layer to ensure that the feature distributions of both domains are similar. The last layer is followed by Sigmoid activation, predicting the input image domain.