Gesture-to-Gesture Translation in the Wild via Category-Independent Conditional Maps

TL;DR

This paper introduces a novel GAN architecture for gesture-to-gesture translation that uses category labels and simple conditional maps, eliminating the need for detailed annotations like key-points, and performs well in real-world scenarios.

Contribution

The work presents a new GAN model that translates gestures using easy-to-annotate category labels and conditional maps, avoiding complex key-point annotations.

Findings

Outperforms state-of-the-art methods quantitatively and qualitatively.

Effectively handles gesture translation in real-world, unstructured environments.

Uses attention and rolling guidance to improve image quality.

Abstract

Recent works have shown Generative Adversarial Networks (GANs) to be particularly effective in image-to-image translations. However, in tasks such as body pose and hand gesture translation, existing methods usually require precise annotations, e.g. key-points or skeletons, which are time-consuming to draw. In this work, we propose a novel GAN architecture that decouples the required annotations into a category label - that specifies the gesture type - and a simple-to-draw category-independent conditional map - that expresses the location, rotation and size of the hand gesture. Our architecture synthesizes the target gesture while preserving the background context, thus effectively dealing with gesture translation in the wild. To this aim, we use an attention module and a rolling guidance approach, which loops the generated images back into the network and produces higher quality images compared to competing works. Thus, our GAN learns to generate new images from simple annotations without requiring key-points or skeleton labels. Results on two public datasets show that our method outperforms state of the art approaches both quantitatively and qualitatively. To the best of our knowledge, no work so far has addressed the gesture-to-gesture translation in the wild by requiring user-friendly annotations.

Tables

Table 1. Table 1. Quantitative comparison for the gesture-to-gesture translation task in normal experimental setting, using the same evaluation metrics as GestureGAN  (Tang et al . , 2018 ) .

Model	NTU Hand Gesture (Ren et al., 2013)			Creative Senz3D (Memo and Zanuttigh, 2018)
	MSE	PSNR	IS	MSE	PSNR	IS
PG2 (Ma et al., 2017)	116.10	28.24	2.42	199.44	26.51	3.37
Yan et al. (Yan et al., 2017)	118.12	28.02	2.49	175.86	26.95	3.33
Ma et al. (Ma et al., 2018)	113.78	30.65	2.45	183.65	26.95	3.38
PoseGAN et al. (Siarohin et al., 2018)	113.65	29.55	2.40	176.35	27.30	3.21
GestureGAN (Tang et al., 2018)	105.73	32.61	2.55	169.92	27.97	3.41
$△$-GAN - no rolling	31.80	33.57	1.92	46.79	31.98	2.31
$△$-GAN	15.76	36.51	2.00	21.73	35.39	2.34

Table 2. Table 2. Quantitative results for the gesture-to-gesture translation task for the two experimental settings.

Model	Experimental setting	Easy to draw map		NTU Hand Gesture (Ren et al., 2013)				Creative Senz3D (Memo and Zanuttigh, 2018)
				PSNR	FID	F1		PSNR	FID	F1
GANimation (Pumarola et al., 2018)	Normal	$\times$		10.03	440.45	0.08		11.11	402.99	0.23
StarGAN (Choi et al., 2018)				17.79	98.84	0.09		11.44	137.88	0.07
PG2 (Siarohin et al., 2018)				21.71	66.83	0.15		21.78	122.08	0.68
GestureGAN (Tang et al., 2018)				34.24	15.06	0.93		28.65	54.00	0.96
$△$-GAN - no rolling				34.07	20.29	0.90		31.98	58.28	0.88
$△$-GAN				36.51	13.73	0.93		35.39	32.04	0.99
PG2 (Ma et al., 2017)	Challenging	✓		21.94	135.32	0.10		18.30	265.73	0.10
GestureGAN (Tang et al., 2018)				25.60	94.10	0.38		18.69	254.37	0.34
GestureGAN†				27.32	59.79	0.43		22.24	192.77	0.38
$△$-GAN - no rolling				27.14	61.14	0.43		22.77	134.54	0.33
$△$-GAN				28.11	47.88	0.61		23.11	101.22	0.58

Table 3. Table 3. Perceptual user study. Percentage of times, on average, when the translated images are selected as “real” by users, in the “fake” vs. “real” comparison.

Model	NTU Hand Gesture (Ren et al., 2013)		Creative Senz3D (Memo and Zanuttigh, 2018)
	Normal	Challenging	Normal	Challenging
GestureGAN	36.54%	3.21%	3.85%	0.64%
$△$-GAN	44.32%	7.05%	16.03%	3.85%

Table 4. Table 4. Performance degradation of △ bold-△ \boldsymbol{{{\bigtriangleup}}} -GAN by removing the rolling guidance approach.

Conditional map	Category	Creative Senz3D (Memo and Zanuttigh, 2018)
	independent	PSNR	FID	F1
Triangle	✓	1.53% ↓	24.77% ↑	75.76% ↓
Boundary	$\sim$	1.84% ↓	35.37% ↑	58.06% ↓
Skeleton	$\times$	10.66% ↓	81.90% ↑	12.50% ↓

Table 5. Table 5. Quantitative results for the gesture-to-gesture translation task for the two experimental settings. Here we describe the difference between the FID score and the mseitzer ’s incorrect implementation (FID*), which was used in (Tang et al . , 2018 ) .

Model	NTU (Ren et al., 2013)			Senz3D (Memo and Zanuttigh, 2018)
	FID*	FID		FID*	FID
Normal setting
GANimation (Pumarola et al., 2018)	403.63	440.45		333.53	402.99
StarGAN (Choi et al., 2018)	91.81	98.84		105.86	137.88
PG2 (Siarohin et al., 2018)	42.98	66.83		119.00	122.08
GestureGAN (Tang et al., 2018)	6.99	15.06		29.75	54.00
$△$-GAN - no rolling	13.32	20.29		45.12	58.28
$△$-GAN	6.63	13.73		16.8	32.04
Challenging setting
PG2 (Ma et al., 2017)	144.18	135.32		185.92	265.73
GestureGAN (Tang et al., 2018)	69.29	94.10		183.02	254.37
GestureGAN†	45.42	59.79		114.85	192.77
$△$-GAN - no rolling	55.76	61.14		122.34	134.54
$△$-GAN	40.02	47.88		87.32	101.22

Table 6. Table 6. Generator network architecture.

