Add files using upload-large-folder tool

parse/train/B1Yy1BxCZ/B1Yy1BxCZ.md

@@ -0,0 +1,234 @@
+# DON’T DECAY THE LEARNING RATE, INCREASE THE BATCH SIZE
+
+Samuel L. Smith∗, Pieter-Jan Kindermans∗, Chris Ying & Quoc V. Le Google Brain {slsmith, pikinder, chrisying, qvl}@google.com
+
+# ABSTRACT
+
+It is common practice to decay the learning rate. Here we show one can usually obtain the same learning curve on both training and test sets by instead increasing the batch size during training. This procedure is successful for stochastic gradient descent (SGD), SGD with momentum, Nesterov momentum, and Adam. It reaches equivalent test accuracies after the same number of training epochs, but with fewer parameter updates, leading to greater parallelism and shorter training times. We can further reduce the number of parameter updates by increasing the learning rate $\epsilon$ and scaling the batch size $B \propto \epsilon$ . Finally, one can increase the momentum coefficient $m$ and scale $B \propto 1 / ( 1 - m )$ , although this tends to slightly reduce the test accuracy. Crucially, our techniques allow us to repurpose existing training schedules for large batch training with no hyper-parameter tuning. We train ResNet-50 on ImageNet to $7 6 . 1 \%$ validation accuracy in under 30 minutes.
+
+# 1 INTRODUCTION
+
+Stochastic gradient descent (SGD) remains the dominant optimization algorithm of deep learning. However while SGD finds minima that generalize well (Zhang et al., 2016; Wilson et al., 2017), each parameter update only takes a small step towards the objective. Increasing interest has focused on large batch training (Goyal et al., 2017; Hoffer et al., 2017; You et al., 2017a), in an attempt to increase the step size and reduce the number of parameter updates required to train a model. Large batches can be parallelized across many machines, reducing training time. Unfortunately, when we increase the batch size the test set accuracy often falls (Keskar et al., 2016; Goyal et al., 2017).
+
+To understand this surprising observation, Smith & Le (2017) argued one should interpret SGD as integrating a stochastic differential equation. They showed that the scale of random fluctuations in the SGD dynamics, $\begin{array} { r } { g = \epsilon ( \frac { N } { B } - 1 ) } \end{array}$ , where $\epsilon$ is the learning rate, $N$ training set size and $B$ batch size. Furthermore, they found that there is an optimum fluctuation scale $g$ which maximizes the test set accuracy (at constant learning rate), and this introduces an optimal batch size proportional to the learning rate when $B \ll N$ . Goyal et al. (2017) already observed this scaling rule empirically and exploited it to train ResNet-50 to $7 6 . 3 \%$ ImageNet validation accuracy in one hour. Here we show,
+
+When one decays the learning rate, one simultaneously decays the scale of random fluctuations $g$ in the SGD dynamics. Decaying the learning rate is simulated annealing. We propose an alternative procedure; instead of decaying the learning rate, we increase the batch size during training. This strategy achieves near-identical model performance on the test set with the same number of training epochs but significantly fewer parameter updates. Our proposal does not require any fine-tuning as we follow pre-existing training schedules; when the learning rate drops by a factor of $\alpha$ , we instead increase the batch size by $\alpha$ . • As shown previously, we can further reduce the number of parameter updates by increasing the learning rate and scaling $B \propto \epsilon$ . One can also increase the momentum coefficient and scale $B \propto \mathrm { \bar { 1 } } / ( 1 - m )$ , although this slightly reduces the test accuracy. We train InceptionResNet-V2 on ImageNet in under 2500 parameter updates, using batches of 65536 images, and reach a validation set accuracy of $7 7 \%$ . We also replicate the setup of Goyal et al. (2017) on TPU and train ResNet-50 on ImageNet to $7 6 . 1 \%$ accuracy in under 30 minutes.
+
+We note that a number of recent works have discussed increasing the batch size during training (Friedlander & Schmidt, 2012; Byrd et al., 2012; Balles et al., 2016; Bottou et al., 2016; De et al., 2017), but to our knowledge no paper has shown empirically that increasing the batch size and decaying the learning rate are quantitatively equivalent. A key contribution of our work is to demonstrate that decaying learning rate schedules can be directly converted into increasing batch size schedules, and vice versa; providing a straightforward pathway towards large batch training.
+
+In section 2 we discuss the convergence criteria for SGD in strongly convex minima, in section 3 we interpret decaying learning rates as simulated annealing, and in section 4 we discuss the difficulties of training with large momentum coefficients. Finally in section 5 we present conclusive experimental evidence that the empirical benefits of decaying learning rates in deep learning can be obtained by instead increasing the batch size during training. We exploit this observation and other tricks to achieve efficient large batch training on CIFAR-10 and ImageNet.
+
+# 2 STOCHASTIC GRADIENT DESCENT AND CONVEX OPTIMIZATION
+
+SGD is a computationally-efficient alternative to full-batch training, but it introduces noise into the gradient, which can obstruct optimization. It is often stated that to reach the minimum of a strongly convex function we should decay the learning rate, such that (Robbins & Monro, 1951):
+
+$$
+\begin{array} { l } { { \displaystyle \sum _ { i = 1 } ^ { \infty } \epsilon _ { i } = \infty } , \ ~ } \\ { { \displaystyle \sum _ { i = 1 } ^ { \infty } \epsilon _ { i } ^ { 2 } < \infty } . } \end{array}
+$$
+
+$\epsilon _ { i }$ denotes the learning rate at the $i ^ { t h }$ gradient update. Intuitively, equation 1 ensures we can reach the minimum, no matter how far away our parameters are initialized, while equation 2 ensures that the learning rate decays sufficiently quickly that we converge to the minimum, rather than bouncing around it due to gradient noise (Welling & Teh, 2011). However, although these equations appear to imply that the learning rate must decay during training, equation 2 holds only if the batch size is constant.1 To consider how to proceed when the batch size can vary, we follow recent work by Smith & Le (2017) and interpret SGD as integrating the stochastic differential equation below,
+
+$$
+\frac { d \omega } { d t } = - \frac { d C } { d \omega } + \eta ( t )
+$$
+
+$C$ represents the cost function (summed over all training examples), and $\omega$ represents the parameters, which evolve in continuous “time” $t$ towards their final values. Meanwhile $\eta ( t )$ represents Gaussian random noise, which models the consequences of estimating the gradient on a mini-batch. They showed that the mean $\langle \eta ( t ) \rangle = 0$ and variance $\langle \eta ( t ) \eta ( t ^ { \prime } ) \rangle = \bar { g } F ( \omega \bar { ) } \delta ( t - t ^ { \prime } )$ , where $F ( \omega )$ describes the covariances in gradient fluctuations between different parameters. They also proved that the “noise scale” $g = \check { \epsilon } ( \frac { N } { B } - 1 )$ , where $\epsilon$ is the learning rate, $N$ the training set size and $B$ the batch size. This noise scale controls the magnitude of the random fluctuations in the training dynamics.
+
+Usually $B \ll N$ , and so we may approximate $g \approx \epsilon N / B$ . When we decay the learning rate, the noise scale falls, enabling us to converge to the minimum of the cost function (this is the origin of equation 2 above). However we can achieve the same reduction in noise scale at constant learning rate by increasing the batch size. The main contribution of this work is to show that it is possible to make efficient use of vast training batches, if one increases the batch size during training at constant learning rate until $B \sim N / 1 0$ . After this point, we revert to the use of decaying learning rates.
+
+# 3 SIMULATED ANNEALING AND THE GENERALIZATION GAP
+
+To the surprise of many researchers, it is now increasingly accepted that small batch training often generalizes better to the test set than large batch training. This “generalization gap” was explored extensively by Keskar et al. (2016). Smith & Le (2017) observed an optimal batch size $B _ { o p t }$ which maximized the test set accuracy at constant learning rate. They argued that this optimal batch size arises when the noise scale $g \approx \epsilon N / B$ is also optimal, and supported this claim by demonstrating empirically that $B _ { o p t } \propto \epsilon N$ . Earlier, Goyal et al. (2017) exploited a linear scaling rule between batch size and learning rate to train ResNet-50 on ImageNet in one hour with batches of 8192 images.
+
+These results indicate that gradient noise can be beneficial, especially in non-convex optimization. It has been proposed that noise helps SGD escape “sharp minima” which generalize poorly (Hochreiter & Schmidhuber, 1997; Chaudhari et al., 2016; Keskar et al., 2016; Smith & Le, 2017). Given these results, it is unclear to the present authors whether equations 1 and 2 are relevant in deep learning. Supporting this view, we note that most researchers employ early stopping (Prechelt, 1998), whereby we intentionally prevent the network from reaching a minimum. Nonetheless, decaying learning rates are empirically successful. To understand this, we note that introducing random fluctuations whose scale falls during training is also a well established technique in non-convex optimization; simulated annealing. The initial noisy optimization phase allows us to explore a larger fraction of the parameter space without becoming trapped in local minima. Once we have located a promising region of parameter space, we reduce the noise to fine-tune the parameters.
+
+Finally, we note that this interpretation may explain why conventional learning rate decay schedules like square roots or exponential decay have become less popular in deep learning in recent years. Increasingly, researchers favor sharper decay schedules like cosine decay (Loshchilov & Hutter, 2016) or step-function drops (Zagoruyko & Komodakis, 2016). To interpret this shift, we note that it is well known in the physical sciences that slowly annealing the temperature (noise scale) helps the system to converge to the global minimum, which may be sharp. Meanwhile annealing the temperature in a series of discrete steps can trap the system in a “robust” minimum whose cost may be higher but whose curvature is lower. We suspect a similar intuition may hold in deep learning.
+
+# 4 THE EFFECTIVE LEARNING RATE AND THE ACCUMULATION VARIABLE
+
+Many researchers no longer use vanilla SGD, instead preferring SGD with momentum. Smith & Le (2017) extended their analysis of SGD to include momentum, and found that the “noise scale”,
+
+$$
+\begin{array} { l c l } { { g } } & { { = } } & { { \displaystyle \frac { \epsilon } { 1 - m } \left( \frac { N } { B } - 1 \right) } } \\ { { } } & { { \approx } } & { { \displaystyle \frac { \epsilon N } { B ( 1 - m ) } } } \end{array}
+$$
+
+This reduces to the noise scale of vanilla SGD when the momentum coefficient $m  0$ . Intuitively, $\epsilon _ { e f f } = \epsilon / ( 1 - m )$ is the effective learning rate. They proposed to reduce the number of parameter updates required to train a model by increasing the learning rate and momentum coefficient, while simultaneously scaling $B \propto \epsilon / ( 1 - \dot { m } )$ . We find that increasing the learning rate and scaling $B \propto \epsilon$ performs well. However increasing the momentum coefficient while scaling $B \propto 1 / ( 1 { - } m )$ slightly reduces the test accuracy. To analyze this observation, consider the momentum update equations,
+
+$$
+\begin{array} { r c l } { { \Delta A } } & { { = } } & { { \displaystyle - ( 1 - m ) A + \frac { d \hat { C } } { d \omega } , } } \\ { { \Delta \omega } } & { { = } } & { { \displaystyle - A \epsilon . } } \end{array}
+$$
+
+$A$ is the “accumulation”, while $\textstyle { \frac { d { \hat { C } } } { d \omega } }$ is the mean gradient per training example, estimated on a batch of size $B$ . In Appendix A we analyze the growth of the accumulation at the start of training. This variable tracks the exponentially decaying average of gradient estimates, but initially it is initialized to zero. We find that the accumulation grows in exponentially towards its steady state value over a “timescale” of approximately $B / ( N ( 1 - m ) )$ training epochs. During this time, the magnitude of the parameter updates $\Delta \omega$ is suppressed, reducing the rate of convergence. Consequently when training at high momentum one must introduce additional epochs to allow the dynamics to catch up.
+
+Furthermore, when we increase the momentum coefficient we increase the timescale required for the accumulation to forget old gradients (this timescale is also $\sim B / ( N ( 1 - m ) ) )$ . Once this timescale becomes several epochs long, the accumulation cannot adapt to changes in the loss landscape, impeding training. This is likely to be particularly problematic at points where the noise scale decays. Kingma & Ba (2014) proposed initialization bias correction, whereby the learning rate is increased at early times to compensate the suppressed initial value of the accumulation. However when the batch size is large, we found that this often causes instabilities during the early stages of training. We note that Goyal et al. (2017) recommended a reduced learning rate for the first few epochs.
+
+![](images/d73e9d1b93ba4ecd119509faab8c9b7cdeaf08ddb27d075ef3af2902d684bb22.jpg)  
+Figure 1: Schedules for the learning rate (a) and batch size (b), as a function of training epochs.
+
+# 5 EXPERIMENTS
+
+In section 5.1, we demonstrate that decreasing the learning rate and increasing the batch size during training are equivalent. In section 5.2, we show we can further reduce the number of parameter updates by increasing the effective learning rate and scaling the batch size. In section 5.3 we apply our insights to train Inception-ResNet-V2 on ImageNet, using vast batches of up to 65536 images. Finally in section 5.4, we train ResNet-50 to $7 6 . 1 \%$ ImageNet validation accuracy within 30 minutes.
+
+# 5.1 SIMULATED ANNEALING IN A WIDE RESNET
+
+Our first experiments are performed on CIFAR-10, using a “16-4” wide ResNet architecture, following the implementation of Zagoruyko & Komodakis (2016). We use ghost batch norm (Hoffer et al., 2017), with a ghost batch size of 128. This ensures the mean gradient is independent of batch size, as required by the analysis of Smith & Le (2017). To demonstrate the equivalence between decreasing the learning rate and increasing the batch size, we consider three different training schedules, as shown in figure 1. “Decaying learning rate” follows the original implementation; the batch size is constant, while the learning rate repeatedly decays by a factor of 5 at a sequence of “steps”. “Hybrid” holds the learning rate constant at the first step, instead increasing the batch size by a factor of 5. However after this first step, the batch size is constant and the learning rate decays by a factor of 5 at each subsequent step. This schedule mimics how one might proceed if hardware imposes a limit on the maximum achievable batch size. In “Increasing batch size”, we hold the learning rate constant throughout training, and increase the batch size by a factor of 5 at every step.
+
+![](images/10712532c719889b00b97e1900e4a985e7027240568ad59f36fa0e9db74b3ab5.jpg)  
+Figure 2: Wide ResNet on CIFAR10. Training set cross-entropy, evaluated as a function of the number of training epochs (a), or the number of parameter updates (b). The three learning curves are identical, but increasing the batch size reduces the number of parameter updates required.
+
+![](images/bce387343d0b4db0706d44ce469bbda419b4177e4c1bc6cbf7ab713d9de09ad9.jpg)  
+Figure 3: Wide ResNet on CIFAR10. Test accuracy during training, for SGD with momentum (a), and Nesterov momentum (b). In both cases, all three schedules track each other extremely closely.
+
+If the learning rate itself must decay during training, then these schedules should show different learning curves (as a function of the number of training epochs) and reach different final test set accuracies. Meanwhile if it is the noise scale which should decay, all three schedules should be indistinguishable. We plot the evolution of the training set cross entropy in figure 2a, where we train using SGD with momentum and a momentum parameter of 0.9. The three training curves are almost identical, despite showing marked drops as we pass through the first two steps (where the noise scale is reduced). These results suggest that it is the noise scale which is relevant, not the learning rate.
+
+To emphasize the potential benefits of increasing the batch size, we replot the training cross-entropy in figure 2b, but as a function of the number of parameter updates rather than the number of epochs. While all three schedules match up to the first “step”, after this point increasing the batch size dramatically reduces the number of parameter updates required to train the model. Finally, to confirm that our alternative learning schedules generalize equally well to the test set, in figure 3a we exhibit the test set accuracy, as a function of the number of epochs (so each curve can be directly compared). Once again, the three schedules are almost identical. We conclude that we can achieve all of the benefits of decaying the learning rate in these experiments by instead increasing the batch size.
+
+We present additional results to establish that our proposal holds for a range of optimizers, all using the schedules presented in figure 1. In figure 3b, we present the test set accuracy, when training with Nesterov momentum (Nesterov, 1983) and momentum parameter 0.9, observing three nearidentical curves. In figure 4a, we repeat the same experiment with vanilla SGD, again obtaining three highly similar curves (In this case, there is no clear benefit of decaying the learning rate after the first step). Finally in figure 4b we repeat the experiment with Adam (Kingma & Ba, 2014). We use the default parameter settings of TensorFlow, such that the initial base learning rate here was $1 0 ^ { - 3 }$ , $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ . Thus the learning rate schedule is obtained by dividing figure 1a by $1 0 ^ { - 2 }$ . Remarkably, even here the three curves closely track each other.
+
+![](images/7a3acd8374c49c6588ad4299f4f686aea4cd7e6380eeafef62505f220d4db08d.jpg)  
+Figure 4: Wide ResNet on CIFAR10. The test set accuracy during training, for vanilla SGD (a) and Adam (b). Once again, all three schedules result in equivalent test set performance.
+
+![](images/c64a2841b91e74b589c9428e7b9c5d898581eba4bce547a7d1df97c63fe6ca1b.jpg)  
+Figure 5: Wide ResNet on CIFAR10. Test accuracy as a function of the number of parameter updates. “Increasing batch size” replaces learning rate decay by batch size increases. “Increased initial learning rate” additionally increases the initial learning rate from 0.1 to 0.5. Finally “Increased momentum coefficient” also increases the momentum coefficient from 0.9 to 0.98.
+
+# 5.2 INCREASING THE EFFECTIVE LEARNING RATE
+
+We now focus on our secondary objective; minimizing the number of parameter updates required to train a model. As shown above, the first step is to replace decaying learning rates by increasing batch sizes. We show here that we can also increase the effective learning rate $\epsilon _ { e f f } = \dot { \epsilon } / ( 1 - m \bar { ) }$ at the start of training, while scaling the initial batch size $B \propto \epsilon _ { e f f }$ . All experiments are conducted using SGD with momentum. There are 50000 images in the CIFAR-10 training set, and since the scaling rules only hold when $B \ll N$ , we decided to set a maximum batch size $B _ { m a x } = 5 1 2 0$ .
+
+We consider four training schedules, all of which decay the noise scale by a factor of five in a series of three steps. “Original training schedule” follows the implementation of Zagoruyko & Komodakis (2016), using an initial learning rate of 0.1 which decays by a factor of 5 at each step, a momentum coefficient of 0.9, and a batch size of 128. “Increasing batch size” also uses a learning rate of 0.1, initial batch size of 128 and momentum coefficient of 0.9, but the batch size increases by a factor of 5 at each step. These schedules are identical to “Decaying learning rate” and “Increasing batch size” in section 5.1 above. “Increased initial learning rate” also uses increasing batch sizes during training, but additionally uses an initial learning rate of 0.5 and an initial batch size of 640. Finally “Increased momentum coefficient” combines increasing batch sizes during training and the increased initial learning rate of 0.5, with an increased momentum coefficient of 0.98, and an initial batch size of 3200. Note that we only increase the batch size until it reaches $B _ { m a x }$ , after this point we achieve subsequent decays in noise scale by decreasing the learning rate. We emphasize that, as in the previous section, all four schedules require the same number of training epochs.
+
+We plot the evolution of the test set accuracy in figure 5, as a function of the number of parameter updates. Our implementation of the original training schedule requires ${ \sim } 8 0 0 0 0$ updates, and reaches a final test accuracy of $9 4 . 3 \%$ (the original paper reports $9 5 \%$ accuracy, which we have not been able to replicate). “Increasing batch size” requires ${ \sim } 2 9 0 0 0$ updates, reaching a final accuracy of $9 4 . 4 \%$ . “Increased initial learning rate” requires under 6500 updates, reaching a final accuracy of $9 4 . 5 \%$ . Finally, “Increased momentum coefficient” requires less than 2500 parameter updates, but reaches a lower test accuracy of $9 3 . 3 \%$ . Across five additional training runs for each schedule, the median accuracies were $9 4 . { \dot { 3 } } \%$ , $9 4 . 2 \%$ , $9 4 . 2 \%$ and $9 3 . 5 \%$ respectively. We discussed a potential explanation for the performance drop when training with large momentum coefficients in section 4. We provide additional results in appendix B, varying the initial learning rate between 0.1 and 3.2 while holding the batch size constant. We find that the test accuracy falls for initial learning rates larger than ${ \sim } 0 . 4$ .
+
+![](images/cb239d8eb35e89fd6feec9cab05500db53c771189fe3662bafbba1dd4318c3fa.jpg)  
+Figure 6: Inception-ResNet-V2 on ImageNet. Increasing the batch size during training achieves similar results to decaying the learning rate, but it reduces the number of parameter updates from just over 14000 to below 6000. We run each experiment twice to illustrate the variance.
+
+# 5.3 TRAINING IMAGENET IN 2500 PARAMETER UPDATES
+
+We now apply our insights to reduce the number of parameter updates required to train ImageNet. Goyal et al. (2017) trained a ResNet-50 on ImageNet in one hour, reaching $7 6 . 3 \%$ validation accuracy. To achieve this, they used batches of 8192, with an initial learning rate of 3.2 and a momentum coefficient of 0.9. They completed 90 training epochs, decaying the learning rate by a factor of ten at the 30th, 60th and 80th epoch. ImageNet contains around 1.28 million images, so this corresponds to ${ \sim } 1 4 0 0 0$ parameter updates. They also introduced a warm-up phase at the start of training, in which the learning rate and batch size was gradually increased.
+
+We also train for 90 epochs and follow the same schedule, decaying the noise scale by a factor of ten at the 30th, 60th and 80th epoch. However we did not include a warm-up phase. To set a stronger baseline, we replaced ResNet-50 by Inception-ResNet-V2 (Szegedy et al., 2017). Initially we used a ghost batch size of 32. In figure 6, we train with a learning rate of 3.0 and a momentum coefficient of 0.9. The initial batch size was 8192. For “Decaying learning rate”, we hold the batch size fixed and decay the learning rate, while in “Increasing batch size” we increase the batch size to 81920 at the first step, but decay the learning rate at the following two steps. We repeat each schedule twice, and find that all four runs exhibit a very similar evolution of the test set accuracy during training. The final accuracies of the two “Decaying learning rate” runs are $7 8 . 7 \%$ and $7 7 . 8 \%$ , while the final accuracy of the two “Increasing batch size” runs are $7 8 . 1 \%$ and $7 6 . 8 \%$ . Although there is a slight drop, the difference in final test accuracies is similar to the variance between training runs. Increasing the batch size reduces the number of parameter updates during training from just over 14000 to below 6000. Note that the training curves appear unusually noisy because we reduced the number of test set evaluations to reduce the model training time.
+
+Goyal et al. (2017) already increased the learning rate close to its maximum stable value. To further reduce the number of parameter updates we must increase the momentum coefficient. We introduce a maximum batch size, $B _ { m a x } = \dot { 2 } ^ { 1 6 } = 6 5 5 3 6$ . This ensures $B \ll N$ , and it also improved the stability of our distributed training. We also increased the ghost batch size to 64, matching the batch size of our GPUs and reducing the training time. We compare three different schedules, all of which have the same base schedule, decaying the noise scale by a factor of ten at the 30th, 60th and 80th epoch. We use an initial learning rate of 3 throughout. “Momentum $0 . 9 ^ { \ast }$ uses an initial batch size of 8192, “Momentum $0 . 9 7 5 ^ { \cdot }$ uses an initial batch size of 16384, and “Momentum $0 . 9 8 7 5 '$ uses an initial batch size of 32768. For all schedules, we decay the noise scale by increasing the batch size until reaching $B _ { m a x }$ , and then decay the learning rate. We plot the test set accuracy in figure 7. “Momentum $0 . 9 ^ { \prime }$ achieves a final accuracy of $7 8 . 8 \%$ in just under 6000 updates. We performed two runs of “Momentum $0 . 9 5 '$ , achieving final accuracies of $7 8 . 1 \%$ and $7 7 . { \bar { 8 \% } }$ in under 3500 updates. Finally “Momentum $0 . 9 7 5 ^ { \cdot }$ achieves final accuracies of $7 7 . 5 \%$ and $7 6 . 8 \%$ in under 2500 updates.
+
+![](images/ad6507b3ef16598af644328b400200847039dd87899409b9b70d11fb2ff2895c.jpg)  
+Figure 7: Inception-ResNet-V2 on ImageNet. Increasing the momentum parameter reduces the number of parameter updates required, but it also leads to a small drop in final test accuracy.
+
+# 5.4 TRAINING IMAGENET IN 30 MINUTES
+
+To confirm that increasing the batch size during training can reduce model training times, we replicated the set-up described by Goyal et al. (2017) on a half TPU pod, comprising 256 tensorcores (Jouppi et al., 2017). Using tensorFlow, we first train ResNet-50 for 90 epochs to $7 6 . 1 \%$ validation set accuracy in under 45 minutes, utilising batches of 8192 images. To utilise the full TPU pod, we then increase the batch size after the first 30 epochs to 16384 images, and achieve the same validation accuracy of $7 6 . 1 \%$ in under 30 minutes. The last 60 epochs and the first 30 epochs both take just under 15 minutes, demonstrating near-perfect scaling efficiency across the pod, such that the number of parameter updates provides a meaningful measure of the training time. To our knowledge, this is the first procedure which has reduced the training time of Goyal et al. (2017) without sacrificing final validation accuracy (You et al., 2017b; Akiba et al., 2017). By contrast, doubling the initial learning rate and using batches of 16384 images throughout training achieves a lower validation set accuracy of $7 5 . 0 \%$ in 22 minutes, demonstrating that increasing the batch size during training is crucial to the performance gains above. These results show that the ideas presented in this paper will become increasingly important as new hardware for large-batch training becomes available.
+
+# 6 RELATED WORK
+
+This paper extends the analysis of SGD in Smith & Le (2017) to include decaying learning rates. Mandt et al. (2017) also interpreted SGD as a stochastic differential equation, in order to discuss how SGD could be modified to perform approximate Bayesian posterior sampling. However they state that their analysis holds only in the neighborhood of a minimum, while Keskar et al. (2016) showed that the beneficial effects of noise are most pronounced at the start of training. Li et al. (2017) proposed the use of control theory to set the learning rate and momentum coefficient.
+
+Goyal et al. (2017) observed a linear scaling rule between batch size and learning rate, $B \propto \epsilon$ and used this rule to reduce the time required to train ResNet-50 on ImageNet to one hour. To our knowledge, this scaling rule was fist adopted by Krizhevsky (2014). Bottou et al. (2016) (section 4.2) demonstrated that SGD converges to strongly convex minima in similar numbers of training√ epochs if $B \propto \epsilon$ . Hoffer et al. (2017) proposed an alternative scaling rule, $B \propto \sqrt { \epsilon }$ .
+
+You et al. (2017a) proposed Layer-wise Adaptive Rate Scaling (LARS), which applies different learning rates to different parameters in the network, and used it to train ImageNet in 14 minutes (You et al., 2017b), albeit to a lower final accuracy of $7 4 . 9 \%$ . K-FAC (Martens & Grosse, 2015) is also gaining popularity as an efficient alternative to SGD. Wilson et al. (2017) argued that adaptive optimization methods tend to generalize less well than SGD and SGD with momentum (although they did not include K-FAC in their study), while our work reduces the gap in convergence speed. Asynchronous-SGD is another popular strategy, which enables the use of multiple GPUs even when batch sizes are small (Recht et al., 2011; Dean et al., 2012). We do not consider asynchronous-SGD in this work, since the scaling rules enabled us to use batch sizes on the order of the training set size.
+
+# 7 CONCLUSIONS
+
+We can often achieve the benefits of decaying the learning rate by instead increasing the batch size during training. We support this claim with experiments on CIFAR-10 and ImageNet, and with a range of optimizers including SGD, Momentum and Adam. Our findings enable the efficient use of vast batch sizes, significantly reducing the number of parameter updates required to train a model. This has the potential to dramatically reduce model training times. We further increase the batch size $B$ by increasing the learning rate $\epsilon$ and momentum parameter $m$ , while scaling $B \propto \epsilon / ( 1 - m )$ . Combining these strategies, we train Inception-ResNet-V2 on ImageNet to $7 7 \%$ validation accuracy in under 2500 parameter updates, using batches of 65536 images. We also exploit increasing batch sizes to train ResNet-50 to $7 6 . 1 \%$ ImageNet validation set accuracy on TPU in under 30 minutes. Most strikingly, we achieve this without any hyper-parameter tuning, since our scaling rules enable us to directly convert existing hyper-parameter choices from the literature for large batch training.
+
+# ACKNOWLEDGMENTS
+
+We thank Prajit Ramachandran, Gabriel Bender, Matthew Johnson and Martin Abadi for helpful discussions. We also thank Vijay Vasudevan, Brennan Saeta, Jonathan Hseu, Bjarke Roune and the rest of the TPU team for technical support.
+
+# REFERENCES
+
+Takuya Akiba, Shuji Suzuki, and Keisuke Fukuda. Extremely large minibatch sgd: Training resnet50 on imagenet in 15 minutes. arXiv preprint arXiv:1711.04325, 2017.
+
+Lukas Balles, Javier Romero, and Philipp Hennig. Coupling adaptive batch sizes with learning rates. arXiv preprint arXiv:1612.05086, 2016.
+
+Leon Bottou, Frank E Curtis, and Jorge Nocedal. Optimization methods for large-scale machine ´ learning. arXiv preprint arXiv:1606.04838, 2016.
+
+Richard H Byrd, Gillian M Chin, Jorge Nocedal, and Yuchen Wu. Sample size selection in optimization methods for machine learning. Mathematical programming, 134(1):127–155, 2012.
+
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, and Yann LeCun. Entropy-SGD: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016.
+
+Soham De, Abhay Yadav, David Jacobs, and Tom Goldstein. Automated inference with adaptive batches. In Artificial Intelligence and Statistics, pp. 1504–1513, 2017.
+
+Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012.
+
+Michael P Friedlander and Mark Schmidt. Hybrid deterministic-stochastic methods for data fitting. SIAM Journal on Scientific Computing, 34(3):A1380–A1405, 2012.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997.
+
+Elad Hoffer, Itay Hubara, and Daniel Soudry. Train longer, generalize better: closing the generalization gap in large batch training of neural networks. arXiv preprint arXiv:1705.08741, 2017.
+
+Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In-datacenter performance analysis of a tensor processing unit. In Proceedings of the 44th Annual International Symposium on Computer Architecture, pp. 1–12. ACM, 2017.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv preprint arXiv:1404.5997, 2014.
+
+Qianxiao Li, Cheng Tai, and E Weinan. Stochastic modified equations and adaptive stochastic gradient algorithms. arXiv preprint arXiv:1511.06251, 2017.
+
+Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with restarts. arXiv preprint arXiv:1608.03983, 2016.
+
+Stephan Mandt, Matthew D Hoffman, and David M Blei. Stochastic gradient descent as approximate bayesian inference. arXiv preprint arXiv:1704.04289, 2017.
+
+James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International Conference on Machine Learning, pp. 2408–2417, 2015.
+
+Yurii Nesterov. A method of solving a convex programming problem with convergence rate o (1/k2). In Soviet Mathematics Doklady, volume 27, pp. 372–376, 1983.
+
+Lutz Prechelt. Early stopping-but when? Neural Networks: Tricks of the trade, pp. 553–553, 1998.
+
+Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011.
+
+Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951.
+
+Samuel L. Smith and Quoc V. Le. A bayesian perspective on generalization and stochastic gradient descent. arXiv preprint arXiv:1710.06451, 2017.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, Inception-ResNet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017.
+
+Max Welling and Yee W Teh. Bayesian learning via stochastic gradient langevin dynamics. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 681–688, 2011.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. arXiv preprint arXiv:1705.08292, 2017.
+
+Yang You, Igor Gitman, and Boris Ginsburg. Scaling SGD batch size to 32k for imagenet training. arXiv preprint arXiv:1708.03888, 2017a.
+
+Yang You, Zhao Zhang, C Hsieh, James Demmel, and Kurt Keutzer. Imagenet training in minutes. CoRR, abs/1709.05011, 2017b.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+# A THE GROWTH OF THE ACCUMULATION AT THE START OF TRAINING
+
+The update equations for SGD with momentum,
+
+$$
+\begin{array} { r c l } { { \Delta A } } & { { = } } & { { \displaystyle - ( 1 - m ) A + \frac { d \hat { C } } { d \omega } , } } \\ { { \Delta \omega } } & { { = } } & { { \displaystyle - A \epsilon . } } \end{array}
+$$
+
+$A$ is the “accumulation” variable, whil e dCˆdω is the mean gradient per training example, estimated on a batch of size $B$ . We initialize the accumulation to zero, and it takes a number of updates for the magnitude of the accumulation to “grow in”. During this time, the size of the parameter updates $\Delta \omega$ is suppressed, reducing the effective learning rate. We can model the growth of the accumulation by assuming that the gradient at the start of training is approximately constant, such that $\begin{array} { r } { \frac { d \hat { C } } { d \omega } \approx G } \end{array}$ . Consequently the accumulation integrates an underlying differential equation,
+
+$$
+\frac { d A } { d s } = - ( 1 - m ) A + G .
+$$
+
+The variable tial equation $s$ describes thas solution, ates performed.. We note that $A ( 0 ) = 0$ s differen-to obtain, $\begin{array} { r } { A = \frac { G } { 1 - m } ( \bar { 1 } - e ^ { - ( 1 - m \bar { ) } s } ) } \end{array}$ $s = ( N / B ) N _ { e p o c h s }$
+
+$$
+A = \frac { G } { 1 - m } \left( 1 - e ^ { - ( 1 - m ) ( N / B ) N _ { e p o c h s } } \right) .
+$$
+
+$N _ { e p o c h s }$ denotes the number of training epochs performed. The accumulation variable grows in exponentially, and consequently we can estimate the effective number of “lost” training epochs,
+
+$$
+\begin{array} { l l l } { { N _ { l o s t } } } & { { = } } & { { \displaystyle \int _ { 0 } ^ { \infty } e ^ { - ( 1 - m ) ( N / B ) N _ { e p o c h s } } d N _ { e p o c h s } } } \\ { { } } & { { = } } & { { \displaystyle \frac { B } { N ( 1 - m ) } } } \end{array}
+$$
+
+Since the batch size $B \propto \epsilon / ( 1 - m )$ , we find $N _ { l o s t } \propto \epsilon / ( N ( 1 - m ) ^ { 2 } )$ . We must either introduce additional training epochs to compensate, or ensure that the number of lost training epochs is negligible, when compared to the total number of training epochs performed before the decaying the noise scale. Note that $N _ { l o s t }$ rises most rapidly when one increases the momentum coefficient.
+
+# B INCREASING THE INITIAL LEARNING RATE
+
+We exhibit the test accuracy of our “16-4” wide ResNet implementation on CIFAR10 in figure 8, as a function of the initial learning rate. For learning rate $\epsilon = 0 . 1$ , the batch size $B = 1 2 8$ is constant throughout training. This matches the “Original training schedule” of section 5.2 of the main text. When we increase the learning rate we scale $B \propto \epsilon$ and perform the same number of training epochs.
+
+![](images/9e086cf53c37c244b47c6603c379a2f2d2d15c0ec310600622b1d600f9e73651.jpg)
+
+Figure 8: Wide ResNet on CIFAR10. We can only increase the initial learning rate to $\sim 0 . 4$ before the final test accuracy starts to fall. Each point provided represents the median of five runs.

parse/train/B1Yy1BxCZ/B1Yy1BxCZ_content_list.json

@@ -0,0 +1,1253 @@
+[
+    {
+        "type": "text",
+        "text": "DON’T DECAY THE LEARNING RATE, INCREASE THE BATCH SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            624,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Samuel L. Smith∗, Pieter-Jan Kindermans∗, Chris Ying & Quoc V. Le Google Brain {slsmith, pikinder, chrisying, qvl}@google.com ",
+        "bbox": [
+            183,
+            170,
+            661,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is common practice to decay the learning rate. Here we show one can usually obtain the same learning curve on both training and test sets by instead increasing the batch size during training. This procedure is successful for stochastic gradient descent (SGD), SGD with momentum, Nesterov momentum, and Adam. It reaches equivalent test accuracies after the same number of training epochs, but with fewer parameter updates, leading to greater parallelism and shorter training times. We can further reduce the number of parameter updates by increasing the learning rate $\\epsilon$ and scaling the batch size $B \\propto \\epsilon$ . Finally, one can increase the momentum coefficient $m$ and scale $B \\propto 1 / ( 1 - m )$ , although this tends to slightly reduce the test accuracy. Crucially, our techniques allow us to repurpose existing training schedules for large batch training with no hyper-parameter tuning. We train ResNet-50 on ImageNet to $7 6 . 1 \\%$ validation accuracy in under 30 minutes. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            472,
+            336,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic gradient descent (SGD) remains the dominant optimization algorithm of deep learning. However while SGD finds minima that generalize well (Zhang et al., 2016; Wilson et al., 2017), each parameter update only takes a small step towards the objective. Increasing interest has focused on large batch training (Goyal et al., 2017; Hoffer et al., 2017; You et al., 2017a), in an attempt to increase the step size and reduce the number of parameter updates required to train a model. Large batches can be parallelized across many machines, reducing training time. Unfortunately, when we increase the batch size the test set accuracy often falls (Keskar et al., 2016; Goyal et al., 2017). ",
+        "bbox": [
+            174,
+            502,
+            825,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To understand this surprising observation, Smith & Le (2017) argued one should interpret SGD as integrating a stochastic differential equation. They showed that the scale of random fluctuations in the SGD dynamics, $\\begin{array} { r } { g = \\epsilon ( \\frac { N } { B } - 1 ) } \\end{array}$ , where $\\epsilon$ is the learning rate, $N$ training set size and $B$ batch size. Furthermore, they found that there is an optimum fluctuation scale $g$ which maximizes the test set accuracy (at constant learning rate), and this introduces an optimal batch size proportional to the learning rate when $B \\ll N$ . Goyal et al. (2017) already observed this scaling rule empirically and exploited it to train ResNet-50 to $7 6 . 3 \\%$ ImageNet validation accuracy in one hour. Here we show, ",
+        "bbox": [
+            174,
+            607,
+            825,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When one decays the learning rate, one simultaneously decays the scale of random fluctuations $g$ in the SGD dynamics. Decaying the learning rate is simulated annealing. We propose an alternative procedure; instead of decaying the learning rate, we increase the batch size during training. This strategy achieves near-identical model performance on the test set with the same number of training epochs but significantly fewer parameter updates. Our proposal does not require any fine-tuning as we follow pre-existing training schedules; when the learning rate drops by a factor of $\\alpha$ , we instead increase the batch size by $\\alpha$ . • As shown previously, we can further reduce the number of parameter updates by increasing the learning rate and scaling $B \\propto \\epsilon$ . One can also increase the momentum coefficient and scale $B \\propto \\mathrm { \\bar { 1 } } / ( 1 - m )$ , although this slightly reduces the test accuracy. We train InceptionResNet-V2 on ImageNet in under 2500 parameter updates, using batches of 65536 images, and reach a validation set accuracy of $7 7 \\%$ . We also replicate the setup of Goyal et al. (2017) on TPU and train ResNet-50 on ImageNet to $7 6 . 1 \\%$ accuracy in under 30 minutes. ",
+        "bbox": [
+            215,
+            717,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We note that a number of recent works have discussed increasing the batch size during training (Friedlander & Schmidt, 2012; Byrd et al., 2012; Balles et al., 2016; Bottou et al., 2016; De et al., 2017), but to our knowledge no paper has shown empirically that increasing the batch size and decaying the learning rate are quantitatively equivalent. A key contribution of our work is to demonstrate that decaying learning rate schedules can be directly converted into increasing batch size schedules, and vice versa; providing a straightforward pathway towards large batch training. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In section 2 we discuss the convergence criteria for SGD in strongly convex minima, in section 3 we interpret decaying learning rates as simulated annealing, and in section 4 we discuss the difficulties of training with large momentum coefficients. Finally in section 5 we present conclusive experimental evidence that the empirical benefits of decaying learning rates in deep learning can be obtained by instead increasing the batch size during training. We exploit this observation and other tricks to achieve efficient large batch training on CIFAR-10 and ImageNet. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 STOCHASTIC GRADIENT DESCENT AND CONVEX OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            732,
+            314
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SGD is a computationally-efficient alternative to full-batch training, but it introduces noise into the gradient, which can obstruct optimization. It is often stated that to reach the minimum of a strongly convex function we should decay the learning rate, such that (Robbins & Monro, 1951): ",
+        "bbox": [
+            174,
+            329,
+            825,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a145d1c632879dca4c6839a4a349ceb29332416420eb03277f7e2c705110957.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\sum _ { i = 1 } ^ { \\infty } \\epsilon _ { i } = \\infty } , \\ ~ } \\\\ { { \\displaystyle \\sum _ { i = 1 } ^ { \\infty } \\epsilon _ { i } ^ { 2 } < \\infty } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            470,
+            376,
+            557,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$\\epsilon _ { i }$ denotes the learning rate at the $i ^ { t h }$ gradient update. Intuitively, equation 1 ensures we can reach the minimum, no matter how far away our parameters are initialized, while equation 2 ensures that the learning rate decays sufficiently quickly that we converge to the minimum, rather than bouncing around it due to gradient noise (Welling & Teh, 2011). However, although these equations appear to imply that the learning rate must decay during training, equation 2 holds only if the batch size is constant.1 To consider how to proceed when the batch size can vary, we follow recent work by Smith & Le (2017) and interpret SGD as integrating the stochastic differential equation below, ",
+        "bbox": [
+            173,
+            465,
+            825,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d91550ac72560fadf01037568a99e7979516dd1f47ff2ad57701938131d02281.jpg",
+        "text": "$$\n\\frac { d \\omega } { d t } = - \\frac { d C } { d \\omega } + \\eta ( t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            569,
+            566,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$C$ represents the cost function (summed over all training examples), and $\\omega$ represents the parameters, which evolve in continuous “time” $t$ towards their final values. Meanwhile $\\eta ( t )$ represents Gaussian random noise, which models the consequences of estimating the gradient on a mini-batch. They showed that the mean $\\langle \\eta ( t ) \\rangle = 0$ and variance $\\langle \\eta ( t ) \\eta ( t ^ { \\prime } ) \\rangle = \\bar { g } F ( \\omega \\bar { ) } \\delta ( t - t ^ { \\prime } )$ , where $F ( \\omega )$ describes the covariances in gradient fluctuations between different parameters. They also proved that the “noise scale” $g = \\check { \\epsilon } ( \\frac { N } { B } - 1 )$ , where $\\epsilon$ is the learning rate, $N$ the training set size and $B$ the batch size. This noise scale controls the magnitude of the random fluctuations in the training dynamics. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            703
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Usually $B \\ll N$ , and so we may approximate $g \\approx \\epsilon N / B$ . When we decay the learning rate, the noise scale falls, enabling us to converge to the minimum of the cost function (this is the origin of equation 2 above). However we can achieve the same reduction in noise scale at constant learning rate by increasing the batch size. The main contribution of this work is to show that it is possible to make efficient use of vast training batches, if one increases the batch size during training at constant learning rate until $B \\sim N / 1 0$ . After this point, we revert to the use of decaying learning rates. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 SIMULATED ANNEALING AND THE GENERALIZATION GAP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            683,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To the surprise of many researchers, it is now increasingly accepted that small batch training often generalizes better to the test set than large batch training. This “generalization gap” was explored extensively by Keskar et al. (2016). Smith & Le (2017) observed an optimal batch size $B _ { o p t }$ which maximized the test set accuracy at constant learning rate. They argued that this optimal batch size arises when the noise scale $g \\approx \\epsilon N / B$ is also optimal, and supported this claim by demonstrating empirically that $B _ { o p t } \\propto \\epsilon N$ . Earlier, Goyal et al. (2017) exploited a linear scaling rule between batch size and learning rate to train ResNet-50 on ImageNet in one hour with batches of 8192 images. ",
+        "bbox": [
+            176,
+            843,
+            825,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These results indicate that gradient noise can be beneficial, especially in non-convex optimization. It has been proposed that noise helps SGD escape “sharp minima” which generalize poorly (Hochreiter & Schmidhuber, 1997; Chaudhari et al., 2016; Keskar et al., 2016; Smith & Le, 2017). Given these results, it is unclear to the present authors whether equations 1 and 2 are relevant in deep learning. Supporting this view, we note that most researchers employ early stopping (Prechelt, 1998), whereby we intentionally prevent the network from reaching a minimum. Nonetheless, decaying learning rates are empirically successful. To understand this, we note that introducing random fluctuations whose scale falls during training is also a well established technique in non-convex optimization; simulated annealing. The initial noisy optimization phase allows us to explore a larger fraction of the parameter space without becoming trapped in local minima. Once we have located a promising region of parameter space, we reduce the noise to fine-tune the parameters. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we note that this interpretation may explain why conventional learning rate decay schedules like square roots or exponential decay have become less popular in deep learning in recent years. Increasingly, researchers favor sharper decay schedules like cosine decay (Loshchilov & Hutter, 2016) or step-function drops (Zagoruyko & Komodakis, 2016). To interpret this shift, we note that it is well known in the physical sciences that slowly annealing the temperature (noise scale) helps the system to converge to the global minimum, which may be sharp. Meanwhile annealing the temperature in a series of discrete steps can trap the system in a “robust” minimum whose cost may be higher but whose curvature is lower. We suspect a similar intuition may hold in deep learning. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 THE EFFECTIVE LEARNING RATE AND THE ACCUMULATION VARIABLE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            444,
+            787,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Many researchers no longer use vanilla SGD, instead preferring SGD with momentum. Smith & Le (2017) extended their analysis of SGD to include momentum, and found that the “noise scale”, ",
+        "bbox": [
+            173,
+            473,
+            828,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2061980b80c73a23788c4f0f052e50021e305a8ac873908583a5cb527323aed6.jpg",
+        "text": "$$\n\\begin{array} { l c l } { { g } } & { { = } } & { { \\displaystyle \\frac { \\epsilon } { 1 - m } \\left( \\frac { N } { B } - 1 \\right) } } \\\\ { { } } & { { \\approx } } & { { \\displaystyle \\frac { \\epsilon N } { B ( 1 - m ) } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            502,
+            586,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This reduces to the noise scale of vanilla SGD when the momentum coefficient $m  0$ . Intuitively, $\\epsilon _ { e f f } = \\epsilon / ( 1 - m )$ is the effective learning rate. They proposed to reduce the number of parameter updates required to train a model by increasing the learning rate and momentum coefficient, while simultaneously scaling $B \\propto \\epsilon / ( 1 - \\dot { m } )$ . We find that increasing the learning rate and scaling $B \\propto \\epsilon$ performs well. However increasing the momentum coefficient while scaling $B \\propto 1 / ( 1 { - } m )$ slightly reduces the test accuracy. To analyze this observation, consider the momentum update equations, ",
+        "bbox": [
+            173,
+            570,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a82d02789a4ef4e5423827702a331dc2372175e209b339b5a0222cc40f8f3c3d.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\Delta A } } & { { = } } & { { \\displaystyle - ( 1 - m ) A + \\frac { d \\hat { C } } { d \\omega } , } } \\\\ { { \\Delta \\omega } } & { { = } } & { { \\displaystyle - A \\epsilon . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            655,
+            598,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$A$ is the “accumulation”, while $\\textstyle { \\frac { d { \\hat { C } } } { d \\omega } }$ is the mean gradient per training example, estimated on a batch of size $B$ . In Appendix A we analyze the growth of the accumulation at the start of training. This variable tracks the exponentially decaying average of gradient estimates, but initially it is initialized to zero. We find that the accumulation grows in exponentially towards its steady state value over a “timescale” of approximately $B / ( N ( 1 - m ) )$ training epochs. During this time, the magnitude of the parameter updates $\\Delta \\omega$ is suppressed, reducing the rate of convergence. Consequently when training at high momentum one must introduce additional epochs to allow the dynamics to catch up. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, when we increase the momentum coefficient we increase the timescale required for the accumulation to forget old gradients (this timescale is also $\\sim B / ( N ( 1 - m ) ) )$ . Once this timescale becomes several epochs long, the accumulation cannot adapt to changes in the loss landscape, impeding training. This is likely to be particularly problematic at points where the noise scale decays. Kingma & Ba (2014) proposed initialization bias correction, whereby the learning rate is increased at early times to compensate the suppressed initial value of the accumulation. However when the batch size is large, we found that this often causes instabilities during the early stages of training. We note that Goyal et al. (2017) recommended a reduced learning rate for the first few epochs. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d73e9d1b93ba4ecd119509faab8c9b7cdeaf08ddb27d075ef3af2902d684bb22.jpg",
+        "image_caption": [
+            "Figure 1: Schedules for the learning rate (a) and batch size (b), as a function of training epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            116,
+            807,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            326,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In section 5.1, we demonstrate that decreasing the learning rate and increasing the batch size during training are equivalent. In section 5.2, we show we can further reduce the number of parameter updates by increasing the effective learning rate and scaling the batch size. In section 5.3 we apply our insights to train Inception-ResNet-V2 on ImageNet, using vast batches of up to 65536 images. Finally in section 5.4, we train ResNet-50 to $7 6 . 1 \\%$ ImageNet validation accuracy within 30 minutes. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.1 SIMULATED ANNEALING IN A WIDE RESNET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            524,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our first experiments are performed on CIFAR-10, using a “16-4” wide ResNet architecture, following the implementation of Zagoruyko & Komodakis (2016). We use ghost batch norm (Hoffer et al., 2017), with a ghost batch size of 128. This ensures the mean gradient is independent of batch size, as required by the analysis of Smith & Le (2017). To demonstrate the equivalence between decreasing the learning rate and increasing the batch size, we consider three different training schedules, as shown in figure 1. “Decaying learning rate” follows the original implementation; the batch size is constant, while the learning rate repeatedly decays by a factor of 5 at a sequence of “steps”. “Hybrid” holds the learning rate constant at the first step, instead increasing the batch size by a factor of 5. However after this first step, the batch size is constant and the learning rate decays by a factor of 5 at each subsequent step. This schedule mimics how one might proceed if hardware imposes a limit on the maximum achievable batch size. In “Increasing batch size”, we hold the learning rate constant throughout training, and increase the batch size by a factor of 5 at every step. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/10712532c719889b00b97e1900e4a985e7027240568ad59f36fa0e9db74b3ab5.jpg",
+        "image_caption": [
+            "Figure 2: Wide ResNet on CIFAR10. Training set cross-entropy, evaluated as a function of the number of training epochs (a), or the number of parameter updates (b). The three learning curves are identical, but increasing the batch size reduces the number of parameter updates required. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            686,
+            805,
+            867
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/bce387343d0b4db0706d44ce469bbda419b4177e4c1bc6cbf7ab713d9de09ad9.jpg",
+        "image_caption": [
+            "Figure 3: Wide ResNet on CIFAR10. Test accuracy during training, for SGD with momentum (a), and Nesterov momentum (b). In both cases, all three schedules track each other extremely closely. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            118,
+            805,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If the learning rate itself must decay during training, then these schedules should show different learning curves (as a function of the number of training epochs) and reach different final test set accuracies. Meanwhile if it is the noise scale which should decay, all three schedules should be indistinguishable. We plot the evolution of the training set cross entropy in figure 2a, where we train using SGD with momentum and a momentum parameter of 0.9. The three training curves are almost identical, despite showing marked drops as we pass through the first two steps (where the noise scale is reduced). These results suggest that it is the noise scale which is relevant, not the learning rate. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To emphasize the potential benefits of increasing the batch size, we replot the training cross-entropy in figure 2b, but as a function of the number of parameter updates rather than the number of epochs. While all three schedules match up to the first “step”, after this point increasing the batch size dramatically reduces the number of parameter updates required to train the model. Finally, to confirm that our alternative learning schedules generalize equally well to the test set, in figure 3a we exhibit the test set accuracy, as a function of the number of epochs (so each curve can be directly compared). Once again, the three schedules are almost identical. We conclude that we can achieve all of the benefits of decaying the learning rate in these experiments by instead increasing the batch size. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We present additional results to establish that our proposal holds for a range of optimizers, all using the schedules presented in figure 1. In figure 3b, we present the test set accuracy, when training with Nesterov momentum (Nesterov, 1983) and momentum parameter 0.9, observing three nearidentical curves. In figure 4a, we repeat the same experiment with vanilla SGD, again obtaining three highly similar curves (In this case, there is no clear benefit of decaying the learning rate after the first step). Finally in figure 4b we repeat the experiment with Adam (Kingma & Ba, 2014). We use the default parameter settings of TensorFlow, such that the initial base learning rate here was $1 0 ^ { - 3 }$ , $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9 9$ . Thus the learning rate schedule is obtained by dividing figure 1a by $1 0 ^ { - 2 }$ . Remarkably, even here the three curves closely track each other. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a3acd8374c49c6588ad4299f4f686aea4cd7e6380eeafef62505f220d4db08d.jpg",
+        "image_caption": [
+            "Figure 4: Wide ResNet on CIFAR10. The test set accuracy during training, for vanilla SGD (a) and Adam (b). Once again, all three schedules result in equivalent test set performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            707,
+            805,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c64a2841b91e74b589c9428e7b9c5d898581eba4bce547a7d1df97c63fe6ca1b.jpg",
+        "image_caption": [
+            "Figure 5: Wide ResNet on CIFAR10. Test accuracy as a function of the number of parameter updates. “Increasing batch size” replaces learning rate decay by batch size increases. “Increased initial learning rate” additionally increases the initial learning rate from 0.1 to 0.5. Finally “Increased momentum coefficient” also increases the momentum coefficient from 0.9 to 0.98. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            98,
+            686,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            405,
+            825,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 INCREASING THE EFFECTIVE LEARNING RATE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            467,
+            529,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now focus on our secondary objective; minimizing the number of parameter updates required to train a model. As shown above, the first step is to replace decaying learning rates by increasing batch sizes. We show here that we can also increase the effective learning rate $\\epsilon _ { e f f } = \\dot { \\epsilon } / ( 1 - m \\bar { ) }$ at the start of training, while scaling the initial batch size $B \\propto \\epsilon _ { e f f }$ . All experiments are conducted using SGD with momentum. There are 50000 images in the CIFAR-10 training set, and since the scaling rules only hold when $B \\ll N$ , we decided to set a maximum batch size $B _ { m a x } = 5 1 2 0$ . ",
+        "bbox": [
+            174,
+            492,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider four training schedules, all of which decay the noise scale by a factor of five in a series of three steps. “Original training schedule” follows the implementation of Zagoruyko & Komodakis (2016), using an initial learning rate of 0.1 which decays by a factor of 5 at each step, a momentum coefficient of 0.9, and a batch size of 128. “Increasing batch size” also uses a learning rate of 0.1, initial batch size of 128 and momentum coefficient of 0.9, but the batch size increases by a factor of 5 at each step. These schedules are identical to “Decaying learning rate” and “Increasing batch size” in section 5.1 above. “Increased initial learning rate” also uses increasing batch sizes during training, but additionally uses an initial learning rate of 0.5 and an initial batch size of 640. Finally “Increased momentum coefficient” combines increasing batch sizes during training and the increased initial learning rate of 0.5, with an increased momentum coefficient of 0.98, and an initial batch size of 3200. Note that we only increase the batch size until it reaches $B _ { m a x }$ , after this point we achieve subsequent decays in noise scale by decreasing the learning rate. We emphasize that, as in the previous section, all four schedules require the same number of training epochs. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We plot the evolution of the test set accuracy in figure 5, as a function of the number of parameter updates. Our implementation of the original training schedule requires ${ \\sim } 8 0 0 0 0$ updates, and reaches a final test accuracy of $9 4 . 3 \\%$ (the original paper reports $9 5 \\%$ accuracy, which we have not been able to replicate). “Increasing batch size” requires ${ \\sim } 2 9 0 0 0$ updates, reaching a final accuracy of $9 4 . 4 \\%$ . “Increased initial learning rate” requires under 6500 updates, reaching a final accuracy of $9 4 . 5 \\%$ . Finally, “Increased momentum coefficient” requires less than 2500 parameter updates, but reaches a lower test accuracy of $9 3 . 3 \\%$ . Across five additional training runs for each schedule, the median accuracies were $9 4 . { \\dot { 3 } } \\%$ , $9 4 . 2 \\%$ , $9 4 . 2 \\%$ and $9 3 . 5 \\%$ respectively. We discussed a potential explanation for the performance drop when training with large momentum coefficients in section 4. We provide additional results in appendix B, varying the initial learning rate between 0.1 and 3.2 while holding the batch size constant. We find that the test accuracy falls for initial learning rates larger than ${ \\sim } 0 . 4$ . ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb239d8eb35e89fd6feec9cab05500db53c771189fe3662bafbba1dd4318c3fa.jpg",
+        "image_caption": [
+            "Figure 6: Inception-ResNet-V2 on ImageNet. Increasing the batch size during training achieves similar results to decaying the learning rate, but it reduces the number of parameter updates from just over 14000 to below 6000. We run each experiment twice to illustrate the variance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            112,
+            805,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 TRAINING IMAGENET IN 2500 PARAMETER UPDATES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            400,
+            583,
+            414
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now apply our insights to reduce the number of parameter updates required to train ImageNet. Goyal et al. (2017) trained a ResNet-50 on ImageNet in one hour, reaching $7 6 . 3 \\%$ validation accuracy. To achieve this, they used batches of 8192, with an initial learning rate of 3.2 and a momentum coefficient of 0.9. They completed 90 training epochs, decaying the learning rate by a factor of ten at the 30th, 60th and 80th epoch. ImageNet contains around 1.28 million images, so this corresponds to ${ \\sim } 1 4 0 0 0$ parameter updates. They also introduced a warm-up phase at the start of training, in which the learning rate and batch size was gradually increased. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also train for 90 epochs and follow the same schedule, decaying the noise scale by a factor of ten at the 30th, 60th and 80th epoch. However we did not include a warm-up phase. To set a stronger baseline, we replaced ResNet-50 by Inception-ResNet-V2 (Szegedy et al., 2017). Initially we used a ghost batch size of 32. In figure 6, we train with a learning rate of 3.0 and a momentum coefficient of 0.9. The initial batch size was 8192. For “Decaying learning rate”, we hold the batch size fixed and decay the learning rate, while in “Increasing batch size” we increase the batch size to 81920 at the first step, but decay the learning rate at the following two steps. We repeat each schedule twice, and find that all four runs exhibit a very similar evolution of the test set accuracy during training. The final accuracies of the two “Decaying learning rate” runs are $7 8 . 7 \\%$ and $7 7 . 8 \\%$ , while the final accuracy of the two “Increasing batch size” runs are $7 8 . 1 \\%$ and $7 6 . 8 \\%$ . Although there is a slight drop, the difference in final test accuracies is similar to the variance between training runs. Increasing the batch size reduces the number of parameter updates during training from just over 14000 to below 6000. Note that the training curves appear unusually noisy because we reduced the number of test set evaluations to reduce the model training time. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Goyal et al. (2017) already increased the learning rate close to its maximum stable value. To further reduce the number of parameter updates we must increase the momentum coefficient. We introduce a maximum batch size, $B _ { m a x } = \\dot { 2 } ^ { 1 6 } = 6 5 5 3 6$ . This ensures $B \\ll N$ , and it also improved the stability of our distributed training. We also increased the ghost batch size to 64, matching the batch size of our GPUs and reducing the training time. We compare three different schedules, all of which have the same base schedule, decaying the noise scale by a factor of ten at the 30th, 60th and 80th epoch. We use an initial learning rate of 3 throughout. “Momentum $0 . 9 ^ { \\ast }$ uses an initial batch size of 8192, “Momentum $0 . 9 7 5 ^ { \\cdot }$ uses an initial batch size of 16384, and “Momentum $0 . 9 8 7 5 '$ uses an initial batch size of 32768. For all schedules, we decay the noise scale by increasing the batch size until reaching $B _ { m a x }$ , and then decay the learning rate. We plot the test set accuracy in figure 7. “Momentum $0 . 9 ^ { \\prime }$ achieves a final accuracy of $7 8 . 8 \\%$ in just under 6000 updates. We performed two runs of “Momentum $0 . 9 5 '$ , achieving final accuracies of $7 8 . 1 \\%$ and $7 7 . { \\bar { 8 \\% } }$ in under 3500 updates. Finally “Momentum $0 . 9 7 5 ^ { \\cdot }$ achieves final accuracies of $7 7 . 5 \\%$ and $7 6 . 8 \\%$ in under 2500 updates. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad6507b3ef16598af644328b400200847039dd87899409b9b70d11fb2ff2895c.jpg",
+        "image_caption": [
+            "Figure 7: Inception-ResNet-V2 on ImageNet. Increasing the momentum parameter reduces the number of parameter updates required, but it also leads to a small drop in final test accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            107,
+            802,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 TRAINING IMAGENET IN 30 MINUTES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            475,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To confirm that increasing the batch size during training can reduce model training times, we replicated the set-up described by Goyal et al. (2017) on a half TPU pod, comprising 256 tensorcores (Jouppi et al., 2017). Using tensorFlow, we first train ResNet-50 for 90 epochs to $7 6 . 1 \\%$ validation set accuracy in under 45 minutes, utilising batches of 8192 images. To utilise the full TPU pod, we then increase the batch size after the first 30 epochs to 16384 images, and achieve the same validation accuracy of $7 6 . 1 \\%$ in under 30 minutes. The last 60 epochs and the first 30 epochs both take just under 15 minutes, demonstrating near-perfect scaling efficiency across the pod, such that the number of parameter updates provides a meaningful measure of the training time. To our knowledge, this is the first procedure which has reduced the training time of Goyal et al. (2017) without sacrificing final validation accuracy (You et al., 2017b; Akiba et al., 2017). By contrast, doubling the initial learning rate and using batches of 16384 images throughout training achieves a lower validation set accuracy of $7 5 . 0 \\%$ in 22 minutes, demonstrating that increasing the batch size during training is crucial to the performance gains above. These results show that the ideas presented in this paper will become increasingly important as new hardware for large-batch training becomes available. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            577
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            341,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper extends the analysis of SGD in Smith & Le (2017) to include decaying learning rates. Mandt et al. (2017) also interpreted SGD as a stochastic differential equation, in order to discuss how SGD could be modified to perform approximate Bayesian posterior sampling. However they state that their analysis holds only in the neighborhood of a minimum, while Keskar et al. (2016) showed that the beneficial effects of noise are most pronounced at the start of training. Li et al. (2017) proposed the use of control theory to set the learning rate and momentum coefficient. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Goyal et al. (2017) observed a linear scaling rule between batch size and learning rate, $B \\propto \\epsilon$ and used this rule to reduce the time required to train ResNet-50 on ImageNet to one hour. To our knowledge, this scaling rule was fist adopted by Krizhevsky (2014). Bottou et al. (2016) (section 4.2) demonstrated that SGD converges to strongly convex minima in similar numbers of training√ epochs if $B \\propto \\epsilon$ . Hoffer et al. (2017) proposed an alternative scaling rule, $B \\propto \\sqrt { \\epsilon }$ . ",
+        "bbox": [
+            174,
+            722,
+            823,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "You et al. (2017a) proposed Layer-wise Adaptive Rate Scaling (LARS), which applies different learning rates to different parameters in the network, and used it to train ImageNet in 14 minutes (You et al., 2017b), albeit to a lower final accuracy of $7 4 . 9 \\%$ . K-FAC (Martens & Grosse, 2015) is also gaining popularity as an efficient alternative to SGD. Wilson et al. (2017) argued that adaptive optimization methods tend to generalize less well than SGD and SGD with momentum (although they did not include K-FAC in their study), while our work reduces the gap in convergence speed. Asynchronous-SGD is another popular strategy, which enables the use of multiple GPUs even when batch sizes are small (Recht et al., 2011; Dean et al., 2012). We do not consider asynchronous-SGD in this work, since the scaling rules enabled us to use batch sizes on the order of the training set size. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            328,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We can often achieve the benefits of decaying the learning rate by instead increasing the batch size during training. We support this claim with experiments on CIFAR-10 and ImageNet, and with a range of optimizers including SGD, Momentum and Adam. Our findings enable the efficient use of vast batch sizes, significantly reducing the number of parameter updates required to train a model. This has the potential to dramatically reduce model training times. We further increase the batch size $B$ by increasing the learning rate $\\epsilon$ and momentum parameter $m$ , while scaling $B \\propto \\epsilon / ( 1 - m )$ . Combining these strategies, we train Inception-ResNet-V2 on ImageNet to $7 7 \\%$ validation accuracy in under 2500 parameter updates, using batches of 65536 images. We also exploit increasing batch sizes to train ResNet-50 to $7 6 . 1 \\%$ ImageNet validation set accuracy on TPU in under 30 minutes. Most strikingly, we achieve this without any hyper-parameter tuning, since our scaling rules enable us to directly convert existing hyper-parameter choices from the literature for large batch training. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            326,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Prajit Ramachandran, Gabriel Bender, Matthew Johnson and Martin Abadi for helpful discussions. We also thank Vijay Vasudevan, Brennan Saeta, Jonathan Hseu, Bjarke Roune and the rest of the TPU team for technical support. ",
+        "bbox": [
+            176,
+            328,
+            823,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            393,
+            285,
+            407
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takuya Akiba, Shuji Suzuki, and Keisuke Fukuda. Extremely large minibatch sgd: Training resnet50 on imagenet in 15 minutes. arXiv preprint arXiv:1711.04325, 2017. ",
+        "bbox": [
+            174,
+            416,
+            821,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lukas Balles, Javier Romero, and Philipp Hennig. Coupling adaptive batch sizes with learning rates. arXiv preprint arXiv:1612.05086, 2016. ",
+        "bbox": [
+            173,
+            455,
+            821,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou, Frank E Curtis, and Jorge Nocedal. Optimization methods for large-scale machine ´ learning. arXiv preprint arXiv:1606.04838, 2016. ",
+        "bbox": [
+            174,
+            494,
+            821,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Richard H Byrd, Gillian M Chin, Jorge Nocedal, and Yuchen Wu. Sample size selection in optimization methods for machine learning. Mathematical programming, 134(1):127–155, 2012. ",
+        "bbox": [
+            173,
+            535,
+            821,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pratik Chaudhari, Anna Choromanska, Stefano Soatto, and Yann LeCun. Entropy-SGD: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016. ",
+        "bbox": [
+            173,
+            575,
+            823,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Soham De, Abhay Yadav, David Jacobs, and Tom Goldstein. Automated inference with adaptive batches. In Artificial Intelligence and Statistics, pp. 1504–1513, 2017. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012. ",
+        "bbox": [
+            176,
+            654,
+            823,
+            698
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael P Friedlander and Mark Schmidt. Hybrid deterministic-stochastic methods for data fitting. SIAM Journal on Scientific Computing, 34(3):A1380–A1405, 2012. ",
+        "bbox": [
+            174,
+            708,
+            821,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            176,
+            748,
+            821,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            173,
+            801,
+            797,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Elad Hoffer, Itay Hubara, and Daniel Soudry. Train longer, generalize better: closing the generalization gap in large batch training of neural networks. arXiv preprint arXiv:1705.08741, 2017. ",
+        "bbox": [
+            171,
+            828,
+            821,
+            857
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In-datacenter performance analysis of a tensor processing unit. In Proceedings of the 44th Annual International Symposium on Computer Architecture, pp. 1–12. ACM, 2017. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            157,
+            821,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv preprint arXiv:1404.5997, 2014. ",
+        "bbox": [
+            173,
+            198,
+            823,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qianxiao Li, Cheng Tai, and E Weinan. Stochastic modified equations and adaptive stochastic gradient algorithms. arXiv preprint arXiv:1511.06251, 2017. ",
+        "bbox": [
+            169,
+            238,
+            825,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with restarts. arXiv preprint arXiv:1608.03983, 2016. ",
+        "bbox": [
+            173,
+            279,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephan Mandt, Matthew D Hoffman, and David M Blei. Stochastic gradient descent as approximate bayesian inference. arXiv preprint arXiv:1704.04289, 2017. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International Conference on Machine Learning, pp. 2408–2417, 2015. ",
+        "bbox": [
+            171,
+            359,
+            823,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov. A method of solving a convex programming problem with convergence rate o (1/k2). In Soviet Mathematics Doklady, volume 27, pp. 372–376, 1983. ",
+        "bbox": [
+            173,
+            400,
+            820,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lutz Prechelt. Early stopping-but when? Neural Networks: Tricks of the trade, pp. 553–553, 1998. ",
+        "bbox": [
+            173,
+            440,
+            823,
+            457
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011. ",
+        "bbox": [
+            173,
+            467,
+            823,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951. ",
+        "bbox": [
+            173,
+            522,
+            821,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel L. Smith and Quoc V. Le. A bayesian perspective on generalization and stochastic gradient descent. arXiv preprint arXiv:1710.06451, 2017. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, Inception-ResNet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Welling and Yee W Teh. Bayesian learning via stochastic gradient langevin dynamics. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 681–688, 2011. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. arXiv preprint arXiv:1705.08292, 2017. ",
+        "bbox": [
+            174,
+            712,
+            826,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Igor Gitman, and Boris Ginsburg. Scaling SGD batch size to 32k for imagenet training. arXiv preprint arXiv:1708.03888, 2017a. ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Zhao Zhang, C Hsieh, James Demmel, and Kurt Keutzer. Imagenet training in minutes. CoRR, abs/1709.05011, 2017b. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            173,
+            887,
+            825,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A THE GROWTH OF THE ACCUMULATION AT THE START OF TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            102,
+            766,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The update equations for SGD with momentum, ",
+        "bbox": [
+            173,
+            133,
+            491,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f990ad3e1c255572f2f5f205f706a47f79b94f0b4f418e79d156af9957276871.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\Delta A } } & { { = } } & { { \\displaystyle - ( 1 - m ) A + \\frac { d \\hat { C } } { d \\omega } , } } \\\\ { { \\Delta \\omega } } & { { = } } & { { \\displaystyle - A \\epsilon . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            154,
+            599,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$A$ is the “accumulation” variable, whil e dCˆdω is the mean gradient per training example, estimated on a batch of size $B$ . We initialize the accumulation to zero, and it takes a number of updates for the magnitude of the accumulation to “grow in”. During this time, the size of the parameter updates $\\Delta \\omega$ is suppressed, reducing the effective learning rate. We can model the growth of the accumulation by assuming that the gradient at the start of training is approximately constant, such that $\\begin{array} { r } { \\frac { d \\hat { C } } { d \\omega } \\approx G } \\end{array}$ . Consequently the accumulation integrates an underlying differential equation, ",
+        "bbox": [
+            173,
+            212,
+            825,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/746a291308bfd44c2703dfdd1145472a95f001b8296927d820dd97582806c19d.jpg",
+        "text": "$$\n\\frac { d A } { d s } = - ( 1 - m ) A + G .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            308,
+            583,
+            339
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The variable tial equation $s$ describes thas solution, ates performed.. We note that $A ( 0 ) = 0$ s differen-to obtain, $\\begin{array} { r } { A = \\frac { G } { 1 - m } ( \\bar { 1 } - e ^ { - ( 1 - m \\bar { ) } s } ) } \\end{array}$ $s = ( N / B ) N _ { e p o c h s }$ ",
+        "bbox": [
+            174,
+            345,
+            825,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80897e34f0b3f9f2105038d84a34d54449a248fc88cb5ff74aa7ad0bbf2a168a.jpg",
+        "text": "$$\nA = \\frac { G } { 1 - m } \\left( 1 - e ^ { - ( 1 - m ) ( N / B ) N _ { e p o c h s } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            383,
+            640,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$N _ { e p o c h s }$ denotes the number of training epochs performed. The accumulation variable grows in exponentially, and consequently we can estimate the effective number of “lost” training epochs, ",
+        "bbox": [
+            174,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93f65e89d97fa83f8d9f3be27575103a93ac218d20fc98a18106e1e3bff6baaa.jpg",
+        "text": "$$\n\\begin{array} { l l l } { { N _ { l o s t } } } & { { = } } & { { \\displaystyle \\int _ { 0 } ^ { \\infty } e ^ { - ( 1 - m ) ( N / B ) N _ { e p o c h s } } d N _ { e p o c h s } } } \\\\ { { } } & { { = } } & { { \\displaystyle \\frac { B } { N ( 1 - m ) } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            452,
+            658,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Since the batch size $B \\propto \\epsilon / ( 1 - m )$ , we find $N _ { l o s t } \\propto \\epsilon / ( N ( 1 - m ) ^ { 2 } )$ . We must either introduce additional training epochs to compensate, or ensure that the number of lost training epochs is negligible, when compared to the total number of training epochs performed before the decaying the noise scale. Note that $N _ { l o s t }$ rises most rapidly when one increases the momentum coefficient. ",
+        "bbox": [
+            173,
+            526,
+            826,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B INCREASING THE INITIAL LEARNING RATE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            563,
+            621
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We exhibit the test accuracy of our “16-4” wide ResNet implementation on CIFAR10 in figure 8, as a function of the initial learning rate. For learning rate $\\epsilon = 0 . 1$ , the batch size $B = 1 2 8$ is constant throughout training. This matches the “Original training schedule” of section 5.2 of the main text. When we increase the learning rate we scale $B \\propto \\epsilon$ and perform the same number of training epochs. ",
+        "bbox": [
+            173,
+            635,
+            826,
+            693
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e086cf53c37c244b47c6603c379a2f2d2d15c0ec310600622b1d600f9e73651.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            352,
+            722,
+            643,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 8: Wide ResNet on CIFAR10. We can only increase the initial learning rate to $\\sim 0 . 4$ before the final test accuracy starts to fall. Each point provided represents the median of five runs. ",
+        "bbox": [
+            171,
+            892,
+            825,
+            921
+        ],
+        "page_idx": 10
+    }
+]

parse/train/BJe7h34YDS/BJe7h34YDS.md

@@ -0,0 +1,554 @@
+# UNDERSTANDING AND STABILIZING GANS’ TRAINING DYNAMICS WITH CONTROL THEORY
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative adversarial networks (GANs) have made significant progress on realistic image generation but often suffer from instability during the training process. Most previous analyses mainly focus on the equilibrium that GANs achieve, whereas a gap exists between such theoretical analyses and practical implementations, where it is the training dynamics that play a vital role in the convergence and stability of GANs. In this paper, we directly model the dynamics of GANs and adopt the control theory to understand and stabilize it. Specifically, we interpret the training process of various GANs as certain types of dynamics in a unified perspective of control theory, which enables us to model the stability and convergence easily. Borrowed from control theory, we adopt the widely-used negative feedback control to stabilize the training dynamics, which can be considered as an $L 2$ regularization on the output of the discriminator. We empirically verify our method on both synthetic data and natural image datasets. The results demonstrate that our method can efficiently stabilize the dynamics and converge to better results.
+
+# 1 INTRODUCTION
+
+Generative adversarial networks (GANs) (Goodfellow et al., 2014) have shown promise in generating realistic natural images (Brock et al., 2018) and facilitating unsupervised and semi-supervised learning (Chen et al., 2016; Li et al., 2017; Donahue & Simonyan, 2019). In GANs, an implicit generator $( G )$ is defined by mapping a noise distribution to the data space. Since no density function is defined for the implicit generator, a discriminator $( D )$ is introduced to estimate the density ratio between the data distribution $p _ { D }$ and the generating distribution $p _ { G }$ by telling the real samples from fake ones. $G$ aims to recover the data distribution by maximizing this ratio. This framework is formulated as a minimax optimization problem, which can be solved by optimizing $G$ and $D$ alternately. In practice, however, GANs can be extremely sensitive to hyperparameters (Lucic et al., 2018; Radford et al., 2015), and oscillations are often observed (Liang et al., 2018; Chavdarova & Fleuret, 2018), thereby suffering from the instability of training (Goodfellow, 2016).
+
+There are some theoretical analyses aiming to understand and stabilize the training process of GANs, such as designing different objective functions using other statistical divergences (Nowozin et al., 2016; Nguyen et al., 2017; Du et al., 2018; Mao et al., 2017), and introducing auxiliary regularization terms (Gulrajani et al., 2017; Arjovsky et al., 2017). However, there is a gap between the theoretical analyses and practical implementations: most of previous work assumes that (1) $D$ achieves optimal when training $G$ (Goodfellow et al., 2014; Arjovsky et al., 2017; Gulrajani et al., 2017; Nowozin et al., 2016); and (2) the optimal $D$ is a smooth function of $G$ (Metz et al., 2016). These two assumptions are violated in most practical cases. First, GANs are optimized by alternating between $k$ steps of optimizing $D$ and one step of optimizing $G$ , where $k$ generally takes 1 or 5. It results in a sub-optimal $D$ , especially in the early stage of the training process. Second, $D$ is constant w.r.t. $G$ when $G$ is optimized, which results in missing gradients and an unstable training process (Metz et al., 2016).
+
+Instead, to ensure practical convergence, it is the training dynamics of both $G$ and $D$ , i.e., how $G$ (or $D$ ) changes given current $G$ and $D$ during the training process, that should be considered, where the previous two assumptions are no more required. There are some methods that focus on the dynamics of the parameters. Mescheder et al. (2017) and Nagarajan $\&$ Kolter (2017) propose to model the dynamics of the parameters using the vector field defined by its gradients. In such cases, the local convergence and stability are fully determined by the eigenvalues of the Jacobian matrix. Mescheder et al. (2018) further propose a regularization term to stabilize GANs by adjusting the eigenvalues of the Jacobian matrix. Gidel et al. (2018) analyze the effect of momentum and propose to stabilize GANs using negative momentum. In these methods, the Jacobian matrix is the key to understand and stabilize the dynamics, whose calculation is, however, computationally expensive. It largely impedes us to generalize this analysis to complex models such as neural networks (LeCun et al., 2015).
+
+In this paper, we argue that modeling the dynamics in the function space is more convenient for convergence analysis. Specifically, we directly model $G$ and $D$ as two dynamics whose output is considered as a signal of time $t$ , i.e., representing the output of $G$ and $D$ as $G ( t , z )$ and $\bar { D ( t , x ) }$ respectively. The control theory (Kailath, 1980) provides a powerful tool to understand them and analyze their stability. Specifically, differential equations can be used to denote the dynamics, e.g., the dyncurrent micsand $G$ can be denoted as y applying Laplaci $\begin{array} { r } { \frac { d G ( t , z ) } { d t } = f ( G , D ) } \end{array}$ , which represents how Widder, 2015) to the diff $G$ changes givenntial equations, $G$ $D$   
+the dynamics can be represented as a transfer function, and then the stability and convergence can be easily modeled (Kailath, 1980) as introduced in Sec. 2.
+
+Under the above perspective of control theory, we unify the dynamics of $G$ and $D$ as certain dynamics that are well-studied in control theory for various GANs, including Standard GAN (SGAN), WGAN and LSGAN (Mao et al., 2017), as illustrated in Sec. 3 and Appendix A. Specifically, the training process of GANs can be considered as a dynamic whose output is determined by its intrinsic properties (i.e., the objective function of $G$ and $D$ ) and its input (i.e., the data distribution). Within the proposed framework, a variety of existing methods (Mao et al., 2017; Mescheder et al., 2018; Gidel et al., 2018) can be considered as certain controller which is widely used in control theory as discussed in Sec. 4.1 and Appendix C. It is worth noting that through control theory, the stability of GANs can be easily inferred from the transfer function, instead of analyzing the complicated Jacobian matrix of the dynamics. The proposed framework provides a promising direction that can further benefit the training dynamics of GANs using advanced control methods. To verify it, we propose to use the widely adopted controlling method, the negative feedback (NF) control (Åström & Hägglund, 1995), to stabilize GANs. What’s more, when applying NF to stable models, the performance can still be improved. The proposed NF acts as a regularization term which penalizes the $L 2$ norm of the output of $D$ as we described in Sec. 4. NF is verified on the toy data such as Dirac GAN as well as the natural images such as CIFAR10 (Krizhevsky et al., 2009). The results demonstrate that our method can successfully stabilize the dynamics of GANs and outperform the baseline significantly.
+
+# 2 PRELIMINARY
+
+In this section, we provide the background and preliminary about Laplacian transformation (LT) and control theory. LT is a powerful tool to present an ordinary differential equation (ODE) as a rational fraction. Since most dynamics can be represented as an ODE, LT can largely simplify the analysis of stability by merely analyzing the properties of the rational fraction.
+
+# 2.1 LAPLACIAN TRANSFORMATION
+
+Laplacian transformation (LT) (Widder, 2015) can be considered as an extension of Fourier transformation (FT), which transforms a signal, i.e., a function of time, to a function of complex variables. Formally, the transformation and its inversion are given by:
+
+$$
+\mathcal { F } ( f ) ( s ) = \int _ { 0 } ^ { \infty } f ( t ) e ^ { - s t } d t , \mathcal { F } ^ { - 1 } ( F ) ( t ) = \frac { 1 } { 2 \pi i } \int _ { c - \infty i } ^ { c + \infty i } e ^ { s t } F ( s ) d s ,
+$$
+
+where $f$ is a signal that is represented as a function over time $t$ , $c$ is a constant that ensures $F ( s ) \leq \infty$ . $s \in \mathbb { C }$ is a complex number, i.e., $s = \sigma + \omega i$ with real numbers $\sigma$ and $\omega$ and for each $s \in \mathbb { C }$ , $F ( s )$ denotes the components of certain frequency in the original signal $f$ similar to FT.
+
+With LT, the integration and derivation can be presented as a single operator, which is given by:
+
+$$
+\mathcal { F } ( \frac { d f ( t ) } { d t } ) = s \mathcal { F } ( f ) , \mathcal { F } ( \int _ { 0 } ^ { t } f ( u ) d u ) = \frac { 1 } { s } \mathcal { F } ( f ) .
+$$
+
+With this property, an ODE can be converted to an algebraic equation by substituting derivation as an operator $s$ . A simple example is illustrated as follows:
+
+$$
+{ \frac { d ^ { 2 } x } { d t ^ { 2 } } } = - x + u  s ^ { 2 } X = - X + U ,
+$$
+
+![](images/8dfe1255c4491ac79d5d9479cb6c47c8751b713d799ffb40acc1082dbae45a98.jpg)  
+Figure 1: The diagram representations of the inputs and dynamics after LT. Left: the original diagram of the spring dynamic in Eqn. (3). Right: the diagram of a classical controlled dynamic with feedback $H _ { b }$ and controller $H _ { c }$ .
+
+where $u$ and $x$ are the input and output signal correspondingly and $U$ and $X$ are their Laplacian transformation. This ODE can represent a spring dynamic, whose acceleration $\textstyle { \frac { d ^ { 2 } x } { d t ^ { 2 } } }$ depends on the input $u$ and the current position $x$ according to Hooke’s law. In this case, the ODE can be solved by simply applying the inverse Laplacian transformation to $\begin{array} { r } { X = \frac { 1 } { s ^ { 2 } + 1 } U = H _ { f } ( s ) U ( s ) } \end{array}$ . Here $\begin{array} { r } { H _ { f } ( s ) = \frac { 1 } { s ^ { 2 } + 1 } } \end{array}$ is the transfer function of this dynamic which can also be represented as a diagram illustrated in Fig. 1. Since the input signal can be considered as summation of infinity Dirac signal at different positions, i.e., $\begin{array} { r } { f ( t ) = \overset { \cdot } { \boldsymbol { \int } } f ( \bar { u ( \boldsymbol { \theta } ) } \delta ( t - u ) d u } \end{array}$ where $\delta$ denotes the Dirac delta function (Dirac, 1981), we only need to analyze the output of the dynamics for Dirac signal whose LT is constant, i.e., $\mathcal { F } ( \delta ) = 1$ . Therefore, the transfer function represents the intrinsic properties of the dynamics.
+
+# 2.2 CONTROL THEORY AND NEGATIVE FEEDBACK
+
+Given a dynamic, or equivalently a transfer function, the stability can be analyzed according to the roots of the denominator of the transfer function, e.g., $s ^ { 2 } + 1 = \mathrm { { \dot { 0 } } }$ for Eqn. (3). The roots are called the poles of the dynamics. Specifically, if all poles’ real parts are negative, the dynamic is stable; if there are poles which are pure imaginary numbers, the dynamic will oscillate; if there is at least one pole with positive real parts, the dynamic will diverge (Kailath, 1980). In the above example, the poles of the dynamic are $0 \pm i$ , which indicates that the object will oscillate around the original.
+
+For those unstable dynamics, we need to stabilize it by adjusting the poles of the dynamics. One of the most commonly adopted methods here is introducing negative feedback with an auxiliary controller (Kailath, 1980). The diagram is illustrated in Fig. 1 (right). The $H _ { b } ( s )$ denotes the transfer function of feedback and $H _ { c } ( s )$ denotes the transfer function of controller.
+
+In this setting, the dynamic takes the error (i.e., $E ( s ) = U ( s ) - H _ { b } ( s ) X ( s ) )$ rather than $U ( s )$ as input, resulting the fact that the transfer function of the whole controlled dynamic is given by:
+
+$$
+E ( s ) = U ( s ) - H _ { b } ( s ) X ( s ) , X ( s ) = H _ { c } ( s ) H _ { f } ( s ) E ( s ) \to X = { \frac { H _ { c } ( s ) H _ { f } ( s ) } { 1 + H _ { c } ( s ) H _ { f } ( s ) H _ { b } ( s ) } } U ,
+$$
+
+which provides us an approach to adjust the poles of an unstable dynamic. For most cases, simply adopting the negative feedback, i.e., let $H _ { b } = H _ { c } = 1$ , is enough to stabilize a dynamic. In the following, we provide the dynamics of GANs in the perspective of control theory and introduce the negative feedback control to stabilize the training process of GANs.
+
+# 3 UNIFYING THE DYNAMICS OF GANS IN CONTROL THEORY
+
+In this section, we provide a novel perspective on the dynamic of GANs. Unlike previous methods that mainly focus on the dynamics of the parameters, we directly model the output of two dynamics $G$ and $D$ in the function space. In this part, we mainly focus on the Dirac GAN as in Mescheder et al. (2018) and unregularized WGAN. This method can be extended to other GANs easily, as we illustrated in Appendix A.
+
+To model the dynamics of GANs, we first denote the output of $G$ and $D$ as a function with respect to time $t$ , which is also known as a signal, i.e., $D = D ( t , x )$ and $G = G ( t , z )$ . Then the training process can be represented as a dynamic using an ODE, and the equilibrium is equivalent to the final value of the dynamics (Oppenheim et al., 1998), i.e., the output of the dynamics with $t \to \infty$ .
+
+# 3.1 THE DYNAMICS OF DIRAC GAN
+
+In Dirac GAN, the data distribution is defined as $p _ { D } ( x ) = \delta _ { c } ( x ) = \delta ( x - c )$ which is the density of an idealized point mass at point $c$ . The generator distribution is defined as $p _ { G } ( x ) = \delta _ { \theta } ( x )$ , where $\theta$ is the learnable parameter of $G$ . In this case, we use $G ( t ) = G ( t , z )$ for simplicity as its output does
+
+![](images/ffcb1e69378a3a3d5782e69967cbbd256632849fabeed55367e1addd1ffeb755.jpg)  
+Figure 2: The diagram block of Dirac GAN and unregularized WGAN. Left: Dirac GAN, Right: unregularized WGAN.
+
+not depend on $z$ . The discriminator is a simple linear function $D ( t , x ) = \phi ( t ) \times x$ . Therefore, the minimax optimization problem of Dirac GAN is formulated as:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \mathbb { E } _ { p _ { D } } [ \phi x ] - \mathbb { E } _ { p _ { G } } [ \phi x ] = c \phi - \theta \phi .
+$$
+
+For the discriminator, the objective function is given by: $\begin{array} { r } { \operatorname* { m a x } _ { \phi } U ( D ) = c \phi - \theta \phi } \end{array}$ , which indicates that the dynamics of $D$ can be formulated as:
+
+$$
+\frac { \partial U ( D ) } { \partial \phi } = c - \theta  \frac { d \phi ( t ) } { d t } = c - \theta  \frac { \partial D ( t , x ) } { \partial t } = x \times ( c - \theta ) , \forall x .
+$$
+
+By considering $c - \theta$ as the error signal, i.e., $e = c - \theta$ , the dynamics of the discriminator can be modeled as an integral part $\begin{array} { r } { D ( t , x ) = x \int _ { 0 } ^ { t } c - G ( t ) d t } \end{array}$ . By applying LT to the dynamic, we have:
+
+$$
+\mathcal { F } ( D ( t , x ) ) = \frac { x \mathcal { F } ( e ) } { s } = \frac { x } { s } E ( s ) , \forall x ,
+$$
+
+where we consider the dynamics of $D$ at each $x$ . For the generator, the objective function is given by $\operatorname* { m a x } _ { G } U ( G ) = \theta \phi$ . Therefore the dynamics of $\mathbf { G }$ can be formulated as:
+
+$$
+{ \frac { \partial U ( G ) } { \partial \theta } } = \phi \to { \frac { d \theta ( t ) } { d t } } = \phi \to { \frac { \partial G ( t ) } { \partial t } } = { \frac { \partial D ( t , x ) } { \partial x } } .
+$$
+
+Since $\begin{array} { r } { D ( t , x ) = x \int _ { 0 } ^ { t } c - G ( t ) d t } \end{array}$ , we have ∂D(t,x)∂x = R t0 c − G(t)dt. We therefore combine the x part in $D$ ’s dynamic and the the partial derivation in $G$ into an identity mapping. Then $D$ can be considered as an integral dynamic and its transfer function is given by $\begin{array} { r } { H _ { D } ( s ) = \frac { 1 } { s } } \end{array}$ . Further, the generator also integrate the output of $D$ , which is also $\textstyle { \frac { 1 } { s } }$ .
+
+Hence, the block diagram of the Dirac GAN is illustrated in the left panel of Fig. 2. As we can see, $D$ takes the difference between the real sample and fake sample, i.e., $c - \theta$ as input, and output the integration of the input signal. The generator takes $D$ ’s output as input and output the generator distribution which is the integration of $D$ ’s output.
+
+Remark 1. When treating $G$ and $D$ as dynamics, the both the inputs and outputs of the dynamics are functions over $t$ . For example, the input of $D$ is $p _ { D } ( t , x ) - p _ { G } ( \bar { t } , x )$ and the output is $D ( t , x )$ .
+
+# 3.2 THE DYNAMICS OF WGAN
+
+In this subsection, we further model the dynamics of WGAN (Arjovsky et al., 2017) without Lipschitz continuity constraints in the function space. In this case, we consider the nonparametric setting, where $D$ is a piece-wise linear function, $G$ is a mapping from the noise space to the data space, and both of them are of infinite capacity. This analysis can be extended to other variants of GANs easily.
+
+In the general case, the objective function of $D$ is given by:
+
+$$
+\operatorname* { m a x } _ { D } U ( D ) = \mathbb { E } _ { p _ { D } } [ D ( x ) ] - \mathbb { E } _ { p _ { G } } [ D ( x ) ] = \int ( p _ { D } ( x ) - p _ { G } ( x ) ) D ( x ) d x .
+$$
+
+According to the calculus of variations (Gelfand et al., 2000), the gradient of $U ( D )$ with respect to the function $D$ , and the dynamic of $D$ are given by:
+
+$$
+\frac { \partial U ( D ) } { \partial D } = p _ { D } - p _ { G }  \frac { d D ( t , x ) } { d t } = p _ { D } ( x ) - p _ { G } ( x ) .
+$$
+
+Since the input signal is $p _ { D } - p _ { G }$ , the dynamics of WGAN is similar to that of the Dirac GAN, whose transfer function can be denoted as $\begin{array} { r } { H _ { D } ( s ) = \frac { 1 } { s } } \end{array}$ .
+
+For the generator, the objective function and its dynamics are given by:
+
+$$
+\operatorname* { m a x } _ { G } U ( G ) = \mathbb { E } _ { p _ { z } ( z ) } [ D ( G ( z ) ) ] = \int p _ { z } ( z ) D ( G ( z ) ) d z  \frac { \partial U ( G ) } { \partial G } = p _ { z } ( z ) \frac { \partial D ( G ( z ) ) } { \partial G ( z ) } , \forall z .
+$$
+
+It is worth noting that compared to Dirac GAN, this integral is taken in the function space, i.e., $G ( t +$ $\begin{array} { r } { \delta _ { t } , z ) = G ( t , z ) + \delta _ { t } p _ { z } ( z ) \frac { \partial D ( G ( z ) ) } { \partial G ( z ) } } \end{array}$ ) ∂D(G(z))∂G(z) . Besides, the generator distribution pG is not a Dirac distribution, resulting in that another operation, which converts the generated samples to the distribution, should be added after $G$ to make the model consistent. The diagram blocks of WGAN is illustrated in Fig. 2 (right). Compared to Dirac-GAN, another two operations are introduced to the framework. We further provide the dynamics of other GANs, including standard GAN proposed by Goodfellow et al. (2014) and Least-Square GAN proposed by Mao et al. (2017) in Appendix A.
+
+Remark 2. We only consider the unregularized WGAN to simplify the analysis. Note that the dynamics of $D$ follows Eqn. (10) at least locally around the equilibrium where updating $D$ according to Eqn. (10) will not violate the Lipschitz constraints. Formally proof is given in Appendix D.
+
+Remark 3. Here we model the dynamics of $G$ and $D$ in the functional space, which is more convenient for the following stability analysis and designing controllers. In practice, we update the models in the parameter space to approximate the dynamics in Eqn. (10) and Eqn. (11).
+
+# 4 UNDERSTANDING AND STABILIZING GANS WITH NEGATIVE FEEDBACK
+
+In this section, we first provide the stability analysis of GANs from the perspective of control theory. Besides, many previous methods can be interpreted in this perspective, and we use the momentum as an example. Other further examples are given in Appendix C. We further propose to stabilize the dynamics of GANs using the negative feedback controlling methods, and an example of another controller is given in Appendix B.
+
+# 4.1 STABILITY
+
+In the dynamics of GANs, we argue that it is dominated by the two integral dynamics of $G$ and $D$ . Therefore, we ignore the two non-linear operations in GANs in the following analysis. Since both $\mathbf { G }$ and D can be considered as integral parts, we can formulate the transfer function of $G$ and $D$ as $\begin{array} { r } { H _ { G } = H _ { D } = \frac { 1 } { s } } \end{array}$ . According to Eqn. (4), the transfer function of WGAN is given by:
+
+$$
+H ( s ) = \frac { H _ { D } } { 1 + H _ { D } H _ { G } } = \frac { 1 / s } { 1 + 1 / s ^ { 2 } } = \frac { s } { 1 + s ^ { 2 } } .
+$$
+
+It is worth noting that the poles of the transfer function of the whole dynamic are $0 \pm i$ , which indicates that the output will oscillate around the equilibrium rather than converge to 0. This result is also consistent with the analysis in (Mescheder et al., 2018). This perspective can also partially explain why larger learning rates or adopting multiple update steps for $D$ , where the transfer function of $D$ can be approximated by $\frac { k } { s }$ with $k > 1$ , cannot provide a principle solution for stabilizing GANs. In this case, the poles of the dynamics are adjusted to $0 \pm \sqrt { k } i$ which is still an oscillation dynamics.
+
+# 4.1.1 THE AFFECT OF MOMENTUM
+
+Our method can also provide stability analysis for other practical techniques used in training GANs. In this part, we use the momentum as an example. Gidel et al. (2018) provide some theoretical analysis of momentum in training GANs, which is formulated in the parameter space. In the following, we re-analyze the momentum in the function space under the perspective of control theory.
+
+The momentum method (Qian, 1999) achieves great success in training deep neural networks. Previous methods such as SGD with momentum can help neural networks to escape from local optima. Its theoretical formulation is given by:
+
+$$
+\tilde { { \boldsymbol { \theta } } } _ { t + 1 } = \beta \tilde { { \boldsymbol { \theta } } } _ { t } + ( 1 - \beta ) \nabla { \boldsymbol { \theta } } _ { t } , { \boldsymbol { \theta } } _ { t + 1 } = { \boldsymbol { \theta } } _ { t } + \eta \tilde { { \boldsymbol { \theta } } } _ { t + 1 } .
+$$
+
+The $\beta$ is the coefficient for the exponential decay of the gradients, which generally takes 0.9. However, things changed when it comes to training GANs. DCGAN (Radford et al., 2015) recommends a smaller momentum with $\beta = 0 . 5$ . Furthermore, recent state-of-the-art models (Mescheder et al., 2018; Brock et al., 2018; Gulrajani et al., 2017) just remove the momentum.
+
+(a) The diagram of GANs with negative feedback.
+
+![](images/afe9f7db83eafc0d8df03b8305eb414165e39fd93c036c945b12bf6b4d18176e.jpg)  
+Figure 3: The diagram and its corresponding dynamics of GANs using negative feedback.
+
+![](images/6972e57326476d6a60ce84bbf76f764ae97b071a66fc39d204d3adedc3dcec84.jpg)  
+(b) The dynamics of GANs with negative feedback.
+
+# Algorithm 1 Negative Feedback GAN
+
+1: Input: Buffer size $N _ { b }$ , feedback coefficient $\lambda$ , batch size $N$ , initialized $\theta$ and $\phi$ , learning rate $\eta$ .   
+2: Initialize $B _ { r }$ and $B _ { f }$ for real samples and fake samples respectively.   
+3: repeat   
+4: Sample a batch of $\{ x _ { r } \} \sim p _ { D }$ , $\{ x _ { f } \} \sim p _ { G }$ of $N$ samples.   
+5: Update $B _ { r }$ with $\{ x _ { r } \}$ . Update $B _ { f }$ with $\{ x _ { f } \}$ .   
+6: Sample a batch of $x _ { r } ^ { \prime } \sim B _ { r }$ , $x _ { f } ^ { \prime } \sim B _ { f }$ of $N$ samples respectively.   
+7: Estimate the objective of D:   
+$\begin{array} { r } { U ( D ) = \frac { 1 } { N } [ \sum _ { x \in \{ x _ { r } \} } ^ { \prime } D ( x ) - \sum _ { x \in \{ x _ { f } \} } D ( x ) ] - \frac { \lambda } { 2 N } [ \sum _ { x \in \{ x _ { r } ^ { \prime } \} } D ^ { 2 } ( x ) + \sum _ { x \in \{ x _ { f } ^ { \prime } \} } D ^ { 2 } ( x ) ] . } \end{array}$   
+8: Update $\phi$ to maximize $U ( D )$ with learning rate $\eta$ .   
+9: Estimate the objective of G: U (G) = 1N Px∈{x } .   
+10: Update $\theta$ to maximize $U ( G )$ with learning rate $\eta$ .
+
+11: until Convergence
+
+In control theory, the momentum is equivalent to adding an exponential decay to the input of the dynamics (An et al., 2018), and the LT of an exponential decay dynamic is 1s+τ . τ > 0 denotes the decay coefficient which depends on $\beta$ . Therefore, the transfer function of the $D$ with momentum is $\begin{array} { r } { H _ { m D } ( s ) = \frac { 1 } { s ( s + \tau ) } } \end{array}$ , and the transfer function of the WGAN with momentum is given by:
+
+$$
+H ( s ) = \frac { H _ { m D } } { 1 + H _ { m D } H _ { G } } = \frac { 1 / ( s ( s + \tau ) ) } { 1 + 1 / ( s ^ { 2 } ( s + \tau ) ) } = \frac { s } { s ^ { 3 } + \tau s ^ { 2 } + 1 } .
+$$
+
+By letting $( s + a ) ( s + b ) ( s + c ) = s ^ { 3 } + \tau s ^ { 2 } + 1$ , we have that $a + b + c = \tau > 0$ , which indicates that there are at least one pole of this dynamic whose real part is larger than 0, indicating the instability of the dynamics for GANs with momentum.
+
+# 4.2 STABILIZE GANS
+
+According to the above analysis, for both the unregularized WGAN and the GAN with momentum, the equilibrium point (i.e., $p _ { G } = p _ { D }$ ) is not a stable point. In the following, we propose to stabilize GANs using negative feedback control, which is the most widely-used method in control theory.
+
+In this setting, we set $H _ { N F } = \lambda$ which is the transfer function of the negative feedback for $D$ . After applying the negative feedback to $D$ , The diagram of the controlled dynamics is given in Fig. 3 (a). According to Eqn. (4), the transfer function of $D$ and the whole dynamic can be represented as:
+
+$$
+H _ { D } ^ { \prime } ( s ) = \frac { 1 / s } { 1 + \lambda / s } = \frac { 1 } { s + \lambda }  H ( s ) = \frac { H _ { D } ^ { \prime } ( s ) } { 1 + H _ { D } ^ { \prime } ( s ) H _ { G } ( s ) } = \frac { s } { s ^ { 2 } + \lambda s + 1 } .
+$$
+
+Therefore, for a positive and small $\lambda$ , the real part of the two poles are $- \frac { \lambda } { 2 } < 0$ , which indicates that the dynamic is stable. The dynamics of the Dirac GAN using different $\bar { \lambda }$ is illustrated in Fig. 3 (b). As we can see, when no feedback is applied (i.e., $\lambda = 0$ ), the dynamic will oscillate around the equilibrium. Applying negative feedback can significant improve the stability of the dynamics.
+
+# 4.2.1 PRACTICAL IMPLEMENTATION
+
+The most direct way to add negative feed is to introduce a regularization term $\begin{array} { r } { R _ { D } = \frac { \lambda } { 2 } \int D ^ { 2 } ( x ) d x } \end{array}$ to the objective function of $D$ . However, directly integrating over the input space is computationally infeasible. Instead, we give an approximation to $R _ { D }$ . We assume that the area where $| D ( x ) |$ is large mainly concentrates on its training samples, i.e., previous samples used to train $D$ . Therefore, we keep two buffers $B _ { r }$ and $B _ { f }$ of size $N _ { b }$ to store the old real samples and fake samples, respectively. Then $R _ { D }$ is evaluated on these two buffers to regularize $D$ , and the two buffers are updated with replacement at each step. The training procedure is illustrated in Alg. 1. In the following, we use NF-GAN $( \cdot )$ to denote our proposed method with the hyperparameters $\lambda / 2$ denoted in the parentheses.
+
+![](images/599d8cde6cddb5e4d156f249749ca729ac1f21b923ef992f8b0c50abf6ef97d0.jpg)  
+Figure 4: The learning curve of baselines and our proposed methods. Left: The Inception Score of CIFAR10. Right: The FID score for CelebA. We plot the curve with respect to time for better representation of the computational cost and convergence speed.
+
+# 5 RELATED WORK
+
+GANs are known for its unstable training process. Radford et al. (2015) provide several practical techniques to stabilize the training, such as designing suitable architecture of neural networks and the hyperparameters selection. The Unrolled GAN (Metz et al., 2016) proposes to make $D$ as a function of $G$ by unrolling the training process of the discriminator where the gap between the theoretical analysis and implementation can be reduced. Arjovsky et al. (2017) provide a theoretical analysis of the gradient vanishing problem and further propose to optimize GANs using Wasserstein distance. Gulrajani et al. (2017) use the gradient penalty to ensure the Lipschitz continuity in discriminator, which is required by WGAN. However, GANs still suffer from instability in the training process.
+
+Besides, there is some work that directly focuses on the stability of the training process. Except for the works mentioned in Sec. 1, Peng et al. (2019) also directly model the dynamics of the parameters and adjust the update rules to stabilize GANs. Gidel et al. (2016) propose to find the saddle point of the optimization problem using Frank-Wolfe algorithms. Feizi et al. (2017) also use the control theory to model the stability of GANs, while the dynamics of GANs are not explicitly captured. Balduzzi et al. (2018) decompose dynamics into the oscillating and non-oscillating behaviour and model training dynamics as finding stable fixed points. However, none of them only can generalize their methods to complex datasets such as natural images.
+
+# 6 EXPERIMENTS
+
+In this section, we empirically verify our proposed method on the widely-adopted CIFAR10 (Krizhevsky et al., 2009) and CelebA (Liu et al., 2015) datasets. We denote the regularization proposed in Mescheder et al. (2018) as Reg-GAN, which is the direct baseline of our method. Besides, we also apply NF-GAN to SN-GAN (Miyato et al., 2018) and provide a significant improvement to the state-of-the-art method. For fair comparisons, our implementation mainly follows the officially released code for Reg-GAN and SN-GAN, respectively. More details about the experimental setting and further results on a synthetic dataset can be found in Appendix B. The code is provided here.
+
+# 6.1 COMPARISON TO REG-GAN
+
+We first compare our proposed method with RegGAN. Since for large datasets, the non-linearity cannot be ignored, which results in the gap between the simulation of Dirac GAN and our methods. A small $\lambda / 2$ , such as 0.01 which is suitable for Dirac GAN is not enough for stabilize the large models. We therefore select the coefficient $\lambda / 2$ among $\{ 1 , 2 , 5 , 1 0 , 1 5 , 2 0 \}$ . In this part, we only report representative results. Though our analysis mainly focuses on the WGAN framework, NF can also easily generalize to SGAN whose stability can also be improved and NF-SGANs with different coefficient $\lambda / 2$ are evaluated.
+
+Table 1: The FID Score (top) and Inception Score (bottom) on CIFAR10. The results reported here are the best results over the training process. The results of IS are averages over 3 runs.   
+
+<table><tr><td rowspan=1 colspan=2>Regularization</td><td rowspan=1 colspan=2>WGAN</td><td rowspan=1 colspan=1>SGAN</td></tr><tr><td rowspan=1 colspan=2>No regularizationReg-GANGradient Penalty</td><td rowspan=1 colspan=2>105.2130.4328.20</td><td rowspan=1 colspan=1>28.5128.391</td></tr><tr><td rowspan=1 colspan=2>NF-GAN(2) (ours)NF-GAN(5) (ours)NF-GAN(10)(ours)</td><td rowspan=1 colspan=2>21.9022.3121.19</td><td rowspan=1 colspan=1>22.3521.6123.34</td></tr><tr><td rowspan=2 colspan=1>Objective</td><td rowspan=2 colspan=2>SN-GAN</td><td></td><td></td></tr><tr><td rowspan=1 colspan=2>NF-SN-GAN</td></tr><tr><td rowspan=1 colspan=1>WGANHinge</td><td rowspan=1 colspan=2>3.298.22 ± .05</td><td rowspan=1 colspan=2>8.28± .098.45 ± .11</td></tr></table>
+
+We use the Inception Score (IS) (Salimans et al., 2016) to evaluate the image quality on CIFAR10 and FID score (Gulrajani et al., 2017) on both CIFAR10 and CelebA. The quantitative results are given in Table 1 and the learning curve is reported in Fig. 4. Our method gives an improvement to the FID and IS for both WGAN and SGAN. Specifically, for unregularized methods, the models demonstrate the unstable training process and finally diverge away from the data distribution. Compared with Reg-GAN, our method maintains stability and provides better convergence results, as also shown in Table 1 (top). Besides, our method is more computationally efficient, since regularizing the output of $D$ needs less computation compared to regularizing $| | \frac { \partial D ( x ) } { \partial x } | |$ and this gap is significant for large dataset. Specifically, on Geforce 1080Ti, our method can conduct approximate $1 2 / 8$ iterations per second of training for CIFAR10/CelebA, whereas Reg-GAN can only conduct $1 0 / 4$ iterations per second. What’s more, our method is robust to the choice of the hyperparameter $\lambda$ . We present the generated images in Fig. 5 and Fig. 6.
+
+![](images/61e72dfd4b8fb7bc75bc4fda19c0458074406662d30deab1e79096c639f7b815.jpg)
+
+![](images/41994638029140ddb5227fa3cefe48b5bd673831567a9d9992c3a35c25422620.jpg)  
+Figure 5: The generated results of CIFAR10 dataset. From left to right: WGAN-GP, Reg-WGAN, NF-WGAN(5), NF-SGAN(5)   
+Figure 6: The generated results of CelebA dataset. From left to right: WGAN-GP, Reg-WGAN, NF-WGAN(15), NF-SGAN(15).
+
+# 6.2 COMPARISON TO SN-GAN
+
+We further apply NF-GAN to the SN-GAN’s architecture. With stability guaranteed, our proposed method can further help SN-GAN to address the potentially unstable issue and converge to better final results, as illustrated in Table 1 (bottom). We manually select $\lambda / 2 \in \{ 0 . 0 1 , 0 . 1 , 1 \}$ and finally adopt $\lambda / 2 = 0 . 1$ . Though SN-GAN provides an elegant normalization method to ensure the Lipschitz continuity, SN-GAN with WGAN loss still cannot converge to the data distribution and provide unreasonable results, which verifies with our stability analysis. Instead, the hinge loss, as introduced Eqn. (16)&(17) in Miyato et al. (2018), is used to stabilize SN-GAN but no theoretical guarantee is provided. In contrast, NF-GAN can successfully regularize SN-GAN with WGAN loss and provide better results to previous state-of-the-art results. What’s more, NF-GAN can also benefit SN-GAN with Hinge loss and provide a significant improvement the IS of CIFAR-10.
+
+# 7 CONCLUSION
+
+In this paper, we propose a novel perspective to analyze the dynamics of GANs. Instead of focusing on the equilibrium, we directly model the dynamics of the discriminator and the generator during the training process. Using Laplacian transformation and control theory, the stability can be easily understood according to the poles of the dynamics. Various methods can be motivated from this perspective, and we verify it with the widely used negative feedback control. The empirical results demonstrate that our method can successfully stabilize GANs and provide better convergence results.
+
+Negative feedback shows promise results, but further analysis is required for better results. For one thing, our analysis mainly focuses on the continuous cases, where the practical implementation optimizes both $G$ and $D$ in discrete time steps, where the $Z$ -transformation provides better tools for discrete-time dynamics. For another, two approximations are made: using the update in the parameter space to approximate the dynamics and ignore two non-linear operations in GANs. Recent analyses of GANs on the functional spaces (Johnson $\&$ Zhang, 2018) provides a promising solution to solve the first approximation and modern control theory and non-linear control methods (Khalil, 2002) can be adopted to solve the second one. Indeed, our method does not provide a perfect solution to GANs’ dynamics. It does provide a novel perspective to understand and stabilize GANs.
+
+# REFERENCES
+
+Wangpeng An, Haoqian Wang, Qingyun Sun, Jun Xu, Qionghai Dai, and Lei Zhang. A pid controller approach for stochastic optimization of deep networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8522–8531, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein generative adversarial networks. In International conference on machine learning, pp. 214–223, 2017.
+
+Karl Johan Åström and Tore Hägglund. PID controllers: theory, design, and tuning, volume 2. Instrument society of America Research Triangle Park, NC, 1995.
+
+David Balduzzi, Sebastien Racaniere, James Martens, Jakob Foerster, Karl Tuyls, and Thore Graepel. The mechanics of n-player differentiable games. arXiv preprint arXiv:1802.05642, 2018.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+Tatjana Chavdarova and François Fleuret. Sgan: An alternative training of generative adversarial networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9407–9415, 2018.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in neural information processing systems, pp. 2172–2180, 2016.
+
+Paul Adrien Maurice Dirac. The principles of quantum mechanics. Number 27. Oxford university press, 1981.
+
+Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. arXiv preprint arXiv:1907.02544, 2019.
+
+Chao Du, Kun Xu, Chongxuan Li, Jun Zhu, and Bo Zhang. Learning implicit generative models by teaching explicit ones. arXiv preprint arXiv:1807.03870, 2018.
+
+Soheil Feizi, Farzan Farnia, Tony Ginart, and David Tse. Understanding gans: the lqg setting. arXiv preprint arXiv:1710.10793, 2017.
+
+Izrail Moiseevitch Gelfand, Richard A Silverman, et al. Calculus of variations. Courier Corporation, 2000.
+
+Gauthier Gidel, Tony Jebara, and Simon Lacoste-Julien. Frank-wolfe algorithms for saddle point problems. arXiv preprint arXiv:1610.07797, 2016.
+
+Gauthier Gidel, Reyhane Askari Hemmat, Mohammad Pezeshki, Remi Lepriol, Gabriel Huang, Simon Lacoste-Julien, and Ioannis Mitliagkas. Negative momentum for improved game dynamics. arXiv preprint arXiv:1807.04740, 2018.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 315–323, 2011.
+
+Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in neural information processing systems, pp. 5767–5777, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Geoffrey Hinton, Nitish Srivastava, and Kevin Swersky. Neural networks for machine learning lecture 6a overview of mini-batch gradient descent. Cited on, 14:8, 2012.
+
+Rie Johnson and Tong Zhang. Composite functional gradient learning of generative adversarial models. arXiv preprint arXiv:1801.06309, 2018.
+
+Thomas Kailath. Linear systems, volume 156. Prentice-Hall Englewood Cliffs, NJ, 1980.
+
+Hassan K Khalil. Nonlinear systems. Upper Saddle River, 2002.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015.
+
+Chongxuan Li, Taufik Xu, Jun Zhu, and Bo Zhang. Triple generative adversarial nets. In Advances in neural information processing systems, pp. 4088–4098, 2017.
+
+Kevin J Liang, Chunyuan Li, Guoyin Wang, and Lawrence Carin. Generative adversarial network training is a continual learning problem. arXiv preprint arXiv:1811.11083, 2018.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015.
+
+Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are gans created equal? a large-scale study. In Advances in neural information processing systems, pp. 700–709, 2018.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2794–2802, 2017.
+
+Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. The numerics of gans. In Advances in Neural Information Processing Systems, pp. 1825–1835, 2017.
+
+Lars Mescheder, Andreas Geiger, and Sebastian Nowozin. Which training methods for gans do actually converge? arXiv preprint arXiv:1801.04406, 2018.
+
+Luke Metz, Ben Poole, David Pfau, and Jascha Sohl-Dickstein. Unrolled generative adversarial networks. ArXiv, abs/1611.02163, 2016.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018.
+
+Vaishnavh Nagarajan and J Zico Kolter. Gradient descent gan optimization is locally stable. In Advances in Neural Information Processing Systems, pp. 5585–5595, 2017.
+
+Tu Nguyen, Trung Le, Hung Vu, and Dinh Phung. Dual discriminator generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2670–2680, 2017.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in neural information processing systems, pp. 271–279, 2016.
+
+Alan V Oppenheim, Alan S Willsky, and S Hamid Nawab. Señales y sistemas. Pearson Educación, 1998.
+
+Wei Peng, Yuhong Dai, Hui Zhang, and Lizhi Cheng. Training gans with centripetal acceleration. arXiv preprint arXiv:1902.08949, 2019.
+
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12(1): 145–151, 1999.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in neural information processing systems, pp. 2234–2242, 2016.
+
+David Vernon Widder. Laplace transform (PMS-6). Princeton university press, 2015.
+
+# A GANS AND THEIR CORRESPONDING DYNAMICS
+
+In this section, we provide an illustration for different kinds of GANs and their corresponding dynamics.
+
+# A.1 VANILLA GAN AND NON-SATURATION GAN
+
+The GANs proposed by (Goodfellow et al., 2014) are formulated as follows: $\displaystyle { \operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \mathbb { E } _ { p _ { D } } [ \log \sigma ( D ( x ) ) ] + \mathbb { E } _ { p _ { G } } [ \log ( 1 - \sigma ( D ( x ) ) ) ] } .$
+
+Therefore, the objective function and the corresponding dynamics of $D$ are given by:
+
+• The objective function:
+
+$$
+\begin{array} { l } { \displaystyle { \operatorname* { m a x } _ { D } U ( D ) = \mathbb { E } _ { p _ { D } } \lbrack \log \sigma ( D ( x ) ) \rbrack + \mathbb { E } _ { p _ { G } } \lbrack \log ( 1 - \sigma ( D ( x ) ) ) \rbrack } } \\ { \displaystyle { \quad \quad = \int p _ { D } ( x ) \log \frac { 1 } { 1 + \exp ( - D ( x ) ) + p _ { G } ( x ) \log \frac { \exp ( - D ( x ) ) } { 1 + \exp ( - D ( x ) ) } } d x } } \\ { \displaystyle { \quad = - \int p _ { D } ( x ) \log ( 1 + \exp ( - D ( x ) ) ) + p _ { G } ( x ) \log ( 1 + \exp ( D ( x ) ) ) d x . } } \end{array}
+$$
+
+• Given current $G$ , the gradient of $U ( D )$ with respect to $D$ at certain $x$ is given by:
+
+$$
+\begin{array} { l } { \displaystyle \frac { \partial U ( D ) } { d D ( x ) } = p _ { D } \frac { \exp ( - D ( x ) ) } { 1 + \exp ( - D ( x ) ) } - p _ { G } \frac { \exp ( D ( x ) ) } { 1 + \exp ( D ( x ) ) } } \\ { \displaystyle = p _ { D } ( 1 - \sigma ( D ( x ) ) ) - p _ { G } \sigma ( D ( x ) ) } \\ { \displaystyle  \frac { d D _ { t } ( x ) } { d t } = \frac { \partial U ( D ( x ) ) } { d D ( x ) } = p _ { D } ( 1 - \sigma ( D ( x ) ) ) - p _ { G } \sigma ( D ( x ) ) . } \end{array}
+$$
+
+The objective function and the corresponding dynamics of $G$ are given by:
+
+• The objective function:
+
+$$
+\begin{array} { l } { \displaystyle { \operatorname* { m i n } _ { G } \ U ( G ) = \mathbb { E } _ { p _ { G } } [ \log ( 1 - \sigma ( D ( x ) ) ) ] = \mathbb { E } _ { p _ { z } } [ \log ( 1 - \sigma ( D ( G ( z ) ) ) ) ] } } \\ { \displaystyle { \quad \quad = \int p _ { z } ( z ) \log \frac { \exp ( - D ( G ( z ) ) ) } { 1 + \exp ( - D ( G ( z ) ) ) } d z } } \\ { \displaystyle { \quad = - 1 \times \int p _ { z } ( z ) \log ( 1 + \exp ( D ( G ( z ) ) ) ) d z . } } \end{array}
+$$
+
+• Since $G$ is optimized using reparameterization, we rewrite $G ( z )$ as $x _ { z }$ for simplicity. Given current $D$ , the gradient of $U ( G )$ w.r.t. $G$ at a certain $z$ is given by:
+
+$$
+\begin{array} { c } { { \displaystyle { \frac { \partial U ( G ) } { \partial x _ { z } } = - 1 \times p ( z ) \frac { \exp ( D ( x _ { z } ) ) } { 1 + \exp ( D ( x _ { z } ) ) } \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } = - 1 \times p ( z ) \sigma ( D ( x _ { z } ) ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } } } \\ { { \displaystyle {  \frac { d G _ { t } ( z ) } { d t } = p ( z ) \sigma ( D ( x _ { z } ) ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } } } \end{array}
+$$
+
+For a well-trained $D$ , which can successfully tell real samples from generated samples with high confidence, i.e., $D ( x _ { z } ) \approx 0$ for all $z$ , the gradient for $\mathbf { G }$ will tend to zero almost everywhere, which will result in gradient vanishing. This analysis is consistent with previous literature (Johnson & Zhang, 2018; Arjovsky et al., 2017).
+
+For non-saturation GAN, the objective function and dynamics of $G$ are given by:
+
+• The objective is given by:
+
+$$
+\begin{array} { r l } { \displaystyle { \operatorname* { m a x } _ { G } } \ U ( G ) = } & { \ } \\ & { \ = \int p _ { z } ( z ) \log \sigma ( D ( x ) ) ] = \mathbb { E } _ { p _ { z } } [ \log \sigma ( D ( G ( z ) ) ) ] } \\ & { \ = \int p _ { z } ( z ) \log \frac { \exp ( D ( G ( z ) ) ) } { 1 + \exp ( D ( G ( z ) ) ) } d z } \\ & { \ = \int p _ { z } ( z ) ( D ( G ( z ) ) - \log ( 1 + \exp ( D ( G ( z ) ) ) ) ) } \end{array}
+$$
+
+• We rewrite $G ( z )$ as $x _ { z }$ and provide the gradient of $U ( G )$ w.r.t. $x _ { z }$ as follows:
+
+$$
+\begin{array} { c l c r } { \displaystyle { \frac { \partial U ( G ) } { \partial x _ { z } } = p _ { z } ( z ) ( 1 - \frac { \exp ( D ( x _ { z } ) ) } { 1 + \exp ( D ( x _ { z } ) ) } ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } } \\ { \displaystyle { = p _ { z } ( z ) ( 1 - \sigma ( D ( x _ { z } ) ) ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } } \\ { \displaystyle {  \frac { d G _ { t } ( z ) } { d t } = p ( z ) ( 1 - \sigma ( D ( x _ { z } ) ) ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } } \end{array}
+$$
+
+# A.2 LEAST-SQUARE GAN
+
+(Mao et al., 2017) propose to use the least square loss to train both the discriminator and the generator. The objective for the $D$ and $G$ are selected differently according to its theoretical analysis. Specifically, the objective function of $D$ and $G$ are given by:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { D } U ( D ) = \frac { 1 } { 2 } \mathbb { E } _ { p _ { D } } [ ( D ( x ) - 1 ) ^ { 2 } ] + \frac { 1 } { 2 } \mathbb { E } _ { p _ { G } } [ ( D ( x ) ) ^ { 2 } ] ; } \\ { \displaystyle \operatorname* { m i n } _ { G } U ( G ) = \frac { 1 } { 2 } \mathbb { E } _ { p _ { z } } [ ( D ( G ( z ) ) - 1 ) ^ { 2 } ] . } \end{array}
+$$
+
+Therefore, the dynamics of the $D$ and $G$ are given by:
+
+• The dynamic of $D$ :
+
+$$
+\begin{array} { l } { { \displaystyle { \frac { \partial { \cal U } ( D ) } { \partial D ( x ) } = \frac { 1 } { 2 } \frac { \partial } { \partial D ( x ) } ( p _ { D } ( D ( x ) - 1 ) ^ { 2 } + p _ { G } D ( x ) ^ { 2 } ) } } \ ~ } \\ { { \displaystyle ~ = p _ { D } ( D ( x ) - 1 ) + p _ { G } D ( x ) . } } \end{array}
+$$
+
+• The dynamic of $G$ :
+
+$$
+\begin{array} { r } { \displaystyle \frac { \partial U ( G ) } { \partial x _ { z } } = p _ { z } ( D ( x _ { z } ) - 1 ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } \\ { \displaystyle  \frac { d G _ { t } ( z ) } { d t } = p _ { z } ( z ) ( 1 - D ( x _ { z } ) ) \frac { \partial D ( x _ { z } ) } { \partial x _ { z } } } \end{array}
+$$
+
+It is worth noting that if the $G$ is fixed, the dynamics of $D$ can be considered as an exponential decay which is the same as the $D$ with negative feedback control. However, since $G$ is changing during the training process, the dynamics of $D$ is actually coupling with the dynamics of $G$ , which generally results in the unstable dynamics (Kailath, 1980). The experimental results on CIFAR10 also verify this argument. It also explains why we use two buffers of old samples to approximate the regularization term instead of directly regularizing the output of $D$ using current samples.
+
+# B FURTHER EXPERIMENTAL RESULTS
+
+# B.1 DETAILED EXPERIMENTAL SETTINGS
+
+In this paper, we mainly focus on the stability of the training dynamics of GANs, and therefore directly compare our proposed method NF-GAN with the vanilla SGAN/WGAN and the most direct baseline Reg-GAN. We use the resnet (He et al., 2016) for both the generator and the discriminator following Mescheder et al. (2018) and adopt the ReLU activation (Glorot et al., 2011). The batch size is 64, and the buffer size is set to 100 times of the batch size for all settings. We use rmsprop (Hinton et al., 2012) optimizer with learning rate as 0.0001 and $\alpha = 0 . 9 9$ for all models.
+
+Note that we make the following two modifications to the original implementation of Reg-GAN, which results in a more challenging setting to the stability. First, in the original Reg-GAN, a coefficient 0.1 is introduced to the residual connection of the ResNet for both G and D. Specifically, $h _ { L + 1 } = h _ { L } + 0 . 1 * f _ { L } ( h _ { L } )$ where $f _ { L }$ is the transformation defined in the $L$ -th layer and $h _ { L }$ is the output of $L - 1$ -th layer as well as the input of the $L$ -th layer. We instead remove the coefficient and just use the regular ResNet, i.e., $h _ { L + 1 } = h _ { L } + f _ { L } ( h _ { L } )$ . Second, for both G and D, we use the ReLU activation, rather than leaky ReLU. The above two modifications make the training of GANs more difficult, which explains why the reported results are not consistent with the scores in the original paper. In this more challenging setting, our method still outperforms the Reg-GAN. Specifically, the inception score of Reg-GAN is below 6.0 in this difficult setting and about 6.5 in the original setting. In contrast, both NF-WGAN and NF-SGAN achieve more than 6.7 in this difficult setting.
+
+![](images/55c36b01233c431a3c352d3c65f88dfc2345023efbdffc3c69eff7f00cf83270.jpg)  
+Figure 7: The generated samples for mixture of gaussian distribution. The red points demonstrate the location of data distribution and the blue points are generated samples. Each distribution is plotted using kernel density estimation with 50,000 samples.
+
+# B.2 SYNTHETIC DATA
+
+In this section, we evaluate our proposed method on a mixture of Gaussian on the two dimensions. The data distribution consists of 8 2D isotropic Gaussian distributions arranged in a ring, where the radius of the ring is 1, and the deviation of each component Gaussian distribution is 0.05. For the coefficient $\lambda / 2$ , we follow the theoretical analysis and set it among $\lambda / 2 \in \{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \}$ . We adopt two-layer MLPs for both the generator and the discriminator whose hidden units are 128 and 512 respectively. The batch size is is 512 and other settings just follow the Reg-GAN.
+
+The generated results are illustrated in Fig. 7 and we further provide the dynamics of the generator distribution in Fig. 8 in Fig. 8. As we can see, the unregularized WGAN and SGAN suffer from severe model collapse problem and cannot cover the whole data distribution. Besides, the oscillation can be observed during the training process of WGAN: the generator distribution oscillates among the modes of data distribution. Our method can successfully cover all modes compared to the WGAN and SGAN and is comparable to Reg-GAN.
+
+# B.3 FURTHER CONTROL METHOD: PD CONTROLLER
+
+Besides negative feedback, the most commonly used controller is the PID controller, which consists of three parts: the partial (P), integration (I) and derivation (D). Specifically, the PID controller takes the error signal as input, and output the summation of the above three parts, whose formal definition is defined as follows:
+
+$$
+c ( t ) = K _ { p } e ( t ) + K _ { i } \int _ { u = 0 } ^ { t } e ( u ) d u + K _ { d } \frac { d e ( t ) } { d t }  H _ { c } ( s ) = \frac { K _ { p } s + K _ { i } + K _ { d } s ^ { 2 } } s .
+$$
+
+$K _ { p }$ , $K _ { i }$ , $K _ { d }$ denotes the corresponding coefficients for PID controller. $e ( t )$ denotes the error signal and $c$ is the output of the controller, which is also the actual input of the dynamic. Generally, the I part can reduce the static error, and the $\mathbf { D }$ part can make the dynamic stable and accelerate the convergence.
+
+The PID controller is introduced to adjust the poles of the dynamic. Since the static error, i.e., the difference between the stable point and targeted point, is zero, the integral part is not necessary, and we only employ the PD controller in the following. By letting $H _ { c } ( s ) = p + d s$ , where $p$ and $d$ is the corresponding coefficient for the $\mathrm { P }$ and $\mathrm { D }$ part, the transfer function of the whole dynamic is given by:
+
+$$
+H ( s ) = { \frac { H _ { c } ( s ) H _ { D } ( s ) } { 1 + H _ { c } ( s ) H _ { G } ( s ) H _ { D } ( s ) } } = { \frac { s ( p + d s ) } { s ^ { 2 } + d s + p } } .
+$$
+
+As we can see, given positive $p$ and $d$ , the PD controller can successfully adjust the real parts poles of the dynamic to negative. In the following analysis and implementation, we fix $p = 1$ for simplicity.
+
+![](images/9adddbc1680ad314464ee90a0b8cef8d1b05a9879882fc77fc21e5a9a7c4a53d.jpg)  
+Figure 8: The training dynamics of various GANs on synthetic data.
+
+![](images/a33371a06709624792bd66f7eabb7475f6514def0a01be62b48f4605fc6c67fb.jpg)  
+Figure 9: The diagram and its corresponding dynamics of GANs using PD controller.
+
+![](images/d908ad221af39206090e6689fc1cffc8b7c611c073cba77695c58f0a951b2ba1.jpg)  
+Figure 10: The generated results of PD controller with $d = 5$ .
+
+![](images/4612fa6bc58fed2514be3e971cb5df72bb279d72742455935b4bca7d93ab55dd.jpg)  
+Figure 11: The diagram of previous methods. Left: the diagram of Reg-GAN which takes the $\textstyle | | { \frac { \partial D } { \partial x } } | |$ as regularization. Right: the diagram of negative momentum together with weight decay.
+
+The dynamics of Dirac GANs using PD controller is given in Fig. 9 (b). With a PD controller, the dynamic can be successfully stabilized. For general GAN, the objective of $D$ at time $t$ is given by:
+
+$$
+\begin{array} { r l r } & { } & { U ( D , t ) = \mathbb { E } _ { p _ { D } ( t , x ) } [ D ( x ) ] - \mathbb { E } _ { p _ { G } ( t , x ) } [ D ( x ) ] + } \\ & { } & { \lambda \{ \mathbb { E } _ { p _ { D } ( t , x ) } [ D ( x ) ] - \mathbb { E } _ { p _ { G } ( t , x ) } [ D ( x ) ] - \mathbb { E } _ { p _ { D } ( t - \delta t , x ) } [ D ( x ) ] + \mathbb { E } _ { p _ { G } ( t - \delta t , x ) } [ D ( x ) ] \} . } \end{array}
+$$
+
+The regularization is actually minimizing the loss of $D$ in the current step as well as maximizing the loss of $\mathrm { D }$ for previous step.
+
+# B.3.1 EXPERIMENTAL RESULTS
+
+The results of the synthetic data are illustrated in Fig. 10. WGAN with PD controller can successfully cover the whole data distribution and be stable at the equilibrium.
+
+However, we fail to generalize PD controller to the natural image dataset such as CIFAR10. We argue that the main reason is the overshooting for the dynamics of $D$ , as illustrated in Fig. 9 (b), where the $D$ gives a large derivation from the equilibrium at the beginning. Because of the highly-nonlinearity in neural networks, this overshooting will result in unexpected behavior of neural networks. In contrast, for the negative feedback, the overshooting is much smaller, which enables it to generalize to the non-linear neural networks.
+
+# C UNIFYING PREVIOUS METHODS IN CONTROL THEORY
+
+In this section, we also provide some analysis that interprets previous methods in the perspective of control theory.
+
+# C.1 REG-GAN
+
+Mescheder et al. (2018) propose a regularization which is added on $D$ ’s gradient of $x$ , i.e., $R _ { d } ( x ) =$ $| | \frac { \partial D ( x ) } { \partial x } | | _ { 2 } ^ { 2 }$ . Therefore, it can be considered as an other form of negative feedback, which is illustrated
+
+Compare to our analysis, Reg-GAN provides more accurate modeling of the dynamics and directly regularizes on the input of the dynamic of $G$ . Therefore, Reg-GAN can also successfully stabilize the dynamic of GANs, which is consistent with our experimental results. Compared to Reg-GAN, our method is more computationally efficient.
+
+# C.2 WEIGHT DECAY AND NEGATIVE MOMENTUM
+
+Gidel et al. (2018) analyze the effect of momentum in the training of GANs, and we already interpret this analysis in the context of control theory. Besides, the authors also propose to use the negative
+
+momentum to stabilize GANs, which is illustrated as follows:
+
+$$
+W _ { t + 1 } = W _ { t } + \eta \nabla W + \lambda ( W _ { t } - W _ { t - 1 } ) .
+$$
+
+Together with weight decay, the controlled dynamics of $W$ is given:
+
+$$
+W _ { t + 1 } = W _ { t } + \eta \nabla W + \lambda _ { 1 } ( W _ { t } - W _ { t - 1 } ) - \lambda _ { 2 } W _ { t } .
+$$
+
+In this setting, Eqn. (21) is equivalent to the PD controller with negative feedback in the parameter space whose diagram can be illustrated in Fig. 11. The $\lambda _ { 1 } ( W _ { t } - W _ { t - 1 } )$ denotes the $\mathrm { D }$ part and $\lambda _ { 2 } W _ { t }$ denotes the $\mathrm { \bf P }$ part.
+
+# D LOCAL APPROXIMATION TO THE REGULARIZED DYNAMICS
+
+In this section, we prove that around the equilibrium, the dynamics of regularized $D$ with Lipschitz constraint is equivalent to the unregularized $D$ as in Eqn. (10). Since the updating direction of $D$ is the gradient of $D$ in the functional space, we only need to prove that updating $D$ according to Eqn. (10) will not violate the Lipschitz constraints, at least locally around the equilibrium. Here we make the following assumptions:
+
+1. Both $p _ { D } ( x )$ and $p _ { G } ( t , x )$ are $C ^ { 1 }$ -smooth: $\textstyle { \frac { d p ( x ) } { d x } }$ exists and is continuous for $p _ { D }$ and $p _ { G } ( t , x ) , \forall t$ .   
+2. $p ( x )  0$ and $\textstyle { \frac { d p ( x ) } { d x } } \to 0$ when $x \to 0$ for $p _ { D }$ and $p _ { G } ( t , x ) , \forall t$ .   
+3. There exists an $M$ such that $| { \frac { d p ( x ) } { d x } } | _ { 2 } < M$ for $p _ { D }$ and $p _ { G } ( t , x ) , \forall t$ .
+
+The above assumptions are satisfied for most probability density functions.
+
+The distance in the function space is defined as $\begin{array} { r } { d ( p _ { 1 } , p _ { 2 } ) = \operatorname* { s u p } _ { x \in \mathbb { R } ^ { n } } | p _ { 1 } ( x ) - p _ { 2 } ( x ) | } \end{array}$ which always exists because of the 2-nd conditions above. We define ΩL = {p(x)|p(x) ∈ C1, | dp(x)dx | and $B ( \epsilon ) = \{ p ( x ) | p ( x ) \in C ^ { 1 } , \operatorname* { s u p } _ { x } | p ( x ) | < \epsilon \}$ . Then we have the follow theorem:
+
+Theorem 1. There exists $\delta > 0$ , such that $\forall D ( x ) \in \Omega _ { 0 . 5 }$ , we have $D ( x ) + \delta ( p _ { D } ( x ) - p _ { G } ( x ) ) \in \Omega _ { 1 }$
+
+Proof. By denoting $D ^ { \prime } ( x ) = D ( x ) + \delta ( p _ { D } ( x ) - p _ { G } ( x ) )$ , We have:
+
+$$
+\frac { d ( D ( x ) + \delta ( p _ { D } ( x ) - p _ { G } ( x ) ) ) } { d x } = \frac { d D ( x ) } { d x } + \delta ( \frac { p _ { D } ( x ) } { d x } - \frac { p _ { G } ( x ) } { d x } ) .
+$$
+
+Therefore, we have
+
+$$
+\begin{array} { l } { \displaystyle | \frac { d ( D ( x ) + \delta ( p _ { D } ( x ) - p _ { G } ( x ) ) ) } { d x } | _ { 2 } \leq | \frac { d D ( x ) } { d x } | _ { 2 } + \delta ( | \frac { p _ { D } ( x ) } { d x } | _ { 2 } + | \frac { p _ { G } ( x ) } { d x } ) | _ { 2 } } \\ { \leq 0 . 5 + \delta ( M + M ) . } \end{array}
+$$
+
+By letting $\begin{array} { r } { \delta = \frac { 1 } { 4 M } } \end{array}$ , we have $| \frac { d ( D ^ { \prime } ) } { d x } | _ { 2 } \leq 0 . 7 5$ . Therefore we have $D ^ { \prime } ( x ) \in \Omega _ { 1 }$ .
+
+The above theorem indicates that when $D ( x )$ is sufficient close to the equilibrium, then the dynamics of $D$ still follows Eqn. (10).
+
+# E CONNECTION TO REGULARIZATION ON JACOBIAN MATRIX
+
+In this paper, we mainly analyze our proposed method in the functional space, including stability analysis and controller designing. Instead, our proposed method can also be interpreted as certain regularization terms on the Jacobian matrix of the training dynamics. Below we provide a formal demonstration.
+
+First, we denote the equilibrium of $G$ and $D$ in the functional space as $( \theta ^ { * } , \phi ^ { * } )$ , where $p _ { G } ( x ; \theta ^ { * } ) =$ $p _ { D } ( x )$ and $D ( x ; \phi ^ { * } ) \bar { = } 0$ for all $x$ . Therefore, we have that $\phi ^ { * }$ is also a global minimum point of the regularization term $\begin{array} { r } { L ( D ) = \int D ^ { 2 } ( x ) d x } \end{array}$ . Then we have ∂2L(D) 0.
+
+We denote $U ( D , G )$ as the objective function of the minimax optimization problem in WGAN without NF regularization. Then the Jacobian matrix of the training dynamic can be denoted as:
+
+$$
+\begin{array} { r } { J = \left( \begin{array} { c c } { \frac { \partial ^ { 2 } U ( D , G ) } { \partial \phi ^ { 2 } } } & { \frac { \partial ^ { 2 } U ( D , G ) } { \partial \phi \partial \theta } } \\ { \frac { \partial ^ { 2 } U ( D , G ) } { \partial \theta \partial \phi } } & { \frac { \partial ^ { 2 } U ( D , G ) } { \partial \theta ^ { 2 } } } \end{array} \right) . } \end{array}
+$$
+
+Because of the linearity of the derivation, the training dynamics of the WGAN with NF regularization is denoted as:
+
+$$
+\begin{array} { r } { J ^ { \prime } = J - J _ { L } = J - \left( \begin{array} { c c } { \frac { \partial ^ { 2 } L ( D ) } { \partial \phi ^ { 2 } } } & { \mathbf { 0 } } \\ { \mathbf { 0 } } & { \mathbf { 0 } } \end{array} \right) , } \end{array}
+$$
+
+where we abuse the 0 to denote the zero matrix with certain size to match the size of $J$ . Since ∂2L(D)∂φ2  0, we have −JL  0. Therefore, the NF regularization introduces a negative semi-definite matrix to the original Jacobian matrix, which is helpful to stabilize the training dynamics of GANs.

parse/train/Kai3KkCOCp/Kai3KkCOCp.md

@@ -0,0 +1,390 @@
+# One-to-many Approach for Improving Super-Resolution
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Super-resolution (SR) is a one-to-many task with multiple possible solutions. However, previous works were not concerned about this characteristic. For a oneto-many pipeline, the generator should be able to generate multiple estimates of the reconstruction, and not be penalized for generating similar and equally realistic images. To achieve this, we propose adding weighted pixel-wise noise after every Residual-in-Residual Dense Block (RRDB) to enable the generator to generate various images. We modify the strict content loss to not penalize the stochastic variation in reconstructed images as long as it has consistent content. Additionally, we observe that there are out-of-focus regions in the DIV2K, DIV8K datasets that provide unhelpful guidelines. We filter blurry regions in the training data using the method of [10]. Finally, we modify the discriminator to receive the lowresolution image as a reference image along with the target image to provide better feedback to the generator. Using our proposed methods, we were able to improve the performance of ESRGAN in $\times 4$ perceptual SR and achieve the state-of-the-art LPIPS score in $\times 1 6$ perceptual extreme SR.
+
+# 16 1 Introduction
+
+17 Super-resolution is the task of recovering a high-resolution (HR) image from a low-resolution (LR)   
+18 image. Recent works have achieved significant performance in SR using deep convolutional neural   
+19 network (CNN) based approaches. Some of them exploit strict content loss as the training objective   
+20 for super-resolution and propose various network architectures to improve the PSNR score. However,   
+21 these methods often result in overly smooth images and have poor perceptual quality [6]. Another   
+22 branch of works focuses on improving perceptual quality with perceptual training methods [1,6,7].   
+23 These methods employ generative adversarial networks (GAN) and perceptual loss functions to drive   
+24 the network’s output towards the natural image manifold of possible HR images. We assess an1d   
+25 further improve the perceptual quality of these works.   
+26 Because super-resolution is a one-to-many problem with multiple possible reconstructions for one   
+27 image, methods based on strict content loss often lead to predicting the average of possible reconstruc  
+28 tions[6]. Perceptual-driven solutions utilize perceptual and adversarial loss, which both don’t penalize   
+29 the generator for generating equally realistic images with stochastic variance. However, we discover   
+30 two incomplete aspects in the current perceptual SR pipeline. First, although the above-mentioned   
+31 losses don’t penalize stochastic variation, the final loss is mixed with the strict content loss which   
+32 strictly penalizes these variations. Second, the generator doesn’t have the ability to generate multiple   
+33 estimates of the image despite a one-to-many problem. To implement such a one-to-many pipeline,   
+34 we provide the generator with pixel-wise noise and improve the content loss so it doesn’t restrict the   
+35 variation in the image while ensuring the consistency of the content.
+
+36 The key contributions of our work can be described as follows:
+
+• We propose a weaker content loss that does not penalize generating high-frequency detail and stochastic variation in the image.   
+• We enable the generator to generate diverse outputs by adding scaled pixel-wise noise after each RRDB block.   
+• We filter blurry regions in the training data using Laplacian activation[10].   
+• We additionally provide the LR image to the discriminator to give better gradient feedback to the generator.
+
+# 44 2 Related work
+
+45 Since the pioneering work of SRCNN[9], many works have exploited the pixel-wise loss and PSNR  
+46 oriented training objectives to learn the end-to-end mapping from LR to HR images. We denote   
+47 such pixel-wise losses as the strict content loss. Many network architectures and techniques were   
+48 experimented with to improve the complexity of such networks. Deeper network architectures[17],   
+49 residual networks[6], channel attention[18], and techniques to remove batch normalization[19] were   
+50 introduced. Although these works achieved state-of-the-art SR performance in the peak signal-to  
+51 noise ratio (PSNR) metric, they often produce overly smooth images.   
+52 To improve the perceptual image quality of SR, SRGAN [6] proposes perceptual loss and GAN-based   
+53 training. The perceptual loss is measured using intermediate activations of the VGG-19 network and   
+54 a discriminator is used for the adversarial training process. Enhanced SRGAN (ESRGAN) further   
+55 improves SRGAN by modifying the generator architecture with Residual in Residual Dense Block   
+56 (RRDB), the Relativistic GAN [16] loss, and improving the perceptual loss. Such methods were   
+57 superior to PSNR-oriented methods at generating photo-realistic SR images with sharp details, achiev  
+58 ing high perceptual scores. However, we could still often find unpleasant artifacts and problematic   
+59 textures in the reconstructions of ESRGAN. Such cases are exemplified in Figure 4.   
+60 Traditional metrics for assessing image quality such as PSNR and SSIM (Structural Similarity Index   
+61 Measure) fail to coincide with human perception[4]. The PSNR score is calculated based on the   
+62 pixel-wise MSE, so methods that minimize pixel-wise differences tend to achieve high PSNR scores   
+63 [9]. However, the PSNR-oriented solutions fail at generating high-frequency details and often drive   
+64 the reconstruction towards the average of possible solutions, producing overly smooth images[6]. The   
+65 learned perceptual image patch similarity (LPIPS) score[4] was proposed to measure the perceptual   
+66 quality on various computer vision tasks. According to [2], the LPIPS score reliably coincides with   
+67 human perception for assessing super-resolved images. We use the LPIPS score as an indicator of   
+68 perceptual image quality in our experiments.   
+69 CycleGAN[8] is a pipeline for image-to-image translation with unpaired images using generative   
+70 adversarial nets and cycle loss. CycleGAN consists of 2 generators $G _ { 1 } , G _ { 2 }$ , and 2 discriminators   
+71 $D _ { 1 } , D _ { 2 }$ , where $G _ { 1 }$ and $G _ { 2 }$ each translate the input image in a cycling manner. The generators are   
+72 trained to minimize the adversarial loss and cycle loss $| | \bar { G } _ { 2 } ( G _ { 1 } ( \bar { x } ) ) - \bar { x } | | _ { 1 }$ between the input image   
+73 and cycled image. We were able to design a loss based on the cycle loss to reliably measure the   
+74 content consistency without such a complicated design.
+
+# 75 3 Method
+
+76 We design a one-to-many approach for perceptual super-resolution by modifying the generator and the   
+77 training objective. We also describe additional modifications to the training process and discriminator   
+78 to improve the perceptual quality of SR.
+
+# 3.1 Cycle consistency loss
+
+80 Most works on perceptual super-resolution[1, 6, 7] combine the content loss, adversarial loss (GAN   
+81 loss), and perceptual loss for the training objective as in Equation 1. Although the strict content   
+82 loss and adversarial loss are fundamentally disagreeing objectives, relying exclusively on either loss   
+83 each has significant issues. The strict content loss guides the network output to be exactly consistent   
+84 with the HR image, guiding the network to learn the mean of possible reconstructions and thus   
+85 tends to give overly-smoothed results. Although the GAN framework is a powerful method for   
+86 photo-realistic image generation, adversarial learning is highly unstable, and while the adversarial   
+87 loss and perceptual loss guide the network to be perceptually convincing, they don’t enforce the   
+88 content of the super-resolved image to be consistent with the low-resolution image.
+
+![](images/5f90468a9ff0b9cfbc11281c309a3a4cf86bef35fe571f45672f0724d203820f.jpg)  
+Figure 1: An overview of our method. The cycle consistency loss is measured by comparing the LR image with the downsampled SR image. The discriminator is provided with the target image and a reference image generated by bicubic-upsampling the LR image.
+
+$$
+L _ { T o t a l } = L _ { p e r c e p } + \lambda L _ { G A N } + \eta L _ { 1 }
+$$
+
+89 We regard simply trading off these disagreeing losses as an incomplete objective for super-resolution   
+90 since the mixing of such losses will obstruct the optimization of either loss. An improved training   
+91 objective must be GAN-oriented while ensuring consistent content of the image. That is, there needs   
+92 a content loss that doesn’t hamper the generation of images with high-frequency details.   
+93 We propose a soft content loss inspired by the cycle loss of CycleGAN[8] to ensure the output of   
+94 the generator to be consistent with the low-resolution image while not disturbing the generation of   
+95 high-frequency information.   
+96 We view the super-resolution problem as an image-to-image translation task between the LR and HR   
+97 image space and apply the CycleGAN framework. To simplify the problem, we exploit our prior   
+98 knowledge on $G _ { 2 } : H R - > L R$ . We can denote the downsampling operation as $f$ and set $G _ { 2 }$ to   
+99 be $f$ instead of learning it. Consequently, our pipeline doesn’t require learning $D _ { 2 }$ which is a tool   
+100 for learning $G _ { 2 }$ . This leaves only $G _ { 1 }$ and $D _ { 1 }$ to be learned. We can write the cycle consistency loss   
+101 as Equation 2. This loss won’t penalize generating high-frequency details in any way while the SR   
+102 image remains consistent with the LR image. Finally, we can conclude our generator loss as Equation   
+103 3.
+
+$$
+L _ { c y c } ( G _ { 1 } ) = | | f ( G _ { 1 } ( L R ) ) - L R | | _ { 1 }
+$$
+
+$$
+L _ { T o t a l } ( G _ { 1 } ) = L _ { c y c } ( G _ { 1 } ) + \lambda L _ { G A N } ( G _ { 1 } , D _ { 1 } ) + \eta L _ { p e r c e p }
+$$
+
+# 104 3.2 Providing scaled Gaussian noise to the generator
+
+105 For the generator to be capable of generating more than one solution given a single image, it must   
+106 receive and apply random information. The variation between super-resolved images will mostly   
+107 be stochastic variation in high-frequency textures. StyleGAN[3] achieves stochastic variation in   
+108 images by adding pixel-wise Gaussian noise to the output of each layer in the generator. We adopt   
+109 this method and add the noise after every RRDB layer in the generator.   
+110 However, the sensitivity and the desired magnitude of noise would differ for each channel. Adding   
+111 the same noise directly after every layer could rather harm the ability of the generator. For example, a   
+112 channel that detects edges would be seriously harmed by the noise. The sensitivity will also depend on   
+113 the depth of the network. To mitigate such possible issues, we allow each channel to learn the desired   
+114 magnitude of the noise. Specifically, before adding the noise to the output of each layer, we multiply   
+115 the noise with a channel-wise scaling factor. The scaling factor is learned concurrently with the   
+116 network parameters. We observe that the desired magnitude differs along the network depending on   
+117 the position of the layer. This shows that our method effectively implements a one-to-many generator   
+118 for super-resolution. The early layers seem to be focusing more on extracting the feature of the image,   
+119 while the final layers preferred the noise to be scaled before being applied to the reconstruction.   
+120 Details are illustrated in Figure 2. The noise is not applied at evaluation.
+
+![](images/1e3c823f21bfc1f901341939547cf91481685756bdee3aed3434cd2a7666db6d.jpg)  
+Figure 2: Boxplot of the scaling factors against the position of the layer in the network. The desired magnitude of noise increases in deeper layers, while the final layers have smaller scaling factors. The sensitivity to random noise varies for each layer and channel.
+
+# 21 3.3 Reference image for the discriminator
+
+122 Traditionally, the discriminator network receives a single image and is trained to classify whether the   
+123 given image is real or a generated image. This setting will provide the generator with gradients to   
+124 "any natural image" instead of towards the corresponding HR image. In an extreme example, the   
+125 traditional discriminator won’t penalize the generator for generating completely different but equally   
+126 realistic images from an LR image. Although this is unlikely due to the existence of other content   
+127 and perceptual losses, the gradient feedback given by the discriminator is sub-optimal for the task of   
+128 super-resolution.   
+129 As a solution, we provide the low-resolution image as a reference along with the target image to the   
+130 discriminator. This enables the discriminator to learn more important features for discriminating   
+131 the generated image and provide better gradient feedback according to the LR image. For details,   
+132 refer to Figure 1. We upsample the LR image to the same size as the HR image and concatenate   
+133 them, feeding a tensor of shape $( H , W , 6 )$ to the discriminator. Despite its simplicity, conditioning   
+134 the discriminator on the input is a crucial modification for training such a supervised problem with   
+135 GAN-oriented losses.
+
+# 136 3.4 Blur detection
+
+137 We recognized that there are often severely blurry regions in the images from the DIV2K[14] and   
+138 DIV8K[15] datasets. Although the authors of [15] argue that the data was collected by "paying special   
+139 attention to image quality", there were many scenes with out-of-focus backgrounds. These blurry   
+140 regions might plague the generator to learn to generate such blurry patches. Blurry backgrounds are   
+141 often indistinguishable from finer objects based only on the LR image. Though some might argue   
+142 that the blurry backgrounds must also be learned, we were able to achieve finer detail and higher   
+143 LPIPS score by detecting and removing blurry patches from both datasets.   
+144 We propose to detect and remove blurry patches before the network is trained on those patches.   
+145 There are various methods for blur detection e.g. algorithmic methods and deep-learning-based   
+146 approaches[11, 12]. However, most deep-learning-based works focus on predicting pixel-wise blur   
+147 maps of the image, which wouldn’t be suited for our needs. Mostly, the algorithmic method of [10]   
+148 was successful at reliably detecting blurry patches as can be observed in Figure 3. We measure the   
+149 variance of the Laplacian activation of the patch and consider patches with variance of under 100 as   
+150 blurry patches. The algorithm detects $2 8 . 8 \%$ blurry patches in a sample of 16,000 randomly cropped   
+151 patches of size $9 6 \times 9 6$ from the DIV2K dataset and $4 8 . 9 \%$ of patches in a sample of 140,000 patches   
+152 from the DIV8K dataset.
+
+![](images/5b3c8f92720e92734d7bbff6c27ce08971f0c5ca993ec1d559aa6ae4a040373b.jpg)  
+Figure 3: Randomly selected samples of the blur detection algorithm tested on image 0031 from the DIV8K dataset. The top two rows are the patches classified as clear and the bottom rows are blurry patches. Regions that are clear in the image (person, pole) are correctly considered as clear patches by the detection algorithm.
+
+# 153 4 Experiments
+
+154 We conduct experiments to evaluate the effectiveness of our proposed techniques in $\times 4$ and $\times 1 6$   
+155 resolution and compare them with the baseline ESRGAN. We first experiment the effects of blur   
+156 detection, then we perform an ablation study of our proposed training methods to evaluate their   
+157 effectiveness. Implementation detail and training logs can be found on GitHub1. All our experiments   
+158 were performed on a single Tesla T4 or Tesla K80 GPU on Google Colaboratory.   
+159 We observed that a large portion of the training was used for loading high-resolution images, despite   
+160 most of the images not being used. As an implementation detail to improve training speed significantly,   
+161 we extract multiple patches and save them in a buffer while training instead of extracting only a single   
+162 patch after loading the image. We randomly pick images from the buffer for training and discard the   
+163 selected patches from the buffer. In all of our experiments, we extract 128 patches from each image   
+164 and create a buffer of 1024 patches.
+
+# 4.1 $\times 4$ super-resolution
+
+# 4.1.1 Training details
+
+167 We employ the ESRGAN network architecture with 23 RRDB blocks and most of its training   
+168 configurations for the baseline of our experiments on $\times 4$ super-resolution. The training process is   
+169 divided into two stages. We first pretrain the PSNR-oriented models then train the ESRGAN-based   
+170 models.   
+71 The PSNR-oriented models are trained with the L1 loss with a batch size of 16 for 500K iterations.   
+72 We apply learning rate decay with an initial learning rate of $2 \times 1 0 ^ { - 4 }$ , decayed by a factor of 2   
+73 every $2 0 0 k$ iterations. We initialize the GAN-based model with the PSNR-oriented model. We   
+74 initialize the learning rate with $1 \times 1 0 ^ { - 4 }$ for both $G _ { 1 }$ and $D _ { 1 }$ , decaying the learning rate by a factor   
+75 of 2 at $[ 5 0 k , 1 0 0 k , 2 0 0 k , 3 0 0 k ]$ iterations. For optimization, we use the Adam optimizer for both   
+76 pretrained networks and GAN-based models, with $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9$ . The learning rate decay   
+77 schedule corresponds to the one proposed by ESRGAN. We implement our models and methods with   
+78 the Tensorflow framework. The loss function is scaled with $\eta = 1 0$ and $\lambda = 5 \times 1 0 ^ { - 3 }$ , which is   
+79 equivalent to the training configuration of ESRGAN used in the PIRM-SR challenge. This is slightly   
+80 different from the configuration used in the released model trained with $\eta = 1 0 ^ { - 2 }$ .   
+181 All of our networks are trained exclusively on the DIV2K dataset[14], while the original ESRGAN   
+182 was trained with DIV2K, Flickr2K, and OST datasets combined. We obtained the LR images by   
+183 downsampling the HR images with MATLAB bicubic interpolation. We compare the effects of our   
+184 methods on LPIPS, PSNR, and SSIM scores on the Set5, Set14, BSD100, and Urban100 datasets.   
+185 Scores evaluated on the Set5 and Set14 datasets are obtained by averaging the final 5 checkpoints,   
+186 each recorded at [480k, 485k, 490k, $4 9 5 k$ , $5 0 0 k ]$ iterations.
+
+Table 1: LPIPS, PSNR, SSIM scores of various configurations for $\times 4$ .   
+
+<table><tr><td>Methods</td><td>Set5 (LPIPS /PSNR/SSIM)</td><td>Set14</td><td>BSD100</td><td>Urban100</td></tr><tr><td>Pretrained (a)</td><td>0.1341/30.3603/0.8679</td><td>0.2223/26.7608/0.7525</td><td>0.2705/27.2264/0.7461</td><td>0.1761/24.8770/0.7764</td></tr><tr><td>+Blur detection (b)</td><td>0.1327 /30.4582/0.7525</td><td>0.2229 /26.8448 /0.7547</td><td>0.2684 /27.2545 /0.7473</td><td>0.1744/25.0816 /0.7821</td></tr><tr><td>ESRGAN (Official)</td><td>0.0597/28.4362/0.8145</td><td>0.1129/23.4729/0.6276</td><td>0.1285/23.3657/0.6108</td><td>0.1025/22.7912/0.7058</td></tr><tr><td>ESRGAN (c)</td><td>0.0538/27.9285/0.7968</td><td>0.1117/24.5264/0.6602</td><td>0.1256/24.6554/0.6447</td><td>0.1026/23.2829/0.7137</td></tr><tr><td>+refGAN (d)</td><td>0.0536 /27.9871/0.8014</td><td>0.1157 /24.4505 /0.6611</td><td>0.1275 /24.5896 /0.6470</td><td>0.1027 /23.0496 /0.7103</td></tr><tr><td>+Add noise (e)</td><td>0.04998/28.23/0.8081</td><td>0.1104 /24.48/0.6626</td><td>0.1209 /24.8439 /0.6577</td><td>0.1007 /23.2204 /0.7203</td></tr><tr><td>+Cycle loss (f)</td><td>0.0524/28.1322/0.8033</td><td>0.1082 /24.5802/0.6634</td><td>0.1264/24.6180 /0.6468</td><td>0.1015 /23.1363 /0.7103</td></tr><tr><td>-Perceptual loss (g)</td><td>0.2690 / 23.4608 /0.6312</td><td>0.2727 /22.2703 /0.5685</td><td>0.2985 /24.1648 /0.5859</td><td>0.2411 /20.8169 /0.6244</td></tr></table>
+
+# 4.1.2 Ablation study
+
+188   
+189   
+190   
+191   
+192   
+193   
+194   
+195   
+196   
+197   
+198   
+199   
+200   
+201
+
+To study the effects of our proposed methods, we perform an ablation study of our proposed method. We enable our proposed methods one by one and list the resulting scores in Table 1. Each training configuration was fully trained with the original training configurations. We provide the saved model and configuration files to reproduce our results in our project repository. We also list the results of the official ESRGAN for fair comparison. The improvements from the official results and the result from configuration(c) is because the $\eta$ value is different from the official model. First, blur detection is experimented with in configuration(b) and improves the LPIPS score for all benchmarks. We train our baseline ESRGAN in configuration(c) and get reasonable results. By applying the technique of Section 3.3 in configuration(d), we slightly harm the network in terms of the LPIPS score. However, providing conditional information to the discriminator is crucial for learning such a supervised problem with adversarial learning. Our method of directly concatenating the reference image in the input is not optimal. The low-resolution image could be applied through SPADE[20] or alternative spatial transformation methods for improvements. Applying scaled noise shows large improvements as experimented in configuration(e).
+
+202 The cycle consistency loss applied in configuration(f) shows neutral and slightly negative effects   
+203 on the LPIPS score. The reason for this is mostly because of the incompetent GAN framework   
+204 lacking the training techniques of modern GAN literature. Our statement is stated by the failure of   
+205 configuration(g) where the GAN framework alone is responsible for learning the super-resolution   
+206 process. The GAN framework of ESRGAN is incapable of lead the training process and thus   
+207 the image quality wasn’t improved when we gave more responsibility to the adversarial loss in   
+208 configuration(f). However, coupled with improved GAN techniques in further research, the cycle   
+209 consistency content loss will further enhance the image quality.
+
+# 4.2 $\times 1 6$ super-resolution
+
+# 4.2.1 Training details
+
+12 We employ the RFB-ESRGAN of [21] as the baseline for our experiments on $\times 1 6$ super-resolution.   
+13 The RFB-ESRGAN proposes an architecture using Receptive Field Blocks(RFB) and Residual of   
+14 Receptive Field Dense Block(RRFDB), each as an alternative for convolution and RRDB blocks. The   
+15 RFB-ESRGAN uses less memory compared to methods that manipulate the image in the intermediate   
+16 $\times 4$ resolution[22] and this allowed larger batch size in our environment. We employ the RFB  
+17 ESRGAN network architecture with 16 RRDB blocks and 8 RRFDB blocks for the baseline of our   
+18 experiments on $\times 1 6$ super-resolution.   
+219 The model is first trained with the L1 loss for 100K iterations with an initial learning rate $2 \times 1 0 ^ { - 4 }$   
+220 decayed by a factor of two every $2 . 5 \times 1 0 ^ { 5 }$ iteration. The GAN-based model is initialized with the   
+221 pretrained model and is trained for 200K iterations, which is shorter than the original 400K iterations.   
+222 Additionally, the batch size is decreased from 16 to 4 and we therefore approximately scale the   
+223 initial learning rate of $1 0 ^ { - 4 }$ to $2 \times 1 0 ^ { - 5 }$ by a factor of 5. The learning rate is decayed at $[ 5 0 k , 1 0 0 k ]$   
+4 iterations. We don’t use model ensemble to further stabilize the network. All other models and   
+25 hyperparameter configurations are equal. We train the network on the DIV8K dataset[15], while the   
+26 original network was trained with additional datasets including DIV2K, Flicker2K, OST dataset. The   
+27 first 1,400 images of DIV8K are used as training data and the rest 100 validation images are used for   
+28 evaluation.
+
+Table 2: LPIPS, PSNR scores for various configurations for $\times 1 6$ super-resolution.   
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>DIV8K validation</td></tr><tr><td rowspan=1 colspan=1>Pretrained (a)+Blur detection (b)</td><td rowspan=1 colspan=1>0.4664/30.36030.4603 / 25.53</td></tr><tr><td rowspan=1 colspan=1>RFB-ESRGAN(official)</td><td rowspan=1 colspan=1>0.345 /24.03</td></tr><tr><td rowspan=1 colspan=1>Baseline RFB-ESRGAN (c)Ours w/o cycle-loss (d)Ours w/ cycle-loss (e)</td><td rowspan=1 colspan=1>0.356/24.780.321 / 23.950.323 / 23.49</td></tr></table>
+
+# 4.2.2 Ablation study
+
+The PSNR-oriented method is improved using blur detection in configuration(b). Our GAN-baed model of configuration(c) achieves worse performance compared the the results reported in [21] because of the lighter training configurations. We were able to make significant improvements in the LPIPS score from the baseline RFB-ESRGAN using our proposed methods in configuration(d). We apply all of our proposed methods except the cycle consistency loss in configuration(d). We also train the model with cycle consistency loss and get similar results in configuration(e). We were able to make such improvements using much lighter training configurations with only half iteration steps, $\times 4$ smaller batch size, and without model ensemble. The results are described in Table 2.
+
+# 238 5 Conclusion
+
+239 We proposed a one-to-many approach for super-resolution and achieve improved perceptual quality   
+240 and better LPIPS score from the baseline ESRGAN configuration and achieve the state-of-art LPIPS   
+241 score in $\mathbf { \boldsymbol { x } } 1 6$ perceptual super-resolution. We provide scaled pixel-wise to the generator to allow   
+242 stochastic variation in the reconstructed image and implement a generator capable of a one-to-many   
+243 pipeline. We also address the limitations of mixing the strict content loss with perceptual losses and   
+244 propose an alternative based on the cycle loss. Our newly modified loss will ensure the consistency   
+245 of the content while not penalizing high-frequency detail. Additionally, we further propose more   
+246 techniques such as blur detection using Laplacian activation and redesign the discriminator input by   
+247 providing a reference image to further improve the perceptual quality of $\times 4$ and $\times 1 6$ super-resolution.   
+248 However, the GAN framework from ESRGAN was incompetent to guide the training on its own.   
+249 Modern GAN training techniques could be applied to further improve the GAN framework used   
+250 in super-resolution. Our proposed loss function will become more effective as a content loss when   
+251 coupled with a robust GAN framework since it will reduce constraints in generating high-frequency   
+252 detail. Such improvements are left for future work.   
+254 [1] Wang, Xintao, et al. "Esrgan: Enhanced super-resolution generative adversarial networks." Proceedings of   
+255 the European Conference on Computer Vision (ECCV) Workshops. 2018.   
+256 [2] Zhang, Kai, Shuhang Gu, and Radu Timofte. "Ntire 2020 challenge on perceptual extreme super-resolution:   
+257 Methods and results." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition   
+258 Workshops. 2020.   
+259 [3] Karras, Tero, Samuli Laine, and Timo Aila. "A style-based generator architecture for generative adversarial   
+260 networks." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   
+261 [4] Zhang, Richard, et al. "The unreasonable effectiveness of deep features as a perceptual metric." Proceedings   
+262 of the IEEE conference on computer vision and pattern recognition. 2018.   
+263 [5] Jo, Younghyun, Sejong Yang, and Seon Joo Kim. "Investigating loss functions for extreme super-resolution."   
+264 Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020.   
+265 [6] Ledig, Christian, et al. "Photo-realistic single image super-resolution using a generative adversarial network."   
+266 Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.   
+267 [7] Sajjadi, Mehdi SM, Bernhard Scholkopf, and Michael Hirsch. "Enhancenet: Single image super-resolution   
+268 through automated texture synthesis." Proceedings of the IEEE International Conference on Computer Vision.   
+269 2017.   
+270 [8] Zhu, Jun-Yan, et al. "Unpaired image-to-image translation using cycle-consistent adversarial networks."   
+271 Proceedings of the IEEE international conference on computer vision. 2017.   
+272 [9] Dong, Chao, et al. "Image super-resolution using deep convolutional networks." IEEE transactions on pattern   
+273 analysis and machine intelligence 38.2 (2015): 295-307.   
+274 [10] Bansal, Raghav, Gaurav Raj, and Tanupriya Choudhury. "Blur image detection using Laplacian operator   
+275 and Open-CV." 2016 International Conference System Modeling & Advancement in Research Trends (SMART).   
+276 IEEE, 2016.   
+277 [11] Tang, Chang, et al. "Defusionnet: Defocus blur detection via recurrently fusing and refining multi-scale   
+278 deep features." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   
+279 [12] Wang, Xuewei, et al. "Accurate and fast blur detection using a pyramid M-Shaped deep neural network."   
+280 IEEE Access 7 (2019): 86611-86624.   
+281 [13] Yuan, Yuan, et al. "Unsupervised image super-resolution using cycle-in-cycle generative adversarial   
+282 networks." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops. 2018.   
+283 [14] Agustsson, Eirikur, and Radu Timofte. "Ntire 2017 challenge on single image super-resolution: Dataset and   
+284 study." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops. 2017.   
+285 [15] Gu, Shuhang, et al. "Div8k: Diverse 8k resolution image dataset." 2019 IEEE/CVF International Conference   
+286 on Computer Vision Workshop (ICCVW). IEEE, 2019.   
+287 [16] Jolicoeur-Martineau, Alexia. "The relativistic discriminator: a key element missing from standard GAN."   
+288 arXiv preprint arXiv:1807.00734 (2018).   
+289 [17] Kim, Jiwon, Jung Kwon Lee, and Kyoung Mu Lee. "Accurate image super-resolution using very deep   
+290 convolutional networks." Proceedings of the IEEE conference on computer vision and pattern recognition. 2016.   
+291 [18] Zhang, Yulun, et al. "Image super-resolution using very deep residual channel attention networks."   
+292 Proceedings of the European conference on computer vision (ECCV). 2018.   
+293 [19] Lim, Bee, et al. "Enhanced deep residual networks for single image super-resolution." Proceedings of the   
+294 IEEE conference on computer vision and pattern recognition workshops. 2017.   
+295 [20] Park, Taesung, et al. "Semantic image synthesis with spatially-adaptive normalization." Proceedings of the   
+296 IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   
+297 [21] Shang, Taizhang, et al. "Perceptual extreme super-resolution network with receptive field block." Proceed  
+298 ings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020.   
+299 [22] Jo, Younghyun, Sejong Yang, and Seon Joo Kim. "Investigating loss functions for extreme super-resolution."   
+300 Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020.
+
+![](images/1a6d0d9b88734d4ca44353bccc5cbf928b82be5e1b229157482c43899b74b8e8.jpg)  
+Figure 4: Qualitative comparison of our methods with the official ESRGAN. We compare the poorly reconstructed outputs of ESRGAN from BSD100 and Urban100 datasets with our proposed model trained with configuration(f). Our method produces sharp textures and more realistic structures compared to the baseline ESRGAN, although it also fails to accurately reconstruct human faces.
+
+# Checklist
+
+The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example:
+
+• Did you include the license to the code and datasets? [Yes] See Section 2. • Did you include the license to the code and datasets? [No] The code and the data are proprietary. • Did you include the license to the code and datasets? [N/A]
+
+Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The focus of our paper is on the proposal of a one-to-many pipeline for super-resolution.   
+(b) Did you describe the limitations of your work? [Yes] The GAN framework used in our work was weak despite the successes of modern GANs.   
+(c) Did you discuss any potential negative societal impacts of your work? [No]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] As mentioned in the paper, all the code and training configurations are available at https://github.com/krenerd/ultimate-sr.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] There was hardware limitations for repeating our work multiple times, however the ablation study sufficiently described improvements of our methods.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All our experiments were executed on Google COLAB with a single Tesla T4 or Tesla K80 GPU.
+
+If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] The DIV2K and DIV8K dataset was used and cited.   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] The DIV2K dataset was used for the baseline ESRGAN, which was compared with our methods and the DIV8K dataset was used for the RFB-ESRGAN.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/Kai3KkCOCp/Kai3KkCOCp_content_list.json

@@ -0,0 +1,921 @@
+[
+    {
+        "type": "text",
+        "text": "One-to-many Approach for Improving Super-Resolution ",
+        "text_level": 1,
+        "bbox": [
+            264,
+            122,
+            735,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Super-resolution (SR) is a one-to-many task with multiple possible solutions. However, previous works were not concerned about this characteristic. For a oneto-many pipeline, the generator should be able to generate multiple estimates of the reconstruction, and not be penalized for generating similar and equally realistic images. To achieve this, we propose adding weighted pixel-wise noise after every Residual-in-Residual Dense Block (RRDB) to enable the generator to generate various images. We modify the strict content loss to not penalize the stochastic variation in reconstructed images as long as it has consistent content. Additionally, we observe that there are out-of-focus regions in the DIV2K, DIV8K datasets that provide unhelpful guidelines. We filter blurry regions in the training data using the method of [10]. Finally, we modify the discriminator to receive the lowresolution image as a reference image along with the target image to provide better feedback to the generator. Using our proposed methods, we were able to improve the performance of ESRGAN in $\\times 4$ perceptual SR and achieve the state-of-the-art LPIPS score in $\\times 1 6$ perceptual extreme SR. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            580,
+            312,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 Super-resolution is the task of recovering a high-resolution (HR) image from a low-resolution (LR)   \n18 image. Recent works have achieved significant performance in SR using deep convolutional neural   \n19 network (CNN) based approaches. Some of them exploit strict content loss as the training objective   \n20 for super-resolution and propose various network architectures to improve the PSNR score. However,   \n21 these methods often result in overly smooth images and have poor perceptual quality [6]. Another   \n22 branch of works focuses on improving perceptual quality with perceptual training methods [1,6,7].   \n23 These methods employ generative adversarial networks (GAN) and perceptual loss functions to drive   \n24 the network’s output towards the natural image manifold of possible HR images. We assess an1d   \n25 further improve the perceptual quality of these works.   \n26 Because super-resolution is a one-to-many problem with multiple possible reconstructions for one   \n27 image, methods based on strict content loss often lead to predicting the average of possible reconstruc  \n28 tions[6]. Perceptual-driven solutions utilize perceptual and adversarial loss, which both don’t penalize   \n29 the generator for generating equally realistic images with stochastic variance. However, we discover   \n30 two incomplete aspects in the current perceptual SR pipeline. First, although the above-mentioned   \n31 losses don’t penalize stochastic variation, the final loss is mixed with the strict content loss which   \n32 strictly penalizes these variations. Second, the generator doesn’t have the ability to generate multiple   \n33 estimates of the image despite a one-to-many problem. To implement such a one-to-many pipeline,   \n34 we provide the generator with pixel-wise noise and improve the content loss so it doesn’t restrict the   \n35 variation in the image while ensuring the consistency of the content. ",
+        "bbox": [
+            147,
+            612,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            742,
+            825,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "36 The key contributions of our work can be described as follows: ",
+        "bbox": [
+            147,
+            887,
+            584,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• We propose a weaker content loss that does not penalize generating high-frequency detail and stochastic variation in the image.   \n• We enable the generator to generate diverse outputs by adding scaled pixel-wise noise after each RRDB block.   \n• We filter blurry regions in the training data using Laplacian activation[10].   \n• We additionally provide the LR image to the discriminator to give better gradient feedback to the generator. ",
+        "bbox": [
+            181,
+            90,
+            826,
+            207
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "44 2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            224,
+            316,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "45 Since the pioneering work of SRCNN[9], many works have exploited the pixel-wise loss and PSNR  \n46 oriented training objectives to learn the end-to-end mapping from LR to HR images. We denote   \n47 such pixel-wise losses as the strict content loss. Many network architectures and techniques were   \n48 experimented with to improve the complexity of such networks. Deeper network architectures[17],   \n49 residual networks[6], channel attention[18], and techniques to remove batch normalization[19] were   \n50 introduced. Although these works achieved state-of-the-art SR performance in the peak signal-to  \n51 noise ratio (PSNR) metric, they often produce overly smooth images.   \n52 To improve the perceptual image quality of SR, SRGAN [6] proposes perceptual loss and GAN-based   \n53 training. The perceptual loss is measured using intermediate activations of the VGG-19 network and   \n54 a discriminator is used for the adversarial training process. Enhanced SRGAN (ESRGAN) further   \n55 improves SRGAN by modifying the generator architecture with Residual in Residual Dense Block   \n56 (RRDB), the Relativistic GAN [16] loss, and improving the perceptual loss. Such methods were   \n57 superior to PSNR-oriented methods at generating photo-realistic SR images with sharp details, achiev  \n58 ing high perceptual scores. However, we could still often find unpleasant artifacts and problematic   \n59 textures in the reconstructions of ESRGAN. Such cases are exemplified in Figure 4.   \n60 Traditional metrics for assessing image quality such as PSNR and SSIM (Structural Similarity Index   \n61 Measure) fail to coincide with human perception[4]. The PSNR score is calculated based on the   \n62 pixel-wise MSE, so methods that minimize pixel-wise differences tend to achieve high PSNR scores   \n63 [9]. However, the PSNR-oriented solutions fail at generating high-frequency details and often drive   \n64 the reconstruction towards the average of possible solutions, producing overly smooth images[6]. The   \n65 learned perceptual image patch similarity (LPIPS) score[4] was proposed to measure the perceptual   \n66 quality on various computer vision tasks. According to [2], the LPIPS score reliably coincides with   \n67 human perception for assessing super-resolved images. We use the LPIPS score as an indicator of   \n68 perceptual image quality in our experiments.   \n69 CycleGAN[8] is a pipeline for image-to-image translation with unpaired images using generative   \n70 adversarial nets and cycle loss. CycleGAN consists of 2 generators $G _ { 1 } , G _ { 2 }$ , and 2 discriminators   \n71 $D _ { 1 } , D _ { 2 }$ , where $G _ { 1 }$ and $G _ { 2 }$ each translate the input image in a cycling manner. The generators are   \n72 trained to minimize the adversarial loss and cycle loss $| | \\bar { G } _ { 2 } ( G _ { 1 } ( \\bar { x } ) ) - \\bar { x } | | _ { 1 }$ between the input image   \n73 and cycled image. We were able to design a loss based on the cycle loss to reliably measure the   \n74 content consistency without such a complicated design. ",
+        "bbox": [
+            147,
+            257,
+            825,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            361,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            608,
+            825,
+            691
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "75 3 Method ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            712,
+            269,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "76 We design a one-to-many approach for perceptual super-resolution by modifying the generator and the   \n77 training objective. We also describe additional modifications to the training process and discriminator   \n78 to improve the perceptual quality of SR. ",
+        "bbox": [
+            148,
+            743,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 Cycle consistency loss ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            803,
+            364,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "80 Most works on perceptual super-resolution[1, 6, 7] combine the content loss, adversarial loss (GAN   \n81 loss), and perceptual loss for the training objective as in Equation 1. Although the strict content   \n82 loss and adversarial loss are fundamentally disagreeing objectives, relying exclusively on either loss   \n83 each has significant issues. The strict content loss guides the network output to be exactly consistent   \n84 with the HR image, guiding the network to learn the mean of possible reconstructions and thus   \n85 tends to give overly-smoothed results. Although the GAN framework is a powerful method for   \n86 photo-realistic image generation, adversarial learning is highly unstable, and while the adversarial   \n87 loss and perceptual loss guide the network to be perceptually convincing, they don’t enforce the   \n88 content of the super-resolved image to be consistent with the low-resolution image. ",
+        "bbox": [
+            148,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f90468a9ff0b9cfbc11281c309a3a4cf86bef35fe571f45672f0724d203820f.jpg",
+        "image_caption": [
+            "Figure 1: An overview of our method. The cycle consistency loss is measured by comparing the LR image with the downsampled SR image. The discriminator is provided with the target image and a reference image generated by bicubic-upsampling the LR image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            93,
+            818,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/150bd2ce25f5e6d8dd8533718f7494eade3e3811cf36eefee1dacf8296e548b5.jpg",
+        "text": "$$\nL _ { T o t a l } = L _ { p e r c e p } + \\lambda L _ { G A N } + \\eta L _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            396,
+            619,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "89 We regard simply trading off these disagreeing losses as an incomplete objective for super-resolution   \n90 since the mixing of such losses will obstruct the optimization of either loss. An improved training   \n91 objective must be GAN-oriented while ensuring consistent content of the image. That is, there needs   \n92 a content loss that doesn’t hamper the generation of images with high-frequency details.   \n93 We propose a soft content loss inspired by the cycle loss of CycleGAN[8] to ensure the output of   \n94 the generator to be consistent with the low-resolution image while not disturbing the generation of   \n95 high-frequency information.   \n96 We view the super-resolution problem as an image-to-image translation task between the LR and HR   \n97 image space and apply the CycleGAN framework. To simplify the problem, we exploit our prior   \n98 knowledge on $G _ { 2 } : H R - > L R$ . We can denote the downsampling operation as $f$ and set $G _ { 2 }$ to   \n99 be $f$ instead of learning it. Consequently, our pipeline doesn’t require learning $D _ { 2 }$ which is a tool   \n100 for learning $G _ { 2 }$ . This leaves only $G _ { 1 }$ and $D _ { 1 }$ to be learned. We can write the cycle consistency loss   \n101 as Equation 2. This loss won’t penalize generating high-frequency details in any way while the SR   \n102 image remains consistent with the LR image. Finally, we can conclude our generator loss as Equation   \n103 3. ",
+        "bbox": [
+            147,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            486,
+            825,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            534,
+            825,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c92e7ca9020f5d1341a0659b6e00126ea64ecc4f73148ba84b1ba518668429a.jpg",
+        "text": "$$\nL _ { c y c } ( G _ { 1 } ) = | | f ( G _ { 1 } ( L R ) ) - L R | | _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            665,
+            617,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96c60541a39583fb6f17bf5625dfdafa2c511708f3a39304a39995cf698e4cca.jpg",
+        "text": "$$\nL _ { T o t a l } ( G _ { 1 } ) = L _ { c y c } ( G _ { 1 } ) + \\lambda L _ { G A N } ( G _ { 1 } , D _ { 1 } ) + \\eta L _ { p e r c e p }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            707,
+            687,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "104 3.2 Providing scaled Gaussian noise to the generator ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            739,
+            550,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "105 For the generator to be capable of generating more than one solution given a single image, it must   \n106 receive and apply random information. The variation between super-resolved images will mostly   \n107 be stochastic variation in high-frequency textures. StyleGAN[3] achieves stochastic variation in   \n108 images by adding pixel-wise Gaussian noise to the output of each layer in the generator. We adopt   \n109 this method and add the noise after every RRDB layer in the generator.   \n110 However, the sensitivity and the desired magnitude of noise would differ for each channel. Adding   \n111 the same noise directly after every layer could rather harm the ability of the generator. For example, a   \n112 channel that detects edges would be seriously harmed by the noise. The sensitivity will also depend on   \n113 the depth of the network. To mitigate such possible issues, we allow each channel to learn the desired   \n114 magnitude of the noise. Specifically, before adding the noise to the output of each layer, we multiply   \n115 the noise with a channel-wise scaling factor. The scaling factor is learned concurrently with the   \n116 network parameters. We observe that the desired magnitude differs along the network depending on   \n117 the position of the layer. This shows that our method effectively implements a one-to-many generator   \n118 for super-resolution. The early layers seem to be focusing more on extracting the feature of the image,   \n119 while the final layers preferred the noise to be scaled before being applied to the reconstruction.   \n120 Details are illustrated in Figure 2. The noise is not applied at evaluation. ",
+        "bbox": [
+            140,
+            766,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e3c823f21bfc1f901341939547cf91481685756bdee3aed3434cd2a7666db6d.jpg",
+        "image_caption": [
+            "Figure 2: Boxplot of the scaling factors against the position of the layer in the network. The desired magnitude of noise increases in deeper layers, while the final layers have smaller scaling factors. The sensitivity to random noise varies for each layer and channel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            823,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            349,
+            825,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "21 3.3 Reference image for the discriminator ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            452,
+            477,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "122 Traditionally, the discriminator network receives a single image and is trained to classify whether the   \n123 given image is real or a generated image. This setting will provide the generator with gradients to   \n124 \"any natural image\" instead of towards the corresponding HR image. In an extreme example, the   \n125 traditional discriminator won’t penalize the generator for generating completely different but equally   \n126 realistic images from an LR image. Although this is unlikely due to the existence of other content   \n127 and perceptual losses, the gradient feedback given by the discriminator is sub-optimal for the task of   \n128 super-resolution.   \n129 As a solution, we provide the low-resolution image as a reference along with the target image to the   \n130 discriminator. This enables the discriminator to learn more important features for discriminating   \n131 the generated image and provide better gradient feedback according to the LR image. For details,   \n132 refer to Figure 1. We upsample the LR image to the same size as the HR image and concatenate   \n133 them, feeding a tensor of shape $( H , W , 6 )$ to the discriminator. Despite its simplicity, conditioning   \n134 the discriminator on the input is a crucial modification for training such a supervised problem with   \n135 GAN-oriented losses. ",
+        "bbox": [
+            142,
+            478,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "136 3.4 Blur detection ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            698,
+            312,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "137 We recognized that there are often severely blurry regions in the images from the DIV2K[14] and   \n138 DIV8K[15] datasets. Although the authors of [15] argue that the data was collected by \"paying special   \n139 attention to image quality\", there were many scenes with out-of-focus backgrounds. These blurry   \n140 regions might plague the generator to learn to generate such blurry patches. Blurry backgrounds are   \n141 often indistinguishable from finer objects based only on the LR image. Though some might argue   \n142 that the blurry backgrounds must also be learned, we were able to achieve finer detail and higher   \n143 LPIPS score by detecting and removing blurry patches from both datasets.   \n144 We propose to detect and remove blurry patches before the network is trained on those patches.   \n145 There are various methods for blur detection e.g. algorithmic methods and deep-learning-based   \n146 approaches[11, 12]. However, most deep-learning-based works focus on predicting pixel-wise blur   \n147 maps of the image, which wouldn’t be suited for our needs. Mostly, the algorithmic method of [10]   \n148 was successful at reliably detecting blurry patches as can be observed in Figure 3. We measure the   \n149 variance of the Laplacian activation of the patch and consider patches with variance of under 100 as   \n150 blurry patches. The algorithm detects $2 8 . 8 \\%$ blurry patches in a sample of 16,000 randomly cropped   \n151 patches of size $9 6 \\times 9 6$ from the DIV2K dataset and $4 8 . 9 \\%$ of patches in a sample of 140,000 patches   \n152 from the DIV8K dataset. ",
+        "bbox": [
+            140,
+            724,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b3c8f92720e92734d7bbff6c27ce08971f0c5ca993ec1d559aa6ae4a040373b.jpg",
+        "image_caption": [
+            "Figure 3: Randomly selected samples of the blur detection algorithm tested on image 0031 from the DIV8K dataset. The top two rows are the patches classified as clear and the bottom rows are blurry patches. Regions that are clear in the image (person, pole) are correctly considered as clear patches by the detection algorithm. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            821,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "153 4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            395,
+            312,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "154 We conduct experiments to evaluate the effectiveness of our proposed techniques in $\\times 4$ and $\\times 1 6$   \n155 resolution and compare them with the baseline ESRGAN. We first experiment the effects of blur   \n156 detection, then we perform an ablation study of our proposed training methods to evaluate their   \n157 effectiveness. Implementation detail and training logs can be found on GitHub1. All our experiments   \n158 were performed on a single Tesla T4 or Tesla K80 GPU on Google Colaboratory.   \n159 We observed that a large portion of the training was used for loading high-resolution images, despite   \n160 most of the images not being used. As an implementation detail to improve training speed significantly,   \n161 we extract multiple patches and save them in a buffer while training instead of extracting only a single   \n162 patch after loading the image. We randomly pick images from the buffer for training and discard the   \n163 selected patches from the buffer. In all of our experiments, we extract 128 patches from each image   \n164 and create a buffer of 1024 patches. ",
+        "bbox": [
+            142,
+            426,
+            825,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            502,
+            825,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 $\\times 4$ super-resolution ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            603,
+            349,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Training details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            334,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "167 We employ the ESRGAN network architecture with 23 RRDB blocks and most of its training   \n168 configurations for the baseline of our experiments on $\\times 4$ super-resolution. The training process is   \n169 divided into two stages. We first pretrain the PSNR-oriented models then train the ESRGAN-based   \n170 models.   \n71 The PSNR-oriented models are trained with the L1 loss with a batch size of 16 for 500K iterations.   \n72 We apply learning rate decay with an initial learning rate of $2 \\times 1 0 ^ { - 4 }$ , decayed by a factor of 2   \n73 every $2 0 0 k$ iterations. We initialize the GAN-based model with the PSNR-oriented model. We   \n74 initialize the learning rate with $1 \\times 1 0 ^ { - 4 }$ for both $G _ { 1 }$ and $D _ { 1 }$ , decaying the learning rate by a factor   \n75 of 2 at $[ 5 0 k , 1 0 0 k , 2 0 0 k , 3 0 0 k ]$ iterations. For optimization, we use the Adam optimizer for both   \n76 pretrained networks and GAN-based models, with $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9$ . The learning rate decay   \n77 schedule corresponds to the one proposed by ESRGAN. We implement our models and methods with   \n78 the Tensorflow framework. The loss function is scaled with $\\eta = 1 0$ and $\\lambda = 5 \\times 1 0 ^ { - 3 }$ , which is   \n79 equivalent to the training configuration of ESRGAN used in the PIRM-SR challenge. This is slightly   \n80 different from the configuration used in the released model trained with $\\eta = 1 0 ^ { - 2 }$ .   \n181 All of our networks are trained exclusively on the DIV2K dataset[14], while the original ESRGAN   \n182 was trained with DIV2K, Flickr2K, and OST datasets combined. We obtained the LR images by   \n183 downsampling the HR images with MATLAB bicubic interpolation. We compare the effects of our   \n184 methods on LPIPS, PSNR, and SSIM scores on the Set5, Set14, BSD100, and Urban100 datasets.   \n185 Scores evaluated on the Set5 and Set14 datasets are obtained by averaging the final 5 checkpoints,   \n186 each recorded at [480k, 485k, 490k, $4 9 5 k$ , $5 0 0 k ]$ iterations. ",
+        "bbox": [
+            142,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            713,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            858,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/16b124caef429a31e05dfb0e0e9d80d10d5aa3fb4fd8af81f45eb6e901241415.jpg",
+        "table_caption": [
+            "Table 1: LPIPS, PSNR, SSIM scores of various configurations for $\\times 4$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Set5 (LPIPS /PSNR/SSIM)</td><td>Set14</td><td>BSD100</td><td>Urban100</td></tr><tr><td>Pretrained (a)</td><td>0.1341/30.3603/0.8679</td><td>0.2223/26.7608/0.7525</td><td>0.2705/27.2264/0.7461</td><td>0.1761/24.8770/0.7764</td></tr><tr><td>+Blur detection (b)</td><td>0.1327 /30.4582/0.7525</td><td>0.2229 /26.8448 /0.7547</td><td>0.2684 /27.2545 /0.7473</td><td>0.1744/25.0816 /0.7821</td></tr><tr><td>ESRGAN (Official)</td><td>0.0597/28.4362/0.8145</td><td>0.1129/23.4729/0.6276</td><td>0.1285/23.3657/0.6108</td><td>0.1025/22.7912/0.7058</td></tr><tr><td>ESRGAN (c)</td><td>0.0538/27.9285/0.7968</td><td>0.1117/24.5264/0.6602</td><td>0.1256/24.6554/0.6447</td><td>0.1026/23.2829/0.7137</td></tr><tr><td>+refGAN (d)</td><td>0.0536 /27.9871/0.8014</td><td>0.1157 /24.4505 /0.6611</td><td>0.1275 /24.5896 /0.6470</td><td>0.1027 /23.0496 /0.7103</td></tr><tr><td>+Add noise (e)</td><td>0.04998/28.23/0.8081</td><td>0.1104 /24.48/0.6626</td><td>0.1209 /24.8439 /0.6577</td><td>0.1007 /23.2204 /0.7203</td></tr><tr><td>+Cycle loss (f)</td><td>0.0524/28.1322/0.8033</td><td>0.1082 /24.5802/0.6634</td><td>0.1264/24.6180 /0.6468</td><td>0.1015 /23.1363 /0.7103</td></tr><tr><td>-Perceptual loss (g)</td><td>0.2690 / 23.4608 /0.6312</td><td>0.2727 /22.2703 /0.5685</td><td>0.2985 /24.1648 /0.5859</td><td>0.2411 /20.8169 /0.6244</td></tr></table>",
+        "bbox": [
+            173,
+            109,
+            821,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            268,
+            826,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            339,
+            328,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "188   \n189   \n190   \n191   \n192   \n193   \n194   \n195   \n196   \n197   \n198   \n199   \n200   \n201 ",
+        "bbox": [
+            140,
+            359,
+            163,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To study the effects of our proposed methods, we perform an ablation study of our proposed method. We enable our proposed methods one by one and list the resulting scores in Table 1. Each training configuration was fully trained with the original training configurations. We provide the saved model and configuration files to reproduce our results in our project repository. We also list the results of the official ESRGAN for fair comparison. The improvements from the official results and the result from configuration(c) is because the $\\eta$ value is different from the official model. First, blur detection is experimented with in configuration(b) and improves the LPIPS score for all benchmarks. We train our baseline ESRGAN in configuration(c) and get reasonable results. By applying the technique of Section 3.3 in configuration(d), we slightly harm the network in terms of the LPIPS score. However, providing conditional information to the discriminator is crucial for learning such a supervised problem with adversarial learning. Our method of directly concatenating the reference image in the input is not optimal. The low-resolution image could be applied through SPADE[20] or alternative spatial transformation methods for improvements. Applying scaled noise shows large improvements as experimented in configuration(e). ",
+        "bbox": [
+            171,
+            363,
+            825,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "202 The cycle consistency loss applied in configuration(f) shows neutral and slightly negative effects   \n203 on the LPIPS score. The reason for this is mostly because of the incompetent GAN framework   \n204 lacking the training techniques of modern GAN literature. Our statement is stated by the failure of   \n205 configuration(g) where the GAN framework alone is responsible for learning the super-resolution   \n206 process. The GAN framework of ESRGAN is incapable of lead the training process and thus   \n207 the image quality wasn’t improved when we gave more responsibility to the adversarial loss in   \n208 configuration(f). However, coupled with improved GAN techniques in further research, the cycle   \n209 consistency content loss will further enhance the image quality. ",
+        "bbox": [
+            143,
+            563,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 $\\times 1 6$ super-resolution ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            689,
+            357,
+            704
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 Training details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            334,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "12 We employ the RFB-ESRGAN of [21] as the baseline for our experiments on $\\times 1 6$ super-resolution.   \n13 The RFB-ESRGAN proposes an architecture using Receptive Field Blocks(RFB) and Residual of   \n14 Receptive Field Dense Block(RRFDB), each as an alternative for convolution and RRDB blocks. The   \n15 RFB-ESRGAN uses less memory compared to methods that manipulate the image in the intermediate   \n16 $\\times 4$ resolution[22] and this allowed larger batch size in our environment. We employ the RFB  \n17 ESRGAN network architecture with 16 RRDB blocks and 8 RRFDB blocks for the baseline of our   \n18 experiments on $\\times 1 6$ super-resolution.   \n219 The model is first trained with the L1 loss for 100K iterations with an initial learning rate $2 \\times 1 0 ^ { - 4 }$   \n220 decayed by a factor of two every $2 . 5 \\times 1 0 ^ { 5 }$ iteration. The GAN-based model is initialized with the   \n221 pretrained model and is trained for 200K iterations, which is shorter than the original 400K iterations.   \n222 Additionally, the batch size is decreased from 16 to 4 and we therefore approximately scale the   \n223 initial learning rate of $1 0 ^ { - 4 }$ to $2 \\times 1 0 ^ { - 5 }$ by a factor of 5. The learning rate is decayed at $[ 5 0 k , 1 0 0 k ]$   \n4 iterations. We don’t use model ensemble to further stabilize the network. All other models and   \n25 hyperparameter configurations are equal. We train the network on the DIV8K dataset[15], while the   \n26 original network was trained with additional datasets including DIV2K, Flicker2K, OST dataset. The   \n27 first 1,400 images of DIV8K are used as training data and the rest 100 validation images are used for   \n28 evaluation. ",
+        "bbox": [
+            155,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/30375bd0f21b0d85053cfe381f963510376d0d695b2f6c82eef2150948722a9a.jpg",
+        "table_caption": [
+            "Table 2: LPIPS, PSNR scores for various configurations for $\\times 1 6$ super-resolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>DIV8K validation</td></tr><tr><td rowspan=1 colspan=1>Pretrained (a)+Blur detection (b)</td><td rowspan=1 colspan=1>0.4664/30.36030.4603 / 25.53</td></tr><tr><td rowspan=1 colspan=1>RFB-ESRGAN(official)</td><td rowspan=1 colspan=1>0.345 /24.03</td></tr><tr><td rowspan=1 colspan=1>Baseline RFB-ESRGAN (c)Ours w/o cycle-loss (d)Ours w/ cycle-loss (e)</td><td rowspan=1 colspan=1>0.356/24.780.321 / 23.950.323 / 23.49</td></tr></table>",
+        "bbox": [
+            320,
+            108,
+            668,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            257,
+            825,
+            328
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            342,
+            328,
+            357
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The PSNR-oriented method is improved using blur detection in configuration(b). Our GAN-baed model of configuration(c) achieves worse performance compared the the results reported in [21] because of the lighter training configurations. We were able to make significant improvements in the LPIPS score from the baseline RFB-ESRGAN using our proposed methods in configuration(d). We apply all of our proposed methods except the cycle consistency loss in configuration(d). We also train the model with cycle consistency loss and get similar results in configuration(e). We were able to make such improvements using much lighter training configurations with only half iteration steps, $\\times 4$ smaller batch size, and without model ensemble. The results are described in Table 2. ",
+        "bbox": [
+            171,
+            366,
+            825,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "238 5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            496,
+            299,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "239 We proposed a one-to-many approach for super-resolution and achieve improved perceptual quality   \n240 and better LPIPS score from the baseline ESRGAN configuration and achieve the state-of-art LPIPS   \n241 score in $\\mathbf { \\boldsymbol { x } } 1 6$ perceptual super-resolution. We provide scaled pixel-wise to the generator to allow   \n242 stochastic variation in the reconstructed image and implement a generator capable of a one-to-many   \n243 pipeline. We also address the limitations of mixing the strict content loss with perceptual losses and   \n244 propose an alternative based on the cycle loss. Our newly modified loss will ensure the consistency   \n245 of the content while not penalizing high-frequency detail. Additionally, we further propose more   \n246 techniques such as blur detection using Laplacian activation and redesign the discriminator input by   \n247 providing a reference image to further improve the perceptual quality of $\\times 4$ and $\\times 1 6$ super-resolution.   \n248 However, the GAN framework from ESRGAN was incompetent to guide the training on its own.   \n249 Modern GAN training techniques could be applied to further improve the GAN framework used   \n250 in super-resolution. Our proposed loss function will become more effective as a content loss when   \n251 coupled with a robust GAN framework since it will reduce constraints in generating high-frequency   \n252 detail. Such improvements are left for future work.   \n254 [1] Wang, Xintao, et al. \"Esrgan: Enhanced super-resolution generative adversarial networks.\" Proceedings of   \n255 the European Conference on Computer Vision (ECCV) Workshops. 2018.   \n256 [2] Zhang, Kai, Shuhang Gu, and Radu Timofte. \"Ntire 2020 challenge on perceptual extreme super-resolution:   \n257 Methods and results.\" Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition   \n258 Workshops. 2020.   \n259 [3] Karras, Tero, Samuli Laine, and Timo Aila. \"A style-based generator architecture for generative adversarial   \n260 networks.\" Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   \n261 [4] Zhang, Richard, et al. \"The unreasonable effectiveness of deep features as a perceptual metric.\" Proceedings   \n262 of the IEEE conference on computer vision and pattern recognition. 2018.   \n263 [5] Jo, Younghyun, Sejong Yang, and Seon Joo Kim. \"Investigating loss functions for extreme super-resolution.\"   \n264 Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020.   \n265 [6] Ledig, Christian, et al. \"Photo-realistic single image super-resolution using a generative adversarial network.\"   \n266 Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.   \n267 [7] Sajjadi, Mehdi SM, Bernhard Scholkopf, and Michael Hirsch. \"Enhancenet: Single image super-resolution   \n268 through automated texture synthesis.\" Proceedings of the IEEE International Conference on Computer Vision.   \n269 2017.   \n270 [8] Zhu, Jun-Yan, et al. \"Unpaired image-to-image translation using cycle-consistent adversarial networks.\"   \n271 Proceedings of the IEEE international conference on computer vision. 2017.   \n272 [9] Dong, Chao, et al. \"Image super-resolution using deep convolutional networks.\" IEEE transactions on pattern   \n273 analysis and machine intelligence 38.2 (2015): 295-307.   \n274 [10] Bansal, Raghav, Gaurav Raj, and Tanupriya Choudhury. \"Blur image detection using Laplacian operator   \n275 and Open-CV.\" 2016 International Conference System Modeling & Advancement in Research Trends (SMART).   \n276 IEEE, 2016.   \n277 [11] Tang, Chang, et al. \"Defusionnet: Defocus blur detection via recurrently fusing and refining multi-scale   \n278 deep features.\" Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   \n279 [12] Wang, Xuewei, et al. \"Accurate and fast blur detection using a pyramid M-Shaped deep neural network.\"   \n280 IEEE Access 7 (2019): 86611-86624.   \n281 [13] Yuan, Yuan, et al. \"Unsupervised image super-resolution using cycle-in-cycle generative adversarial   \n282 networks.\" Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops. 2018.   \n283 [14] Agustsson, Eirikur, and Radu Timofte. \"Ntire 2017 challenge on single image super-resolution: Dataset and   \n284 study.\" Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops. 2017.   \n285 [15] Gu, Shuhang, et al. \"Div8k: Diverse 8k resolution image dataset.\" 2019 IEEE/CVF International Conference   \n286 on Computer Vision Workshop (ICCVW). IEEE, 2019.   \n287 [16] Jolicoeur-Martineau, Alexia. \"The relativistic discriminator: a key element missing from standard GAN.\"   \n288 arXiv preprint arXiv:1807.00734 (2018).   \n289 [17] Kim, Jiwon, Jung Kwon Lee, and Kyoung Mu Lee. \"Accurate image super-resolution using very deep   \n290 convolutional networks.\" Proceedings of the IEEE conference on computer vision and pattern recognition. 2016.   \n291 [18] Zhang, Yulun, et al. \"Image super-resolution using very deep residual channel attention networks.\"   \n292 Proceedings of the European conference on computer vision (ECCV). 2018.   \n293 [19] Lim, Bee, et al. \"Enhanced deep residual networks for single image super-resolution.\" Proceedings of the   \n294 IEEE conference on computer vision and pattern recognition workshops. 2017.   \n295 [20] Park, Taesung, et al. \"Semantic image synthesis with spatially-adaptive normalization.\" Proceedings of the   \n296 IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2019.   \n297 [21] Shang, Taizhang, et al. \"Perceptual extreme super-resolution network with receptive field block.\" Proceed  \n298 ings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020.   \n299 [22] Jo, Younghyun, Sejong Yang, and Seon Joo Kim. \"Investigating loss functions for extreme super-resolution.\"   \n300 Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops. 2020. ",
+        "bbox": [
+            140,
+            527,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a6d0d9b88734d4ca44353bccc5cbf928b82be5e1b229157482c43899b74b8e8.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative comparison of our methods with the official ESRGAN. We compare the poorly reconstructed outputs of ESRGAN from BSD100 and Urban100 datasets with our proposed model trained with configuration(f). Our method produces sharp textures and more realistic structures compared to the baseline ESRGAN, although it also fails to accurately reconstruct human faces. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            142,
+            926,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            147,
+            828,
+            916
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example: ",
+        "bbox": [
+            158,
+            119,
+            825,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Did you include the license to the code and datasets? [Yes] See Section 2. • Did you include the license to the code and datasets? [No] The code and the data are proprietary. • Did you include the license to the code and datasets? [N/A] ",
+        "bbox": [
+            217,
+            181,
+            803,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below. ",
+        "bbox": [
+            158,
+            241,
+            826,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            292,
+            330,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The focus of our paper is on the proposal of a one-to-many pipeline for super-resolution.   \n(b) Did you describe the limitations of your work? [Yes] The GAN framework used in our work was weak despite the successes of modern GANs.   \n(c) Did you discuss any potential negative societal impacts of your work? [No]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            240,
+            310,
+            825,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            411,
+            467,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            240,
+            428,
+            691,
+            457
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            462,
+            377,
+            474
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] As mentioned in the paper, all the code and training configurations are available at https://github.com/krenerd/ultimate-sr.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] There was hardware limitations for repeating our work multiple times, however the ablation study sufficiently described improvements of our methods.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All our experiments were executed on Google COLAB with a single Tesla T4 or Tesla K80 GPU. ",
+        "bbox": [
+            240,
+            479,
+            825,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            227,
+            630,
+            764,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] The DIV2K and DIV8K dataset was used and cited.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] The DIV2K dataset was used for the baseline ESRGAN, which was compared with our methods and the DIV8K dataset was used for the RFB-ESRGAN.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] ",
+        "bbox": [
+            240,
+            647,
+            825,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            776,
+            658,
+            789
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            240,
+            792,
+            825,
+            875
+        ],
+        "page_idx": 9
+    }
+]

parse/train/SyfdsjA9FX/SyfdsjA9FX.md

@@ -0,0 +1,299 @@
+# LIVE FACE DE-IDENTIFICATION IN VIDEO
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a method for face de-identification that enables fully automatic video modification at high frame rates. The goal is to maximally decorrelate the identity, while having the perception (pose, illumination and expression) fixed. We achieve this by a novel feed forward encoder-decoder network architecture that is conditioned on the high-level representation of a person’s facial image. The network is global, in the sense that it does not need to be retrained for a given video or for a given identity, and it creates natural-looking image sequences with little distortion in time.
+
+# 1 INTRODUCTION
+
+In consumer image and video applications, the face has a unique importance that stands out from all other objects. For example, face recognition (detection followed by identification) is perhaps much more widely applicable than any other object recognition (categorization, detection, or instance identification) in consumer images. Similarly, putting aside image processing operators that are applied to the entire frame, face filters remain the most popular filters for consumer video. Since face technology is both useful and impactful, it also raises many ethical concerns. Face recognition can lead to loss of privacy and face replacement technology may be misused to create misleading videos.
+
+In this work, we focus on a video de-identification, which is a video filtering application that both requires a technological leap over the current state-of-the-art and is benign in nature. This application requires the creation of a video of a similar looking person, such that the perceived identity is changed. This allows, for example, the user to leave a natural-looking video message in a public forum in an anonymous way that would presumably prevent face recognition technology from recognizing them.
+
+The problem of video de-identification is a challenging computational task. The video needs to be modified in a seamless way, without causing flickering or other visual artifacts and distortions, such that the identity is changed, while all other factors remain identical. These factors include pose and expression, occlusion, illumination and shadow, and their dynamics.
+
+In order to tackle these challenges, we introduce a novel encoder-decoder architecture. To the latent space, we concatenate the activations of the representation layer of a network trained to perform face recognition. The loss terms separate between low- and mid-level perceptual terms and high-level terms. The former are used to tie the output image to the input video frame, while the latter is used to obtain the desired modification. Additional losses include reconstruction losses, edge losses, and an adversarial loss. The network outputs both an image and a mask, which are used, in tandem, to reconstruct the output frame.
+
+In contrast to the literature methods, which are limited to still images and often swap the image’s face with a dataset face, our method handles video and generates de novo faces. Our experiments show convincing performance for unconstrained videos, producing natural looking videos. The person in those videos has a similar appearance to the original person. However, a state-of-the-art face-recognition network fails to identify the person. A similar experiment, shows that humans cannot identify the generated face, even without time constraints.
+
+# 2 PREVIOUS WORK
+
+Faces have been modeled by computer graphics systems for a long time. In machine learning, faces have been one of the key benchmarks for GAN-based generative models (Goodfellow et al.,
+
+Table 1: A comparison to literature de-identification methods. †The face is swapped with an average of a few dataset faces.   
+
+<table><tr><td></td><td>(Newton, &#x27;05)</td><td>(Gross, &#x27;08)</td><td>(Samarzija, &#x27;14)</td><td>(Jourabloo, &#x27;15)</td><td>(Wu, &#x27;18)</td><td>Our</td></tr><tr><td>Preserves expression</td><td></td><td>1</td><td>1</td><td>1</td><td>=</td><td>+</td></tr><tr><td>Preserves pose</td><td></td><td>+</td><td>+</td><td></td><td>=</td><td>+</td></tr><tr><td>Generates new faces</td><td></td><td>+</td><td>1</td><td>+</td><td>+</td><td>+</td></tr><tr><td>Demonstrated on video</td><td></td><td>1</td><td></td><td>1</td><td></td><td>+</td></tr><tr><td>Demonstrated on a diverse dataset (gender, ethnicity, age, etc.)</td><td></td><td>+</td><td></td><td>+</td><td></td><td>+</td></tr></table>
+
+2014; Radford et al., 2015; Salimans et al., 2016) since their inception. Recently, high resolution natural looking faces were generated by training both the generator and the discriminator of the GAN progressively, starting with shallower networks and lower resolutions and enlarging these gradually (Karras et al., 2018).
+
+Conditional generation of faces has been a key task in various unsupervised domain translation contributions, where the task is to learn to map, e.g., a person without eyewear to a person with eyeglasses, without seeing matching samples from the two domains (Kim et al., 2017; Yi et al., 2017; Benaim & Wolf, 2017; Liu et al., 2017). For more distant domain mapping, such as mapping between a face image and the matching computer graphics avatar, additional supervision in the form of a face descriptor network was used (Taigman et al., 2017). Our work uses these face descriptors in order to distance the identity of the output from that of the input.
+
+As far as we know, our work is the first de-identification work to present results on videos. In still images, several methods have been previously suggested. Earlier work implemented different types of image distortions for face de-identification (Newton et al., 2005b; Gross et al., 2008), while more recent works rely on techniques for selecting distant faces (Samarzija & Ribaric, 2014) or averaging/fusing faces from pre-existing datasets Newton et al. (2005a); Jourabloo et al. (2015). The experiments conducted by the aforementioned techniques are restricted, in most cases to lowresolution, black and white results. Although it is possible to create eye-pleasing results, they are not robust to different poses, illuminations and facial structures, making them inadequate for video generation. The use of GANs for face de-identification has been suggested in the work of Wu et al. (2018). However, the experiments were restricted to a homogeneous dataset, with no apparent expression preservation within the results. See Tab. 1 for a comparative view of the literature.
+
+The current literature on de-identification often involves face swapping (our method does not). Face swapping, i.e., the replacement of a person’s face in an image with another person’s face, has been an active research topic for some time, starting with the influential work of (Blanz et al., 2004; Bitouk et al., 2008). Recent contributions have shown a great deal of robustness to the source image as well as for the properties of the image, from which the target face is taken (Kemelmacher-Shlizerman, 2016; Nirkin et al., 2017). While these classical face swapping methods work in the pixel space and copy the expression of the target image, recent deep-learning based work swap the identity, while maintaining the other aspects of the source image (Korshunova et al., 2017). In comparison to our work, (Korshunova et al., 2017) requires training a new network for every target person, the transferred expression does not show subtleties (which would be critical, e.g., for a speaking person), and the results are not as natural as ours. These limitations are probably a result of capturing the appearance of the target by restricting the output to be similar, patch by patch, to a collection of patches from the target person. Moreover, (Korshunova et al., 2017) is limited to stills and was not demonstrated on video.
+
+The face swapping (FS) project (Faceswap, 2017) is an unpublished work that replaces faces in video in a way that can be very convincing, given suitable inputs. Unlike our network, the FS is retrained for every pair of source-video and target-video persons. The input to the FS system, during training, is two large sets of images, one from each identity. Typically, in order to obtain good results, thousands of images from each individual with a significant variability in pose, expression, and illumination are used. In many cases, a large subset of the images of the source person are taken from the video that is going to be converted. In addition, FS often fails, and in order to obtain a convincing output, the person in the source video and the target person need to have similar facial structure. These limitations make it unsuitable for de-identification purposes.
+
+![](images/09a71ca4c372f6c19354d086b6fd71813ac67b60350864254ed771aae2076d7d.jpg)  
+Figure 1: (a) The architecture of our network. For conditioning, a pre-trained face recognition network is used. (b) An illustration of the multi-image perceptual loss used, which employs two replicas of the same face recognition network.
+
+Like ours, the FS method is based on an encoder-decoder architecture, where both an image and output mask are produced. A few technical novelties of FS are shared with our work. Most notably is the way in which augmentation is performed in order to train a more semantic encoder-decoder network. During training of FS, the input image is modified by rotating or scaling it, before it is fed to the encoder. The image that the decoder outputs is compared to the undistorted image. Another common property is that the GAN variant used employs virtual examples created using the mixup technique (Zhang et al., 2017). In addition, in order to maintain the pose and expression, which are considered low- or mid-level features in face descriptors (orthogonal to the identity) FS employs a perceptual loss (Johnson et al., 2016; Ulyanov et al., 2016a) that is based on the layers of a face-recognition network.
+
+# 3 METHOD
+
+Our architecture is based on an adversarial autoencoder (Makhzani et al., 2015), coupled with a trained face-classifier. By concatenating the autoencoder’s latent space with the face-classifier representation layer, we achieve a rich latent space, embedding both identity and expression information. The network is trained in a counter-factual way, i.e., the output differs from the input in key aspects, as dictated by the conditioning. The generation task is, therefore, highly semantic, and the loss required to capture its success cannot be a conventional reconstruction loss.
+
+For the task of de-identification, we employ a target image, which is any image of the person in the video. The method then distances the face descriptors of the output video from those of the target image. The target image does not need to be based on a frame from the input video. This contributes to the applicability of the method, allowing it to be applied to live videos. In our experiments, we do not use an input frame in order to show the generality of the approach. To encode the target image, we use a pre-trained face classifier ResNet-50 network by He et al. (2016b), trained over the VGGFace2 dataset of Cao et al. (2017).
+
+The process during test time is similar to the steps taken in the face swapping literature and involves the following steps: (a) A square bounding box is extracted using a face detector, we employ dlib (King, 2009). (b) Multiple facial points are detected. In our implementation we use the 68 points provided by dlib. (c) A transformation matrix is extracted, using an estimated similarity transformation (scale, rotation and translation) to an averaged face. (d) The estimated transformation is applied to the input face. (e) The transformed face is passed to our network, together with the representation of the target image, obtaining both an output image and a mask. (f) The output image and mask are projected back, using the inverse of the similarity transformation. (g) We generate an output frame by linearly mixing, per pixel, the input and the network’s transformed output image, according to the weights of the transformed mask. (h) The outcome is merged into the original frame, in the region defined by the convex hull of the facial points.
+
+Training is performed on image datasets and not on video. At training time, we perform the following steps: (a) The face image is distorted and augmented. This is done by applying random scaling, rotation and elastic deformation. (b) The distorted image is fed into the network, together with the representation of a target image. During training, we select the same image, undistorted. (c) A linear combination of the masked output (computed as in step (g) above) and the undistorted input is fed to the discriminator. This is the mixup technique (Zhang et al., 2017) discussed below. (d) Losses are applied on the network’s mask and image output, as well as to the masked output, as detailed below.
+
+Note that there is a discrepancy between how the network is trained and how it is applied. Not only that we do not make any explicit effort to train on videos, the target images are selected in a different way. During training, we extract the identity from the training image itself and not from an independent target image. The method is still able to generalize to perform the actual application on unconstrained videos.
+
+# 3.1 NETWORK ARCHITECTURE
+
+The architecture is illustrated in Fig. 1(a). The encoder is composed of a convolutional layer, followed by five strided, depth-wise separable (Chollet, 2017) convolutions with instance normalization (Ulyanov et al., 2016b). Subsequently, a single fully connected layer is employed, and the target face representation is concatenated. The decoder is composed of a fully connected layer, followed by a lattice of upscale and residual (He et al., 2016a) blocks, terminated with a tanh activated convolution for the output image, and a sigmoid activated convolution for the mask output. Each upscale block is comprised of a 2D convolution with twice the number of filters than the input channel size. Following an instance normalization and a LReLU (He et al., 2015) activation, the activations are re-ordered such that the width and height are doubled, while the channel size is halved. Each residual block input is summed with the output of a Conv2D-LReLU-Conv2D chain.
+
+A low-capacity Unet connection (Ronneberger et al., 2015) is employed $( 3 2 \mathrm { x } 3 2 \mathrm { x } 1 )$ ), thus relieving the autoencoder’s bottleneck, allowing a stronger focus on the encoding of transfer-related information. The connection size does not exceed the bottleneck size (1024) and due to the distortion of the input image, a collapse into a simple reconstructing autoencoder in early training stages is averted.
+
+The discriminator consists of four strided convolutions with LReLU activations, with instance normalization applied on all but the first one. A sigmoid activated convolution yields a single output.
+
+# 3.2 TRAINING AND THE LOSSES USED
+
+For training all networks, except for the GAN’s discriminator $D$ , we use a compound loss $\mathcal { L }$ , which is a weighted sum of multiple parts:
+
+$$
+\begin{array} { r l } & { \mathcal { L } = \alpha _ { 0 } \mathcal { L } _ { G } + \alpha _ { 1 } \mathcal { L } _ { R } ^ { r a w } + \alpha _ { 1 } \mathcal { L } _ { R } ^ { m a s k e d } + \alpha _ { 2 } \mathcal { L } _ { x } ^ { r a w } + \alpha _ { 2 } \mathcal { L } _ { y } ^ { r a w } + \alpha _ { 2 } \mathcal { L } _ { x } ^ { m a s k e d } + \alpha _ { 2 } \mathcal { L } _ { y } ^ { m a s k e d } } \\ & { \qquad + \alpha _ { 3 } \mathcal { L } _ { p } ^ { r a w } + \alpha _ { 3 } \mathcal { L } _ { p } ^ { m a s k e d } + \alpha _ { 4 } \mathcal { L } ^ { m } + \alpha _ { 5 } \mathcal { L } _ { x } ^ { m } + \alpha _ { 5 } \mathcal { L } _ { y } ^ { m } , } \end{array}
+$$
+
+where the de $\mathcal { L } _ { G }$ ier enerator’s loss, and the version $\mathcal { L } _ { R } ^ { r a w }$ and  app $\mathcal { L } _ { R } ^ { m a s k e d }$ are recomasking n, ses fand he output image ofare reconstruction $z ^ { r a w }$ $z ^ { m a s k e d }$ $\mathcal { L } _ { x } ^ { * }$ $\mathcal { L } _ { y } ^ { * }$ losses applied to the spatial images derivatives, $\mathcal { L } _ { p } ^ { * }$ are the perceptual losses, and $\mathcal { L } _ { * } ^ { m }$ are regularization losses on the mask. The perceptual loss terms are the only terms that differ between the two applications. The discriminator network is trained using its own loss $\mathcal { L } _ { D }$ . Throughout our experiments, we employ $\alpha _ { 0 } = \alpha _ { 1 } = \alpha _ { 2 } = \alpha _ { 3 } = 0 . 5 , \alpha _ { 4 } = 3 \cdot 1 0 ^ { - 3 } , \alpha _ { 5 } = 1 0 ^ { - 2 } .$ .
+
+To maintain realistic looking generator outputs, adversarial loss is imposed with a convex combination of example pairs (known as mixup) (Zhang et al., 2017) over a Least Square GAN (Mao et al., 2017)
+
+loss:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { D } = \Vert D ( \delta _ { m x } ) - \lambda _ { \beta } \Im \Vert _ { 2 } ^ { 2 } \qquad \mathcal { L } _ { G } = \alpha _ { 0 } \Vert D ( \delta _ { m x } ) - ( 1 - \lambda _ { \beta } ) \Im \Vert _ { 2 } ^ { 2 } } \end{array}
+$$
+
+While, $\delta _ { m x } = \lambda _ { \beta } { \cdot } x + ( 1 { - } \lambda _ { \beta } ) z ^ { m a s k e d }$ and $\lambda _ { \beta }$ is sampled out of a Beta distribution $\lambda _ { \beta } \sim B e t a ( \alpha , \alpha )$ $x$ is the undistorted input “real” sample and $z ^ { m a s k e d }$ is the post masking generated sample. A value of $\alpha = 0 . 2$ is used throughout the experiments.
+
+Additional losses are exercised to both retain source-to-output similarity, yet drive a perceptible transformation. Several losses are distributed equally between the raw and masked outputs, imposing constraints on both. An L1 reconstruction loss is used to enforce pixel-level similarity:
+
+$$
+\mathcal { L } _ { R } ^ { r a w } = \alpha _ { 1 } \| z ^ { r a w } - x \| _ { 1 } \qquad \mathcal { L } _ { R } ^ { m a s k e d } = \alpha _ { 1 } \| z ^ { m a s k e d } - x \| _ { 1 }
+$$
+
+where $z ^ { r a w }$ is the output image itself. This results in a non-trivial constraint, as the encoder input image is distorted. An edge-preserving loss is used to constrain pixel-level derivative differences in both the $x$ and $y$ image axes. Calculated as the absolute difference between the source and output derivatives in each axis direction for both the raw and masked outputs:
+
+$$
+\begin{array} { r l r } { \mathcal { L } _ { x } ^ { r a w } = \alpha _ { 2 } \| z _ { x } ^ { \prime } - x _ { x } ^ { \prime } \| _ { 1 } } & { } & { \qquad \mathcal { L } _ { y } ^ { r a w } = \alpha _ { 2 } \| z _ { y } ^ { \prime } - x _ { y } ^ { \prime } \| _ { 1 } } \\ { \mathcal { L } _ { x } ^ { m a s k e d } = \alpha _ { 2 } \| z _ { x } ^ { \prime } - x _ { x } ^ { \prime } \| _ { 1 } } & { } & { \qquad \mathcal { L } _ { y } ^ { m a s k e d } = \alpha _ { 2 } \| z _ { y } ^ { \prime } - x _ { y } ^ { \prime } \| _ { 1 } } \end{array}
+$$
+
+where $x _ { x } ^ { \prime }$ is the derivative of the undistorted input image $x$ along the $x$ axis.
+
+Additional losses are applied to the blending mask $m$ , where 0 indicates that the value of this pixel would be taken from the input image $x , 1$ indicates taking the value from $z ^ { r a w }$ , and intermediate values indicate linear mixing. We would like the mask to be both minimal and smooth and, therefore, employ the following losses:
+
+$$
+\begin{array} { r } { \mathcal { L } ^ { m } = \| m \| _ { 1 } \qquad \mathcal { L } _ { x } ^ { m } = \| m _ { x } ^ { \prime } \| _ { 1 } \qquad \mathcal { L } _ { y } ^ { m } = \| m _ { y } ^ { \prime } \| _ { 1 } } \end{array}
+$$
+
+where $m _ { x } ^ { \prime }$ and $m _ { y } ^ { \prime }$ are the spatial derivatives of the mask.
+
+# 3.2.1 A MULTI-IMAGE PERCEPTUAL LOSS
+
+A new variant of the perceptual loss (Johnson et al., 2016) is employed to maintain source expression, pose and lighting conditions, while capturing the target identity essence. This is achieved by employing a perceptual loss between the undistorted source and generated output on several low-tomedium abstraction layers, while constraining the high abstraction layer perceptual loss between the target and generated output.
+
+Let $a _ { n \times n } ^ { r }$ be the activations of an $n \times n$ spatial block within the face classifier network for image $r$ where in our case $r$ can be either the input image $x$ , the application dependent target image $t$ , the raw output $z ^ { r a w }$ , or the masked output $z ^ { m \bar { a } s k e d }$ .
+
+We consider the spatial activations maps of size $1 1 2 \times 1 1 2 , 5 6 \times 5 6 , 2 8 \times 2 8$ and $7 \times 7$ , as well as the representation layer of size $1 \times 1$ . The lower layers (larger maps) are used to enforce similarity to the input image $x$ , while the $7 \times 7$ layer is used to enforce similarity to $t$ , and the $1 \times 1$ feature vector is used to enforce dissimilarity to the target image.
+
+Let us define $\ell _ { n \times n } ^ { r _ { 1 } , r _ { 2 } } = c _ { n } \| a _ { r _ { 1 } , n \times n } - a _ { r _ { 2 } , n \times n } \| _ { 1 }$ , where $c _ { n }$ is a normalizing constant, corresponding to the size of the spatial activation map.
+
+The perceptual loss is given by:
+
+$$
+\mathcal { L } _ { p } ^ { c } = \ell _ { 1 1 2 \times 1 1 2 } ^ { x , z ^ { c } } + \ell _ { 5 6 \times 5 6 } ^ { x , z ^ { c } } + \ell _ { 2 8 \times 2 8 } ^ { x , z ^ { c } } + \ell _ { 7 \times 7 } ^ { t , z ^ { c } } - \lambda \ell _ { 1 \times 1 } ^ { t , z }
+$$
+
+for $c$ that is either raw or masked, and where $\lambda > 0$ is a hyperparameter, which determines the distance of the generated face’s high level features from those of the target image.
+
+The application of the multi-image perceptual loss during training is depicted in Fig. 1(b). During training, the target is the source and there is only one input image. The resulting image has the texture, pose and expression of the source, but the face is modified to distance the identity, as can be seen in Fig. 2. Note that we call it multi-image perceptual loss, since its aim is to minimize the analog error term during inference (generalization error). However, as a training loss, it is only applied during train, where it receives a pair of images, similarly to other perceptual losses.
+
+Table 2: User study. (a) Success rate in user identification of a real video from a modified one. Closer to $50 \%$ is better. (b) The confusion matrix in identifying the five persons for the real images (control). (c) The confusion matrix for identifying based on the de-identified images.
+
+![](images/e06c8965266f781dc1ba18274f00e49d23341b7e1f5fccd8735611010c81be19.jpg)
+
+At inference time, the network is fed an input frame and a target image. The target image is transmitted through the face classifier, resulting in a target feature vector, which, in turn, is concatenated to the latent embedding space. Due to the way the network is trained, the decoder will drive the output image away from the target feature vector.
+
+# 4 EXPERIMENTS
+
+Training is done using the Adam (Kingma & Ba, 2016) optimizer, with the learning rate set to $1 0 ^ { - 4 }$ , $\beta _ { 1 } = 0 . 5$ , and $\beta _ { 2 } = 0 . 9 9$ . At each training iteration, a batch of 32 images is randomly selected and augmented. We initialize all convolutional weights using a random normal distribution, with a mean of 0 and a standard deviation of 0.02. Bias weights are not used. The decoder includes LReLU activations with $\alpha = 0 . 2$ for residual blocks and $\alpha = 0 . 1$ otherwise. The network was trained on a union of LFW (Huang et al.), CelebA (Liu et al., 2015) and PubFig (Kumar et al., 2009), totaling 260,000 images, the vast majority from CelebA. The identity information is not used during training. The model was trained for $2 3 0 \mathrm { k }$ iterations with a gradual increasing strength of the hyperparameter $\lambda$ , ranging from $\lambda = 1 \cdot 1 0 ^ { - 7 }$ to $\lambda = 2 \cdot 1 0 ^ { - 6 }$ , in four steps. Without this gradual increase, the naturalness of the generated face is diminished.
+
+Sample results are shown in Fig. 3. In each pair of frames, we show the original frame, the target frame from which the identity was extracted, and the modified (output) frame. As can be seen, our method produces natural looking images that match the input frame. Identity is indeed modified, while the other aspects of the frame are maintained.
+
+The supplementary media available at anonymous-deid-iclr2019submission.github. io contains sample videos, with significant motion, pose, expression and illumination changes, to which our method was applied. It is evident that the method can deal with videos, without causing motion- or instability-based distortions. This is despite being strictly based on per-frame analysis.
+
+To test the naturalness of the approach, we tested the ability of humans to discriminate between videos that were modified to those that were not. The human observers $n = 2 0$ ) were fully aware of the type of manipulation that the images had undergone. Still, the human performance is close to random with an average success rate of $5 3 . 6 \%$ $( \mathrm { S D } { = } 1 3 . 0 \%$ ), see Tab. 2)(a). In order to avoid a decision based on a familiar face, this was evaluated on a non-celebrity dataset created specifically for this purpose, which contained 10 videos (samples are attached as supplementary).
+
+Another user study tested how identifiable the resulting images were. We considered images of five persons from a TV show and collected two sets of images: gallery and source. The source images were modified by our method using the same images also as target. As can be seen in the confusion matrix of Tab. 2(b) the users had no problem identifying the correct gallery image based on the source images. However, as Tab. 2(c) shows, post de-identification the answers had little correlation with the true identity, as desired.
+
+In order to automatically quantify the performance of de-identification, we applied state-of-the-art face-recognition networks. Namely, the LResNet34E-IR and LResNet50E-IR networks of ArcFace (Deng et al., 2018). These networks were selected both for their performance and for the difference between these networks and the VGGFace 2 network, used as part of our network, in both training set and loss.
+
+The results of the automatic identification are presented in Tab. 3. Identification is performed out of the 54,000 persons in the ArcFace verification set. The table reports the rank of the true person out of all persons, when sorting the softmax probabilities that the face recognition network produces. The ranking of the true identity in the original video shows an excellent recognition capability, with most of the frames identifying the correct person as the top-1 result. For the de-identified frames, despite the large similarity between the original and the modified frames (Fig. 3), the rank is typically in the thousands.
+
+To emphasize the ability of identity-distancing, while maintaining pixel-space similarity, we compare our method to the work of Samarzija & Ribaric (2014). While that method relies on finding a dissimilar identity within a given dataset, ours is single-image dependent, in the sense that it does not rely on other images within a dataset. It is, therefore, resilient to different poses, expressions, lighting conditions and face structures. Given the figures provided by Samarzija & Ribaric (2014), we compare our generated outputs (Fig. 4) by high-level perceptual distance from the source face, taking into account pixel-level similarity (Fig. 4). A comparison of the distance between the original and de-identified image for the two methods (Fig. 4(e)) reveals that our method results in lower pixel differences but with face descriptor distances that are as high.
+
+A comparison with the work of Wu et al. (2018) is given in Fig. 5. Our results are at least as good as the literature ones, despite us having to run on the cropped faces extracted from the paper’s PDF. Although Wu et al. (2018) presents visually pleasing results, unlike our work, they do not maintain low-level and medium-level features, including mouth expression and facial hair. Note that this previous work presents results on low-resolution black and white images only, with no pose variance.
+
+To further demonstrate the robustness of our methods, we applied the technique to the images of the very difficult inputs from (Phillips et al., 2011), as copied directly from the sample figure there. As can be seen in Fig. 6, our method can deal with very challenging illuminations.
+
+To demonstrate the control of the hyperparameter $\lambda$ over the identity distance, we provide a sequence of generated images, where each trained model is identical, apart from the strength of $\lambda$ . The incremental shift in identity can be seen in Fig. 7.
+
+An ablation analysis is shown in Fig. 8. The various options include: a no-mask option, a partial adversarial loss that applies only to the masked output and not to the raw output, training without the gradual increase of $\lambda$ , and an attempt to incorporate an additional output with a lower resolution to be taken into account, as part of the compound loss.
+
+A numerical analysis of the ablation analysis with the same options is given in Fig. 9. Each method is evaluated along two axis of comparison between the input image and the output image: on the $\cdot$ -axis we show the difference in appearance as measured by the L1 norm between the images; the y-axis shows the difference in ID, as computed by the L1 norm between the VGGFace2 representation of the two images. The plots show mean results obtained for our method (marked (b) to match Fig. 8) and the various ablation methods (marked (c)–(g)). As can be seen, our method maintains image similarity and also has a larger difference in ID than any other method with the exception of the method marked as (c). This is expected, since this variant is the mask-less one, which does not blend in the original image. Variant (f) is considerably more similar to the original image on both axis, since the de-ID performed is very weak with this variant.
+
+For many applications, one would require a higher resolution face recognition. The supplementary video, for example, might look blurry at times, despite the share output of the generator due to the limited resolution. In order to overcome it, we trained a high-resolution (256x256) model that is obtained similarly with the following distinctions: (a) The decoder architecture is simplified and enlarged to be a lattice of 6x(Upscale block $- >$ Residual block), (b) The batch size is set to 64, and (c) The model is trained for 80k iterations.
+
+Training the second model, the resolution is improved, as can be seen in the supplementary video, while the de-identification affect remains as large, as can be seen in Tab. 4.
+
+![](images/0e3ebad31c3c505a9d1cf2a9f1fb15ac8565618313b62bf108d2b11addb33d79.jpg)  
+Figure 2: Training the de-identification network. Shown, in each pair, are the source (left) and output (right) images. During training (but not during test), the target image used is the same as the source one and the output maintains the low-level features of the source and distances the high-level features from it.
+
+![](images/4f173221cf7521283ea603371fcf720438795e18adbbb057f53cde934feacff7.jpg)  
+Figure 3: Sample results for de-identification (zoom). Triplets of source frame, converted frame and target are shown. The modified frame looks similar but the identity is completely different.
+
+# 5 CONCLUSIONS
+
+The appearance of a face is hard to model. For example, computer graphics animations avoid realistic faces in order to stay out of the uncanny valley. The recent GAN technology can create realistic high resolution (frontal) facial images, given a latent space vector $z$ . However, the domain of faces is not completely covered: the recent generators suffer from both mode collapse and mode canceling, and for many face images $I$ , one cannot find a latent vector $z$ , such that a modern generator $G$ would generate $G ( z ) = I$ .
+
+In this work, we employ an encoder-decoder architecture, which avoids the mode canceling pitfalls. However, unlike latent-space generators, not every mid-network activation leads to the generation of a valid face downstream. Despite this shortcoming, we show that an encoder-decoder architecture is flexible enough to support multiple conditional generation tasks.
+
+![](images/d6c312dd09e472ef8bde12136c30555bedbd344d2e3d91041110102de34739d0.jpg)  
+Figure 4: Comparison with the work of Samarzija & Ribaric (2014) (taken from that paper’s sample image). (a) Original image (also used for the target of our method). (b) Our generated output. (c) Result of (Samarzija & Ribaric, 2014). (d) Target used by Samarzija & Ribaric (2014). (e) A comparison of the distance between the original and de-identified image for the two methods. Our method results in lower pixel differences but with face descriptor distances that are as high or higher.
+
+![](images/cde0bb3f7689ab057a1fad8105129397ee99c7ddb75456642946e47e0964430c.jpg)  
+Figure 5: Comparison with Wu et al. (2018) (taken from that paper’s sample image). Row 1 - Original images. Row 2 - results of Wu et al. (2018). Row 3 - Our generated outputs. The previous work does not maintain expression, pose, and facial hair.
+
+![](images/9dac4c72d6dca88f421a2a83c9d58debee754fbc03cfad1fc7fbfb6b118a0093.jpg)  
+Figure 6: De-Identification applied to the examples labeled as very challenging in the NIST Face Recognition Challenge (Phillips et al., 2011) (taken from that paper’s sample image, images are zoomed in).
+
+![](images/548c8642bfcc85c58c9fbd42a1f2d94ab362c548e1712b0f9281d61411139847.jpg)  
+Figure 7: A sequence of images, generated with an incrementally (left-to-right) growing $\lambda$ . The gradual identity shift can be observed. (a) Source. (b) $\lambda = - 2 \cdot 1 0 ^ { - 7 }$ . (c) $\lambda = - 5 \cdot 1 0 ^ { - 7 }$ . (d) $\bar { \lambda } = - 1 \cdot 1 0 ^ { - 6 }$ . (e) $\lambda = - 2 \cdot 1 0 ^ { - 6 }$ .
+
+![](images/45f81cba93d7c9ea76ecf8c672358c5baaa512310ed0d313dd639c18dcd3c98c.jpg)  
+Figure 8: An ablation study. (a) Source image. (b) Our result. (c) No mask. Bad face edge, artifacts near the mouth, glasses occlusion handled poorly. (d) Adversarial loss on masked output only. Artifacts around the right eye, green stripes near the mouth. (e) No gradual $\lambda$ strength in training. Collapse into unnatural blurred face. (f) Additional lower resolution output for the compound loss. Weak de-id, checkerboard pattern near the nose, artifacts on the nose, between eyebrows and when handling occlusions. (g) Weak $\lambda$ and adversarial loss on masked output only. Weak de-id, artifacts near the eyes and eyebrows.
+
+![](images/e2126ed05914800d9264af2ecb12e94c77deb5d71e6c2c749bf684b67c5066fc.jpg)  
+Figure 9: Quantitative ablation study results: for our method – marked as (b) – and the various variants in columns (c)–(g) of Fig. 8 we measure the mean pixel-level distance and the mean ID distance (as evaluated by the differences in the last layer of the VGGFace2 classifier), both in L1. The first should be low, while the second should be high. As can be seen in the results, the model we use (b) is very high in the ID distance, while considerably low in the pixel-level distance. The raw (unmasked) model (c) achieves an even higher ID distance, but this is anticipated, since it is not blended with the source image.
+
+Table 3: Ranking of the true identity out of a dataset of 54,000 persons ( $S \mathrm { D } { = } \ S$ Standard Deviation). Evaluation is performed on the pre-trained LResNet34E-IR / LResNet50E-IR ArcFace networks.   
+
+<table><tr><td></td><td colspan="4">LResNet34E-IR</td><td colspan="4">LResNet50E-IR</td></tr><tr><td>Person</td><td colspan="2">Original frames</td><td colspan="2">De-Identified frames</td><td colspan="2">Original frames</td><td colspan="2">De-Identified frames</td></tr><tr><td></td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td></tr><tr><td>Simone Biles</td><td>1</td><td>6±91</td><td>1298</td><td>2038.7±2167</td><td>1</td><td>3±50</td><td>1730</td><td>2400.6±2142</td></tr><tr><td>Billy Corgan</td><td>1</td><td>147.4±615</td><td>3891</td><td>4112.6±2569</td><td>1</td><td>95.6±313</td><td>3156</td><td>3456.3±2601</td></tr><tr><td>Selena Gomez</td><td>1</td><td>1±0</td><td>2653</td><td>3017.7±1873</td><td>1</td><td>1±0</td><td>2256</td><td>2704±1873</td></tr><tr><td>Scarlett Johansson</td><td>1</td><td>1.3±4</td><td>9191</td><td>8146.6±2953</td><td>1</td><td>3.8±38.6</td><td>9012</td><td>7753.5±3112</td></tr><tr><td>Steven Yeun</td><td>1</td><td>1.1±1</td><td>7923</td><td>6115.4±4060</td><td>1</td><td>1.02±0.6</td><td>5806</td><td>4976.2±3167</td></tr><tr><td>Sarah J.Parker</td><td>1</td><td>1±0</td><td>980</td><td>1770.5±1787</td><td>1</td><td>1±0</td><td>679</td><td>1069.3±1096</td></tr><tr><td>Average</td><td>1</td><td>26</td><td>4322</td><td>4200</td><td>1</td><td>17</td><td>3773</td><td>3726</td></tr></table>
+
+Table 4: Ranking results for the high resolution model. Show is the ranking of the true identity out of a dataset of 54,000 persons ( $\mathrm { S D } { = } 1$ Standard Deviation). Evaluation is performed on the pre-trained LResNet50E-IR ArcFace network.   
+
+<table><tr><td rowspan="2">Person</td><td colspan="2">Original frames</td><td colspan="2">De-Id 256x256 frames</td></tr><tr><td>Median</td><td>Mean ±SD</td><td>Median</td><td>Mean 士SD</td></tr><tr><td>Simone Biles</td><td>1</td><td>3±50</td><td>1725</td><td>2223±1814</td></tr><tr><td>Billy Corgan</td><td>1</td><td>95.6±313</td><td>901</td><td>1334±1518</td></tr><tr><td>Selena Gomez</td><td>1</td><td>1±0</td><td>8058</td><td>8110±2186</td></tr><tr><td>Scarlett Johansson</td><td>1</td><td>3.8±38.6</td><td>4493</td><td>4830±2544</td></tr><tr><td>Steven Yeun</td><td>1</td><td>1.02±0.6</td><td>1069</td><td>1814±2544</td></tr><tr><td>Sarah J.Parker</td><td>1</td><td>1±0</td><td>408</td><td>620±665</td></tr><tr><td>Average</td><td>1</td><td>17</td><td>2776</td><td>3155</td></tr></table>
+
+# REFERENCES
+
+Sagie Benaim and Lior Wolf. One-sided unsupervised domain mapping. In NIPS, 2017.
+
+Dmitri Bitouk, Neeraj Kumar, Samreen Dhillon, Peter Belhumeur, and Shree K. Nayar. Face swapping: Automatically replacing faces in photographs. In SIGGRAPH, 2008.
+
+Volker Blanz, Kristina Scherbaum, Thomas Vetter, and Hans-Peter Seidel. Exchanging faces in images. In Computer Graphics Forum, volume 23, pp. 669–676. Wiley Online Library, 2004.
+
+Qiong Cao, Li Shen, Weidi Xie, Omkar M Parkhi, and Andrew Zisserman. Vggface2: A dataset for recognising faces across pose and age. arXiv preprint arXiv:1710.08092, 2017.
+
+Francois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1251–1258, 2017.
+
+Jiankang Deng, Jia Guo, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. arXiv preprint arXiv:1801.07698, 2018.
+
+Faceswap. Github project, https://github.com/deepfakes/faceswap. 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS. 2014.
+
+R. Gross, L. Sweeney, F. de la Torre, and S. Baker. Semi-supervised learning of multi-factor models for face de-identification. In 2008 IEEE Conference on Computer Vision and Pattern Recognition, 2008.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In ICCV, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016b.
+
+Gary B Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical report.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV, 2016.
+
+Amin Jourabloo, Xi Yin, and Xiaoming Liu. Attribute preserved face deidentification. In In ICB, 2015.
+
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In ICLR, 2018.
+
+Ira Kemelmacher-Shlizerman. Transfiguring portraits. ACM Trans. Graph., 35(4), 2016.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jungkwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. arXiv preprint arXiv:1703.05192, 2017.
+
+Davis E King. Dlib-ml: A machine learning toolkit. Journal of Machine Learning Research, 10(Jul): 1755–1758, 2009.
+
+D.P. Kingma and J. Ba. Adam: A method for stochastic optimization. In ICLR, 2016.
+
+Iryna Korshunova, Wenzhe Shi, Joni Dambre, and Lucas Theis. Fast face-swap using convolutional neural networks. In The IEEE International Conference on Computer Vision, 2017.
+
+Neeraj Kumar, Alexander C Berg, Peter N Belhumeur, and Shree K Nayar. Attribute and simile classifiers for face verification. In CVPR, 2009.
+
+Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. In NIPS. 2017.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, 2015.
+
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In ICCV, 2017.
+
+E. M. Newton, L. Sweeney, and B. Malin. Preserving privacy by de-identifying face images. IEEE Transactions on Knowledge and Data Engineering, 17(2):232–243, 2005a.
+
+Elaine M Newton, Latanya Sweeney, and Bradley Malin. Preserving privacy by de-identifying face images. IEEE transactions on Knowledge and Data Engineering, 17(2):232–243, 2005b.
+
+Yuval Nirkin, Iacopo Masi, Anh Tuan Tran, Tal Hassner, and Gerard Medioni. On face segmentation, face swapping, and face perception. arXiv preprint arXiv:1704.06729, 2017.
+
+P Jonathon Phillips, J Ross Beveridge, Bruce A Draper, Geof Givens, Alice J O’Toole, David S Bolme, Joseph Dunlop, Yui Man Lui, Hassan Sahibzada, and Samuel Weimer. An introduction to the good, the bad, & the ugly face recognition challenge problem. In Automatic Face & Gesture Recognition, 2011.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+O. Ronneberger, P.Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), 2015.
+
+Tim Salimans, Ian J. Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016.
+
+B. Samarzija and S. Ribaric. An approach to the de-identification of faces in different poses. In 2014 37th International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO), 2014.
+
+Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations (ICLR), 2017.
+
+Dmitry Ulyanov, Vadim Lebedev, Victor Lempitsky, et al. Texture networks: Feed-forward synthesis of textures and stylized images. In ICML, 2016a.
+
+Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016b.
+
+Yifan Wu, Fan Yang, and Haibin Ling. Privacy-protective-gan for face de-identification. arXiv preprint arXiv:1806.08906, 2018.
+
+Zili Yi, Hao Zhang, Ping Tan, and Minglun Gong. DualGAN: Unsupervised dual learning for image-to-image translation. arXiv preprint arXiv:1704.02510, 2017.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+# A DE-IDENTIFICATION USER STUDY
+
+We attach the images as they were presented in the second user study. The users were asked to identify either the images on the 2nd row or the images on the 3rd row based on the gallery images in the first row. The users were shown all images at once, were given unlimited time, and were asked to perform the task as accurately as they could.
+
+![](images/912707ef41b2eb6339c11c67b6b7dfcf1e4defd08ec260040b233bab52e2350d.jpg)  
+Figure 10: The images from the user study. Each column is a different individual. The first row are the gallery images, i.e, the album images the users were asked to select the identity from. The second row is the input image. The third row is the output of our method, i.e., the de-identified version of the second row.
+
+# B DE-IDENTIFICATION RESULTS WITHOUT THE ZOOM
+
+For completeness, we append the original sized results, where no zoom-in was applied.
+
+![](images/761f5e7f493f2216135aec638325f69e419eead4b074764a6b190fe4a109ab06.jpg)  
+Figure 11: Same as Fig. 3 but without the zoom.
+
+![](images/bf2bc1b11ced7e4e56dadca2b9ca0eda3cee05e427e2b07c30580d1690f0c8eb.jpg)  
+Figure 12: Same as Fig. 6 but without the zoom.

parse/train/SyfdsjA9FX/SyfdsjA9FX_content_list.json

@@ -0,0 +1,1597 @@
+[
+    {
+        "type": "text",
+        "text": "LIVE FACE DE-IDENTIFICATION IN VIDEO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            679,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a method for face de-identification that enables fully automatic video modification at high frame rates. The goal is to maximally decorrelate the identity, while having the perception (pose, illumination and expression) fixed. We achieve this by a novel feed forward encoder-decoder network architecture that is conditioned on the high-level representation of a person’s facial image. The network is global, in the sense that it does not need to be retrained for a given video or for a given identity, and it creates natural-looking image sequences with little distortion in time. ",
+        "bbox": [
+            232,
+            241,
+            766,
+            352
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            336,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In consumer image and video applications, the face has a unique importance that stands out from all other objects. For example, face recognition (detection followed by identification) is perhaps much more widely applicable than any other object recognition (categorization, detection, or instance identification) in consumer images. Similarly, putting aside image processing operators that are applied to the entire frame, face filters remain the most popular filters for consumer video. Since face technology is both useful and impactful, it also raises many ethical concerns. Face recognition can lead to loss of privacy and face replacement technology may be misused to create misleading videos. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            508
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on a video de-identification, which is a video filtering application that both requires a technological leap over the current state-of-the-art and is benign in nature. This application requires the creation of a video of a similar looking person, such that the perceived identity is changed. This allows, for example, the user to leave a natural-looking video message in a public forum in an anonymous way that would presumably prevent face recognition technology from recognizing them. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The problem of video de-identification is a challenging computational task. The video needs to be modified in a seamless way, without causing flickering or other visual artifacts and distortions, such that the identity is changed, while all other factors remain identical. These factors include pose and expression, occlusion, illumination and shadow, and their dynamics. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            648
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In order to tackle these challenges, we introduce a novel encoder-decoder architecture. To the latent space, we concatenate the activations of the representation layer of a network trained to perform face recognition. The loss terms separate between low- and mid-level perceptual terms and high-level terms. The former are used to tie the output image to the input video frame, while the latter is used to obtain the desired modification. Additional losses include reconstruction losses, edge losses, and an adversarial loss. The network outputs both an image and a mask, which are used, in tandem, to reconstruct the output frame. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            752
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast to the literature methods, which are limited to still images and often swap the image’s face with a dataset face, our method handles video and generates de novo faces. Our experiments show convincing performance for unconstrained videos, producing natural looking videos. The person in those videos has a similar appearance to the original person. However, a state-of-the-art face-recognition network fails to identify the person. A similar experiment, shows that humans cannot identify the generated face, even without time constraints. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            843
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 PREVIOUS WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            351,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Faces have been modeled by computer graphics systems for a long time. In machine learning, faces have been one of the key benchmarks for GAN-based generative models (Goodfellow et al., ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1288151b8cc5df9fb1d07b9f5d45788afe92727490ed3323c5c921747b83de7.jpg",
+        "table_caption": [
+            "Table 1: A comparison to literature de-identification methods. †The face is swapped with an average of a few dataset faces. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>(Newton, &#x27;05)</td><td>(Gross, &#x27;08)</td><td>(Samarzija, &#x27;14)</td><td>(Jourabloo, &#x27;15)</td><td>(Wu, &#x27;18)</td><td>Our</td></tr><tr><td>Preserves expression</td><td></td><td>1</td><td>1</td><td>1</td><td>=</td><td>+</td></tr><tr><td>Preserves pose</td><td></td><td>+</td><td>+</td><td></td><td>=</td><td>+</td></tr><tr><td>Generates new faces</td><td></td><td>+</td><td>1</td><td>+</td><td>+</td><td>+</td></tr><tr><td>Demonstrated on video</td><td></td><td>1</td><td></td><td>1</td><td></td><td>+</td></tr><tr><td>Demonstrated on a diverse dataset (gender, ethnicity, age, etc.)</td><td></td><td>+</td><td></td><td>+</td><td></td><td>+</td></tr></table>",
+        "bbox": [
+            178,
+            145,
+            818,
+            273
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2014; Radford et al., 2015; Salimans et al., 2016) since their inception. Recently, high resolution natural looking faces were generated by training both the generator and the discriminator of the GAN progressively, starting with shallower networks and lower resolutions and enlarging these gradually (Karras et al., 2018). ",
+        "bbox": [
+            174,
+            311,
+            825,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Conditional generation of faces has been a key task in various unsupervised domain translation contributions, where the task is to learn to map, e.g., a person without eyewear to a person with eyeglasses, without seeing matching samples from the two domains (Kim et al., 2017; Yi et al., 2017; Benaim & Wolf, 2017; Liu et al., 2017). For more distant domain mapping, such as mapping between a face image and the matching computer graphics avatar, additional supervision in the form of a face descriptor network was used (Taigman et al., 2017). Our work uses these face descriptors in order to distance the identity of the output from that of the input. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As far as we know, our work is the first de-identification work to present results on videos. In still images, several methods have been previously suggested. Earlier work implemented different types of image distortions for face de-identification (Newton et al., 2005b; Gross et al., 2008), while more recent works rely on techniques for selecting distant faces (Samarzija & Ribaric, 2014) or averaging/fusing faces from pre-existing datasets Newton et al. (2005a); Jourabloo et al. (2015). The experiments conducted by the aforementioned techniques are restricted, in most cases to lowresolution, black and white results. Although it is possible to create eye-pleasing results, they are not robust to different poses, illuminations and facial structures, making them inadequate for video generation. The use of GANs for face de-identification has been suggested in the work of Wu et al. (2018). However, the experiments were restricted to a homogeneous dataset, with no apparent expression preservation within the results. See Tab. 1 for a comparative view of the literature. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            632
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The current literature on de-identification often involves face swapping (our method does not). Face swapping, i.e., the replacement of a person’s face in an image with another person’s face, has been an active research topic for some time, starting with the influential work of (Blanz et al., 2004; Bitouk et al., 2008). Recent contributions have shown a great deal of robustness to the source image as well as for the properties of the image, from which the target face is taken (Kemelmacher-Shlizerman, 2016; Nirkin et al., 2017). While these classical face swapping methods work in the pixel space and copy the expression of the target image, recent deep-learning based work swap the identity, while maintaining the other aspects of the source image (Korshunova et al., 2017). In comparison to our work, (Korshunova et al., 2017) requires training a new network for every target person, the transferred expression does not show subtleties (which would be critical, e.g., for a speaking person), and the results are not as natural as ours. These limitations are probably a result of capturing the appearance of the target by restricting the output to be similar, patch by patch, to a collection of patches from the target person. Moreover, (Korshunova et al., 2017) is limited to stills and was not demonstrated on video. ",
+        "bbox": [
+            174,
+            638,
+            826,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The face swapping (FS) project (Faceswap, 2017) is an unpublished work that replaces faces in video in a way that can be very convincing, given suitable inputs. Unlike our network, the FS is retrained for every pair of source-video and target-video persons. The input to the FS system, during training, is two large sets of images, one from each identity. Typically, in order to obtain good results, thousands of images from each individual with a significant variability in pose, expression, and illumination are used. In many cases, a large subset of the images of the source person are taken from the video that is going to be converted. In addition, FS often fails, and in order to obtain a convincing output, the person in the source video and the target person need to have similar facial structure. These limitations make it unsuitable for de-identification purposes. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/09a71ca4c372f6c19354d086b6fd71813ac67b60350864254ed771aae2076d7d.jpg",
+        "image_caption": [
+            "Figure 1: (a) The architecture of our network. For conditioning, a pre-trained face recognition network is used. (b) An illustration of the multi-image perceptual loss used, which employs two replicas of the same face recognition network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            102,
+            826,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            433,
+            825,
+            476
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Like ours, the FS method is based on an encoder-decoder architecture, where both an image and output mask are produced. A few technical novelties of FS are shared with our work. Most notably is the way in which augmentation is performed in order to train a more semantic encoder-decoder network. During training of FS, the input image is modified by rotating or scaling it, before it is fed to the encoder. The image that the decoder outputs is compared to the undistorted image. Another common property is that the GAN variant used employs virtual examples created using the mixup technique (Zhang et al., 2017). In addition, in order to maintain the pose and expression, which are considered low- or mid-level features in face descriptors (orthogonal to the identity) FS employs a perceptual loss (Johnson et al., 2016; Ulyanov et al., 2016a) that is based on the layers of a face-recognition network. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            641,
+            281,
+            657
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our architecture is based on an adversarial autoencoder (Makhzani et al., 2015), coupled with a trained face-classifier. By concatenating the autoencoder’s latent space with the face-classifier representation layer, we achieve a rich latent space, embedding both identity and expression information. The network is trained in a counter-factual way, i.e., the output differs from the input in key aspects, as dictated by the conditioning. The generation task is, therefore, highly semantic, and the loss required to capture its success cannot be a conventional reconstruction loss. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the task of de-identification, we employ a target image, which is any image of the person in the video. The method then distances the face descriptors of the output video from those of the target image. The target image does not need to be based on a frame from the input video. This contributes to the applicability of the method, allowing it to be applied to live videos. In our experiments, we do not use an input frame in order to show the generality of the approach. To encode the target image, we use a pre-trained face classifier ResNet-50 network by He et al. (2016b), trained over the VGGFace2 dataset of Cao et al. (2017). ",
+        "bbox": [
+            174,
+            763,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The process during test time is similar to the steps taken in the face swapping literature and involves the following steps: (a) A square bounding box is extracted using a face detector, we employ dlib (King, 2009). (b) Multiple facial points are detected. In our implementation we use the 68 points provided by dlib. (c) A transformation matrix is extracted, using an estimated similarity transformation (scale, rotation and translation) to an averaged face. (d) The estimated transformation is applied to the input face. (e) The transformed face is passed to our network, together with the representation of the target image, obtaining both an output image and a mask. (f) The output image and mask are projected back, using the inverse of the similarity transformation. (g) We generate an output frame by linearly mixing, per pixel, the input and the network’s transformed output image, according to the weights of the transformed mask. (h) The outcome is merged into the original frame, in the region defined by the convex hull of the facial points. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training is performed on image datasets and not on video. At training time, we perform the following steps: (a) The face image is distorted and augmented. This is done by applying random scaling, rotation and elastic deformation. (b) The distorted image is fed into the network, together with the representation of a target image. During training, we select the same image, undistorted. (c) A linear combination of the masked output (computed as in step (g) above) and the undistorted input is fed to the discriminator. This is the mixup technique (Zhang et al., 2017) discussed below. (d) Losses are applied on the network’s mask and image output, as well as to the masked output, as detailed below. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that there is a discrepancy between how the network is trained and how it is applied. Not only that we do not make any explicit effort to train on videos, the target images are selected in a different way. During training, we extract the identity from the training image itself and not from an independent target image. The method is still able to generalize to perform the actual application on unconstrained videos. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            400,
+            400,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The architecture is illustrated in Fig. 1(a). The encoder is composed of a convolutional layer, followed by five strided, depth-wise separable (Chollet, 2017) convolutions with instance normalization (Ulyanov et al., 2016b). Subsequently, a single fully connected layer is employed, and the target face representation is concatenated. The decoder is composed of a fully connected layer, followed by a lattice of upscale and residual (He et al., 2016a) blocks, terminated with a tanh activated convolution for the output image, and a sigmoid activated convolution for the mask output. Each upscale block is comprised of a 2D convolution with twice the number of filters than the input channel size. Following an instance normalization and a LReLU (He et al., 2015) activation, the activations are re-ordered such that the width and height are doubled, while the channel size is halved. Each residual block input is summed with the output of a Conv2D-LReLU-Conv2D chain. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A low-capacity Unet connection (Ronneberger et al., 2015) is employed $( 3 2 \\mathrm { x } 3 2 \\mathrm { x } 1 )$ ), thus relieving the autoencoder’s bottleneck, allowing a stronger focus on the encoding of transfer-related information. The connection size does not exceed the bottleneck size (1024) and due to the distortion of the input image, a collapse into a simple reconstructing autoencoder in early training stages is averted. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            630
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The discriminator consists of four strided convolutions with LReLU activations, with instance normalization applied on all but the first one. A sigmoid activated convolution yields a single output. ",
+        "bbox": [
+            176,
+            636,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING AND THE LOSSES USED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            454,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For training all networks, except for the GAN’s discriminator $D$ , we use a compound loss $\\mathcal { L }$ , which is a weighted sum of multiple parts: ",
+        "bbox": [
+            173,
+            708,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b529045e40d41ac826bcddec58cdabd3f3f6a4996d4d1a32037fca1722308a56.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } = \\alpha _ { 0 } \\mathcal { L } _ { G } + \\alpha _ { 1 } \\mathcal { L } _ { R } ^ { r a w } + \\alpha _ { 1 } \\mathcal { L } _ { R } ^ { m a s k e d } + \\alpha _ { 2 } \\mathcal { L } _ { x } ^ { r a w } + \\alpha _ { 2 } \\mathcal { L } _ { y } ^ { r a w } + \\alpha _ { 2 } \\mathcal { L } _ { x } ^ { m a s k e d } + \\alpha _ { 2 } \\mathcal { L } _ { y } ^ { m a s k e d } } \\\\ & { \\qquad + \\alpha _ { 3 } \\mathcal { L } _ { p } ^ { r a w } + \\alpha _ { 3 } \\mathcal { L } _ { p } ^ { m a s k e d } + \\alpha _ { 4 } \\mathcal { L } ^ { m } + \\alpha _ { 5 } \\mathcal { L } _ { x } ^ { m } + \\alpha _ { 5 } \\mathcal { L } _ { y } ^ { m } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            742,
+            787,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the de $\\mathcal { L } _ { G }$ ier enerator’s loss, and the version $\\mathcal { L } _ { R } ^ { r a w }$ and  app $\\mathcal { L } _ { R } ^ { m a s k e d }$ are recomasking n, ses fand he output image ofare reconstruction $z ^ { r a w }$ $z ^ { m a s k e d }$ $\\mathcal { L } _ { x } ^ { * }$ $\\mathcal { L } _ { y } ^ { * }$ losses applied to the spatial images derivatives, $\\mathcal { L } _ { p } ^ { * }$ are the perceptual losses, and $\\mathcal { L } _ { * } ^ { m }$ are regularization losses on the mask. The perceptual loss terms are the only terms that differ between the two applications. The discriminator network is trained using its own loss $\\mathcal { L } _ { D }$ . Throughout our experiments, we employ $\\alpha _ { 0 } = \\alpha _ { 1 } = \\alpha _ { 2 } = \\alpha _ { 3 } = 0 . 5 , \\alpha _ { 4 } = 3 \\cdot 1 0 ^ { - 3 } , \\alpha _ { 5 } = 1 0 ^ { - 2 } .$ . ",
+        "bbox": [
+            174,
+            801,
+            825,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To maintain realistic looking generator outputs, adversarial loss is imposed with a convex combination of example pairs (known as mixup) (Zhang et al., 2017) over a Least Square GAN (Mao et al., 2017) ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "loss: ",
+        "bbox": [
+            173,
+            104,
+            205,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4c6e7ebcb8b663760ef5a635439be1a345e5fc0f90e02f30f24386264a7a6ad.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { D } = \\Vert D ( \\delta _ { m x } ) - \\lambda _ { \\beta } \\Im \\Vert _ { 2 } ^ { 2 } \\qquad \\mathcal { L } _ { G } = \\alpha _ { 0 } \\Vert D ( \\delta _ { m x } ) - ( 1 - \\lambda _ { \\beta } ) \\Im \\Vert _ { 2 } ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            121,
+            741,
+            141
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While, $\\delta _ { m x } = \\lambda _ { \\beta } { \\cdot } x + ( 1 { - } \\lambda _ { \\beta } ) z ^ { m a s k e d }$ and $\\lambda _ { \\beta }$ is sampled out of a Beta distribution $\\lambda _ { \\beta } \\sim B e t a ( \\alpha , \\alpha )$ $x$ is the undistorted input “real” sample and $z ^ { m a s k e d }$ is the post masking generated sample. A value of $\\alpha = 0 . 2$ is used throughout the experiments. ",
+        "bbox": [
+            173,
+            147,
+            825,
+            191
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additional losses are exercised to both retain source-to-output similarity, yet drive a perceptible transformation. Several losses are distributed equally between the raw and masked outputs, imposing constraints on both. An L1 reconstruction loss is used to enforce pixel-level similarity: ",
+        "bbox": [
+            173,
+            199,
+            825,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/596d80def30b67deab30df615cc0a41e8473de868a3961e377ed6744d409d4eb.jpg",
+        "text": "$$\n\\mathcal { L } _ { R } ^ { r a w } = \\alpha _ { 1 } \\| z ^ { r a w } - x \\| _ { 1 } \\qquad \\mathcal { L } _ { R } ^ { m a s k e d } = \\alpha _ { 1 } \\| z ^ { m a s k e d } - x \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            246,
+            730,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $z ^ { r a w }$ is the output image itself. This results in a non-trivial constraint, as the encoder input image is distorted. An edge-preserving loss is used to constrain pixel-level derivative differences in both the $x$ and $y$ image axes. Calculated as the absolute difference between the source and output derivatives in each axis direction for both the raw and masked outputs: ",
+        "bbox": [
+            173,
+            268,
+            825,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78c607d543335221c91fecd3ee90fbd2fc15e2a5889bfa612c9ba24539beff41.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\mathcal { L } _ { x } ^ { r a w } = \\alpha _ { 2 } \\| z _ { x } ^ { \\prime } - x _ { x } ^ { \\prime } \\| _ { 1 } } & { } & { \\qquad \\mathcal { L } _ { y } ^ { r a w } = \\alpha _ { 2 } \\| z _ { y } ^ { \\prime } - x _ { y } ^ { \\prime } \\| _ { 1 } } \\\\ { \\mathcal { L } _ { x } ^ { m a s k e d } = \\alpha _ { 2 } \\| z _ { x } ^ { \\prime } - x _ { x } ^ { \\prime } \\| _ { 1 } } & { } & { \\qquad \\mathcal { L } _ { y } ^ { m a s k e d } = \\alpha _ { 2 } \\| z _ { y } ^ { \\prime } - x _ { y } ^ { \\prime } \\| _ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            329,
+            723,
+            373
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $x _ { x } ^ { \\prime }$ is the derivative of the undistorted input image $x$ along the $x$ axis. ",
+        "bbox": [
+            174,
+            376,
+            669,
+            391
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additional losses are applied to the blending mask $m$ , where 0 indicates that the value of this pixel would be taken from the input image $x , 1$ indicates taking the value from $z ^ { r a w }$ , and intermediate values indicate linear mixing. We would like the mask to be both minimal and smooth and, therefore, employ the following losses: ",
+        "bbox": [
+            173,
+            397,
+            826,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac59edd4a08ca912da9b0bbd6025ec7dfe1e4fc536b163c2b3f5633f6672033a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } ^ { m } = \\| m \\| _ { 1 } \\qquad \\mathcal { L } _ { x } ^ { m } = \\| m _ { x } ^ { \\prime } \\| _ { 1 } \\qquad \\mathcal { L } _ { y } ^ { m } = \\| m _ { y } ^ { \\prime } \\| _ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            458,
+            728,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $m _ { x } ^ { \\prime }$ and $m _ { y } ^ { \\prime }$ are the spatial derivatives of the mask. ",
+        "bbox": [
+            173,
+            482,
+            549,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 A MULTI-IMAGE PERCEPTUAL LOSS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            483,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A new variant of the perceptual loss (Johnson et al., 2016) is employed to maintain source expression, pose and lighting conditions, while capturing the target identity essence. This is achieved by employing a perceptual loss between the undistorted source and generated output on several low-tomedium abstraction layers, while constraining the high abstraction layer perceptual loss between the target and generated output. ",
+        "bbox": [
+            174,
+            535,
+            826,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $a _ { n \\times n } ^ { r }$ be the activations of an $n \\times n$ spatial block within the face classifier network for image $r$ where in our case $r$ can be either the input image $x$ , the application dependent target image $t$ , the raw output $z ^ { r a w }$ , or the masked output $z ^ { m \\bar { a } s k e d }$ . ",
+        "bbox": [
+            173,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We consider the spatial activations maps of size $1 1 2 \\times 1 1 2 , 5 6 \\times 5 6 , 2 8 \\times 2 8$ and $7 \\times 7$ , as well as the representation layer of size $1 \\times 1$ . The lower layers (larger maps) are used to enforce similarity to the input image $x$ , while the $7 \\times 7$ layer is used to enforce similarity to $t$ , and the $1 \\times 1$ feature vector is used to enforce dissimilarity to the target image. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let us define $\\ell _ { n \\times n } ^ { r _ { 1 } , r _ { 2 } } = c _ { n } \\| a _ { r _ { 1 } , n \\times n } - a _ { r _ { 2 } , n \\times n } \\| _ { 1 }$ , where $c _ { n }$ is a normalizing constant, corresponding to the size of the spatial activation map. ",
+        "bbox": [
+            176,
+            724,
+            821,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The perceptual loss is given by: ",
+        "bbox": [
+            174,
+            761,
+            382,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64a2cb7e6b77bb9ed3811da4278d30333c60f259b2443ca12e137e31d92617aa.jpg",
+        "text": "$$\n\\mathcal { L } _ { p } ^ { c } = \\ell _ { 1 1 2 \\times 1 1 2 } ^ { x , z ^ { c } } + \\ell _ { 5 6 \\times 5 6 } ^ { x , z ^ { c } } + \\ell _ { 2 8 \\times 2 8 } ^ { x , z ^ { c } } + \\ell _ { 7 \\times 7 } ^ { t , z ^ { c } } - \\lambda \\ell _ { 1 \\times 1 } ^ { t , z }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            780,
+            668,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for $c$ that is either raw or masked, and where $\\lambda > 0$ is a hyperparameter, which determines the distance of the generated face’s high level features from those of the target image. ",
+        "bbox": [
+            173,
+            805,
+            821,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The application of the multi-image perceptual loss during training is depicted in Fig. 1(b). During training, the target is the source and there is only one input image. The resulting image has the texture, pose and expression of the source, but the face is modified to distance the identity, as can be seen in Fig. 2. Note that we call it multi-image perceptual loss, since its aim is to minimize the analog error term during inference (generalization error). However, as a training loss, it is only applied during train, where it receives a pair of images, similarly to other perceptual losses. ",
+        "bbox": [
+            173,
+            839,
+            826,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [
+            "Table 2: User study. (a) Success rate in user identification of a real video from a modified one. Closer to $50 \\%$ is better. (b) The confusion matrix in identifying the five persons for the real images (control). (c) The confusion matrix for identifying based on the de-identified images. "
+        ],
+        "table_footnote": [],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e06c8965266f781dc1ba18274f00e49d23341b7e1f5fccd8735611010c81be19.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            156,
+            823,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At inference time, the network is fed an input frame and a target image. The target image is transmitted through the face classifier, resulting in a target feature vector, which, in turn, is concatenated to the latent embedding space. Due to the way the network is trained, the decoder will drive the output image away from the target feature vector. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            326,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training is done using the Adam (Kingma & Ba, 2016) optimizer, with the learning rate set to $1 0 ^ { - 4 }$ , $\\beta _ { 1 } = 0 . 5$ , and $\\beta _ { 2 } = 0 . 9 9$ . At each training iteration, a batch of 32 images is randomly selected and augmented. We initialize all convolutional weights using a random normal distribution, with a mean of 0 and a standard deviation of 0.02. Bias weights are not used. The decoder includes LReLU activations with $\\alpha = 0 . 2$ for residual blocks and $\\alpha = 0 . 1$ otherwise. The network was trained on a union of LFW (Huang et al.), CelebA (Liu et al., 2015) and PubFig (Kumar et al., 2009), totaling 260,000 images, the vast majority from CelebA. The identity information is not used during training. The model was trained for $2 3 0 \\mathrm { k }$ iterations with a gradual increasing strength of the hyperparameter $\\lambda$ , ranging from $\\lambda = 1 \\cdot 1 0 ^ { - 7 }$ to $\\lambda = 2 \\cdot 1 0 ^ { - 6 }$ , in four steps. Without this gradual increase, the naturalness of the generated face is diminished. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sample results are shown in Fig. 3. In each pair of frames, we show the original frame, the target frame from which the identity was extracted, and the modified (output) frame. As can be seen, our method produces natural looking images that match the input frame. Identity is indeed modified, while the other aspects of the frame are maintained. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The supplementary media available at anonymous-deid-iclr2019submission.github. io contains sample videos, with significant motion, pose, expression and illumination changes, to which our method was applied. It is evident that the method can deal with videos, without causing motion- or instability-based distortions. This is despite being strictly based on per-frame analysis. ",
+        "bbox": [
+            174,
+            688,
+            826,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test the naturalness of the approach, we tested the ability of humans to discriminate between videos that were modified to those that were not. The human observers $n = 2 0$ ) were fully aware of the type of manipulation that the images had undergone. Still, the human performance is close to random with an average success rate of $5 3 . 6 \\%$ $( \\mathrm { S D } { = } 1 3 . 0 \\%$ ), see Tab. 2)(a). In order to avoid a decision based on a familiar face, this was evaluated on a non-celebrity dataset created specifically for this purpose, which contained 10 videos (samples are attached as supplementary). ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another user study tested how identifiable the resulting images were. We considered images of five persons from a TV show and collected two sets of images: gallery and source. The source images were modified by our method using the same images also as target. As can be seen in the confusion matrix of Tab. 2(b) the users had no problem identifying the correct gallery image based on the source images. However, as Tab. 2(c) shows, post de-identification the answers had little correlation with the true identity, as desired. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to automatically quantify the performance of de-identification, we applied state-of-the-art face-recognition networks. Namely, the LResNet34E-IR and LResNet50E-IR networks of ArcFace (Deng et al., 2018). These networks were selected both for their performance and for the difference between these networks and the VGGFace 2 network, used as part of our network, in both training set and loss. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results of the automatic identification are presented in Tab. 3. Identification is performed out of the 54,000 persons in the ArcFace verification set. The table reports the rank of the true person out of all persons, when sorting the softmax probabilities that the face recognition network produces. The ranking of the true identity in the original video shows an excellent recognition capability, with most of the frames identifying the correct person as the top-1 result. For the de-identified frames, despite the large similarity between the original and the modified frames (Fig. 3), the rank is typically in the thousands. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To emphasize the ability of identity-distancing, while maintaining pixel-space similarity, we compare our method to the work of Samarzija & Ribaric (2014). While that method relies on finding a dissimilar identity within a given dataset, ours is single-image dependent, in the sense that it does not rely on other images within a dataset. It is, therefore, resilient to different poses, expressions, lighting conditions and face structures. Given the figures provided by Samarzija & Ribaric (2014), we compare our generated outputs (Fig. 4) by high-level perceptual distance from the source face, taking into account pixel-level similarity (Fig. 4). A comparison of the distance between the original and de-identified image for the two methods (Fig. 4(e)) reveals that our method results in lower pixel differences but with face descriptor distances that are as high. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A comparison with the work of Wu et al. (2018) is given in Fig. 5. Our results are at least as good as the literature ones, despite us having to run on the cropped faces extracted from the paper’s PDF. Although Wu et al. (2018) presents visually pleasing results, unlike our work, they do not maintain low-level and medium-level features, including mouth expression and facial hair. Note that this previous work presents results on low-resolution black and white images only, with no pose variance. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further demonstrate the robustness of our methods, we applied the technique to the images of the very difficult inputs from (Phillips et al., 2011), as copied directly from the sample figure there. As can be seen in Fig. 6, our method can deal with very challenging illuminations. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the control of the hyperparameter $\\lambda$ over the identity distance, we provide a sequence of generated images, where each trained model is identical, apart from the strength of $\\lambda$ . The incremental shift in identity can be seen in Fig. 7. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An ablation analysis is shown in Fig. 8. The various options include: a no-mask option, a partial adversarial loss that applies only to the masked output and not to the raw output, training without the gradual increase of $\\lambda$ , and an attempt to incorporate an additional output with a lower resolution to be taken into account, as part of the compound loss. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            647
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A numerical analysis of the ablation analysis with the same options is given in Fig. 9. Each method is evaluated along two axis of comparison between the input image and the output image: on the $\\cdot$ -axis we show the difference in appearance as measured by the L1 norm between the images; the y-axis shows the difference in ID, as computed by the L1 norm between the VGGFace2 representation of the two images. The plots show mean results obtained for our method (marked (b) to match Fig. 8) and the various ablation methods (marked (c)–(g)). As can be seen, our method maintains image similarity and also has a larger difference in ID than any other method with the exception of the method marked as (c). This is expected, since this variant is the mask-less one, which does not blend in the original image. Variant (f) is considerably more similar to the original image on both axis, since the de-ID performed is very weak with this variant. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For many applications, one would require a higher resolution face recognition. The supplementary video, for example, might look blurry at times, despite the share output of the generator due to the limited resolution. In order to overcome it, we trained a high-resolution (256x256) model that is obtained similarly with the following distinctions: (a) The decoder architecture is simplified and enlarged to be a lattice of 6x(Upscale block $- >$ Residual block), (b) The batch size is set to 64, and (c) The model is trained for 80k iterations. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training the second model, the resolution is improved, as can be seen in the supplementary video, while the de-identification affect remains as large, as can be seen in Tab. 4. ",
+        "bbox": [
+            173,
+            891,
+            825,
+            920
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e3ebad31c3c505a9d1cf2a9f1fb15ac8565618313b62bf108d2b11addb33d79.jpg",
+        "image_caption": [
+            "Figure 2: Training the de-identification network. Shown, in each pair, are the source (left) and output (right) images. During training (but not during test), the target image used is the same as the source one and the output maintains the low-level features of the source and distances the high-level features from it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f173221cf7521283ea603371fcf720438795e18adbbb057f53cde934feacff7.jpg",
+        "image_caption": [
+            "Figure 3: Sample results for de-identification (zoom). Triplets of source frame, converted frame and target are shown. The modified frame looks similar but the identity is completely different. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            372,
+            823,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            328,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The appearance of a face is hard to model. For example, computer graphics animations avoid realistic faces in order to stay out of the uncanny valley. The recent GAN technology can create realistic high resolution (frontal) facial images, given a latent space vector $z$ . However, the domain of faces is not completely covered: the recent generators suffer from both mode collapse and mode canceling, and for many face images $I$ , one cannot find a latent vector $z$ , such that a modern generator $G$ would generate $G ( z ) = I$ . ",
+        "bbox": [
+            173,
+            722,
+            825,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we employ an encoder-decoder architecture, which avoids the mode canceling pitfalls. However, unlike latent-space generators, not every mid-network activation leads to the generation of a valid face downstream. Despite this shortcoming, we show that an encoder-decoder architecture is flexible enough to support multiple conditional generation tasks. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6c312dd09e472ef8bde12136c30555bedbd344d2e3d91041110102de34739d0.jpg",
+        "image_caption": [
+            "Figure 4: Comparison with the work of Samarzija & Ribaric (2014) (taken from that paper’s sample image). (a) Original image (also used for the target of our method). (b) Our generated output. (c) Result of (Samarzija & Ribaric, 2014). (d) Target used by Samarzija & Ribaric (2014). (e) A comparison of the distance between the original and de-identified image for the two methods. Our method results in lower pixel differences but with face descriptor distances that are as high or higher. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            138,
+            810,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cde0bb3f7689ab057a1fad8105129397ee99c7ddb75456642946e47e0964430c.jpg",
+        "image_caption": [
+            "Figure 5: Comparison with Wu et al. (2018) (taken from that paper’s sample image). Row 1 - Original images. Row 2 - results of Wu et al. (2018). Row 3 - Our generated outputs. The previous work does not maintain expression, pose, and facial hair. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            564,
+            727,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dac4c72d6dca88f421a2a83c9d58debee754fbc03cfad1fc7fbfb6b118a0093.jpg",
+        "image_caption": [
+            "Figure 6: De-Identification applied to the examples labeled as very challenging in the NIST Face Recognition Challenge (Phillips et al., 2011) (taken from that paper’s sample image, images are zoomed in). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            117,
+            825,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/548c8642bfcc85c58c9fbd42a1f2d94ab362c548e1712b0f9281d61411139847.jpg",
+        "image_caption": [
+            "Figure 7: A sequence of images, generated with an incrementally (left-to-right) growing $\\lambda$ . The gradual identity shift can be observed. (a) Source. (b) $\\lambda = - 2 \\cdot 1 0 ^ { - 7 }$ . (c) $\\lambda = - 5 \\cdot 1 0 ^ { - 7 }$ . (d) $\\bar { \\lambda } = - 1 \\cdot 1 0 ^ { - 6 }$ . (e) $\\lambda = - 2 \\cdot 1 0 ^ { - 6 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            411,
+            810,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/45f81cba93d7c9ea76ecf8c672358c5baaa512310ed0d313dd639c18dcd3c98c.jpg",
+        "image_caption": [
+            "Figure 8: An ablation study. (a) Source image. (b) Our result. (c) No mask. Bad face edge, artifacts near the mouth, glasses occlusion handled poorly. (d) Adversarial loss on masked output only. Artifacts around the right eye, green stripes near the mouth. (e) No gradual $\\lambda$ strength in training. Collapse into unnatural blurred face. (f) Additional lower resolution output for the compound loss. Weak de-id, checkerboard pattern near the nose, artifacts on the nose, between eyebrows and when handling occlusions. (g) Weak $\\lambda$ and adversarial loss on masked output only. Weak de-id, artifacts near the eyes and eyebrows. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            613,
+            823,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/e2126ed05914800d9264af2ecb12e94c77deb5d71e6c2c749bf684b67c5066fc.jpg",
+        "image_caption": [
+            "Figure 9: Quantitative ablation study results: for our method – marked as (b) – and the various variants in columns (c)–(g) of Fig. 8 we measure the mean pixel-level distance and the mean ID distance (as evaluated by the differences in the last layer of the VGGFace2 classifier), both in L1. The first should be low, while the second should be high. As can be seen in the results, the model we use (b) is very high in the ID distance, while considerably low in the pixel-level distance. The raw (unmasked) model (c) achieves an even higher ID distance, but this is anticipated, since it is not blended with the source image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            103,
+            785,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/16e450ae2e530c03bd40ceb3dbf427011722b5c013a02d8efb65d6abbe53fc27.jpg",
+        "table_caption": [
+            "Table 3: Ranking of the true identity out of a dataset of 54,000 persons ( $S \\mathrm { D } { = } \\ S$ Standard Deviation). Evaluation is performed on the pre-trained LResNet34E-IR / LResNet50E-IR ArcFace networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">LResNet34E-IR</td><td colspan=\"4\">LResNet50E-IR</td></tr><tr><td>Person</td><td colspan=\"2\">Original frames</td><td colspan=\"2\">De-Identified frames</td><td colspan=\"2\">Original frames</td><td colspan=\"2\">De-Identified frames</td></tr><tr><td></td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td><td>Me- dian</td><td>Mean ±SD</td></tr><tr><td>Simone Biles</td><td>1</td><td>6±91</td><td>1298</td><td>2038.7±2167</td><td>1</td><td>3±50</td><td>1730</td><td>2400.6±2142</td></tr><tr><td>Billy Corgan</td><td>1</td><td>147.4±615</td><td>3891</td><td>4112.6±2569</td><td>1</td><td>95.6±313</td><td>3156</td><td>3456.3±2601</td></tr><tr><td>Selena Gomez</td><td>1</td><td>1±0</td><td>2653</td><td>3017.7±1873</td><td>1</td><td>1±0</td><td>2256</td><td>2704±1873</td></tr><tr><td>Scarlett Johansson</td><td>1</td><td>1.3±4</td><td>9191</td><td>8146.6±2953</td><td>1</td><td>3.8±38.6</td><td>9012</td><td>7753.5±3112</td></tr><tr><td>Steven Yeun</td><td>1</td><td>1.1±1</td><td>7923</td><td>6115.4±4060</td><td>1</td><td>1.02±0.6</td><td>5806</td><td>4976.2±3167</td></tr><tr><td>Sarah J.Parker</td><td>1</td><td>1±0</td><td>980</td><td>1770.5±1787</td><td>1</td><td>1±0</td><td>679</td><td>1069.3±1096</td></tr><tr><td>Average</td><td>1</td><td>26</td><td>4322</td><td>4200</td><td>1</td><td>17</td><td>3773</td><td>3726</td></tr></table>",
+        "bbox": [
+            173,
+            535,
+            856,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/89cedd6f2d510cf4c925a6520c152bae135528948e697223301656e09752757e.jpg",
+        "table_caption": [
+            "Table 4: Ranking results for the high resolution model. Show is the ranking of the true identity out of a dataset of 54,000 persons ( $\\mathrm { S D } { = } 1$ Standard Deviation). Evaluation is performed on the pre-trained LResNet50E-IR ArcFace network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Person</td><td colspan=\"2\">Original frames</td><td colspan=\"2\">De-Id 256x256 frames</td></tr><tr><td>Median</td><td>Mean ±SD</td><td>Median</td><td>Mean 士SD</td></tr><tr><td>Simone Biles</td><td>1</td><td>3±50</td><td>1725</td><td>2223±1814</td></tr><tr><td>Billy Corgan</td><td>1</td><td>95.6±313</td><td>901</td><td>1334±1518</td></tr><tr><td>Selena Gomez</td><td>1</td><td>1±0</td><td>8058</td><td>8110±2186</td></tr><tr><td>Scarlett Johansson</td><td>1</td><td>3.8±38.6</td><td>4493</td><td>4830±2544</td></tr><tr><td>Steven Yeun</td><td>1</td><td>1.02±0.6</td><td>1069</td><td>1814±2544</td></tr><tr><td>Sarah J.Parker</td><td>1</td><td>1±0</td><td>408</td><td>620±665</td></tr><tr><td>Average</td><td>1</td><td>17</td><td>2776</td><td>3155</td></tr></table>",
+        "bbox": [
+            281,
+            768,
+            712,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sagie Benaim and Lior Wolf. One-sided unsupervised domain mapping. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            126,
+            750,
+            141
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dmitri Bitouk, Neeraj Kumar, Samreen Dhillon, Peter Belhumeur, and Shree K. Nayar. Face swapping: Automatically replacing faces in photographs. In SIGGRAPH, 2008. ",
+        "bbox": [
+            174,
+            148,
+            823,
+            179
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volker Blanz, Kristina Scherbaum, Thomas Vetter, and Hans-Peter Seidel. Exchanging faces in images. In Computer Graphics Forum, volume 23, pp. 669–676. Wiley Online Library, 2004. ",
+        "bbox": [
+            174,
+            188,
+            823,
+            217
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qiong Cao, Li Shen, Weidi Xie, Omkar M Parkhi, and Andrew Zisserman. Vggface2: A dataset for recognising faces across pose and age. arXiv preprint arXiv:1710.08092, 2017. ",
+        "bbox": [
+            173,
+            224,
+            823,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Francois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1251–1258, 2017. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Jia Guo, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. arXiv preprint arXiv:1801.07698, 2018. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Faceswap. Github project, https://github.com/deepfakes/faceswap. 2017. ",
+        "bbox": [
+            173,
+            338,
+            653,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS. 2014. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "R. Gross, L. Sweeney, F. de la Torre, and S. Baker. Semi-supervised learning of multi-factor models for face de-identification. In 2008 IEEE Conference on Computer Vision and Pattern Recognition, 2008. ",
+        "bbox": [
+            176,
+            401,
+            825,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In ICCV, 2015. ",
+        "bbox": [
+            171,
+            453,
+            825,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016b. ",
+        "bbox": [
+            173,
+            529,
+            823,
+            558
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gary B Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical report. ",
+        "bbox": [
+            171,
+            568,
+            825,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            604,
+            823,
+            635
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amin Jourabloo, Xi Yin, and Xiaoming Liu. Attribute preserved face deidentification. In In ICB, 2015. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            681,
+            825,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ira Kemelmacher-Shlizerman. Transfiguring portraits. ACM Trans. Graph., 35(4), 2016. ",
+        "bbox": [
+            169,
+            718,
+            754,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jungkwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. arXiv preprint arXiv:1703.05192, 2017. ",
+        "bbox": [
+            174,
+            742,
+            828,
+            785
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Davis E King. Dlib-ml: A machine learning toolkit. Journal of Machine Learning Research, 10(Jul): 1755–1758, 2009. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D.P. Kingma and J. Ba. Adam: A method for stochastic optimization. In ICLR, 2016. ",
+        "bbox": [
+            174,
+            832,
+            735,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Iryna Korshunova, Wenzhe Shi, Joni Dambre, and Lucas Theis. Fast face-swap using convolutional neural networks. In The IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Neeraj Kumar, Alexander C Berg, Peter N Belhumeur, and Shree K Nayar. Attribute and simile classifiers for face verification. In CVPR, 2009. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. In NIPS. 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            171
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E. M. Newton, L. Sweeney, and B. Malin. Preserving privacy by de-identifying face images. IEEE Transactions on Knowledge and Data Engineering, 17(2):232–243, 2005a. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Elaine M Newton, Latanya Sweeney, and Bradley Malin. Preserving privacy by de-identifying face images. IEEE transactions on Knowledge and Data Engineering, 17(2):232–243, 2005b. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuval Nirkin, Iacopo Masi, Anh Tuan Tran, Tal Hassner, and Gerard Medioni. On face segmentation, face swapping, and face perception. arXiv preprint arXiv:1704.06729, 2017. ",
+        "bbox": [
+            171,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "P Jonathon Phillips, J Ross Beveridge, Bruce A Draper, Geof Givens, Alice J O’Toole, David S Bolme, Joseph Dunlop, Yui Man Lui, Hassan Sahibzada, and Samuel Weimer. An introduction to the good, the bad, & the ugly face recognition challenge problem. In Automatic Face & Gesture Recognition, 2011. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            433,
+            820,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "O. Ronneberger, P.Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), 2015. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            501
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian J. Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016. ",
+        "bbox": [
+            173,
+            507,
+            823,
+            539
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B. Samarzija and S. Ribaric. An approach to the de-identification of faces in different poses. In 2014 37th International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO), 2014. ",
+        "bbox": [
+            174,
+            545,
+            823,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            627
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Vadim Lebedev, Victor Lempitsky, et al. Texture networks: Feed-forward synthesis of textures and stylized images. In ICML, 2016a. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016b. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            703
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yifan Wu, Fan Yang, and Haibin Ling. Privacy-protective-gan for face de-identification. arXiv preprint arXiv:1806.08906, 2018. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zili Yi, Hao Zhang, Ping Tan, and Minglun Gong. DualGAN: Unsupervised dual learning for image-to-image translation. arXiv preprint arXiv:1704.02510, 2017. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            779
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            815
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A DE-IDENTIFICATION USER STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            495,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We attach the images as they were presented in the second user study. The users were asked to identify either the images on the 2nd row or the images on the 3rd row based on the gallery images in the first row. The users were shown all images at once, were given unlimited time, and were asked to perform the task as accurately as they could. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            189
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/912707ef41b2eb6339c11c67b6b7dfcf1e4defd08ec260040b233bab52e2350d.jpg",
+        "image_caption": [
+            "Figure 10: The images from the user study. Each column is a different individual. The first row are the gallery images, i.e, the album images the users were asked to select the identity from. The second row is the input image. The third row is the output of our method, i.e., the de-identified version of the second row. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            203,
+            794,
+            472
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B DE-IDENTIFICATION RESULTS WITHOUT THE ZOOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            643,
+            584
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For completeness, we append the original sized results, where no zoom-in was applied. ",
+        "bbox": [
+            173,
+            598,
+            741,
+            614
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/761f5e7f493f2216135aec638325f69e419eead4b074764a6b190fe4a109ab06.jpg",
+        "image_caption": [
+            "Figure 11: Same as Fig. 3 but without the zoom. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            646,
+            825,
+            829
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf2bc1b11ced7e4e56dadca2b9ca0eda3cee05e427e2b07c30580d1690f0c8eb.jpg",
+        "image_caption": [
+            "Figure 12: Same as Fig. 6 but without the zoom. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            383,
+            825,
+            609
+        ],
+        "page_idx": 14
+    }
+]

parse/train/aHK-onEhYRg/aHK-onEhYRg.md

@@ -0,0 +1,322 @@
+# On Success and Simplicity: A Second Look at Transferable Targeted Attacks
+
+Zhengyu Zhao, Zhuoran Liu, Martha Larson Radboud University {z.zhao,z.liu,m.larson}@cs.ru.nl
+
+# Abstract
+
+Achieving transferability of targeted attacks is reputed to be remarkably difficult. The current state of the art has resorted to resource-intensive solutions that necessitate training model(s) for each target class with additional data. In our investigation, we find, however, that simple transferable attacks which require neither model training nor additional data can achieve surprisingly strong targeted transferability. This insight has been overlooked until now, mainly because the widespread practice of attacking with only few iterations has largely limited the attack convergence to optimal targeted transferability. In particular, we, for the first time, identify that a very simple logit loss can largely surpass the commonly adopted crossentropy loss, and yield even better results than the resource-intensive state of the art. Our analysis spans a variety of transfer scenarios, especially including three new, realistic scenarios: an ensemble transfer scenario with little model similarity, a worse-case scenario with low-ranked target classes, and also a real-world attack on the Google Cloud Vision API. Results in these new transfer scenarios demonstrate that the commonly adopted, easy scenarios cannot fully reveal the actual strength of different attacks and may cause misleading comparative results. We also show the usefulness of the simple logit loss for generating targeted universal adversarial perturbations in a data-free manner. Overall, the aim of our analysis is to inspire a more meaningful evaluation on targeted transferability. Code is available at https://github.com/ZhengyuZhao/Targeted-Tansfer.
+
+# 1 Introduction
+
+Deep neural networks have achieved remarkable performance in various machine learning tasks, but are known to be vulnerable to adversarial attacks [1]. A key property of adversarial attacks that makes them critical in realistic, black-box scenarios is their transferability [2, 3]. Current work on adversarial transferability has achieved great success for non-targeted attacks [4–12], while several initial attempts [3, 4, 13] at targeted transferability have shown its extreme difficulty. Targeted transferability is known to be much more challenging and worth exploring since it can raise more critical concerns by fooling models into predicting a chosen, highly dangerous target class.
+
+However, so far state-of-the-art results can only be secured by resource-intensive transferable attacks [14–16]. Specifically, the FDA approach [14, 15] is based on modeling layer-wise feature distributions by training target-class-specific auxiliary classifiers on large-scale labeled data, and then optimizing adversarial perturbations using these auxiliary classifiers from across the deep feature space. The TTP approach [16] is based on training target-class-specific Generative Adversarial Networks (GANs) through global and local distribution matching, and then using the trained generator to directly generate perturbations on any given input image.
+
+In this paper, we take a second, thorough look at current research on targeted transferability. Our main contribution is the finding that simple transferable attacks [4, 6, 8] that require neither model training nor additional data can actually achieve surprisingly strong targeted transferability. We argue that this insight has been overlooked mainly because current research has unreasonably restricted the attack convergence by only using a small number of iterations (see detailed discussion in Section 3). Another key contribution of our work is, for the first time, demonstrating the general superiority of a very simple logit loss, which even outperforms the resource-intensive state of the art.
+
+In order to validate the general effectiveness of simple transferable attacks, in Section 4.1, we conduct extensive experiments in a wide range of transfer scenarios. We test the commonly adopted single-model and ensemble transfer scenarios, but also introduce three new scenarios that are more challenging and realistic: an ensemble transfer scenario with little model similarity, a worse-case scenario with low-ranked target classes, and also a real-world attack on the Google Cloud Vision API. Experimental results in these new scenarios suggest that evaluation in only the commonly adopted, easy scenarios cannot reveal the actual strength of different attacks, and may cause misleading comparative results. Additional experiments in Section 4.2 have shown the better performance of the simple transferable attacks than the state-of-the-art resource-intensive approaches. Finally, in Section 4.3, inspired by the observation that the generated perturbations themselves reflect specific target semantics, we use the simple Logit attack to generate targeted Universal Adversarial Perturbations (UAPs) in a data-free manner. In contrast, recent advances in targeted UAPs [16–19] have inevitably relied on large-scale optimization over additional data.
+
+Overall, we hope our analysis of the weakness of commonly adopted attack settings and transfer scenarios will inspire a more meaningful evaluation on targeted transferability.
+
+# 2 Related Work
+
+In this section, we review existing simple transferable attacks (Section 2.1), and also recent resourceintensive transferable attacks (Section 2.2). Finally, we discuss related work on generating universal adversarial perturbations.
+
+# 2.1 Simple Transferable Attacks
+
+We refer to transferable attacks that require neither model training nor additional data, but only use iterative optimization on a single (original) image as simple transferable attacks. Simple transferable attacks have been extensively studied in the non-targeted case [4–12], and also attempted in the targeted case [3, 4, 20]. These attacks are commonly built up on the well-known Iterative-Fast Gradient Sign Method (I-FGSM) [21, 22], which can be formulated as:
+
+$$
+\begin{array} { r } { \pmb { x } _ { 0 } ^ { \prime } = \pmb { x } , \pmb { x } _ { i + 1 } ^ { \prime } = \pmb { x } _ { i } ^ { \prime } - \alpha \cdot \mathrm { s i g n } ( \nabla _ { \pmb { x } } J ( \pmb { x } _ { i } ^ { \prime } , y _ { t } ) ) , } \end{array}
+$$
+
+where $\pmb { x } _ { i } ^ { \prime }$ denotes the perturbed image in the $i$ -th iteration, and $y _ { t }$ is the target class label. In order to ensure the imperceptibility, the added perturbations are restricted with respect to some $L _ { p }$ distance, i.e., satisfying $\| { \pmb x } ^ { \prime } - { \pmb x } \| _ { p } \overset { \cdot } { \le } \epsilon$ . Current transferable attack methods have commonly adopted the $L _ { \infty }$ distance, but can also be easily adapted to the $L _ { 2 }$ distance based on an $L _ { 2 }$ normalization [23].
+
+For the loss function $J ( \cdot , \cdot )$ , most simple transferable attacks have adopted the Cross-Entropy (CE) loss. However, the CE loss has been recently shown to be insufficient in the targeted case due to its decreasing gradient problem [20]. To address this problem, the authors in [20] have proposed the $\mathbf { P 0 + T r i p }$ loss, in which the Poincare distance was used to adapt the gradients’ magnitude: ´
+
+$$
+L _ { P o } = d ( { \pmb u } , { \pmb v } ) = \mathrm { a r c c o s h } ( 1 + \delta ( { \pmb u } , { \pmb v } ) ) ,
+$$
+
+$$
+\delta ( \pmb { u } , \pmb { v } ) = \frac { 2 \cdot \| \pmb { u } - \pmb { v } \| _ { 2 } ^ { 2 } } { ( 1 - \| \pmb { u } \| _ { 2 } ^ { 2 } ) ( 1 - \| \pmb { v } \| _ { 2 } ^ { 2 } ) } , \pmb { u } = \frac { l ( \pmb { x } ^ { \prime } ) } { \| l ( \pmb { x } ^ { \prime } ) \| } , \pmb { v } = \operatorname* { m a x } \{ \pmb { v } - \pmb { \xi } , 0 \} ,
+$$
+
+where $\textbf { \em u }$ is the normalized logit vector and $\pmb { v }$ is the one-hot vector with respect to the target class. $\xi = 1 0 ^ { - 5 }$ is a small constant to ensure numerical stability. The following triplet loss is also integrated for pushing the image away from the original class while pulling it into the target class:
+
+$$
+L _ { T r i p } = [ D ( l ( \pmb { x } ^ { \prime } ) , y _ { t } ) - D ( l ( \pmb { x } ^ { \prime } ) , y _ { o } ) + \gamma ] _ { + } , D ( l ( \pmb { x } ^ { \prime } ) , y ) = 1 - \frac { \| l ( \pmb { x } ^ { \prime } ) \cdot \pmb { y } \| _ { 1 } } { \| l ( \pmb { x } ^ { \prime } ) \| _ { 2 } \| y \| _ { 2 } } .
+$$
+
+The overall loss function is then formulated as $L _ { P o + T r i p } = L _ { P o } + \lambda L _ { T r i p }$ . Note that in the original work, ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ was evaluated in the commonly adopted, easy ensemble transfer scenario, which only involves models with similar architectures.
+
+In addition to devising new loss functions, there are other transfer methods [4, 6, 8, 9] developed based on the assumption that preventing the attack optimization from overfitting to the specific source model can improve transferability. Such transfer methods can be easily plugged into different attacks without modifications, in contrast to the above methods that need to apply new attack loss functions. In this paper, we consider three [4, 6, 8] of such transfer methods that have been widely used in the literature, as described in the following text.
+
+Momentum Iterative-FGSM (MI-FGSM) [4] integrates a momentum term, which accumulates previous gradients in order to achieve more stable update directions. It can be expressed as:
+
+$$
+{ \bf \mathcal { G } } _ { i + 1 } = \mu \cdot { \bf g } _ { i } + \frac { \nabla _ { x } J ( { \pmb x } _ { i } ^ { \prime } , y _ { t } ) } { \| \nabla _ { \pmb x } J ( { \pmb x } _ { i } ^ { \prime } , y _ { t } ) \| _ { 1 } } , ~ { \pmb x } _ { i + 1 } ^ { \prime } = { \pmb x } _ { i } ^ { \prime } - \alpha \cdot \mathrm {  ~ \mathrm { s i g n } } ( { \pmb g } _ { i } ) ,
+$$
+
+where $\mathbf { \pmb { g } } _ { i }$ is the accumulated gradients at the $i$ -th iteration, and $\mu$ is a decay factor. Another similar technique that instead uses the Nesterov accelerated gradient was explored in [9].
+
+Translation Invariant-FGSM (TI-FGSM) [6] randomly translates the input image during attack optimization in order to prevent the attack from overfitting to the specific source model. This approach is inspired by the data augmentation techniques used for preventing overfitting in normal model training. Instead of calculating gradients for multiple translated images separately, the authors have proposed an approximate solution to accelerate the implementation. It is achieved by directly computing locally smoothed gradients on the original image via convolution with a kernel:
+
+$$
+\pmb { x } _ { i + 1 } ^ { \prime } = \pmb { x } _ { i } ^ { \prime } - \alpha \cdot \mathrm { s i g n } ( W * \nabla _ { \pmb { x } } J ( \pmb { x } _ { i } ^ { \prime } , y _ { t } ) ) ,
+$$
+
+where $W$ is the convolution kernel used for smoothing. TI-FGSM was originally designed for boosting transferability with adversarially-trained models as target models and has been recently shown that a smaller kernel size should be used when transferring to normally-trained models [12].
+
+Diverse Input-FGSM (DI-FGSM) [8] follows a similar idea to TI-FGSM, but applies random resizing and padding for data augmentation. Another important difference is that DI-FGSM randomizes augmentation parameters over iterations rather than fixing them as in TI-FGSM. The attack optimization of DI-FGSM can be formulated as:
+
+$$
+\pmb { x } _ { i + 1 } ^ { \prime } = \pmb { x } _ { i } ^ { \prime } - \alpha \cdot \mathrm { s i g n } \big ( \nabla _ { \pmb { x } } J ( T ( \pmb { x } _ { i } ^ { \prime } , p ) , y _ { t } ) \big ) ,
+$$
+
+where the stochastic transformation $T ( \pmb { x } _ { i } ^ { \prime } , p )$ is implemented with probability $p$ at each iteration. In Section 4.1, we demonstrate that simple transfer attacks with these three transfer methods can actually achieve surprisingly strong targeted transferability in a wide range of transfer scenarios.
+
+# 2.2 Resource-Intensive Transferable Attacks
+
+Due to the broad consensus that achieving targeted transferability is extremely difficult, recent researchers have resorted to resource-intensive approaches that require training target-class-specific models on large-scale additional data. Specifically, the Feature Distribution Attack (FDA) [14] follows the same attack pipeline as the above simple transferable attacks, but requires auxiliary classifiers that have been trained on additional labeled data as part of the source model. Each auxiliary classifier is a small, binary, one-versus-all classifier trained for a specific target class at a specific layer. That is to say, the number of auxiliary classifiers is the number of layers that are probed multiplied by the number of target classes that are required to model [14]. The attack loss function of FDA can be formulated as:
+
+$$
+L _ { F D A } = J ( \mathcal { F } _ { l } ( \pmb { x } ^ { \prime } ) , y _ { t } ) - \eta \frac { \| \mathcal { F } _ { l } ( \pmb { x } ^ { \prime } ) - \mathcal { F } _ { l } ( \pmb { x } ) \| _ { 2 } } { \| \mathcal { F } _ { l } ( \pmb { x } ) \| _ { 2 } } ,
+$$
+
+where each auxiliary classifiers $F _ { l } ( \cdot )$ can model the probability that a feature map at layer $l$ is from a specific target class $y _ { t }$ . $\mathbf { F D A } ^ { ( N ) } \mathbf { + x e n t }$ [15] extends FDA by aggregating features from $L$ layers and also incorporating the cross-entropy loss $H ( \cdot , \cdot )$ of the original network $\mathcal F ( \cdot )$ . The loss function of $\mathrm { F D A } ^ { ( N ) } -$ +xent can be expressed as:
+
+$$
+L _ { F D A ^ { ( N ) } + x e n t } = \sum _ { l \in L } \lambda _ { l } ( L _ { F D A } + \gamma H ( \mathcal { F } ( \pmb { x } ^ { \prime } ) , y _ { t } ) ) , \mathrm { ~ w h e r e ~ } \sum _ { l \in L } \lambda _ { l } = 1 .
+$$
+
+Very recently, TTP [16] has achieved state-of-the-art targeted transferability by directly generating perturbations using target-class-specific GANs that have been trained via matching the distributions of perturbations and a specific target class both globally and locally. Specifically, the global distribution matching is achieved by minimizing the Kullback Leibler (KL) divergence, and the local distribution matching is by enforcing the neighbourhood similarity. In order to further boost the performance, data augmentation techniques, such as image rotation, crop resize, horizontal flip, color jittering and gray-scale transformation, have been applied during model training. We refer the readers to [16] for more technical details of TTP.
+
+These two transferable attacks, $\mathrm { F D A } ^ { ( N ) } +$ xent and TTP, are resource intensive due to the use of largescale model training and additional data. However, in Section 4.2, we show that simple transferable attacks, which require neither model training nor additional data, can actually achieve even better performance than them.
+
+# 2.3 Universal Adversarial Perturbations
+
+Previous research has shown the existence of Universal Adversarial Perturbations (UAPs), i.e., a single image perturbation vector that fools a classifier on multiple images [24]. UAPs have been extensively studied for non-targeted attacks [24–28], but also explored in the more challenging, targeted case [17–19]. Although recent studies have shown comparable performance of using reconstructed class impressions [25] or proxy datasets [18] to original training data, large-scale optimization over image data is still necessary for most existing methods. Differently, a data-free approach [26] has been proposed for non-targeted UAPs by iteratively optimizing randomly-initialized perturbations with an objective of disrupting the intermediate features of the model at multiple layers. However, this approach cannot be applied to targeted UAPs because targeted perturbations aim at a specific direction but not random disruption as in the non-targeted case. To bridge this gap, in Section 4.3, we demonstrate how the simple Logit attack can be used to generate targeted UAPs in a data-free manner.
+
+# 3 New Insights into Simple Transferable Attacks
+
+In this section, we revisit simple transferable targeted attacks, and provide new insights into them. Specifically, we demonstrate that simple transferable attacks that are based on existing transfer methods (TI-, MI-, and DI-FGSM) need more iterations to converge, and attacking with a simple logit loss can yield much better results than the commonly adopted Cross-Entropy (CE) loss.
+
+# 3.1 Existing Transfer Methods with More Iterations Yield Good Results
+
+Existing attempts have concluded that using simple transferable attacks to achieve targeted transferability is extremely difficult [3, 4, 13–15]. However, these attempts have been limited to the MI transfer method. Here, we tested all the three transfer methods. As can be seen form Figure 1, integrating all the three transfer methods leads to the best performance. In particular, we find that using only DI can actually yield substantial targeted transferability, while using only TI or MI makes little difference to the original poor targeted transferability. The fact that DI outperforms TI may be explained by the fact that DI randomizes the image augmentation parameters over iterations rather than fixing them as in TI. In this way, the gradients towards the target class become more generic and so avoid overfitting to the white-box source model. MI is essentially different from DI and TI because it can only stabilize update directions but not serve to achieve more accurate gradient directions towards a specific (target) class.
+
+As we have pointed out in Section 1, common practice of generating transferable targeted perturbations [13–15, 20] has limited the attack optimization to few iterations (typically $\leq 2 0$ ). This is somewhat understandable given that extensive research on non-targeted transferability has done the same. However, as can be seen from Figure 1, targeted attacks actually require much more iterations to converge to optimal transferability, in contrast to the fast convergence of non-targeted attacks. This implies that evaluating the targeted transferability under only few iterations is problematic. On the one hand, comparing different optimization processes that have not converged is not meaningful and may cause misleading comparisons (see evidence in Section 4.1). This observation is consistent with the evaluation suggestion in [29] that restricting the number of iterations without verifying the attack convergence is one of the common pitfalls in evaluating adversarial robustness. Several advanced defenses have been defeated by simply increasing the number of iterations [30]. On the other hand, considering the realistic threat model, it is not meaningful to artificially restrict the computational power of a practical attack (e.g., to fewer than several thousand attack iterations) [31].
+
+![](images/fca3998a05bc361aeb1a80acdda333e959d92ecde001d361628249fa2a53dc0c.jpg)  
+Figure 1: Transfer success rates of simple transferable attacks using CE or logit loss in the non-targeted and targeted scenarios.
+
+![](images/e2c049957a94f6a754c65e1915a056f2b2266017247f535e6e9e8ad04ee22485.jpg)  
+Figure 2: White-box (wb) and black-box (bb) attack performance in terms of the predicted confidence (left, higher is better) and ranking (right, lower is better) of the target class.
+
+# 3.2 A Simple yet Strong Logit Attack
+
+Existing simple transferable attacks have commonly adopted the Cross-Entropy (CE) loss. However, as pointed out in [20], during the attack optimization, the CE loss will cause the gradient to decrease and tend to vanish as the number of iterations is increased. To address this problem, the ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ loss [20] takes a very aggressive strategy by arbitrarily reversing the decrease of the gradient, i.e., gradually increasing the magnitude of the gradients over iterations. However, we argue that this operation has led to too large step size, and as a result cause the attack optimization to overshoot the minima. Our results in Section 4.1 support this argument by showing that $\mathrm { P o + }$ Trip even yielded worse results than CE in the ensemble transfer scenario with diverse model architectures, since the loss surface is relatively non-smooth.
+
+Here, for the loss function, we eliminate the final softmax function used in the CE loss and just backpropagate the gradients from the logit output:
+
+$$
+L _ { L o g i t } = - l _ { t } ( { \bf r } ^ { \prime } ) ,
+$$
+
+where $l _ { t } ( \cdot )$ denotes the logit output with respect to the target class. Although the idea of attacking logits is not new, its superior performance in targeted transferability has not been recognized so far. We also find that using the well-known logit-based loss, C&W [32], yields consistently worse results (see detailed comparisons in Appendix A). Another logit loss that is similar to the C&W loss has also been adopted by [18], but in the task of generating UAPs with large-scale data.
+
+Below, we show that this logit loss leads to stronger gradients than the CE loss. As can be observed from Equation 10, the gradient of the CE loss with respect to the target logit input, $z _ { t }$ , will monotonically decrease as the probability of the target class, $p _ { t }$ , increases during attack optimization. In addition, due to the use of the softmax function, $p _ { t }$ will quickly reach 1, and as a result the gradient tends to vanish. This phenomenon makes the attack hard to improve even with more iterations applied. Differently, as shown by Equation 11, the gradient of the logit loss equals a constant. In this way, the attack can keep improving as the number of iterations is increased. In Appendix B, we provide further comparisons on the trends of loss/gradient magnitude and the target logit value over iterations, which show that the logit loss leads to better results than both CE and ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ .
+
+$$
+\begin{array} { c } { { { \cal L } _ { C E } = - 1 \cdot \log ( p _ { t } ) = - \log ( { \displaystyle \frac { e ^ { z _ { t } } } { \sum e ^ { z _ { j } } } } ) = - z _ { t } + \log ( \sum _ { } e ^ { z _ { j } } ) , } } \\ { { { \cal \frac { \partial L _ { C E } } { \partial z _ { t } } } = - 1 + { \displaystyle \frac { \partial \log ( \sum e ^ { z _ { j } } ) } { \partial e ^ { z _ { t } } } } \cdot { \displaystyle \frac { \partial e ^ { z _ { t } } } { \partial z _ { t } } } = - 1 + { \displaystyle \frac { e ^ { z _ { t } } } { \sum e ^ { z _ { j } } } } = - 1 + p _ { t } . } } \end{array}
+$$
+
+$$
+L _ { L o g i t } = - z _ { t } , \frac { \partial L _ { L o g i t } } { \partial z _ { t } } = - 1 .
+$$
+
+Table 1: Targeted transfer success rates $( \% )$ in the single-model transfer scenario. We consider three attacks with different loss functions: cross-entropy (CE), Poincare distance with Triplet loss ´ $( { \mathrm { P o } } + { \mathrm { T r i p } } )$ [20], and the logit loss. Results with 20/100/300 iterations are reported.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="3">Source Model: Res50</td><td colspan="3">Source Model: Dense121</td></tr><tr><td>→Dense121</td><td>→VGG16</td><td>→Inc-v3</td><td>→Res50</td><td>→VGG16</td><td>→Inc-v3</td></tr><tr><td>CE</td><td>26.9/39.4/42.6</td><td>17.3/27.3/30.4</td><td>2.4/3.8/4.1</td><td>13.1/17.3/19.4</td><td>7.7/10.8/10.9</td><td>1.9/3.3/3.5</td></tr><tr><td>Po+Trip</td><td>26.7/53.0/54.7</td><td>18.8/34.2/34.4</td><td>2.9/6.0/5.9</td><td>10.1/14.7/14.7</td><td>6.7/8.3/7.7</td><td>2.1/3.0/2.7</td></tr><tr><td>Logit</td><td>29.3/63.3/72.5</td><td>24.0/55.7/62.7</td><td>3.0/7.2/9.4</td><td>17.2/39.7/43.7</td><td>13.5/35.3/38.7</td><td>2.7/6.9/7.6</td></tr><tr><td rowspan="2">Attack</td><td colspan="3">Source Model: VGG16</td><td colspan="3">Source Model: Inc-v3</td></tr><tr><td>→Res50</td><td>→Dense121</td><td>→Inc-v3</td><td>→Res50</td><td>→Dense121</td><td>→VGG16</td></tr><tr><td>CE</td><td>0.7/0.4/0.6</td><td>0.5/0.3/0.1</td><td>0/0.1/0</td><td>0.6/2.1/2.4</td><td>0.8/2.5/2.9</td><td>0.7/1.6/2.0</td></tr><tr><td>Po+Trip</td><td>0.6/0.8/0.5</td><td>0.6/0.6/0.7</td><td>0.2/0.1/0.1</td><td>0.6/2.0/2.5</td><td>0.8/3.1/3.3</td><td>0.5/2.1/2.0</td></tr><tr><td>Logit</td><td>3.3/8.7/11.2</td><td>3.6/11.7/13.2</td><td>0.2/0.7/0.9</td><td>0.8/1.6/2.9</td><td>1.2/2.8/5.3</td><td>0.7/2.2/3.7</td></tr></table>
+
+# 4 Experimental Evidence on Simple Transferable Attacks
+
+In this section, we provide experimental evidence to show the general effectiveness of simple transferable attacks. Firstly, in Section 4.1, we evaluate the simple transferable attacks in a variety of transfer scenarios, including single-model transfer, ensemble transfer (easy and challenging scenarios), a worse-case scenario with low-ranked target classes, and a real-world attack on the Google Cloud Vision API. Then, in Section 4.2, we compare the simple transferable attacks with two state-of-the-art resource-intensive transferable attacks, $\mathrm { F D A } ^ { ( N ) } { + } \mathrm { x e n i }$ [15] and TTP [16]. Finally, in Section 4.3, we apply the Logit attack to achieving targeted UAPs in a data-free manner.
+
+Following recent work [14–16, 20], we focus on targeted transferability of ImageNet-like images, which is known to be much more difficult than other data sets (e.g, MNIST and CIFAR-10) with smaller-size images and fewer classes. Specifically, we used the 1000 images from the development set of the ImageNet-Compatible Dataset1, which was introduced along with the NIPS 2017 Competition on Adversarial Attacks and Defenses. All these images are associated with 1000 ImageNet class labels and cropped to $2 9 9 \times 2 9 9$ before use. Our experiments were run on an NVIDIA Tesla P100 GPU with 12GB of memory.
+
+# 4.1 Simple Transferable Attacks in Various Transfer Scenarios
+
+We tested three different attack losses: CE, ${ \mathrm { P o + T r i p } }$ [20] and Logit. All attacks used TI, MI, and DI with optimal hyperparameters provided in their original work. Specifically, $\| \mathbf { W } \| _ { 1 } = 5$ was used for ‘TI’ as suggested by [12]. For each image, we used the target label that was officially specified in the dataset. If not mentioned specifically, all attacks were run with 300 iterations to ensure convergence. When being executed with a batch size of 20, the optimization process took about three seconds per image. A moderate step size of 2 was used for all attacks, and the results were shown to be not sensitive to the setting of step size (see evidence in Appendix C). We considered four diverse classifier architectures: ResNet [33], DenseNet [34], VGGNet [35], and Inception [36]. Following the common practice, the perturbations were restricted by $L _ { \infty }$ norm with $\epsilon = 1 6$ .
+
+Single-model transfer. Table 1 reports the targeted transferability when transferring between each pair of different model architectures. As can be seen, the logit loss outperformed CE and ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ by a large margin in almost all cases. When comparing different model architectures, we can find that the attacks achieved lower performance when transferring from the VGGNet16 or Inception-v3 than from ResNet50 or DenseNet121. This is consistent with the observations in [14, 15] and may be explained by the fact that skip connections in ResNet50 and DenseNet121 boosts transferability [37]. Another finding is that when using Inception-v3 as the target model, the transfer success rates were always low. This might be explained by the heavily engineered nature of the Inception architecture, i.e., the Inception architecture has multiple-size convolution and two auxiliary classifiers.
+
+Table 2: Targeted transfer success rates $( \% )$ in the commonly adopted, easy ensemble transfer scenario, where the hold-out target model (denoted by $\cdot \underline { { \cdot } }$ ) and the ensemble models share similar architectures. Results with 20/100 iterations are reported.   
+
+<table><tr><td>Attack</td><td>-Inc-v3</td><td>-Inc-v4</td><td>-IncRes-v2</td><td>-Res50</td><td>-Res101</td><td>-Res152</td><td>Average</td></tr><tr><td>CE</td><td>48.8/85.3</td><td>47.2/83.3</td><td>47.5/83.9</td><td>50.9/89.8</td><td>58.5/93.2</td><td>56.7/90.7</td><td>51.6/87.7</td></tr><tr><td>Po+Trip</td><td>59.3/84.4</td><td>55.0/82.4</td><td>51.4/80.8</td><td>56.9/85.0</td><td>60.5/87.9</td><td>57.6/85.7</td><td>56.8/84.4</td></tr><tr><td>Logit</td><td>56.4/85.5</td><td>52.9/85.8</td><td>54.4/85.1</td><td>57.5/90.0</td><td>64.4/91.4</td><td>61.3/90.8</td><td>57.8/88.1</td></tr></table>
+
+![](images/fdd5ac90f4750155748fa1b30949e95ff900d67c18e964d24e5a9e0a6a8ee7a4.jpg)  
+Figure 3: Targeted transfer success rates $( \% )$ in our challenging ensemble transfer scenario, where each hold-out target model shares no similar architecture with the source models used for ensemble.
+
+Ensemble transfer in both easy and challenging scenarios. A common approach to further boosting transferability is to generate perturbations on an ensemble of white-box source models. Following the common practice, we simply assigned equal weights to all the source models. We first look at the commonly adopted ensemble transfer scenario [4, 6, 20, 38] in which each hold-out target model shares a similar architecture with some of the white-box ensemble models. As can be seen from Table 2, the transfer success rates of all three attacks have got saturated when given enough iterations to converge. As a result, this transfer scenario could not fully reveal the actual strength of different attacks. We can also observe that ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ performed better than the CE loss only when the attack optimization is unreasonably restricted to 20 iterations, but became even worse with enough iterations. This finding suggests that evaluating different attacks under only few iterations may cause misleading comparative results.
+
+We next considered a more challenging transfer scenario with no architectural overlap between the source ensemble models and the target model, in order to fully reveal the potential of different attacks. This scenario is also more realistic since it is hard for an attacker to know the specific architecture of a real-world target mode. Figure 3 shows that in this scenario, the Logit largely outperformed CE and ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ . In addition, the results of both CE and Logit were substantially improved over the single-model transfer results reported in Table 1. However, ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ performed even worst in some cases maybe because its use of arbitrarily increasing the gradient magnitude has caused the optimization to overshoot the minima in this ensemble transfer scenario where the loss surface is relatively non-smooth due to the model diversity. Note that as in the single transfer scenario, transferring to Inception-v3 is still the most difficult.
+
+Table 3: Targeted transfer success rates $( \% )$ when varying the target from the high-ranked class to low.   
+
+<table><tr><td>Attack</td><td>2nd</td><td>10th</td><td>200th</td><td>500th</td><td>800th</td><td>1000th</td></tr><tr><td>CE</td><td>89.9</td><td>76.7</td><td>49.7</td><td>43.1</td><td>37.0</td><td>25.1</td></tr><tr><td>Po+Trip</td><td>82.6</td><td>77.6</td><td>58.4</td><td>53.6</td><td>49.1</td><td>38.2</td></tr><tr><td>Logit</td><td>83.8</td><td>81.3</td><td>75.0</td><td>71.0</td><td>65.1</td><td>52.8</td></tr></table>
+
+A worse-case transfer scenario with lowranked target classes. In conventional security studies, a comprehensive evaluation commonly involves a range of attack scenarios with varied difficulty. Existing work on white-box adversarial attacks [32, 21, 23, 38] has also looked at different cases with varied difficulty regarding the ranking position of the target class in the prediction list of the original image.
+
+Specifically, in the best case, the targeted success is basically equal to non-targeted success, i.e., an attack is regarded to be successful as long as it can succeed on any arbitrary target other than the original class. In the average case, the target class is randomly specified, while in the worst case, the target is specified as the lowest-ranked/least-likely class.
+
+![](images/38b602e565fc865a9d8cfba5c4abadd7750ba6e392a528b19f1cb12a999c026c.jpg)  
+Figure 4: Successful targeted adversarial images on Google Cloud Vision generated by the Logit attack with ensemble transfer. More examples can be found in Appendix D.
+
+Table 4: Non-targeted and targeted transfer success rates $( \% )$ of different attacks on Google Cloud Vision.   
+
+<table><tr><td></td><td>CE</td><td>Po+Trip</td><td>Logit</td></tr><tr><td>Targeted</td><td>7</td><td>8</td><td>18</td></tr><tr><td>Non-targeted</td><td>51</td><td>44</td><td>51</td></tr></table>
+
+However, to the best of our knowledge, current evaluation of transfer-based attacks has been limited to the best and average cases. To address this limitation, we consider a worse-case transfer scenario by varying the target from the highest-ranked class gradually to the lowest one. As can be seen from Table 3, there exists a non-negligible correlation between the ranking position of the target class and the targeted transferability. More specifically, it becomes increasingly difficult as the target moves down the prediction list. We can also observe that the results with higher-ranked targets might not reveal the actual strength of different attacks as in the more realistic, worse cases with lower-ranked targets. In particular, only looking the best case with the highest-ranked target may lead to a misleading conclusion that CE leads to the most effective attack. This finding suggests that a more meaningful evaluation on targeted transferability should further increase difficulty beyond the current best and average cases.
+
+Transfer-based attacks on Google Cloud Vision. Most existing work on fooling real-world computer vision systems has been focused on the query-based attacks, where a large number of queries are required [39–41]. Although several recent studies have also explored real-world transfer-based attacks, they were limited to face recognition and the non-targeted attacks [42–44]. In contrast, we applied the simple transferable attacks in the more challenging, targeted case on a more generallyused image recognition system, the Google Cloud Vision API. Specifically, we used the targeted adversarial images generated on the ensemble of all four diverse source models with 300 iterations.
+
+The API predicts a list of semantic labels along with confidence scores. Specifically, only the top classes with confidence no lower than $5 0 \%$ are returned, and at most 10 classes are shown. Note that the confidence score here is not a probability (which would sum to one). We measured both the targeted and non-targeted transferability. Since all returned labels are with relatively high confidence $( \geq 5 0 \% )$ ), we do not limit our measure of success rates to only top-1 class. Instead, for non-targeted success, we measured whether or not the ground-truth class appeared in the returned list, while for targeted success, whether or not the target class appeared. Due to the fact that the semantic label set predicted by the API does not exactly correspond to the 1000 ImageNet classes, we treated semantically similar classes as the same class.
+
+Table 4 reports the results averaged over 100 images that originally yield correct predictions. As can be seen, in general, achieving targeted transfer success is much more difficult than non-targeted success. In particular, the Logit attack achieved the best targeted transferability, with quasi-imperceptible perturbations shown in Figure 4. Our results reveal the potential vulnerability of Google Cloud Vision against simple transfer-based attacks, which require no query interaction.
+
+# 4.2 Simple vs. Resource-Intensive Transferable Attacks
+
+In this subsection, we compared simple transferable attacks with state-of-the-art resource-intensive approaches, TTP [16] and FDA(N)+xent [15], which necessitate training target-class-specific models on additional data.
+
+Compared with TTP. We compared the Logit attack with the state-of-the-art TTP, which is based on training target-class-specific GANs on additional data. We tested both Logit and TTP on our dataset following the “10-Targets (all-source)” setting in [16]. We chose ResNet50 as the white-box model in the single-model transfer scenario and an ensemble of $\mathrm { R e s N e t } \{ 1 8 , 5 0 , 1 0 1 , 1 5 2 \}$ in the ensemble transfer scenario. DenseNet121 and VGG16 bn are tested as the target models. Note that the same knowledge of the white-box model is available to both attacks but it is leveraged in different ways.
+
+Specifically, for the Logit attack, the white-box model is used as a source model for iterative attack optimization, while for TTP, it is used as a discriminator during training the GANs.
+
+As shown in Table 5, under the commonly adopted $\epsilon = 1 6$ , the Logit attack can achieve comparable results to TTP in all cases. Specifically, we can observe that the model ensemble is more helpful to Logit than for TTP. This might be because even with the single model as the discriminator, TTP can learn good enough features of target semantics by training with the objective of matching the perturbation and target class distributions with large-scale data. The clearer target semantics learned by TTP can be confirmed by comparing the unbounded perturbations achieved by TTP (e.g., Figure 3 in [16]) with those by the Logit shown in Figure 5.
+
+Table 5: Targeted transfer success rates $( \% )$ of Logit vs. TTP in single-model and ensemble transfer scenarios under two norm bounds.   
+
+<table><tr><td>Bound</td><td>Attack</td><td>D121</td><td>V16</td><td>D121-ens</td><td>V16-ens</td></tr><tr><td rowspan="2">e= 16</td><td>TTP</td><td>79.6</td><td>78.6</td><td>92.9</td><td>89.6</td></tr><tr><td>Logit</td><td>75.9</td><td>72.5</td><td>99.4</td><td>97.7</td></tr><tr><td rowspan="2">e=8</td><td>TTP</td><td>37.5</td><td>46.7</td><td>63.2</td><td>66.2</td></tr><tr><td>Logit</td><td>44.5</td><td>46.8</td><td>92.6</td><td>87.0</td></tr></table>
+
+This fact that TTP perturbations heavily rely on semantic patterns of the target class might cause TTP to degrade under lower norm bounds. To validate this assumption, we further compared Logit and TTP under $\epsilon = 8$ . As expected, the Logit attack consistently surpassed TTP, especially with a very large margin in the ensemble transfer scenario. The different comparing results for the two perturbation sizes also suggest that comparing attacks only under a single perturbation size may not reveal their characteristics.
+
+Table 6: Targeted transfer success rates $( \% )$ of unbounded adversarial images by different attacks with the same iteration budget.   
+
+<table><tr><td></td><td>FDA(4) +xent</td><td>CE</td><td>Po+Trip</td><td>Logit</td></tr><tr><td>Res50-→Dense121</td><td>65.8</td><td>69.3</td><td>88.1</td><td>84.1</td></tr><tr><td>Res50→VGG16</td><td>48.1</td><td>54.1</td><td>67.8</td><td>74.2</td></tr></table>
+
+![](images/d0c0f928a7bbb988714c9d633bdb653be7f458932d6324a2cba9b55e81b07fd1.jpg)  
+Figure 5: Unbounded adversarial examples that reflect target semantics. More examples can be found in Appendix E.
+
+Compared with FDA(N)+xent. We compared the three simple transferable attacks (CE, ${ \mathrm { P o } } { + } { \mathrm { T r i p } }$ and Logit) with $\mathrm { F D A } ^ { ( N ) }$ +xent on generating unbounded adversarial images, in consistence with “distal transfer” in $[ 1 5 ] ^ { 2 }$ . Specifically, the adversarial perturbations were initialized as random Gaussian noise and allowed to be as large as possible. Although such unbounded adversarial images may not be practically compelling, they can provide better isolated indication on transferability by eliminating the dependency on the source images and the bound restrictions. The results were averaged over 4000 image examples, each of which was optimized towards a random target class. As suggested by [15], the MI transfer method was removed since it empirically harms the performance in this unbounded case.
+
+Table 6 shows that all the three simple transferable attacks achieved stronger targeted transferability than $\mathrm { F D A } ^ { ( N ) } \mathrm { + x e n t }$ . As can be seen from Figure 5, the unbounded adversarial perturbations can somehow reflect the target semantics. This finding suggests that achieving targeted transferability relies on robust, semantic features [45] that are expected to be learned by various models and also understood by humans. In this way, achieving targeted transferability is fundamentally different from non-targeted transferability, for which attacking non-robust features is known to be sufficient [45]. It is also worth noting that in practical scenarios with small norm bounds, the semantically-aligned perturbations would not be expected to change human judgements.
+
+# 4.3 Simple Logit Attack for Targeted UAPs in a Data-Free Manner
+
+The above observation that the perturbations can reflect certain target semantics motivates us to apply the Logit attack to achieving targeted Universal Adversarial Perturbations (UAPs), which can drive multiple original images into a specific target class. Existing attempts at achieving targeted UAPs have mainly relied on large-scale optimization over additional data [17–19]. However, the simple Logit attack can be easily extended to generate targeted UAPs in a data-free manner. The only difference from the above transferable Logit attack is that here a mean image (all pixel values set as 0.5 out of [0,1]) is used as the original image.
+
+Table 7: Success rates $( \% )$ of targeted UAPs generated by CE and Logit attacks for different models.   
+
+<table><tr><td>Attack</td><td>Inc-v3</td><td>Res50</td><td>Dense121</td><td>VGG16</td></tr><tr><td>CE</td><td>2.6</td><td>9.2</td><td>8.7</td><td>20.1</td></tr><tr><td>Logit</td><td>4.7</td><td>22.8</td><td>21.8</td><td>65.9</td></tr></table>
+
+![](images/a965d24ae8b97cf0eca96389dc830cba0f3a40618f1425879de5ff1b25bee39a.jpg)  
+Figure 6: UAPs $\epsilon = 1 6$ , VGG16) with different classes using CE and Logit. More examples can be found in Appendix F.
+
+In our experiment, for each target class, we generated a single targeted UAP vector $\epsilon = 1 6$ ) with 300 iterations and applied it to all 1000 images in our dataset. Table 7 reports the results averaged over all the 1000 ImageNet classes. As can be seen, the logit loss can yield substantial success, remarkably outperforming the CE loss. This can be confirmed by Figure 6, which shows the Logit attack can yield more semantically-aligned perturbations than CE. This observation also supports the claim from [18] that universal perturbations contain dominant features, and images act like noise with respect to perturbations.
+
+# 5 Conclusion and Outlook
+
+In this paper, we have demonstrated that achieving targeted transferability is not as difficult as current work concludes. Specifically, we find that simple transferable attacks can actually achieve surprisingly strong targeted transferability when given enough iterations for convergence. We have validated the effectiveness of simple transferable attacks in a wide range of transfer scenarios, including three newly-introduced challenging scenarios. These challenging scenarios have better revealed the actual strength of different attacks. In particular, we demonstrate that a very simple Logit attack is superior in all transfer scenarios, achieving even better results than the state-of-the-art resource-intensive approaches. We also show the potential usefulness of the Logit attack for generating targeted universal adversarial perturbations in a data-free manner. Overall, we hope our findings will inspire future research to conduct a more meaningful evaluation on targeted transferability. Our future work will focus on studying why different model architectures yield different transferability. In particular, the very low success rates when targeting Inception-v3 should be explored. Moving forward, there needs to be a more comprehensive discussion on the resource consumption of different attacks from multiple aspects, such as training and inference time, hardware resources, and data size.
+
+Strong transferability can obviously benefit black-box applications of adversarial images for social good, such as protecting user privacy [42, 43, 46–48]. In addition, it will also motivate the community to design stronger defenses given our finding that even simple attacks can generate highly transferable adversarial images. It remains a possibility that our methodology may be misused by malicious actors to break legitimate systems. However, we firmly believe that the help that our paper can provide to researchers significantly outweighs the help that it may provide an actual malicious actor.
+
+# Acknowledgments
+
+This work was carried out on the Dutch national e-infrastructure with the support of SURF Cooperative.
+
+# References
+
+[1] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.   
+[2] Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.   
+[3] Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.   
+[4] Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In CVPR, 2018.   
+[5] Wen Zhou, Xin Hou, Yongjun Chen, Mengyun Tang, Xiangqi Huang, Xiang Gan, and Yong Yang. Transferable adversarial perturbations. In ECCV, 2018.   
+[6] Yinpeng Dong, Tianyu Pang, Hang Su, and Jun Zhu. Evading defenses to transferable adversarial examples by translation-invariant attacks. In CVPR, 2019.   
+[7] Qian Huang, Isay Katsman, Horace He, Zeqi Gu, Serge Belongie, and Ser-Nam Lim. Enhancing adversarial example transferability with an intermediate level attack. In ICCV, 2019.   
+[8] Cihang Xie, Zhishuai Zhang, Yuyin Zhou, Song Bai, Jianyu Wang, Zhou Ren, and Alan L Yuille. Improving transferability of adversarial examples with input diversity. In CVPR, 2019.   
+[9] Jiadong Lin, Chuanbiao Song, Kun He, Liwei Wang, and John E Hopcroft. Nesterov accelerated gradient and scale invariance for adversarial attacks. In ICLR, 2020.   
+[10] Yingwei Li, Song Bai, Yuyin Zhou, Cihang Xie, Zhishuai Zhang, and Alan L Yuille. Learning transferable adversarial examples via ghost networks. In AAAI, 2020.   
+[11] Weibin Wu, Yuxin Su, Xixian Chen, Shenglin Zhao, Irwin King, Michael R Lyu, and Yu-Wing Tai. Boosting the transferability of adversarial samples via attention. In CVPR, 2020.   
+[12] Lianli Gao, Qilong Zhang, Jingkuan Song, Xianglong Liu, and Heng Tao Shen. Patch-wise attack for fooling deep neural network. In ECCV, 2020.   
+[13] Nathan Inkawhich, Wei Wen, Hai Helen Li, and Yiran Chen. Feature space perturbations yield more transferable adversarial examples. In CVPR, 2019.   
+[14] Nathan Inkawhich, Kevin Liang, Lawrence Carin, and Yiran Chen. Transferable perturbations of deep feature distributions. In ICLR, 2020.   
+[15] Nathan Inkawhich, Kevin J Liang, Binghui Wang, Matthew Inkawhich, Lawrence Carin, and Yiran Chen. Perturbing across the feature hierarchy to improve standard and strict blackbox attack transferability. In NeurIPS, 2020.   
+[16] Muzammal Naseer, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Fatih Porikli. On generating transferable targeted perturbations. In ICCV, 2021.   
+[17] Omid Poursaeed, Isay Katsman, Bicheng Gao, and Serge Belongie. Generative adversarial perturbations. In CVPR, 2018.   
+[18] Chaoning Zhang, Philipp Benz, Tooba Imtiaz, and In So Kweon. Understanding adversarial examples from the mutual influence of images and perturbations. In CVPR, 2020.   
+[19] Philipp Benz, Chaoning Zhang, Tooba Imtiaz, and In So Kweon. Double targeted universal adversarial perturbations. In ACCV, 2020.   
+[20] Maosen Li, Cheng Deng, Tengjiao Li, Junchi Yan, Xinbo Gao, and Heng Huang. Towards transferable targeted attack. In CVPR, 2020.   
+[21] Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. In ICLR, 2017.   
+[22] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   
+[23] Jer´ ome Rony, Luiz G. Hafemann, Luiz S. Oliveira, Ismail Ben Ayed, Robert Sabourin, and Eric ˆ Granger. Decoupling direction and norm for efficient gradient-based $L _ { 2 }$ adversarial attacks and defenses. In CVPR, 2019.   
+[24] Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In CVPR, 2017.   
+[25] Konda Reddy Mopuri, Phani Krishna Uppala, and R Venkatesh Babu. Ask, acquire, and attack: Data-free UAP generation using class impressions. In ECCV, 2018.   
+[26] Konda Reddy Mopuri, Aditya Ganeshan, and R Venkatesh Babu. Generalizable data-free objective for crafting universal adversarial perturbations. IEEE TPAMI, 41(10):2452–2465, 2018.   
+[27] Muzammal Naseer, Salman H Khan, Harris Khan, Fahad Shahbaz Khan, and Fatih Porikli. Cross-domain transferability of adversarial perturbations. In NeurIPS, 2019.   
+[28] Yingwei Li, Song Bai, Cihang Xie, Zhenyu Liao, Xiaohui Shen, and Alan L Yuille. Regional homogeneity: Towards learning transferable universal adversarial perturbations against defenses. In ECCV, 2020.   
+[29] Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. In arXiv preprint arXiv:1902.06705, 2019.   
+[30] Florian Tramer, Nicholas Carlini, Wieland Brendel, and Aleksander Madry. On adaptive attacks to adversarial example defenses. In NeurIPS, 2020.   
+[31] Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018.   
+[32] Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE S&P, 2017.   
+[33] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[34] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   
+[35] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[36] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.   
+[37] Dongxian Wu, Yisen Wang, Shu-Tao Xia, James Bailey, and Xingjun Ma. Skip connections matter: On the transferability of adversarial examples generated with resnets. In ICLR, 2020.   
+[38] Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick \` McDaniel. Ensemble adversarial training: Attacks and defenses. In ICLR, 2018.   
+[39] Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In AISec, 2017.   
+[40] Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In ICLR, 2018.   
+[41] Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In ICML, 2018.   
+[42] Valeriia Cherepanova, Micah Goldblum, Harrison Foley, Shiyuan Duan, John Dickerson, Gavin Taylor, and Tom Goldstein. LowKey: Leveraging adversarial attacks to protect social media users from facial recognition. In ICLR, 2021.   
+[43] Arezoo Rajabi, Rakesh B Bobba, Mike Rosulek, Charles Wright, and Wu-chi Feng. On the (im) practicality of adversarial perturbation for image privacy. PoPETs, 2021.   
+[44] Shawn Shan, Emily Wenger, Jiayun Zhang, Huiying Li, Haitao Zheng, and Ben Y Zhao. Fawkes: Protecting privacy against unauthorized deep learning models. In USENIX Security, 2020.   
+[45] Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In NeurIPS, 2019.   
+[46] Martha Larson, Zhuoran Liu, Simon Brugman, and Zhengyu Zhao. Pixel privacy: Increasing image appeal while blocking automatic inference of sensitive scene information. In MediaEval Multimedia Benchmark Workshop, 2018.   
+[47] Zhuoran Liu, Zhengyu Zhao, and Martha Larson. Who’s afraid of adversarial queries? the impact of image modifications on content-based image retrieval. In ICMR, 2019.   
+[48] Seong Joon Oh, Mario Fritz, and Bernt Schiele. Adversarial image perturbation for privacy protection a game theory perspective. In ICCV, 2017.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] We described the limitation in the first sentence of the final section.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] We discuss them at the end of the final section.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code (including instructions and a link to data we have used) has been submitted as the supplemental material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Our experiments did not involve any model training, but all the algorithm details were specified.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We fixed the random seed for all the experiments. Now the main randomness comes from the $p$ in the existing method, DI (see Eq. 6). We confirm that it has little impact on the results.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We mentioned the run time of the attacks and our hardware settings in Section 4.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] In Section 4.   
+(b) Did you mention the license of the assets? [Yes] In a footnote of Section 4.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] We did not use any new assets.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] In the same footnote as above.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] In the same footnote as above.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/aHK-onEhYRg/aHK-onEhYRg_content_list.json

@@ -0,0 +1,1401 @@
+[
+    {
+        "type": "text",
+        "text": "On Success and Simplicity: A Second Look at Transferable Targeted Attacks ",
+        "text_level": 1,
+        "bbox": [
+            204,
+            122,
+            795,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhengyu Zhao, Zhuoran Liu, Martha Larson Radboud University {z.zhao,z.liu,m.larson}@cs.ru.nl ",
+        "bbox": [
+            339,
+            226,
+            656,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Achieving transferability of targeted attacks is reputed to be remarkably difficult. The current state of the art has resorted to resource-intensive solutions that necessitate training model(s) for each target class with additional data. In our investigation, we find, however, that simple transferable attacks which require neither model training nor additional data can achieve surprisingly strong targeted transferability. This insight has been overlooked until now, mainly because the widespread practice of attacking with only few iterations has largely limited the attack convergence to optimal targeted transferability. In particular, we, for the first time, identify that a very simple logit loss can largely surpass the commonly adopted crossentropy loss, and yield even better results than the resource-intensive state of the art. Our analysis spans a variety of transfer scenarios, especially including three new, realistic scenarios: an ensemble transfer scenario with little model similarity, a worse-case scenario with low-ranked target classes, and also a real-world attack on the Google Cloud Vision API. Results in these new transfer scenarios demonstrate that the commonly adopted, easy scenarios cannot fully reveal the actual strength of different attacks and may cause misleading comparative results. We also show the usefulness of the simple logit loss for generating targeted universal adversarial perturbations in a data-free manner. Overall, the aim of our analysis is to inspire a more meaningful evaluation on targeted transferability. Code is available at https://github.com/ZhengyuZhao/Targeted-Tansfer. ",
+        "bbox": [
+            232,
+            334,
+            766,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            310,
+            652
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have achieved remarkable performance in various machine learning tasks, but are known to be vulnerable to adversarial attacks [1]. A key property of adversarial attacks that makes them critical in realistic, black-box scenarios is their transferability [2, 3]. Current work on adversarial transferability has achieved great success for non-targeted attacks [4–12], while several initial attempts [3, 4, 13] at targeted transferability have shown its extreme difficulty. Targeted transferability is known to be much more challenging and worth exploring since it can raise more critical concerns by fooling models into predicting a chosen, highly dangerous target class. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, so far state-of-the-art results can only be secured by resource-intensive transferable attacks [14–16]. Specifically, the FDA approach [14, 15] is based on modeling layer-wise feature distributions by training target-class-specific auxiliary classifiers on large-scale labeled data, and then optimizing adversarial perturbations using these auxiliary classifiers from across the deep feature space. The TTP approach [16] is based on training target-class-specific Generative Adversarial Networks (GANs) through global and local distribution matching, and then using the trained generator to directly generate perturbations on any given input image. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we take a second, thorough look at current research on targeted transferability. Our main contribution is the finding that simple transferable attacks [4, 6, 8] that require neither model training nor additional data can actually achieve surprisingly strong targeted transferability. We argue that this insight has been overlooked mainly because current research has unreasonably restricted the attack convergence by only using a small number of iterations (see detailed discussion in Section 3). Another key contribution of our work is, for the first time, demonstrating the general superiority of a very simple logit loss, which even outperforms the resource-intensive state of the art. ",
+        "bbox": [
+            174,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to validate the general effectiveness of simple transferable attacks, in Section 4.1, we conduct extensive experiments in a wide range of transfer scenarios. We test the commonly adopted single-model and ensemble transfer scenarios, but also introduce three new scenarios that are more challenging and realistic: an ensemble transfer scenario with little model similarity, a worse-case scenario with low-ranked target classes, and also a real-world attack on the Google Cloud Vision API. Experimental results in these new scenarios suggest that evaluation in only the commonly adopted, easy scenarios cannot reveal the actual strength of different attacks, and may cause misleading comparative results. Additional experiments in Section 4.2 have shown the better performance of the simple transferable attacks than the state-of-the-art resource-intensive approaches. Finally, in Section 4.3, inspired by the observation that the generated perturbations themselves reflect specific target semantics, we use the simple Logit attack to generate targeted Universal Adversarial Perturbations (UAPs) in a data-free manner. In contrast, recent advances in targeted UAPs [16–19] have inevitably relied on large-scale optimization over additional data. ",
+        "bbox": [
+            173,
+            166,
+            826,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Overall, we hope our analysis of the weakness of commonly adopted attack settings and transfer scenarios will inspire a more meaningful evaluation on targeted transferability. ",
+        "bbox": [
+            173,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            400,
+            323,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we review existing simple transferable attacks (Section 2.1), and also recent resourceintensive transferable attacks (Section 2.2). Finally, we discuss related work on generating universal adversarial perturbations. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Simple Transferable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            411,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We refer to transferable attacks that require neither model training nor additional data, but only use iterative optimization on a single (original) image as simple transferable attacks. Simple transferable attacks have been extensively studied in the non-targeted case [4–12], and also attempted in the targeted case [3, 4, 20]. These attacks are commonly built up on the well-known Iterative-Fast Gradient Sign Method (I-FGSM) [21, 22], which can be formulated as: ",
+        "bbox": [
+            173,
+            513,
+            825,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be31c403a64489b9e2a812ef51e3f62dd12d1bfb1450f1a815d587025f69605f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { x } _ { 0 } ^ { \\prime } = \\pmb { x } , \\pmb { x } _ { i + 1 } ^ { \\prime } = \\pmb { x } _ { i } ^ { \\prime } - \\alpha \\cdot \\mathrm { s i g n } ( \\nabla _ { \\pmb { x } } J ( \\pmb { x } _ { i } ^ { \\prime } , y _ { t } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            587,
+            655,
+            606
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { x } _ { i } ^ { \\prime }$ denotes the perturbed image in the $i$ -th iteration, and $y _ { t }$ is the target class label. In order to ensure the imperceptibility, the added perturbations are restricted with respect to some $L _ { p }$ distance, i.e., satisfying $\\| { \\pmb x } ^ { \\prime } - { \\pmb x } \\| _ { p } \\overset { \\cdot } { \\le } \\epsilon$ . Current transferable attack methods have commonly adopted the $L _ { \\infty }$ distance, but can also be easily adapted to the $L _ { 2 }$ distance based on an $L _ { 2 }$ normalization [23]. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the loss function $J ( \\cdot , \\cdot )$ , most simple transferable attacks have adopted the Cross-Entropy (CE) loss. However, the CE loss has been recently shown to be insufficient in the targeted case due to its decreasing gradient problem [20]. To address this problem, the authors in [20] have proposed the $\\mathbf { P 0 + T r i p }$ loss, in which the Poincare distance was used to adapt the gradients’ magnitude: ´ ",
+        "bbox": [
+            174,
+            670,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a63edf3047001234b651c2fd749e5e711eb6782c4000d4850d9642be953b52b.jpg",
+        "text": "$$\nL _ { P o } = d ( { \\pmb u } , { \\pmb v } ) = \\mathrm { a r c c o s h } ( 1 + \\delta ( { \\pmb u } , { \\pmb v } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            729,
+            632,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/750e5f32e76c5d7e618d3436108f46c447a57e6e3d930cced8f706ceb19faeae.jpg",
+        "text": "$$\n\\delta ( \\pmb { u } , \\pmb { v } ) = \\frac { 2 \\cdot \\| \\pmb { u } - \\pmb { v } \\| _ { 2 } ^ { 2 } } { ( 1 - \\| \\pmb { u } \\| _ { 2 } ^ { 2 } ) ( 1 - \\| \\pmb { v } \\| _ { 2 } ^ { 2 } ) } , \\pmb { u } = \\frac { l ( \\pmb { x } ^ { \\prime } ) } { \\| l ( \\pmb { x } ^ { \\prime } ) \\| } , \\pmb { v } = \\operatorname* { m a x } \\{ \\pmb { v } - \\pmb { \\xi } , 0 \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            750,
+            733,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf { \\em u }$ is the normalized logit vector and $\\pmb { v }$ is the one-hot vector with respect to the target class. $\\xi = 1 0 ^ { - 5 }$ is a small constant to ensure numerical stability. The following triplet loss is also integrated for pushing the image away from the original class while pulling it into the target class: ",
+        "bbox": [
+            174,
+            786,
+            823,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4cbfad03931f33334e8e905bcae743a5427a8248ecbf8fc3466c644e23d25fbf.jpg",
+        "text": "$$\nL _ { T r i p } = [ D ( l ( \\pmb { x } ^ { \\prime } ) , y _ { t } ) - D ( l ( \\pmb { x } ^ { \\prime } ) , y _ { o } ) + \\gamma ] _ { + } , D ( l ( \\pmb { x } ^ { \\prime } ) , y ) = 1 - \\frac { \\| l ( \\pmb { x } ^ { \\prime } ) \\cdot \\pmb { y } \\| _ { 1 } } { \\| l ( \\pmb { x } ^ { \\prime } ) \\| _ { 2 } \\| y \\| _ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            832,
+            764,
+            866
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The overall loss function is then formulated as $L _ { P o + T r i p } = L _ { P o } + \\lambda L _ { T r i p }$ . Note that in the original work, ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ was evaluated in the commonly adopted, easy ensemble transfer scenario, which only involves models with similar architectures. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to devising new loss functions, there are other transfer methods [4, 6, 8, 9] developed based on the assumption that preventing the attack optimization from overfitting to the specific source model can improve transferability. Such transfer methods can be easily plugged into different attacks without modifications, in contrast to the above methods that need to apply new attack loss functions. In this paper, we consider three [4, 6, 8] of such transfer methods that have been widely used in the literature, as described in the following text. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            175
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Momentum Iterative-FGSM (MI-FGSM) [4] integrates a momentum term, which accumulates previous gradients in order to achieve more stable update directions. It can be expressed as: ",
+        "bbox": [
+            173,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9f3d54775f55c28cd3b312babeefa1fd943313ea9b1b16aaf40260f8fbf98f3.jpg",
+        "text": "$$\n{ \\bf \\mathcal { G } } _ { i + 1 } = \\mu \\cdot { \\bf g } _ { i } + \\frac { \\nabla _ { x } J ( { \\pmb x } _ { i } ^ { \\prime } , y _ { t } ) } { \\| \\nabla _ { \\pmb x } J ( { \\pmb x } _ { i } ^ { \\prime } , y _ { t } ) \\| _ { 1 } } , ~ { \\pmb x } _ { i + 1 } ^ { \\prime } = { \\pmb x } _ { i } ^ { \\prime } - \\alpha \\cdot \\mathrm {  ~ \\mathrm { s i g n } } ( { \\pmb g } _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            214,
+            704,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\pmb { g } } _ { i }$ is the accumulated gradients at the $i$ -th iteration, and $\\mu$ is a decay factor. Another similar technique that instead uses the Nesterov accelerated gradient was explored in [9]. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Translation Invariant-FGSM (TI-FGSM) [6] randomly translates the input image during attack optimization in order to prevent the attack from overfitting to the specific source model. This approach is inspired by the data augmentation techniques used for preventing overfitting in normal model training. Instead of calculating gradients for multiple translated images separately, the authors have proposed an approximate solution to accelerate the implementation. It is achieved by directly computing locally smoothed gradients on the original image via convolution with a kernel: ",
+        "bbox": [
+            173,
+            287,
+            825,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d6c6d01d0d89cb2bab15cba4916abac3106ced39d1ce1b36b6af7ab0294e130.jpg",
+        "text": "$$\n\\pmb { x } _ { i + 1 } ^ { \\prime } = \\pmb { x } _ { i } ^ { \\prime } - \\alpha \\cdot \\mathrm { s i g n } ( W * \\nabla _ { \\pmb { x } } J ( \\pmb { x } _ { i } ^ { \\prime } , y _ { t } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            377,
+            640,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W$ is the convolution kernel used for smoothing. TI-FGSM was originally designed for boosting transferability with adversarially-trained models as target models and has been recently shown that a smaller kernel size should be used when transferring to normally-trained models [12]. ",
+        "bbox": [
+            173,
+            400,
+            826,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Diverse Input-FGSM (DI-FGSM) [8] follows a similar idea to TI-FGSM, but applies random resizing and padding for data augmentation. Another important difference is that DI-FGSM randomizes augmentation parameters over iterations rather than fixing them as in TI-FGSM. The attack optimization of DI-FGSM can be formulated as: ",
+        "bbox": [
+            173,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77e09dab4aa6d52e63ab767f46b1b432ffadd71bf73b2a23ecd3ca3806aa3162.jpg",
+        "text": "$$\n\\pmb { x } _ { i + 1 } ^ { \\prime } = \\pmb { x } _ { i } ^ { \\prime } - \\alpha \\cdot \\mathrm { s i g n } \\big ( \\nabla _ { \\pmb { x } } J ( T ( \\pmb { x } _ { i } ^ { \\prime } , p ) , y _ { t } ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            508,
+            642,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the stochastic transformation $T ( \\pmb { x } _ { i } ^ { \\prime } , p )$ is implemented with probability $p$ at each iteration. In Section 4.1, we demonstrate that simple transfer attacks with these three transfer methods can actually achieve surprisingly strong targeted transferability in a wide range of transfer scenarios. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Resource-Intensive Transferable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            496,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Due to the broad consensus that achieving targeted transferability is extremely difficult, recent researchers have resorted to resource-intensive approaches that require training target-class-specific models on large-scale additional data. Specifically, the Feature Distribution Attack (FDA) [14] follows the same attack pipeline as the above simple transferable attacks, but requires auxiliary classifiers that have been trained on additional labeled data as part of the source model. Each auxiliary classifier is a small, binary, one-versus-all classifier trained for a specific target class at a specific layer. That is to say, the number of auxiliary classifiers is the number of layers that are probed multiplied by the number of target classes that are required to model [14]. The attack loss function of FDA can be formulated as: ",
+        "bbox": [
+            173,
+            614,
+            826,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4923c7f8e58b2b0b9c480dbd21e10f0319e9edb4ee14496f9a47698bf5c20de.jpg",
+        "text": "$$\nL _ { F D A } = J ( \\mathcal { F } _ { l } ( \\pmb { x } ^ { \\prime } ) , y _ { t } ) - \\eta \\frac { \\| \\mathcal { F } _ { l } ( \\pmb { x } ^ { \\prime } ) - \\mathcal { F } _ { l } ( \\pmb { x } ) \\| _ { 2 } } { \\| \\mathcal { F } _ { l } ( \\pmb { x } ) \\| _ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            736,
+            660,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where each auxiliary classifiers $F _ { l } ( \\cdot )$ can model the probability that a feature map at layer $l$ is from a specific target class $y _ { t }$ . $\\mathbf { F D A } ^ { ( N ) } \\mathbf { + x e n t }$ [15] extends FDA by aggregating features from $L$ layers and also incorporating the cross-entropy loss $H ( \\cdot , \\cdot )$ of the original network $\\mathcal F ( \\cdot )$ . The loss function of $\\mathrm { F D A } ^ { ( N ) } -$ +xent can be expressed as: ",
+        "bbox": [
+            173,
+            772,
+            825,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56188fac2b1edf6e52c58ef3002fbb7eab3150b14eb0cffad847eec9e5b7c9cf.jpg",
+        "text": "$$\nL _ { F D A ^ { ( N ) } + x e n t } = \\sum _ { l \\in L } \\lambda _ { l } ( L _ { F D A } + \\gamma H ( \\mathcal { F } ( \\pmb { x } ^ { \\prime } ) , y _ { t } ) ) , \\mathrm { ~ w h e r e ~ } \\sum _ { l \\in L } \\lambda _ { l } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            837,
+            735,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Very recently, TTP [16] has achieved state-of-the-art targeted transferability by directly generating perturbations using target-class-specific GANs that have been trained via matching the distributions of perturbations and a specific target class both globally and locally. Specifically, the global distribution matching is achieved by minimizing the Kullback Leibler (KL) divergence, and the local distribution matching is by enforcing the neighbourhood similarity. In order to further boost the performance, data augmentation techniques, such as image rotation, crop resize, horizontal flip, color jittering and gray-scale transformation, have been applied during model training. We refer the readers to [16] for more technical details of TTP. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These two transferable attacks, $\\mathrm { F D A } ^ { ( N ) } +$ xent and TTP, are resource intensive due to the use of largescale model training and additional data. However, in Section 4.2, we show that simple transferable attacks, which require neither model training nor additional data, can actually achieve even better performance than them. ",
+        "bbox": [
+            176,
+            180,
+            825,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Universal Adversarial Perturbations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            255,
+            465,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Previous research has shown the existence of Universal Adversarial Perturbations (UAPs), i.e., a single image perturbation vector that fools a classifier on multiple images [24]. UAPs have been extensively studied for non-targeted attacks [24–28], but also explored in the more challenging, targeted case [17–19]. Although recent studies have shown comparable performance of using reconstructed class impressions [25] or proxy datasets [18] to original training data, large-scale optimization over image data is still necessary for most existing methods. Differently, a data-free approach [26] has been proposed for non-targeted UAPs by iteratively optimizing randomly-initialized perturbations with an objective of disrupting the intermediate features of the model at multiple layers. However, this approach cannot be applied to targeted UAPs because targeted perturbations aim at a specific direction but not random disruption as in the non-targeted case. To bridge this gap, in Section 4.3, we demonstrate how the simple Logit attack can be used to generate targeted UAPs in a data-free manner. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 New Insights into Simple Transferable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            468,
+            594,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we revisit simple transferable targeted attacks, and provide new insights into them. Specifically, we demonstrate that simple transferable attacks that are based on existing transfer methods (TI-, MI-, and DI-FGSM) need more iterations to converge, and attacking with a simple logit loss can yield much better results than the commonly adopted Cross-Entropy (CE) loss. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Existing Transfer Methods with More Iterations Yield Good Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            684,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Existing attempts have concluded that using simple transferable attacks to achieve targeted transferability is extremely difficult [3, 4, 13–15]. However, these attempts have been limited to the MI transfer method. Here, we tested all the three transfer methods. As can be seen form Figure 1, integrating all the three transfer methods leads to the best performance. In particular, we find that using only DI can actually yield substantial targeted transferability, while using only TI or MI makes little difference to the original poor targeted transferability. The fact that DI outperforms TI may be explained by the fact that DI randomizes the image augmentation parameters over iterations rather than fixing them as in TI. In this way, the gradients towards the target class become more generic and so avoid overfitting to the white-box source model. MI is essentially different from DI and TI because it can only stabilize update directions but not serve to achieve more accurate gradient directions towards a specific (target) class. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As we have pointed out in Section 1, common practice of generating transferable targeted perturbations [13–15, 20] has limited the attack optimization to few iterations (typically $\\leq 2 0$ ). This is somewhat understandable given that extensive research on non-targeted transferability has done the same. However, as can be seen from Figure 1, targeted attacks actually require much more iterations to converge to optimal transferability, in contrast to the fast convergence of non-targeted attacks. This implies that evaluating the targeted transferability under only few iterations is problematic. On the one hand, comparing different optimization processes that have not converged is not meaningful and may cause misleading comparisons (see evidence in Section 4.1). This observation is consistent with the evaluation suggestion in [29] that restricting the number of iterations without verifying the attack convergence is one of the common pitfalls in evaluating adversarial robustness. Several advanced defenses have been defeated by simply increasing the number of iterations [30]. On the other hand, considering the realistic threat model, it is not meaningful to artificially restrict the computational power of a practical attack (e.g., to fewer than several thousand attack iterations) [31]. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fca3998a05bc361aeb1a80acdda333e959d92ecde001d361628249fa2a53dc0c.jpg",
+        "image_caption": [
+            "Figure 1: Transfer success rates of simple transferable attacks using CE or logit loss in the non-targeted and targeted scenarios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            429,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e2c049957a94f6a754c65e1915a056f2b2266017247f535e6e9e8ad04ee22485.jpg",
+        "image_caption": [
+            "Figure 2: White-box (wb) and black-box (bb) attack performance in terms of the predicted confidence (left, higher is better) and ranking (right, lower is better) of the target class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            464,
+            107,
+            805,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            311,
+            823,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 A Simple yet Strong Logit Attack ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            444,
+            373
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Existing simple transferable attacks have commonly adopted the Cross-Entropy (CE) loss. However, as pointed out in [20], during the attack optimization, the CE loss will cause the gradient to decrease and tend to vanish as the number of iterations is increased. To address this problem, the ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ loss [20] takes a very aggressive strategy by arbitrarily reversing the decrease of the gradient, i.e., gradually increasing the magnitude of the gradients over iterations. However, we argue that this operation has led to too large step size, and as a result cause the attack optimization to overshoot the minima. Our results in Section 4.1 support this argument by showing that $\\mathrm { P o + }$ Trip even yielded worse results than CE in the ensemble transfer scenario with diverse model architectures, since the loss surface is relatively non-smooth. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, for the loss function, we eliminate the final softmax function used in the CE loss and just backpropagate the gradients from the logit output: ",
+        "bbox": [
+            173,
+            515,
+            823,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33897c3e9b788b67c3c21c812c403cd8d3917f0a4a85d72585f0464eb553e382.jpg",
+        "text": "$$\nL _ { L o g i t } = - l _ { t } ( { \\bf r } ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            553,
+            560,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $l _ { t } ( \\cdot )$ denotes the logit output with respect to the target class. Although the idea of attacking logits is not new, its superior performance in targeted transferability has not been recognized so far. We also find that using the well-known logit-based loss, C&W [32], yields consistently worse results (see detailed comparisons in Appendix A). Another logit loss that is similar to the C&W loss has also been adopted by [18], but in the task of generating UAPs with large-scale data. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Below, we show that this logit loss leads to stronger gradients than the CE loss. As can be observed from Equation 10, the gradient of the CE loss with respect to the target logit input, $z _ { t }$ , will monotonically decrease as the probability of the target class, $p _ { t }$ , increases during attack optimization. In addition, due to the use of the softmax function, $p _ { t }$ will quickly reach 1, and as a result the gradient tends to vanish. This phenomenon makes the attack hard to improve even with more iterations applied. Differently, as shown by Equation 11, the gradient of the logit loss equals a constant. In this way, the attack can keep improving as the number of iterations is increased. In Appendix B, we provide further comparisons on the trends of loss/gradient magnitude and the target logit value over iterations, which show that the logit loss leads to better results than both CE and ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ . ",
+        "bbox": [
+            173,
+            655,
+            826,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2f52929761654b615d40bfbb9a7265e3cfe8acfdc5a926404ecd2f3fa360022.jpg",
+        "text": "$$\n\\begin{array} { c } { { { \\cal L } _ { C E } = - 1 \\cdot \\log ( p _ { t } ) = - \\log ( { \\displaystyle \\frac { e ^ { z _ { t } } } { \\sum e ^ { z _ { j } } } } ) = - z _ { t } + \\log ( \\sum _ { } e ^ { z _ { j } } ) , } } \\\\ { { { \\cal \\frac { \\partial L _ { C E } } { \\partial z _ { t } } } = - 1 + { \\displaystyle \\frac { \\partial \\log ( \\sum e ^ { z _ { j } } ) } { \\partial e ^ { z _ { t } } } } \\cdot { \\displaystyle \\frac { \\partial e ^ { z _ { t } } } { \\partial z _ { t } } } = - 1 + { \\displaystyle \\frac { e ^ { z _ { t } } } { \\sum e ^ { z _ { j } } } } = - 1 + p _ { t } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            799,
+            717,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/144ea0a28bc0d891cb0a7747bd387f6c935a23d1861053ca4178afeba89782cf.jpg",
+        "text": "$$\nL _ { L o g i t } = - z _ { t } , \\frac { \\partial L _ { L o g i t } } { \\partial z _ { t } } = - 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            883,
+            604,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9608ea412586a4f98a57cb476ebf0dc47ef6bfda71601d95752fceef5a0bda36.jpg",
+        "table_caption": [
+            "Table 1: Targeted transfer success rates $( \\% )$ in the single-model transfer scenario. We consider three attacks with different loss functions: cross-entropy (CE), Poincare distance with Triplet loss ´ $( { \\mathrm { P o } } + { \\mathrm { T r i p } } )$ [20], and the logit loss. Results with 20/100/300 iterations are reported. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Attack</td><td colspan=\"3\">Source Model: Res50</td><td colspan=\"3\">Source Model: Dense121</td></tr><tr><td>→Dense121</td><td>→VGG16</td><td>→Inc-v3</td><td>→Res50</td><td>→VGG16</td><td>→Inc-v3</td></tr><tr><td>CE</td><td>26.9/39.4/42.6</td><td>17.3/27.3/30.4</td><td>2.4/3.8/4.1</td><td>13.1/17.3/19.4</td><td>7.7/10.8/10.9</td><td>1.9/3.3/3.5</td></tr><tr><td>Po+Trip</td><td>26.7/53.0/54.7</td><td>18.8/34.2/34.4</td><td>2.9/6.0/5.9</td><td>10.1/14.7/14.7</td><td>6.7/8.3/7.7</td><td>2.1/3.0/2.7</td></tr><tr><td>Logit</td><td>29.3/63.3/72.5</td><td>24.0/55.7/62.7</td><td>3.0/7.2/9.4</td><td>17.2/39.7/43.7</td><td>13.5/35.3/38.7</td><td>2.7/6.9/7.6</td></tr><tr><td rowspan=\"2\">Attack</td><td colspan=\"3\">Source Model: VGG16</td><td colspan=\"3\">Source Model: Inc-v3</td></tr><tr><td>→Res50</td><td>→Dense121</td><td>→Inc-v3</td><td>→Res50</td><td>→Dense121</td><td>→VGG16</td></tr><tr><td>CE</td><td>0.7/0.4/0.6</td><td>0.5/0.3/0.1</td><td>0/0.1/0</td><td>0.6/2.1/2.4</td><td>0.8/2.5/2.9</td><td>0.7/1.6/2.0</td></tr><tr><td>Po+Trip</td><td>0.6/0.8/0.5</td><td>0.6/0.6/0.7</td><td>0.2/0.1/0.1</td><td>0.6/2.0/2.5</td><td>0.8/3.1/3.3</td><td>0.5/2.1/2.0</td></tr><tr><td>Logit</td><td>3.3/8.7/11.2</td><td>3.6/11.7/13.2</td><td>0.2/0.7/0.9</td><td>0.8/1.6/2.9</td><td>1.2/2.8/5.3</td><td>0.7/2.2/3.7</td></tr></table>",
+        "bbox": [
+            176,
+            145,
+            823,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Evidence on Simple Transferable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            669,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide experimental evidence to show the general effectiveness of simple transferable attacks. Firstly, in Section 4.1, we evaluate the simple transferable attacks in a variety of transfer scenarios, including single-model transfer, ensemble transfer (easy and challenging scenarios), a worse-case scenario with low-ranked target classes, and a real-world attack on the Google Cloud Vision API. Then, in Section 4.2, we compare the simple transferable attacks with two state-of-the-art resource-intensive transferable attacks, $\\mathrm { F D A } ^ { ( N ) } { + } \\mathrm { x e n i }$ [15] and TTP [16]. Finally, in Section 4.3, we apply the Logit attack to achieving targeted UAPs in a data-free manner. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following recent work [14–16, 20], we focus on targeted transferability of ImageNet-like images, which is known to be much more difficult than other data sets (e.g, MNIST and CIFAR-10) with smaller-size images and fewer classes. Specifically, we used the 1000 images from the development set of the ImageNet-Compatible Dataset1, which was introduced along with the NIPS 2017 Competition on Adversarial Attacks and Defenses. All these images are associated with 1000 ImageNet class labels and cropped to $2 9 9 \\times 2 9 9$ before use. Our experiments were run on an NVIDIA Tesla P100 GPU with 12GB of memory. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Simple Transferable Attacks in Various Transfer Scenarios ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            622,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We tested three different attack losses: CE, ${ \\mathrm { P o + T r i p } }$ [20] and Logit. All attacks used TI, MI, and DI with optimal hyperparameters provided in their original work. Specifically, $\\| \\mathbf { W } \\| _ { 1 } = 5$ was used for ‘TI’ as suggested by [12]. For each image, we used the target label that was officially specified in the dataset. If not mentioned specifically, all attacks were run with 300 iterations to ensure convergence. When being executed with a batch size of 20, the optimization process took about three seconds per image. A moderate step size of 2 was used for all attacks, and the results were shown to be not sensitive to the setting of step size (see evidence in Appendix C). We considered four diverse classifier architectures: ResNet [33], DenseNet [34], VGGNet [35], and Inception [36]. Following the common practice, the perturbations were restricted by $L _ { \\infty }$ norm with $\\epsilon = 1 6$ . ",
+        "bbox": [
+            173,
+            612,
+            825,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Single-model transfer. Table 1 reports the targeted transferability when transferring between each pair of different model architectures. As can be seen, the logit loss outperformed CE and ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ by a large margin in almost all cases. When comparing different model architectures, we can find that the attacks achieved lower performance when transferring from the VGGNet16 or Inception-v3 than from ResNet50 or DenseNet121. This is consistent with the observations in [14, 15] and may be explained by the fact that skip connections in ResNet50 and DenseNet121 boosts transferability [37]. Another finding is that when using Inception-v3 as the target model, the transfer success rates were always low. This might be explained by the heavily engineered nature of the Inception architecture, i.e., the Inception architecture has multiple-size convolution and two auxiliary classifiers. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/10d3892245a3347e4e01b2873ff7b232614f9afa3ad38c44c108d5af850625b1.jpg",
+        "table_caption": [
+            "Table 2: Targeted transfer success rates $( \\% )$ in the commonly adopted, easy ensemble transfer scenario, where the hold-out target model (denoted by $\\cdot \\underline { { \\cdot } }$ ) and the ensemble models share similar architectures. Results with 20/100 iterations are reported. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>-Inc-v3</td><td>-Inc-v4</td><td>-IncRes-v2</td><td>-Res50</td><td>-Res101</td><td>-Res152</td><td>Average</td></tr><tr><td>CE</td><td>48.8/85.3</td><td>47.2/83.3</td><td>47.5/83.9</td><td>50.9/89.8</td><td>58.5/93.2</td><td>56.7/90.7</td><td>51.6/87.7</td></tr><tr><td>Po+Trip</td><td>59.3/84.4</td><td>55.0/82.4</td><td>51.4/80.8</td><td>56.9/85.0</td><td>60.5/87.9</td><td>57.6/85.7</td><td>56.8/84.4</td></tr><tr><td>Logit</td><td>56.4/85.5</td><td>52.9/85.8</td><td>54.4/85.1</td><td>57.5/90.0</td><td>64.4/91.4</td><td>61.3/90.8</td><td>57.8/88.1</td></tr></table>",
+        "bbox": [
+            176,
+            145,
+            820,
+            217
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fdd5ac90f4750155748fa1b30949e95ff900d67c18e964d24e5a9e0a6a8ee7a4.jpg",
+        "image_caption": [
+            "Figure 3: Targeted transfer success rates $( \\% )$ in our challenging ensemble transfer scenario, where each hold-out target model shares no similar architecture with the source models used for ensemble. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            239,
+            820,
+            348
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ensemble transfer in both easy and challenging scenarios. A common approach to further boosting transferability is to generate perturbations on an ensemble of white-box source models. Following the common practice, we simply assigned equal weights to all the source models. We first look at the commonly adopted ensemble transfer scenario [4, 6, 20, 38] in which each hold-out target model shares a similar architecture with some of the white-box ensemble models. As can be seen from Table 2, the transfer success rates of all three attacks have got saturated when given enough iterations to converge. As a result, this transfer scenario could not fully reveal the actual strength of different attacks. We can also observe that ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ performed better than the CE loss only when the attack optimization is unreasonably restricted to 20 iterations, but became even worse with enough iterations. This finding suggests that evaluating different attacks under only few iterations may cause misleading comparative results. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next considered a more challenging transfer scenario with no architectural overlap between the source ensemble models and the target model, in order to fully reveal the potential of different attacks. This scenario is also more realistic since it is hard for an attacker to know the specific architecture of a real-world target mode. Figure 3 shows that in this scenario, the Logit largely outperformed CE and ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ . In addition, the results of both CE and Logit were substantially improved over the single-model transfer results reported in Table 1. However, ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ performed even worst in some cases maybe because its use of arbitrarily increasing the gradient magnitude has caused the optimization to overshoot the minima in this ensemble transfer scenario where the loss surface is relatively non-smooth due to the model diversity. Note that as in the single transfer scenario, transferring to Inception-v3 is still the most difficult. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/721353a77d0bfde3286cebeecd1ce4b30bd8994f1b50321bc89a3b554b566c56.jpg",
+        "table_caption": [
+            "Table 3: Targeted transfer success rates $( \\% )$ when varying the target from the high-ranked class to low. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>2nd</td><td>10th</td><td>200th</td><td>500th</td><td>800th</td><td>1000th</td></tr><tr><td>CE</td><td>89.9</td><td>76.7</td><td>49.7</td><td>43.1</td><td>37.0</td><td>25.1</td></tr><tr><td>Po+Trip</td><td>82.6</td><td>77.6</td><td>58.4</td><td>53.6</td><td>49.1</td><td>38.2</td></tr><tr><td>Logit</td><td>83.8</td><td>81.3</td><td>75.0</td><td>71.0</td><td>65.1</td><td>52.8</td></tr></table>",
+        "bbox": [
+            467,
+            771,
+            821,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A worse-case transfer scenario with lowranked target classes. In conventional security studies, a comprehensive evaluation commonly involves a range of attack scenarios with varied difficulty. Existing work on white-box adversarial attacks [32, 21, 23, 38] has also looked at different cases with varied difficulty regarding the ranking position of the target class in the prediction list of the original image. ",
+        "bbox": [
+            173,
+            718,
+            454,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Specifically, in the best case, the targeted success is basically equal to non-targeted success, i.e., an attack is regarded to be successful as long as it can succeed on any arbitrary target other than the original class. In the average case, the target class is randomly specified, while in the worst case, the target is specified as the lowest-ranked/least-likely class. ",
+        "bbox": [
+            176,
+            857,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/38b602e565fc865a9d8cfba5c4abadd7750ba6e392a528b19f1cb12a999c026c.jpg",
+        "image_caption": [
+            "Figure 4: Successful targeted adversarial images on Google Cloud Vision generated by the Logit attack with ensemble transfer. More examples can be found in Appendix D. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            563,
+            175
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b5ee2edb9bfaf454baed1249a625ce0099fbb06d0510bec79b55f40990489ef.jpg",
+        "table_caption": [
+            "Table 4: Non-targeted and targeted transfer success rates $( \\% )$ of different attacks on Google Cloud Vision. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CE</td><td>Po+Trip</td><td>Logit</td></tr><tr><td>Targeted</td><td>7</td><td>8</td><td>18</td></tr><tr><td>Non-targeted</td><td>51</td><td>44</td><td>51</td></tr></table>",
+        "bbox": [
+            583,
+            156,
+            821,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "However, to the best of our knowledge, current evaluation of transfer-based attacks has been limited to the best and average cases. To address this limitation, we consider a worse-case transfer scenario by varying the target from the highest-ranked class gradually to the lowest one. As can be seen from Table 3, there exists a non-negligible correlation between the ranking position of the target class and the targeted transferability. More specifically, it becomes increasingly difficult as the target moves down the prediction list. We can also observe that the results with higher-ranked targets might not reveal the actual strength of different attacks as in the more realistic, worse cases with lower-ranked targets. In particular, only looking the best case with the highest-ranked target may lead to a misleading conclusion that CE leads to the most effective attack. This finding suggests that a more meaningful evaluation on targeted transferability should further increase difficulty beyond the current best and average cases. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            412
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Transfer-based attacks on Google Cloud Vision. Most existing work on fooling real-world computer vision systems has been focused on the query-based attacks, where a large number of queries are required [39–41]. Although several recent studies have also explored real-world transfer-based attacks, they were limited to face recognition and the non-targeted attacks [42–44]. In contrast, we applied the simple transferable attacks in the more challenging, targeted case on a more generallyused image recognition system, the Google Cloud Vision API. Specifically, we used the targeted adversarial images generated on the ensemble of all four diverse source models with 300 iterations. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            516
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The API predicts a list of semantic labels along with confidence scores. Specifically, only the top classes with confidence no lower than $5 0 \\%$ are returned, and at most 10 classes are shown. Note that the confidence score here is not a probability (which would sum to one). We measured both the targeted and non-targeted transferability. Since all returned labels are with relatively high confidence $( \\geq 5 0 \\% )$ ), we do not limit our measure of success rates to only top-1 class. Instead, for non-targeted success, we measured whether or not the ground-truth class appeared in the returned list, while for targeted success, whether or not the target class appeared. Due to the fact that the semantic label set predicted by the API does not exactly correspond to the 1000 ImageNet classes, we treated semantically similar classes as the same class. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            647
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 reports the results averaged over 100 images that originally yield correct predictions. As can be seen, in general, achieving targeted transfer success is much more difficult than non-targeted success. In particular, the Logit attack achieved the best targeted transferability, with quasi-imperceptible perturbations shown in Figure 4. Our results reveal the potential vulnerability of Google Cloud Vision against simple transfer-based attacks, which require no query interaction. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Simple vs. Resource-Intensive Transferable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            748,
+            571,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we compared simple transferable attacks with state-of-the-art resource-intensive approaches, TTP [16] and FDA(N)+xent [15], which necessitate training target-class-specific models on additional data. ",
+        "bbox": [
+            176,
+            777,
+            821,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compared with TTP. We compared the Logit attack with the state-of-the-art TTP, which is based on training target-class-specific GANs on additional data. We tested both Logit and TTP on our dataset following the “10-Targets (all-source)” setting in [16]. We chose ResNet50 as the white-box model in the single-model transfer scenario and an ensemble of $\\mathrm { R e s N e t } \\{ 1 8 , 5 0 , 1 0 1 , 1 5 2 \\}$ in the ensemble transfer scenario. DenseNet121 and VGG16 bn are tested as the target models. Note that the same knowledge of the white-box model is available to both attacks but it is leveraged in different ways. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Specifically, for the Logit attack, the white-box model is used as a source model for iterative attack optimization, while for TTP, it is used as a discriminator during training the GANs. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 5, under the commonly adopted $\\epsilon = 1 6$ , the Logit attack can achieve comparable results to TTP in all cases. Specifically, we can observe that the model ensemble is more helpful to Logit than for TTP. This might be because even with the single model as the discriminator, TTP can learn good enough features of target semantics by training with the objective of matching the perturbation and target class distributions with large-scale data. The clearer target semantics learned by TTP can be confirmed by comparing the unbounded perturbations achieved by TTP (e.g., Figure 3 in [16]) with those by the Logit shown in Figure 5. ",
+        "bbox": [
+            174,
+            126,
+            485,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c3b7293737e512839ffa02751933ba8cf4619297a516d2d25ac0cf2064aff82.jpg",
+        "table_caption": [
+            "Table 5: Targeted transfer success rates $( \\% )$ of Logit vs. TTP in single-model and ensemble transfer scenarios under two norm bounds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Bound</td><td>Attack</td><td>D121</td><td>V16</td><td>D121-ens</td><td>V16-ens</td></tr><tr><td rowspan=\"2\">e= 16</td><td>TTP</td><td>79.6</td><td>78.6</td><td>92.9</td><td>89.6</td></tr><tr><td>Logit</td><td>75.9</td><td>72.5</td><td>99.4</td><td>97.7</td></tr><tr><td rowspan=\"2\">e=8</td><td>TTP</td><td>37.5</td><td>46.7</td><td>63.2</td><td>66.2</td></tr><tr><td>Logit</td><td>44.5</td><td>46.8</td><td>92.6</td><td>87.0</td></tr></table>",
+        "bbox": [
+            500,
+            193,
+            821,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            291,
+            772,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This fact that TTP perturbations heavily rely on semantic patterns of the target class might cause TTP to degrade under lower norm bounds. To validate this assumption, we further compared Logit and TTP under $\\epsilon = 8$ . As expected, the Logit attack consistently surpassed TTP, especially with a very large margin in the ensemble transfer scenario. The different comparing results for the two perturbation sizes also suggest that comparing attacks only under a single perturbation size may not reveal their characteristics. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e59a2e2c59015f4dbfbfc7da463c3388bb2665a393071bf30a79aa45ee7c0f4.jpg",
+        "table_caption": [
+            "Table 6: Targeted transfer success rates $( \\% )$ of unbounded adversarial images by different attacks with the same iteration budget. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FDA(4) +xent</td><td>CE</td><td>Po+Trip</td><td>Logit</td></tr><tr><td>Res50-→Dense121</td><td>65.8</td><td>69.3</td><td>88.1</td><td>84.1</td></tr><tr><td>Res50→VGG16</td><td>48.1</td><td>54.1</td><td>67.8</td><td>74.2</td></tr></table>",
+        "bbox": [
+            176,
+            467,
+            496,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0c0f928a7bbb988714c9d633bdb653be7f458932d6324a2cba9b55e81b07fd1.jpg",
+        "image_caption": [
+            "Figure 5: Unbounded adversarial examples that reflect target semantics. More examples can be found in Appendix E. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            404,
+            821,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Compared with FDA(N)+xent. We compared the three simple transferable attacks (CE, ${ \\mathrm { P o } } { + } { \\mathrm { T r i p } }$ and Logit) with $\\mathrm { F D A } ^ { ( N ) }$ +xent on generating unbounded adversarial images, in consistence with “distal transfer” in $[ 1 5 ] ^ { 2 }$ . Specifically, the adversarial perturbations were initialized as random Gaussian noise and allowed to be as large as possible. Although such unbounded adversarial images may not be practically compelling, they can provide better isolated indication on transferability by eliminating the dependency on the source images and the bound restrictions. The results were averaged over 4000 image examples, each of which was optimized towards a random target class. As suggested by [15], the MI transfer method was removed since it empirically harms the performance in this unbounded case. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows that all the three simple transferable attacks achieved stronger targeted transferability than $\\mathrm { F D A } ^ { ( N ) } \\mathrm { + x e n t }$ . As can be seen from Figure 5, the unbounded adversarial perturbations can somehow reflect the target semantics. This finding suggests that achieving targeted transferability relies on robust, semantic features [45] that are expected to be learned by various models and also understood by humans. In this way, achieving targeted transferability is fundamentally different from non-targeted transferability, for which attacking non-robust features is known to be sufficient [45]. It is also worth noting that in practical scenarios with small norm bounds, the semantically-aligned perturbations would not be expected to change human judgements. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Simple Logit Attack for Targeted UAPs in a Data-Free Manner ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            650,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The above observation that the perturbations can reflect certain target semantics motivates us to apply the Logit attack to achieving targeted Universal Adversarial Perturbations (UAPs), which can drive multiple original images into a specific target class. Existing attempts at achieving targeted UAPs have mainly relied on large-scale optimization over additional data [17–19]. However, the simple Logit attack can be easily extended to generate targeted UAPs in a data-free manner. The only difference from the above transferable Logit attack is that here a mean image (all pixel values set as 0.5 out of [0,1]) is used as the original image. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/45114acf407a882ce07a2bb8bf4c51f360dfb27de75f9d833520195ae23a0216.jpg",
+        "table_caption": [
+            "Table 7: Success rates $( \\% )$ of targeted UAPs generated by CE and Logit attacks for different models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Inc-v3</td><td>Res50</td><td>Dense121</td><td>VGG16</td></tr><tr><td>CE</td><td>2.6</td><td>9.2</td><td>8.7</td><td>20.1</td></tr><tr><td>Logit</td><td>4.7</td><td>22.8</td><td>21.8</td><td>65.9</td></tr></table>",
+        "bbox": [
+            176,
+            190,
+            465,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/a965d24ae8b97cf0eca96389dc830cba0f3a40618f1425879de5ff1b25bee39a.jpg",
+        "image_caption": [
+            "Figure 6: UAPs $\\epsilon = 1 6$ , VGG16) with different classes using CE and Logit. More examples can be found in Appendix F. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            88,
+            821,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            318,
+            825,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In our experiment, for each target class, we generated a single targeted UAP vector $\\epsilon = 1 6$ ) with 300 iterations and applied it to all 1000 images in our dataset. Table 7 reports the results averaged over all the 1000 ImageNet classes. As can be seen, the logit loss can yield substantial success, remarkably outperforming the CE loss. This can be confirmed by Figure 6, which shows the Logit attack can yield more semantically-aligned perturbations than CE. This observation also supports the claim from [18] that universal perturbations contain dominant features, and images act like noise with respect to perturbations. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion and Outlook ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            408,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have demonstrated that achieving targeted transferability is not as difficult as current work concludes. Specifically, we find that simple transferable attacks can actually achieve surprisingly strong targeted transferability when given enough iterations for convergence. We have validated the effectiveness of simple transferable attacks in a wide range of transfer scenarios, including three newly-introduced challenging scenarios. These challenging scenarios have better revealed the actual strength of different attacks. In particular, we demonstrate that a very simple Logit attack is superior in all transfer scenarios, achieving even better results than the state-of-the-art resource-intensive approaches. We also show the potential usefulness of the Logit attack for generating targeted universal adversarial perturbations in a data-free manner. Overall, we hope our findings will inspire future research to conduct a more meaningful evaluation on targeted transferability. Our future work will focus on studying why different model architectures yield different transferability. In particular, the very low success rates when targeting Inception-v3 should be explored. Moving forward, there needs to be a more comprehensive discussion on the resource consumption of different attacks from multiple aspects, such as training and inference time, hardware resources, and data size. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Strong transferability can obviously benefit black-box applications of adversarial images for social good, such as protecting user privacy [42, 43, 46–48]. In addition, it will also motivate the community to design stronger defenses given our finding that even simple attacks can generate highly transferable adversarial images. It remains a possibility that our methodology may be misused by malicious actors to break legitimate systems. However, we firmly believe that the help that our paper can provide to researchers significantly outweighs the help that it may provide an actual malicious actor. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            328,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was carried out on the Dutch national e-infrastructure with the support of SURF Cooperative. ",
+        "bbox": [
+            173,
+            848,
+            825,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.   \n[2] Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.   \n[3] Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.   \n[4] Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In CVPR, 2018.   \n[5] Wen Zhou, Xin Hou, Yongjun Chen, Mengyun Tang, Xiangqi Huang, Xiang Gan, and Yong Yang. Transferable adversarial perturbations. In ECCV, 2018.   \n[6] Yinpeng Dong, Tianyu Pang, Hang Su, and Jun Zhu. Evading defenses to transferable adversarial examples by translation-invariant attacks. In CVPR, 2019.   \n[7] Qian Huang, Isay Katsman, Horace He, Zeqi Gu, Serge Belongie, and Ser-Nam Lim. Enhancing adversarial example transferability with an intermediate level attack. In ICCV, 2019.   \n[8] Cihang Xie, Zhishuai Zhang, Yuyin Zhou, Song Bai, Jianyu Wang, Zhou Ren, and Alan L Yuille. Improving transferability of adversarial examples with input diversity. In CVPR, 2019.   \n[9] Jiadong Lin, Chuanbiao Song, Kun He, Liwei Wang, and John E Hopcroft. Nesterov accelerated gradient and scale invariance for adversarial attacks. In ICLR, 2020.   \n[10] Yingwei Li, Song Bai, Yuyin Zhou, Cihang Xie, Zhishuai Zhang, and Alan L Yuille. Learning transferable adversarial examples via ghost networks. In AAAI, 2020.   \n[11] Weibin Wu, Yuxin Su, Xixian Chen, Shenglin Zhao, Irwin King, Michael R Lyu, and Yu-Wing Tai. Boosting the transferability of adversarial samples via attention. In CVPR, 2020.   \n[12] Lianli Gao, Qilong Zhang, Jingkuan Song, Xianglong Liu, and Heng Tao Shen. Patch-wise attack for fooling deep neural network. In ECCV, 2020.   \n[13] Nathan Inkawhich, Wei Wen, Hai Helen Li, and Yiran Chen. Feature space perturbations yield more transferable adversarial examples. In CVPR, 2019.   \n[14] Nathan Inkawhich, Kevin Liang, Lawrence Carin, and Yiran Chen. Transferable perturbations of deep feature distributions. In ICLR, 2020.   \n[15] Nathan Inkawhich, Kevin J Liang, Binghui Wang, Matthew Inkawhich, Lawrence Carin, and Yiran Chen. Perturbing across the feature hierarchy to improve standard and strict blackbox attack transferability. In NeurIPS, 2020.   \n[16] Muzammal Naseer, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Fatih Porikli. On generating transferable targeted perturbations. In ICCV, 2021.   \n[17] Omid Poursaeed, Isay Katsman, Bicheng Gao, and Serge Belongie. Generative adversarial perturbations. In CVPR, 2018.   \n[18] Chaoning Zhang, Philipp Benz, Tooba Imtiaz, and In So Kweon. Understanding adversarial examples from the mutual influence of images and perturbations. In CVPR, 2020.   \n[19] Philipp Benz, Chaoning Zhang, Tooba Imtiaz, and In So Kweon. Double targeted universal adversarial perturbations. In ACCV, 2020.   \n[20] Maosen Li, Cheng Deng, Tengjiao Li, Junchi Yan, Xinbo Gao, and Heng Huang. Towards transferable targeted attack. In CVPR, 2020.   \n[21] Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. In ICLR, 2017.   \n[22] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   \n[23] Jer´ ome Rony, Luiz G. Hafemann, Luiz S. Oliveira, Ismail Ben Ayed, Robert Sabourin, and Eric ˆ Granger. Decoupling direction and norm for efficient gradient-based $L _ { 2 }$ adversarial attacks and defenses. In CVPR, 2019.   \n[24] Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In CVPR, 2017.   \n[25] Konda Reddy Mopuri, Phani Krishna Uppala, and R Venkatesh Babu. Ask, acquire, and attack: Data-free UAP generation using class impressions. In ECCV, 2018.   \n[26] Konda Reddy Mopuri, Aditya Ganeshan, and R Venkatesh Babu. Generalizable data-free objective for crafting universal adversarial perturbations. IEEE TPAMI, 41(10):2452–2465, 2018.   \n[27] Muzammal Naseer, Salman H Khan, Harris Khan, Fahad Shahbaz Khan, and Fatih Porikli. Cross-domain transferability of adversarial perturbations. In NeurIPS, 2019.   \n[28] Yingwei Li, Song Bai, Cihang Xie, Zhenyu Liao, Xiaohui Shen, and Alan L Yuille. Regional homogeneity: Towards learning transferable universal adversarial perturbations against defenses. In ECCV, 2020.   \n[29] Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. In arXiv preprint arXiv:1902.06705, 2019.   \n[30] Florian Tramer, Nicholas Carlini, Wieland Brendel, and Aleksander Madry. On adaptive attacks to adversarial example defenses. In NeurIPS, 2020.   \n[31] Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018.   \n[32] Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE S&P, 2017.   \n[33] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[34] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   \n[35] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[36] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.   \n[37] Dongxian Wu, Yisen Wang, Shu-Tao Xia, James Bailey, and Xingjun Ma. Skip connections matter: On the transferability of adversarial examples generated with resnets. In ICLR, 2020.   \n[38] Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick \\` McDaniel. Ensemble adversarial training: Attacks and defenses. In ICLR, 2018.   \n[39] Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In AISec, 2017.   \n[40] Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In ICLR, 2018.   \n[41] Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In ICML, 2018.   \n[42] Valeriia Cherepanova, Micah Goldblum, Harrison Foley, Shiyuan Duan, John Dickerson, Gavin Taylor, and Tom Goldstein. LowKey: Leveraging adversarial attacks to protect social media users from facial recognition. In ICLR, 2021.   \n[43] Arezoo Rajabi, Rakesh B Bobba, Mike Rosulek, Charles Wright, and Wu-chi Feng. On the (im) practicality of adversarial perturbation for image privacy. PoPETs, 2021.   \n[44] Shawn Shan, Emily Wenger, Jiayun Zhang, Huiying Li, Haitao Zheng, and Ben Y Zhao. Fawkes: Protecting privacy against unauthorized deep learning models. In USENIX Security, 2020.   \n[45] Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In NeurIPS, 2019.   \n[46] Martha Larson, Zhuoran Liu, Simon Brugman, and Zhengyu Zhao. Pixel privacy: Increasing image appeal while blocking automatic inference of sensitive scene information. In MediaEval Multimedia Benchmark Workshop, 2018.   \n[47] Zhuoran Liu, Zhengyu Zhao, and Martha Larson. Who’s afraid of adversarial queries? the impact of image modifications on content-based image retrieval. In ICMR, 2019.   \n[48] Seong Joon Oh, Mario Fritz, and Bernt Schiele. Adversarial image perturbation for privacy protection a game theory perspective. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            95,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            381
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            407,
+            254,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            435,
+            339,
+            449
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] We described the limitation in the first sentence of the final section.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] We discuss them at the end of the final section.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            455,
+            825,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            579,
+            493,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            598,
+            738,
+            630
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            635,
+            393,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code (including instructions and a link to data we have used) has been submitted as the supplemental material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Our experiments did not involve any model training, but all the algorithm details were specified.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We fixed the random seed for all the experiments. Now the main randomness comes from the $p$ in the existing method, DI (see Eq. 6). We confirm that it has little impact on the results.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We mentioned the run time of the attacks and our hardware settings in Section 4. ",
+        "bbox": [
+            238,
+            655,
+            825,
+            856
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            861,
+            823,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] In Section 4.   \n(b) Did you mention the license of the assets? [Yes] In a footnote of Section 4.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] We did not use any new assets.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] In the same footnote as above.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] In the same footnote as above. ",
+        "bbox": [
+            236,
+            881,
+            779,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            238,
+            92,
+            825,
+            179
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            184,
+            705,
+            199
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            203,
+            825,
+            292
+        ],
+        "page_idx": 13
+    }
+]