Part	Input $\to$ Output Shape	Layer Information
$E_1$	($h$, $w$, 3) $\to$ ($h$, $w$, 64)	CONV-(N64, K7x7, S1, P3), IN, ReLU
	($h$, $w$, 64) $\to$ ($\frac{h}{2}$, $\frac{w}{2}$, 128)	CONV-(N128, K3x3, S2, P1), IN, ReLU
	($\frac{h}{2}$, $\frac{w}{2}$, 128) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	CONV-(N256, K3x3, S2, P1), IN, ReLU
$E_2$	($h$, $w$, $n_c$+$n_d$+(3)) $\to$ ($h$, $w$, 64)	CONV-(N64, K7x7, S1, P3), IN, ReLU
	($h$, $w$, 64) $\to$ ($\frac{h}{2}$, $\frac{w}{2}$, 64)	CONV-(N64, K3x3, S2, P1), IN, ReLU
	($\frac{h}{2}$, $\frac{w}{2}$, 64) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 64)	CONV-(N64, K3x3, S2, P1), IN, ReLU
Concat+CONV	($\frac{h}{2}$, $\frac{w}{2}$, 64+256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	CONV-(N256, K3x3, S1, P1), IN, ReLU
$F_{res}$	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	Residual Block: CONV-(N256, K3x3, S1, P1), IN, ReLU
Concat+CONV	($\frac{h}{4}$, $\frac{w}{4}$, 64+256) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 256)	CONV-(N256, K3x3, S1, P1), IN, ReLU
$F_{dec}$	($\frac{h}{4}$, $\frac{w}{4}$, 256) $\to$ ($\frac{h}{2}$, $\frac{w}{2}$, 128)	DECONV-(N128, K4x4, S2, P1), IN, ReLU
	($\frac{h}{2}$, $\frac{w}{2}$, 128) $\to$ ($h$, $w$, 64)	DECONV-(N64, K4x4, S2, P1), IN, ReLU
$G_C$	($h$, $w$, 64) $\to$ ($h$, $w$, 3)	CONV-(N3, K7x7, S1, P3), Tanh
$G_A$	($h$, $w$, 64) $\to$ ($h$, $w$, 1)	CONV-(N1, K7x7, S1, P3), Sigmoid

Table 7. Table 7. Discriminator network architecture.

Layer	Input $\to$ Output Shape	Layer Information
Input Layer	($h$, $w$, 3+$n_d$) $\to$ ($\frac{h}{2}$, $\frac{w}{2}$, 64)	CONV-(N64, K4$\times$4, S2, P1), Leaky ReLU
Hidden Layer	($\frac{h}{2}$, $\frac{w}{2}$, 64) $\to$ ($\frac{h}{4}$, $\frac{w}{4}$, 128)	CONV-(N128, K4$\times$4, S2, P1), Leaky ReLU
Hidden Layer	($\frac{h}{4}$, $\frac{w}{4}$, 128) $\to$ ($\frac{h}{8}$, $\frac{w}{8}$, 256)	CONV-(N256, K4$\times$4, S2, P1), Leaky ReLU
Hidden Layer	($\frac{h}{8}$, $\frac{w}{8}$, 256) $\to$ ($\frac{h}{16}$, $\frac{w}{16}$, 512)	CONV-(N512, K4$\times$4, S2, P1), Leaky ReLU
Hidden Layer	($\frac{h}{16}$, $\frac{w}{16}$, 512) $\to$ ($\frac{h}{32}$, $\frac{w}{32}$, 1024)	CONV-(N1024, K4$\times$4, S2, P1), Leaky ReLU
Hidden Layer	($\frac{h}{32}$, $\frac{w}{32}$, 1024) $\to$ ($\frac{h}{64}$, $\frac{w}{64}$, 2048)	CONV-(N2048, K4$\times$4, S2, P1), Leaky ReLU
$D_{cls}$	($\frac{h}{64}$, $\frac{w}{64}$, 2048) $\to$ (1, 1, $n_c$)	CONV-(N($n_c$), K$\frac{h}{64}\times \frac{w}{64}$, S1, P0)
$D_{prob}$	($\frac{h}{64}$, $\frac{w}{64}$, 64) $\to$ ($\frac{h}{64}$, $\frac{w}{64}$, 1)	CONV-(N1, K4$\times$4, S1, P1)

Equations

$${\hat{\mathbf{I}}}_Y=\mathbf{A}\ast {\mathbf{I}}_X+(1-\mathbf{A})\ast {\tilde{\mathbf{I}}}_Y$$

$${\mathcal{L}}_{GAN}=$$

$${\mathbb{E}}_{{\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y\sim \mathbb{P}}[\log (1-D_{prob}(G({\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y),{\mathbf{S}}_Y))]$$

$${\mathcal{L}}_{rec}=\Vert G({\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y)-{\mathbf{I}}_Y{\Vert }_1$$

$${\mathcal{L}}_{idt}=\Vert G({\mathbf{I}}_X,{\mathbf{S}}_X,C_X)-{\mathbf{I}}_X{\Vert }_1$$

$${\mathcal{L}}_{cyc}=\Vert G(G({\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y),{\mathbf{S}}_X,C_X)-{\mathbf{I}}_X{\Vert }_1$$

$${\mathcal{L}}_{cls}={\mathbb{E}}_{{\mathbf{I}}_Y,C_Y}[-\log D_{cat}(C_Y|{\mathbf{I}}_Y,{\mathbf{S}}_Y)]$$

$${\mathcal{L}}_{\widehat{cls}}={\mathbb{E}}_{{\hat{\mathbf{I}}}_Y,C_Y}[-\log D_{cat}(C_Y|{\hat{\mathbf{I}}}_Y,{\mathbf{S}}_Y)]$$

$${\mathcal{L}}_{tv}=f_{tv}(G_C({\mathbf{I}}_X,{\mathbf{S}}_X,C_X)+f_{tv}(G_C({\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y))$$

$$f_{tv}(\mathbf{I})={\mathbb{E}}_{\mathbf{I}}\left[\sum _{i,j}^{H-1,W-1}[({\mathbf{I}}_{i+1,j}-{\mathbf{I}}_{i,j}{)}^2+({\mathbf{I}}_{i,j+1}-{\mathbf{I}}_{i,j}{)}^2]\right]$$

$${\mathcal{L}}_D={\lambda }_D{\mathcal{L}}_{GAN}+{\lambda }_{cls}{\mathcal{L}}_{cls}$$

$${\mathcal{L}}_G={\lambda }_G{\mathcal{L}}_{GAN}+{\lambda }_{rec}{\mathcal{L}}_{rec}+{\lambda }_{idt}{\mathcal{L}}_{idt}+{\lambda }_{cyc}{\mathcal{L}}_{cyc}+{\lambda }_{cls}{\mathcal{L}}_{\widehat{cls}}+{\lambda }_{tv}{\mathcal{L}}_{tv}$$

$${\mathcal{L}}_{WGAN}=$$

$${\mathbb{E}}_{{\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y\sim \mathbb{P}}[D_{prob}(G({\mathbf{I}}_X,{\mathbf{S}}_Y,C_Y),{\mathbf{S}}_Y)]$$

$${\mathcal{L}}_{gp}={\mathbb{E}}_{\bar{I}\sim {\mathbb{P}}_{\bar{I}},{\mathbf{S}}_Y\sim \mathbb{P}}[(\Vert {▽}_{\bar{\mathbf{I}}}{D}_{prob}(\bar{\mathbf{I}},{\mathbf{S}}_Y){\Vert }_2-1{)}^2]$$

Full text

GANs, image translation, hand gesture

††journalyear: 2019††copyright: acmlicensed††conference: Proceedings of the 27th ACM International Conference on Multimedia; October 21–25, 2019; Nice, France††booktitle: Proceedings of the 27th ACM Int’l Conf. on Multimedia (MM’19), Oct. 21–25, 2019, Nice, France††price: 15.00††doi: 10.1145/3343031.3351020††isbn: 978-1-4503-6889-6/19/10††ccs: Computing methodologies Computer vision††ccs: Computing methodologies Machine learning

1. Introduction

Photo-editing software, fashion, and retail markets would enormously benefit from the possibility of modifying an image through a simple user input describing the changes to make (e.g. change the hand gesture of the person in the picture from “open hand” to “ok”). However, despite the significant advances of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014; Radford et al., 2016; Arjovsky et al., 2017; Gulrajani et al., 2017), the generation of images in the wild without precise annotations (e.g. hand skeleton) is still an open problem. Previous literature on image-to-image translation has relied either on pixel-to-pixel mappings (Isola et al., 2017; Zhu et al., 2017a; Yang et al., 2018) or precise annotations to localize the instance to be manipulated, such as segmentation masks (Mo et al., 2019), key-points (Siarohin et al., 2018), skeletons (Tang et al., 2018) and facial landmarks (Sanchez and Valstar, 2018). However, obtaining such annotations is not trivial. On one hand, automatic methods for key-points extraction (Cao et al., 2017; Simon et al., 2017) may fail or the reference gesture image/video (Siarohin et al., 2019) may be not available. On the other, drawing such annotations is complicated, time-consuming, and their quality directly affects the performance of the network.

Moreover, existing methods often focus on foreground content, e.g., the target gesture or facial expression, generating blurred and imprecise backgrounds (Siarohin et al., 2018; Ma et al., 2017; Reed et al., 2016). These methods are well suited in the cases where share fixed or similar spatial structures, such as facial expression datasets (Liu et al., 2015; Fabian Benitez-Quiroz et al., 2016). Instead, in image-to-image translations in the wild, both the foreground and background between the source image and target image can vary a lot (Tang et al., 2018).

In this paper, we propose a novel method, named as ${{{\bigtriangleup}}}$-GAN, that requires a simple-to-draw annotation, such as a triangle, and focuses on the challenging task of hand gesture-to-gesture translation in the wild. In general, annotations such as key-points or skeletons are category-dependent since they provide four types of information at the same time, namely category (e.g., gesture “5”), location, scale and orientation of the hand gesture. Instead, our ${{{\bigtriangleup}}}$-GAN decouples the category from the location-scale-orientation information. Using a category-independent conditional map significantly lowers the annotation cost, allowing to generate multiple target images while requiring users to draw only a single map. In this work, we refer to “annotations” as the user effort to draw the desired target gesture also at deploy time, besides the effort needed for generating the training data for our model. The intuition of our approach is depicted in Figure 1. Furthermore, we propose a novel architecture that uses an attention module and a rolling guidance approach to perform gesture-to-gesture translation in the wild. Our research yields three main contributions:

• •

Decoupled conditional map and category. We designed a general architecture for gesture-to-gesture translations that separately encodes the category label (e.g., gesture “5”) and the category-independent conditional map. This allows to perform several image translations with the same conditional map.

• •

Rolling guidance and attention mask. We propose a novel rolling guidance approach that allows generating higher quality output images by feeding the generated image back to the input as an additional condition to be considered. Also, ${{{\bigtriangleup}}}$-GAN learns unsupervisedly an attention mask that allows to preserve the details shared between the input and target image.

• •

Simple-to-draw conditional maps. We propose a triangle conditional map as the simplest and minimal necessary user provided condition for gesture-to-gesture translation. To the best of our knowledge, no work so far has addressed the gesture-to-gesture translation task in the wild by requiring user-friendly annotations. Furthermore, we assess the performance of our method with different shapes, such as boundary and skeleton maps. Finally, we enrich two public datasets with different conditional maps for each gesture image, specifically based on triangles and boundaries.

2. Related work

Recently, there have been a lot of works on Generative Adversarial Networks (GANs) and, particularly, on conditional GANs for the task of image-to-image translation (Isola et al., 2017; Zhu et al., 2017a; Zhu et al., 2017b; Choi et al., 2018; Pumarola et al., 2018). A significant line of these works have focused on translation tasks where the the input and target images are spatially aligned, as in the case of style transfer (Zhu et al., 2017a; Johnson et al., 2016; Isola et al., 2017), emotional content transfer (Zhao et al., 2018) or image inpaiting (Zhang et al., 2018). In general, these works aim to preserve the main image content while presenting them in various styles. Another line of works have tackled the more challenging task of image translation where the target object is spatially unaligned with respect to the original location, shape or size of the input original object. This is the case of image-to-image translation tasks like facial expression (Sanchez and Valstar, 2018; Zhenglin Geng, 2019), human pose (Ma et al., 2017; Siarohin et al., 2018) or hand gesture translation (Tang et al., 2018). To this aim, methods usually require geometry information as guidance to guarantee where and how to edit visual patterns corresponding to the image attributes, such as key-points (Ma et al., 2017; Siarohin et al., 2019; Ma et al., 2018), skeletons (Tang et al., 2018), object segmentation masks (Mo et al., 2019), facial landmarks (Sanchez and Valstar, 2018), action units (Pumarola et al., 2018) or 3D models (Zhenglin Geng, 2019). GANimation (Pumarola et al., 2018) learns an attention mask to preserve the background content of the source image for the spatially aligned translation of facial expressions. InstaGAN (Mo et al., 2019) performs multi-instance domain-to-domain image translation by requiring as input precise segmentation masks for the target objects. Pose Guided Person Generation Network (PG2) (Ma et al., 2017) proposes a two stages generating framework to refine the output image given a reference image and a target pose. MonkeyNet (Siarohin et al., 2019) generates a conditioned video transferring body movements from a target driving video to a reference appearance image. The target key-points are obtained automatically using state-of-the-art detectors. Relatively few works have considered the challenging task of image translation in the wild, where both the foreground content and the background context undergoes significant variation (Tang et al., 2018). In these cases, not only the networks learn to synthesize the target object or attribute, but they also have to correctly locate it in the image while the pixels depicting the content are preserved from the original image. GestureGAN (Tang et al., 2018) proposes a novel color loss to improve the output image quality and to produce sharper results. However, this approach does not aim to separately encode the foreground content and the background context.

Furthermore, the large majority of image-to-image translations works focus on one to one domain mapping. Recently, efficient solutions have been proposed to address the multi-domain translations (Choi et al., 2018; Zhenglin Geng, 2019). In particular, StarGAN (Choi et al., 2018) proposes the use of multiple mask vectors to generalize on different datasets and domain labels. 3DMM (Zhenglin Geng, 2019) decomposes an image into shape and texture spaces, and relies on an identity and target coefficients to generate images in multiple domains. They, however, focus on multi-domain face attributes where neither the background quality or the misalignment are considered.

Our work falls within the category of multi-domain and image-to-image translation in the wild. Still, rather than asking expensive annotation to the user, we propose a novel user-friendly annotation strategy. To the best of our knowledge, no works so far have investigated other approaches for gesture translation that also allow to reduce the annotation effort.

3. Our approach

The goal of this work is to perform gesture translation in the wild, conditioned on the user provided gesture attributes, such as the desired category, location, scale and orientation. Specifically, we seek to estimate the mapping $\mathcal{M}$: $(\mathbf{I}_{X},\mathbf{S}_{Y},C_{Y})\rightarrow\mathbf{I}_{Y}$ that translates an input image $\mathbf{I}_{X}$ into an output image $\mathbf{I}_{Y}$, conditioned to a hand gesture category $C_{Y}$ and a simple-to-draw conditional map $\mathbf{S}_{Y}$, which encodes the desired location, scale and orientation of the gesture. The generated image is discriminated through a Conditional Critic discriminator (Pumarola et al., 2018) that judges the photo-realism of the generated image and assess the category of the generated gesture (e.g. gesture ”5”). Furthermore, in order to efficiently deal with the gesture translation in the wild, we propose a rolling guidance approach and an attention mask module. Figure 2 depicts the architecture of our approach. In this Section we further explain the details of the architecture and the loss functions used to train our framework.

3.1. Network Architecture

Generator. Our Generator $G$ takes as input the conditional image $\textbf{I}_{X}$, the category label $C_{Y}$ and the conditional map $\textbf{S}_{Y}$ and it outputs the translated image $\textbf{I}_{Y}$. The original image and the target gesture conditions are encoded respectively through the encoder $E_{1}$ and $E_{2}$, and then concatenated and provided to $F_{res}$. Then, the output features of $E_{2}$ and $F_{res}$ are concatenated and provided to $F_{dec}$. Similarly to (Pumarola et al., 2018), in the decoder we learn to predict in an unsupervised manner the approximated image $\widetilde{\textbf{I}}_{Y}$ and an Attention Mask $\mathbf{A}\in[0,1.0]^{{H\times W}}$. Since both the background and foreground between the input and target images can vary a lot, the learned attention mask $\mathbf{A}$ tends to preserve the shared part between $\mathbf{I}_{X}$ and $\mathbf{I}_{Y}$. Pixels in $\mathbf{A}$ with higher value indicate to preserve the corresponding pixels from $\mathbf{I}_{X}$, otherwise from $\widetilde{\mathbf{I}}_{Y}$. The final generated image is thus obtained as:

[TABLE]

Furthermore, the generated image $\mathbf{I}_{Y}$ is rolled back as an input condition and concatenated together with the category label $C_{Y}$ and the conditional map $\textbf{S}_{Y}$. More details are provided in Section 3.3.

Discriminator. Our Discriminator $D$ takes as input the generated image $\widehat{\textbf{I}}_{Y}$ and its conditional map $\textbf{S}_{Y}$. The outputs of $D$ consist of two parts: $D_{cat}$ predicts the category label and $D_{prob}$ classifies whether local image patches are real or fake. As in (Pumarola et al., 2018), Dprob is based on PatchGANs (Isola et al., 2017). The conditional map $\textbf{S}_{Y}$ is needed by $D$ to verify that the generated gesture has also the right location, scale and orientation.

We refer to the Supplementary Material for additional details in the architecture.

3.2. Objective Formulation

The loss function of ${{{\bigtriangleup}}}$-GAN is composed of four main components, namely GAN Loss that pushes the generated image distribution to the distribution of source images; Reconstruction loss that forces the generator to reconstruct the source and target image; Category Label loss that allows to properly classify the generated image into hand gesture classes; and Total Variation loss that indirectly learns the attention mask in an unsupervised fashion.

GAN Loss. To generate images with the same distribution of the source images, we adopt an adversarial loss:

[TABLE]

where $\mathbb{P}$ is the data distribution of the hand gesture images in the dataset, and where $G$ generates an image $G(\mathbf{I}_{X},\mathbf{S}_{Y},C_{Y})$ conditioned on both the input image $\mathbf{I}_{X}$, the conditional map $\mathbf{S}_{Y}$, and the target category $C_{Y}$, while $D$ tries to distinguish between real and fake images. In this paper, we refer to the term $D_{prob}(\mathbf{I},\mathbf{S})$ as a probability distribution over sources given by $D$.

Reconstruction Loss. The adversarial loss does not guarantee that the generated image is consistent with both the target conditional map $\mathbf{S}$ and category $C$. Thus, we first apply a forward reconstruction loss that ties together the target image $\mathbf{I}_{Y}$ with its target conditional map $\mathbf{S}_{Y}$ and category $C_{Y}$:

[TABLE]

Then, instead of using perceptual features (e.g. extracted from VGG (Simonyan and Zisserman, 2015) networks) to force the model to reconstruct the source image, we propose a simplified self-reconstruction (identity) loss:

[TABLE]

where $\mathbf{S}_{X}$ is the conditional map of the source image and $C_{X}$ the category label of the source image. Finally, we apply the cycle consistency loss (Zhu et al., 2017a; Kim et al., 2017) to reconstruct the original image from the generated one:

[TABLE]

Note that we apply the cycle reconstruction loss only in one direction to reduce computation, i.e., A-to-B-to-A, since a translation pair based on two images A and B may be sampled either as A-to-B or as B-to-A during the training.

Category Label loss. We enforce the generator to render realistic samples that have to be correctly classified to the hand gesture expressed by the input category label. Similarly to StarGAN (Choi et al., 2018), we split the Category Label loss in two terms: a gesture classification loss of the real image $\mathbf{I}_{Y}$ used to optimize $D$, and a gesture classification loss of the generated image $\hat{\mathbf{I}}_{Y}$, used to optimize $G$. Specifically:

[TABLE]

[TABLE]

where $D_{cat}(C_{Y}|\mathbf{I}_{Y},\mathbf{S}_{Y})$ and $D_{cat}(C_{Y}|\hat{\mathbf{I}}_{Y},\mathbf{S}_{Y})$ represent a probability distribution over the categories of hand gestures respectively in the real and generated images. In other words, these losses allow to generate images that can be correctly classified as the target hand gesture category.

Total Variation loss. To prevent the final generated image having artifacts, we use a Total Variation Regularization, $f_{tv}$, as in GANimation (Pumarola et al., 2018). However, differently from them, we calculate $f_{tv}$ over the approximated image $\widetilde{\mathbf{I}}_{Y}$ instead of the attention mask $\mathbf{A}$, thus allowing to freely explore the shared pixels between the source and target images. The total variation loss is applied both to the forward reconstruction and self-reconstruction and is formulated as:

[TABLE]

The total variation regularization $f_{tv}$ is defined as:

[TABLE]

where $\mathbf{I}_{i,j}$ is the entry $i,j$ of the image matrix $\mathbf{I}$.

Total loss. The final objective function used to optimize $G$ and $D$ is formulated as follows:

[TABLE]

[TABLE]

where $\lambda_{D}$, $\lambda_{G}$, $\lambda_{rec}$, $\lambda_{idt}$, $\lambda_{cyc}$, $\lambda_{cls}$, and $\lambda_{tv}$ are hyper-parameters that control the relative importance of each loss term.

3.3. Rolling Guidance

While the total variation loss $\mathcal{L}_{tv}$ also enforces the approximated images $\widetilde{\mathbf{I}}_{Y}$ to be smooth, the source and target images might contain edges and details that have to be preserved. Moreover, the $E_{1}$ and $E_{2}$ encoders mostly focus on the gesture, failing to learn important details of the context, which might result in blurred images. Inspired by previous works (Mosinska et al., 2018; Ma et al., 2017; Zhang et al., 2014), we propose a Rolling Guidance approach to refine the generated image in a two-stage process. First, the network generates an initial version $\widehat{\mathbf{I}}_{Y}$ from input ($\mathbf{I}_{X}$, $\mathbf{S}_{Y}$, $C_{Y}$). Then, $\widehat{\mathbf{I}}_{Y}$ is fed back to $E_{2}$. Thus, the network generates a refined version of $\widehat{\mathbf{I}}_{Y}$ from input ($\mathbf{I}_{X}$, $\mathbf{S}_{Y}$, $C_{Y}$, $\widehat{\mathbf{I}}_{Y}$). Note that there exists some approaches, like PG2 (Ma et al., 2017), feed the initial generated image back and concatenated to the source input to learn difference map to refine the results. However, images with a considerable variation in both the foreground and background between source and target images might result in an ill-posed problem. Gesture-to-gesture translation in the wild shows such an issue. For this reason, in ${{{\bigtriangleup}}}$-GAN, we feedback the generated image to $E_{2}$ to refine the generated image and to learn the condition related features of the target gesture at the same time. This results in better generalization and significantly improves the results as well.

4. Experiments

We compare our model with the state of the art techniques on two hand gesture datasets. First, we evaluate our model quantitatively through various widely used metrics that compare the generated image with the ground truth. Then, we also evaluate our results qualitatively through a perceptual user study. We released the resulted dataset and annotations, source code and trained models are available at: https://github.com/yhlleo/TriangleGAN.

4.1. Datasets

The NTU Hand Gesture dataset (Ren et al., 2013) is a collection of 1,000 RGB-D images recorded with a Kinect sensor. It includes 10 gestures repeated 10 times by 10 subjects under a cluttered background. Image resolution is 640x480. The Creative Senz3D dataset (Memo and Zanuttigh, 2018) is a collection of 1,320 images, where 11 gestures are repeated 30 times by 4 subjects. Image resolution is 640x480.

Experimental setting. We consider two dataset setups in our experimental evaluation.

Normal uses the same setup as GestureGAN (Tang et al., 2018), in order to directly compare with the state of the art. GestureGAN authors used only a subset of the datasets (acquired by OpenPose (Cao et al., 2018)): 647 images out of 1,000 for NTU Hand Gesture and 494 out of 1,320 for Creative Senz3d. It shows that the state-of-the-art detector OpenPose (Cao et al., 2018) fails at detecting key-points for about 50% of the images. The resulting number of training and test data pairs obtained are respectively the following: 21,153 and 8,087 for NTU Hand Gesture; 30,704 and 11,234 for Creative Senz3D. These numbers are different from those reported in (Tang et al., 2018) since we here report only the unique pairs without considering flipping and A-to-B reverse ordering.

Challenging pushes the limits of our model by ensuring that all the translation pairs ”A-to-B” to a specific image ”B” are included either in the train or in the test, a condition not ensured by the normal setting and, thus, by state of the art. As a consequence, the model here generates multi-domain images without previous knowledge about it. We randomly select for the training and test data the following number of pairs: 22,050 and 13,500 for NTU Hand Gesture; 138,864 and 16,500 for the Creative Senz3D.

Conditional Maps. We consider three possible shapes of the conditional map to prove the effectiveness and generality of our method. Sample images are reported in Figure 3.

Triangle Map. In this type of annotation, the user has to provide an oriented triangle which outlines the size, base and orientation of the hand palm. This conditional map is easy to draw, as it is possible to provide a simple interface where users can draw a triangle simply specifying the three delimiting points of the triangle, plus its base. Moreover, the triangle conditional map is category independent, as it does not contain any information about the gesture. We annotated all images for both datasets with the corresponding triangle conditional maps.

Boundary Map. In the boundary map annotation, the user has to draw the contour of the desired target gesture. This type of annotation is weakly category dependent, since from the conditional map (see Figure 3 in the center) it may be possible to infer the target gesture category. However, as this shape is easy to draw, it may be a valid alternative to the skeleton and triangle maps. We annotated all 1,320 images for the NTU Hand dataset with the corresponding boundary annotations.

Skeleton Map. In the skeleton map, the user is required to draw either a complicated skeleton of the hand gesture or the exact position of the hand gesture key-points. However, when the target gesture image is available, it is sometimes possible to draw them automatically. As in (Tang et al., 2018), we obtain the skeleton conditional maps by connecting the key-points obtained through OpenPose, a state of the art hand key-points detector (Simon et al., 2017; Cao et al., 2018). In the case of normal experimental setting, the hand pose is detected for all the 647 and 494 images of the two datasets. Instead, in the case of challenging experimental setting, the key-points could not be obtained for over half of the image set. To this reason, the skeleton map is considered only in the normal experimental setting. This conditional map is hard to draw, and strongly dependent on the category of hand gesture.

4.2. Evaluation

Baseline models. As our baseline models we select the state of the art for hand gesture translation in the wild GestureGAN (Tang et al., 2018). Also, we adopt StarGAN (Choi et al., 2018), GANimation (Pumarola et al., 2018), and PG2 (Ma et al., 2017) as they showed impressive results on multi-domain image-to-image translation. Both StarGAN and GANimation learn to use attribute vectors to transfer facial images from one expression to another one. GestureGAN learns to transfer hand gestures via category-dependent skeleton maps.

Evaluation metrics. We quantitatively evaluate our method performance using two metrics that measure the quality of generated images, namely Peak Signal-to-Noise Ratio (PSNR) and Fréchet Inception Distance (FID) (Heusel et al., 2017), and the F1-score, which measures whether the generated images depict a consistent category label. Moreover, to be comparable with GestureGAN (Tang et al., 2018), we employ the Mean Squared Error (MSE) between pixels and the Inception Score (IS) (Gulrajani et al., 2017). However, these two metrics were indicated as highly unstable (Barratt and Sharma, 2018; Borji, 2019) and they are not strictly related to the quality of generated images. To this reason, we report their results on a separate table and do not further discuss them.

PSNR. It compares two images through their MSE and the maximal pixel intensity ($MAX_{I}=255$). It is defined as: $PSNR=20\log_{10}(\frac{MAX_{I}}{\sqrt{MSE}})$.

FID. It is defined as the distance between two Gaussian with mean and covariance $(\mu_{x},\Sigma_{x})$ and $(\mu_{y},\Sigma_{y})$: $FID(x,y)=||\mu_{x}-\mu_{y}||^{2}_{2}+Tr(\Sigma_{x}+\Sigma_{y}-2(\Sigma_{x}\Sigma_{y})^{1/2})$, where the two Gaussians are defined in the feature space of the Inception model.

F1. The F1-score for binary classifiers is defined as $F_{1}=(2pr)/(p+r)$ where $p$ and $r$ are the precision and recall. For multi-class classifiers it can be defined as the sum of the F1-scores of each class, weighted by the percentage of labels belonging to the class. The resulting measure ranges from 0 to 1, where 1 means that all the classes are correctly classified and 0 the opposite. Thus, we use the F1-score to evaluate the category consistence of our generated images. To compute the F1-score, we train a network to recognize hand gestures. Further details are provided in the Implementation Details.

Perceptual User study. We run a “fake” vs “real” perceptual user study following the same protocol as (Tang et al., 2018; Yang et al., 2018). Users are shown a pair of images, the original and the generated image, and they are asked to select the fake one. The images are displayed for only 1 second before the user can provide his or her choice. The image pairs are randomly shuffled in order to avoid introducing bias in the results. Overall, we collected perceptual annotations from 12 users and each user was asked to vote for 98 image comparisons. Specifically, 12 image translation pairs were selected for each dataset and experimental setting.

Implementation Details. Inspired by previous methods (Zhu et al., 2017a; Choi et al., 2018), both $E_{1}$ and $E_{2}$ are composed of two convolutional layers with the stride size of two for downsampling, $F_{res}$ refers to six residual blocks (He et al., 2016), and $F_{dec}$ is composed of two transposed convolutional layers with the stride size of two for upsampling. We train our model using Adam (Kingma and Ba, 2014) with $\beta_{1}=0.5$ and $\beta_{2}=0.999$ and batch size 4. We use an $n$-dimensional one-hot vector to represent the category label ($n=10$ for NTU dataset and $n=11$ for Senz3D Dataset). For data augmentation we flip the images horizontally with a probability of 0.5 and we reverse the “A-to-B” direction with a probability of 0.5. The initial learning rate is set to $0.0002$. We train for 20 epochs and linearly decay the rate to zero over the last 10 epochs. To reduce model oscillation (Goodfellow, 2016), we follow previous works (Shrivastava et al., 2017; Zhu et al., 2017a) and update the discriminators using a history of generated images rather than the ones produced by the latest generators. We use instance normalization (Ulyanov et al., 2016) for the generator $G$. For all the experiments, the weight coefficients for the loss term in Eq. 10 and Eq. 11 are set to $\lambda_{D}=1$, $\lambda_{G}=2$, $\lambda_{cls}=1$, $\lambda_{rec}=100$, $\lambda_{idt}=10$, $\lambda_{cyc}=10$ and $\lambda_{tv}=1e-5$. Baseline models are optimized using the same settings described in the respective articles. We used the source code released by the authors for all competing works, except for GestureGAN, which was implemented from scratch following the description of the original article (Tang et al., 2018). ${{{\bigtriangleup}}}$-GAN is implemented using the deep learning framework PyTorch.

To compute the F1-score, we train a network on hand gesture recognition using Inception v3 (Szegedy et al., 2016) network fine tuned on the NTU Hand Gesture and Creative Senz3D datasets. The network achieves F1-score 0.93 and 0.99 on Creative Senz3D and NTU Hand Gesture test sets, respectively. Additional details on the training can be found in the supplementary materials.

5. Results

Quantitative Results. We begin by directly comparing ${{{\bigtriangleup}}}$-GAN with the same experimental protocol and metrics used by our most similar competitor, GestureGAN (Tang et al., 2018). Table 1 shows that ${{{\bigtriangleup}}}$-GAN performs better than all competing works in terms of MSE and PSNR, especially when the rolling guidance is employed. In terms of IS GestureGAN performs better. However, the MSE and the IS are not directly related to the quality of the generated images. The MSE is indeed a metric of pixel difference, while the low reliability of the Inception Score is well known (Barratt and Sharma, 2018).

For this reason, we compare our method with competing works using the PSNR, F1-score and the FID score, both in normal and challenging experimental settings. These metrics compare the diversity, quality and hand-gesture consistency of the generated images. Table 2 shows that ${{{\bigtriangleup}}}$-GAN outperforms all competing works, in both the experimental settings and for all the metrics. In the normal setting, compared to GestureGAN, we achieve higher PSNR (36.51 vs 34.24 and 35.39 vs 28.65), F1-score (0.99 vs 0.96) and lower FID (13.73 vs 15.06 and 32.04 vs 54.00) in both datasets. Other methods perform particularly poor in terms of F1-score. For example, GANimation and StarGAN perform near randomness in the F1-score (random baseline $\sim 0.09$), while ${{{\bigtriangleup}}}$-GAN  achieves near-perfect performance in Creative Senz3D ($0.99$) and NTU Hand Gesture ($0.93$). These outcomes might be related to the fact that GANimation, StarGAN and PG2 are not designed for image translation in the wild.

${{{\bigtriangleup}}}$-GAN significantly outperforms the competing methods in the challenging setting, where we enforce a stricter division of training and test gestures, and we use the 100% of the data, differently from GestureGAN’s settings. In particular, the FID score reduces by 49% and 60% from GestureGAN in NTU Hand Gesture and Creative Senz3D, respectively. In terms of F1-score, the result improves by 61% and 71% in NTU Hand Gesture and Creative Senz3D, respectively. The PSNR improves by 10% and 24% in NTU Hand Gesture and Creative Senz3D, respectively. We note that the rolling guidance applied to GestureGAN (denoted in Table 2 as GestureGAN*†*) improves the original FID results by 36% and 24% in NTU Hand Gesture and Creative Senz3D, respectively.

Altogether, the quantitative results show that ${{{\bigtriangleup}}}$-GAN outperforms the state of the art, both in the normal and challenging setting.

Qualitative Results. Figure 4 shows some randomly selected gesture-to-gesture translations in the normal experimental setting. Both GestureGAN (Tang et al., 2018) and ${{{\bigtriangleup}}}$-GAN produce sharper output results while the output gestures from PG2 (Ma et al., 2017) are very blurry. ${{{\bigtriangleup}}}$-GAN also produces a better define sharper background than GestureGAN. StarGAN and GANimation, however, fail to produce gestures from the provided conditional map.

We further inspect the reason behind the poor results of PG2 and GANimation. These methods focus on multi-domain translation and are specifically tailored to the task of facial expression translation and to the cases where the input and target objects are aligned. Figure 5 depicts two sample cases of the difference and attention masks generated by these methods. It can be seen that PG2 fails at finding the difference mask, especially in the NTU Hand Gesture dataset (top row). Similarly, GANimation generates an empty attention mask, which might also be the cause of its poor results in both Figure 4 and Table 2. ${{{\bigtriangleup}}}$-GAN, instead, learns to focus on the differences between the source and target images.

Figure 6 shows the results in the challenging setting. ${{{\bigtriangleup}}}$-GAN generates sharper images with recognizable hand gestures, while other methods such as GestureGAN fails at it. This result is in line with the F1-scores reported in Table 2 (bottom), which range within 0.10 and 0.38 for the competing works, and within 0.58 and 0.61 in case of ${{{\bigtriangleup}}}$-GAN. Both qualitative and quantitative results confirm that state-of-the-art methods are not adapted to perform gesture translation in the challenging settings, i.e. where a user-friendly category independent conditional map is provided, and where the network is asked to translate to an unseen gesture for a given user. We refer to the Supplementary Material for additional qualitative Figures.

Diversity Study. ${{{\bigtriangleup}}}$-GAN decouples the desired hand gesture category, specified through a class number, from its location, scale and orientation, which are specified by a conditional map. This means that users can use the same conditional map with different hand gesture categories to generate multiple images. Figure 7 shows that ${{{\bigtriangleup}}}$-GAN can generate three different distinguishable hand gestures by using the same triangle conditional map and different category numbers. Instead, when using non category-independent shapes are used (e.g. boundary or skeleton), ${{{\bigtriangleup}}}$-GAN fails to synthesize several hand gestures categories from the same conditional map. As mentioned before, Boundary maps are weakly category dependent, as their shape might suggest the type of gesture, while Skeleton and Key-points maps are category dependent.

Furthermore, we test the performance of ${{{\bigtriangleup}}}$-GAN with the same source image and category, but with different conditional maps. For this test, we manually draw three triangle conditional maps with arbitrary size, location and orientation. Figure 8 shows that our method faithfully synthesizes the target gestures in all cases. Altogether, we show that users can generate hand gestures in the wild with much less effort than state-of-the-art models, that require complex annotations that are dependent on the specific hand gesture users want to generate.

Perception User Study. Table 3 shows the outcome of the perceptual user study, where we report the percentage of times when the translated image wins against the original target image in the real vs fake comparison, i.e when the original image is selected as fake. It can be seen that ${{{\bigtriangleup}}}$-GAN outperforms GestureGAN (Tang et al., 2018) in both experimental settings. This means that ${{{\bigtriangleup}}}$-GAN generates higher quality images that can be mistaken with the real ones at higher rates than competitors.

Ablation study. We further investigate the effect of the rolling guidance approach by removing this component from ${{{\bigtriangleup}}}$-GAN. In the quantitative results, Table 2 it can be seen that the rolling guidance allows to significantly improves the quality of the generated images. In Table 4 we report the degradation of our method performance without rolling guidance, on Creative Senz3D dataset, for the three types of annotation maps. Specifically, we observe 24.77%, 35.37% and 81.90% worse (increased) FID score for the Triangle, Boundary and Skeleton maps, respectively. While the F1-score decreases by 75.76% and 58.06% on the Triangle and Boundary maps respectively, for Skeleton maps it decreases by 12.50%. In terms of PSNR the degradation is less significant for the Triangle and Boundary, but higher (10.66%) for Skeleton maps. Finally, we observed that a single rolling is sufficient to improve the generated results, while ${{{\bigtriangleup}}}$-GAN does not benefit from additional rolling iterations.

6. Conclusion

We have presented a novel GAN architecture for gesture-to-gesture translation in the wild. Our model decouples the conditional input into a category label and an easy-to-draw conditional map. The proposed attention module and rolling guidance approach allow generating sharper images in the wild, faithfully generating the target gesture while preserving the background context. Experiments on two public datasets have shown that ${{{\bigtriangleup}}}$-GAN outperforms state of the art both quantitatively and qualitatively. Moreover, it allows the use of simple-to-draw and category-independent conditional maps, such as triangles. This significantly reduces the annotation effort both at drawing time and allowing to use a single map for multiple gesture translations. The proposed framework is not limited to category labels but can also be used through embedding, learned from the data, that can express the gesture characteristics. In future work users could easily provide a reference image instead of a label, and translate the original image to the target gesture expressed by the reference image.

Our approach is especially important when the target image, and thus the target conditional map, is not available, which is the typical scenario in photo-editing software.

Acknowledgements.

We gratefully acknowledge NVIDIA Corporation for the donation of the Titan X GPUs and Fondazione Caritro for supporting the SMARTourism project.

Appendix A Network Architecture

The network architectures of ${{{\bigtriangleup}}}$-GAN are shown in Table 6 and Table 7. For the generator network, we use instance normalization in all layers except the last output layer. For the discriminator network, we use Leaky ReLU (Xu et al., 2015) with a negative slope of 0.01. We use the following notations: $n_{c}$: the number of gesture category, $n_{d}$: the channels of conditional map ($n_{d}=1$). N: the number of output channels, K: kernel size, S: stride size, P: padding size, IN: instance normalization. Note that $E_{2}$ part takes ($\mathbf{S}_{Y}$, $C_{Y}$) as input with $n_{c}$+$n_{d}$ channels in the first stage, and takes ($\mathbf{S}_{Y}$, $C_{Y}$, $\widehat{\mathbf{I}}_{Y}$) as input with $n_{c}$+$n_{d}$+3 channels in the second stage.

Appendix B WGAN Loss

During the training, we try the WGAN loss (Arjovsky et al., 2017) $\mathcal{L}_{WGAN}$ that uses the Earth Mover Distance to minimize the differences of the distributions, and a gradient penalty $\mathcal{L}_{gp}$ that improves the stability with respect to other adversarial losses (Gulrajani et al., 2017). The WGAN and Gradient Penalty loss are formalized as follows:

[TABLE]

[TABLE]

where $\bar{\mathbf{I}}$ is uniformly sampled as a linear combination between the ground truth $\textbf{I}_{Y}$ and the generated $\hat{\mathbf{I}}_{Y}$. However, there are no significant improvements in the experiments compared with using $L_{GAN}$.

Appendix C F1-score Discriminator details

To compute the F1-score, we train a network on hand gesture recognition using Inception v3 (Szegedy et al., 2016) network fine tuned on the NTU Hand Gesture and Creative Senz3D datasets. We freeze all layers but the last three (the fully connected and the two Inception modules) and fine tune the network using 10% of the data for validation, 10% for testing and the rest is used for training. For training we used SGD with learning rate 0.001, batch-size 64, and momentum 0.9. We use random rotation (until $40\degree$) and flip as data augmentation with probability 0.5. Given in input the ${{{\bigtriangleup}}}$-GAN generated images, this network is expected to predict the ground truth category label of the gesture.

Appendix D FID score

We note the previous state of the art GestureGAN (Tang et al., 2018) reports lower FID scores than what we report in our manuscript. We verified that this is due to a software bug in the FID score implementation in PyTorch (https://github.com/mseitzer/pytorch-fid/). In particular, this implementation used a wrong input normalization that scaled the input in the range [0,0.5):

⬇

x[:,0]=x[:,0]*(0.229/0.5) + (0.485-0.5)/0.5

x[:,1]=x[:,1]*(0.224/0.5) + (0.456-0.5)/0.5

x[:,2]=x[:,2]*(0.225/0.5) + (0.406-0.5)/0.5

This incorrect implementation was later modified in May 27th 2019 into $x=2*x-1$ (mseitzer, 2019). We used this corrected implementation, which results in higher FID scores. Table 5 reports both the scores. The column of FID* shows the result of the incorrect implementation.

Appendix E Additional Qualitative Results

E.1. More Comparisons

Figure 9 and Figure 10 show additional images with 256$\times$256 resolutions generated by ${{{\bigtriangleup}}}$-GAN in both normal and challenging settings, respectively.

E.2. Feature Visualization

Inspired by Monkey-Net (Siarohin et al., 2019), we employ softmax activations for the last layer of the encoder $E_{2}$ to obtain heatmaps, which transfers the $K$-channels feature maps into heatmaps $H_{K}\in[0,1.0]^{\frac{H}{4}\times\frac{W}{4}}$, one for each channel. Thus, we estimate the location of the confidence from the heatmaps, which can reveal the spatial distribution of learned features. Figure 11 shows that the rolling guidance approach helps the model to learn additional information that significantly refines the generated results.

E.3. Failure Cases

Figure 12 shows sample failure cases of our method. (a), (b) and (c) show that our method may lose some details of finger or arm sometimes, especially in the NTU dataset, in which hand gestures are very small. (d) shows some distortion of the generated gesture. Handling more diverse and extreme transformations, especially geometric constraints, is an important problem for future work.