Add files using upload-large-folder tool

parse/train/S1xNEhR9KX/S1xNEhR9KX.md

@@ -0,0 +1,444 @@
+# ON THE SENSITIVITY OF ADVERSARIAL ROBUSTNESS TO INPUT DATA DISTRIBUTIONS
+
+Gavin Weiguang Ding, Kry Yik Chau Lui, Xiaomeng Jin, Luyu Wang, Ruitong Huang Borealis AI Canada
+
+# ABSTRACT
+
+Neural networks are vulnerable to small adversarial perturbations. Existing literature largely focused on understanding and mitigating the vulnerability of learned models. In this paper, we demonstrate an intriguing phenomenon about the most popular robust training method in the literature, adversarial training: Adversarial robustness, unlike clean accuracy, is sensitive to the input data distribution. Even a semantics-preserving transformations on the input data distribution can cause a significantly different robustness for the adversarial trained model that is both trained and evaluated on the new distribution. Our discovery of such sensitivity on data distribution is based on a study which disentangles the behaviors of clean accuracy and robust accuracy of the Bayes classifier. Empirical investigations further confirm our finding. We construct semantically-identical variants for MNIST and CIFAR10 respectively, and show that standardly trained models achieve comparable clean accuracies on them, but adversarially trained models achieve significantly different robustness accuracies. This counter-intuitive phenomenon indicates that input data distribution alone can affect the adversarial robustness of trained neural networks, not necessarily the tasks themselves. Lastly, we discuss the practical implications on evaluating adversarial robustness, and make initial attempts to understand this complex phenomenon.
+
+# 1 INTRODUCTION
+
+Neural networks have been demonstrated to be vulnerable to adversarial examples (Szegedy et al., 2013; Biggio et al., 2013). Since the first discovery of adversarial examples, great progress has been made in constructing stronger adversarial attacks (Goodfellow et al., 2014; Moosavi-Dezfooli et al., 2016; Madry et al., 2017; Carlini and Wagner, 2017). In contrast, defenses fell behind in the arms race (Carlini and Wagner, 2016; Athalye et al., 2017; 2018). Recently a line of works have been focusing on understanding the difficulty in achieving adversarial robustness from the perspective of data distribution. In particular, Tsipras et al. (2019) demonstrated the inevitable tradeoff between robustness and clean accuracy in some particular examples. Schmidt et al. (2018) showed that the sample complexity of “learning to be robust” learning could be significantly higher than that of “learning to be accurate”.
+
+In this paper, we contribute to this growing literature from a new angle, by studying the relationship between adversarial robustness and the input data distribution. We focus on the adversarial training method, arguably the most popular defense method so far due to its simplicity, effectiveness and scalability (Goodfellow et al., 2014; Huang et al., 2015; Kurakin et al., 2016; Madry et al., 2017; Erraqabi et al., 2018). Our main contribution is the finding that adversarial robustness is highly sensitive to the input data distribution:
+
+# A semantically-lossless shift on the data distribution could result in a drastically different robustness for adversarially trained models.
+
+Note that this is different from the transferability of a fixed model that is trained on one data distribution but tested on another distribution. Even retraining the model on the new data distribution may give us a completely different adversarial robustness on the same new distribution. This is also in sharp contrast to the clean accuracy of standard training, which, as we show in later sections, is insensitive to such shifts. To our best knowledge, our paper is the first work in the literature that demonstrates such sensitivity.
+
+Our investigation is motivated by the empirical observations on the MNIST dataset and the CIFAR10 dataset. In particular, while comparable SOTA clean accuracies (the difference is less than $3 \%$ ) are achieved by MNIST and CIFAR10 (Gastaldi, 2017), CIFAR10 suffers from much lower achievable robustness than MNIST in practice.1 Results of this paper consist of two parts. First in theory, we start with analyzing the difference between the regular Bayes error and the robust error, and show that the regular Bayes error is invariant to invertible transformations of the data distribution, but the robust error is not. We further prove that if the input data is uniformly distributed, then the perfect decision boundary cannot be robust. However, we also manage to find a robust model for the binarized MNIST dataset (semantically almost identical to MNIST, later described in Section 3). The certification method by Wong and Kolter (2018) guarantees that this model achieves at most $3 \%$ robust error. Such a sharp contrast suggests the important role of the data distribution in adversarial robustness, and leads to our second contribution on the empirical side: we design a series of augmented MNIST and CIFAR10 datasets to demonstrate the sensitivity of adversarial robustness to the input data distribution.
+
+Our finding of such sensitivity raises the question of how to properly evaluate adversarial robustness. In particular, the sensitivity of adversarial robustness suggests that certain datasets may not be sufficiently representative when benchmarking different robust learning algorithms. It also raises serious concerns about the deployment of believed-to-be-robust training algorithm in a real product. In a standard development procedure, various models (for example different network architectures) would be prototyped and measured on the existing data. However, the sensitivity of adversarial robustness makes the truthfulness of the performance estimations questionable, as one would expect future data to be slightly shifted. We illustrate the practical implications in Section 4 with two practical examples: 1) the robust accuracy of PGD trained model is sensitive to gamma values of gamma-corrected CIFAR10 images. This indicates that image datasets collected under different light conditions may have different robustness properties; 2) both as a “harder” version of MNIST, the fashion-MNIST (Xiao et al., 2017) and edge-fashion-MNIST (an edge detection variant described in Section 4.2) exhibit completely different robustness characteristics. This demonstrates that different datasets may give completely different evaluations for the same algorithm.
+
+Finally, our finding opens up a new angle and provides novel insights to the adversarial vulnerability problem, complementing several recent works on the issue of data distributions’ influences on robustness. Tsipras et al. (2019) hypothesize that there is an intrinsic tradeoff between clean accuracy and adversarial robustness. Our studies complement this result, showing that there are different levels of tradeoffs depending on the characteristics of input data distribution, under the same learning settings (training algorithm, model and training set size). Schmidt et al. (2018) show that different data distributions could have drastically different properties of adversarially robust generalization, theoretically on Bernoulli vs mixtures of Gaussians, and empirically on standard benchmark datasets. From the sensitivity perspective, we demonstrate that being from completely different distributions (e.g. binary vs Gaussian or MNIST vs CIFAR10) may not be the essential reason for having large robustness difference. Gradual semantics-preserving transformations of data distribution can also cause large changes to datasets’ achievable robustness. We make initial attempts in Section 5 to further understand this sensitivity. We investigated perturbable volume and inter-class distance as the natural causes of the sensitivity; model capacity and sample complexity as the natural remedies. However, the complexity of the problem has so far defied our efforts to give a definitive answer.
+
+# 1.1 NOTATION AND PROBLEM SETUP
+
+We specifically consider the image classification problem where the input data is inside a high dimensional unit cube. We denote the data distribution as a joint distribution $\mathbb { P } ( x , y )$ , where $x \in [ 0 , 1 ] ^ { d }$ , $d$ is the number of pixels, and $y _ { \cdot } \in \ \{ 1 , 2 , \ldots , k \}$ is the discrete label. We assume the support of $x$ is the whole pixel space $[ 0 , 1 ] ^ { d }$ . When $x$ is a random noise (or human perceptually unclassifiable image), one can think of $\mathbb { P } ( y \mid x )$ being closed to uniform distribution on labels. In the standard setting, the samples $( x _ { i } , y _ { i } )$ can be interpreted as $x _ { i }$ is independently sampled from the marginal distribution $\mathbb { P } ( x )$ , and then $y _ { i }$ is sampled from $\mathbb { P } ( x | x _ { i } )$ . In this paper, we discuss $\mathbb { P } ( x )$ ’s influences on adversarial robustness, given a fixed $\mathbb { P } ( y | x )$ .
+
+In our experiments, we only discuss the whitebox robustness, as it represents the “intrinsic” robustness. We use models learned by adversarially augmented training (Madry et al., 2017) (PGD training), which has the SOTA whitebox robustness. We consider bounded $\ell _ { \infty }$ attack as the attack for evaluating robustness for 2 reasons: 1) PGD training can defend against $\ell _ { \infty }$ relatively well, while for other attacks, how to train a robust model is still an open question; 2) in the image domain $\ell _ { \infty }$ attack is the mostly widely researched attack.
+
+Let $\mathcal { H }$ denote the universal set of all the measurable functions. Given a joint distribution $\mathbb { P } ( x , y )$ on the space $\mathcal { X } \times \mathcal { V }$ , we define the Bayes error $\begin{array} { r } { R ^ { * } = \operatorname* { i n f } _ { h \in \mathcal { H } } \mathbb { E } _ { \mathbb { P } ( x , y ) } L ( \mathcal { \bar { y } } ; h ( x ) ) = R ^ { * } ( \mathbb { P } ( x , y ) ) . } \end{array}$ , where $L$ is the objective function. In other words, Bayes error is the error of the best possible classifier we can have, $h ^ { * }$ , without restriction on the function space of classifiers. We further define (adversarial) robust error $\begin{array} { r } { R R ( h ) = \mathbb { E } _ { \mathbb { P } ( x , y ) } \operatorname* { m a x } _ { \| \delta \| _ { \infty } < \epsilon } L ( y ; h ( x + \delta ) ) = R R ( \mathbb { P } ( x , y ) ) } \end{array}$ . We denote $R R ^ { * } = R R ( h ^ { * } )$ to be the robust error achieved by the Bayes classifier $h ^ { * }$ . For simplicity, we assume our algorithm can always learn $h ^ { * }$ , which reduces clean accuracy to be (1 − Bayes error), and robust accuracy of the Bayes classifier to be $\left( 1 - R R ^ { * } \right)$ .
+
+# 2 THEORETICAL ANALYSES AND PROVABLE CASES
+
+As mentioned in the introduction, although the SOTA clean accuracies are similar for MNIST and CIFAR10, the robust accuracy on CIFAR10 is much more difficult to achieve, which indicates the different behaviors of the clean accuracy and robust accuracy. The first result in this section is to further confirm this indication in a simple setting, where the clean accuracy remains the same but the robust accuracy completely changes under a distribution shift. Based on results from the concentration of measure literature, we further show that under uniform distribution, no algorithm can achieve good robustness, as long as they have high clean accuracy. On the other hand, we examine the performance of a verifiable defense method on binarized MNIST (pixels values rounded to 0 and 1), and the result suggests the exact opposite: provable adversarial robustness on a MNISTlike dataset is achievable. Such contrast thus suggests the important role of the data distribution in achieving adversarial robustness.
+
+# 2.1 DISENTANGLE CLEAN ACCURACY AND ROBUST ACCURACY
+
+One immediate result is that Bayes error remains the same under any distribution shift induced by an injective map $T : \mathcal { X }  \mathcal { X }$ . To see that, simply note that $T ^ { - 1 }$ exists and $h ^ { \ast } \circ T ^ { - 1 }$ gives the same Bayes error for the shifted distribution. However, such invariance property does not hold for the robust error of the Bayes classifier. Furthermore, the following two examples show that Bayes error can have completely different behavior from its robust error. Although both examples have 0 Bayes error, they have completely different robust errors.
+
+Example 1. Assume $x$ is uniformly distributed in $[ 0 , 1 ] ^ { d }$ and $y = 1$ , for all $x$ with $x ^ { \top } e _ { 1 } > 1 / 2$ and $y = 0$ , for $x ^ { \top } e _ { 1 } \leq 1 / 2$ , where $e _ { 1 }$ is the one-hot vector. We use the 0-1 loss here. Note that the Bayes error decision boundaries are given by the following hyperplane: $H P _ { 1 } = \{ x \in [ 0 , 1 ] ^ { d } : x _ { 1 } = \operatorname { \bar { 0 } } \}$ , and thus
+
+$$
+R ^ { * } = 0 ; \qquad R R ^ { * } = 2 \epsilon ,
+$$
+
+under the budget $\| \delta \| _ { \infty } < \epsilon .$ . In this case, the robust error is tolerable and relatively robust measured by the fraction of points that are successfully attacked, 2.
+
+Moreover, consider an injective map $T$ which maps $\{ x : x ^ { \top } e _ { 1 } > 1 / 2 \}$ to $\{ x : x ^ { \top } I > \textstyle { \frac { d } { 2 } } \}$ , and $\{ x : x ^ { \top } e _ { 1 } \leq 1 / 2 \}$ to $\{ x : x ^ { \top } I \leq \textstyle { \frac { d } { 2 } } \} ^ { 2 }$ . The Bayes error on the new distribution remains 0, as $T$ is invertible. In contrast, the robust error is much worse. In fact,
+
+$$
+R R ^ { * } \geq 1 - \frac { 1 } { 4 d \epsilon ^ { 2 } } .
+$$
+
+Remark 2.1. Note that here the robust error of the Bayes classifier will grow to 1 as the dimensionality increases, for a fixed budget .
+
+# 2.2 DIFFICULTY IN ACHIEVING ROBUSTNESS
+
+Example 1 shows that good clean accuracy does not necessary lead to good robust accuracy. In contrast, we will show in this section that achieving a good robust accuracy is impossible given uniformly distributed data, as long as we ask for good clean accuracies. Our tool are classical results from the concentration of measure (Ledoux, 2005).
+
+Let $A _ { \epsilon } : = \{ x \in \mathbb { R } ^ { N } | \mathbf { d } ( x , A ) < \epsilon \}$ denote the $\epsilon$ -neighborhood of the nonempty set $A$ , where $\operatorname { d } ( x , A )$ is the distance from $x$ to the set $A$ . Theorem 2.1 provides a lower bound on the mass in $A _ { \epsilon }$ .
+
+Theorem 2.1 (Concentration of Measure on the Unit Cube and the Unit Ball). Let $[ 0 , 1 ] ^ { d }$ denote the unit $d$ -cube and $B ^ { d }$ denote the Euclidean unit $d$ -ball, both equipped with uniform probability distributions. Let $\epsilon > 0$ . Then for any $A \subset [ 0 , 1 ] ^ { d }$ with $\mathbb { P } ( A ) \geq 1 / 2$ , we have:
+
+$$
+\begin{array} { r } { \mathbb { P } ( A _ { \epsilon } ) \geq \Phi ( \epsilon \sqrt { 2 \pi } + \Phi ^ { - 1 } ( \mathbb { P } ( A ) ) ) \geq 1 - e ^ { - \pi \epsilon ^ { 2 } } } \end{array}
+$$
+
+For any $B \subset B ^ { d }$ , with $\mathbb { P } ( B ) \ge 1 / 2$ ,
+
+$$
+\mathbb { P } ( B _ { \epsilon } ) \geq 1 - \frac { 1 } { \mathbb { P } ( B ) } ( 1 - \delta _ { \ell _ { 2 } } ( \epsilon ) ) ^ { 2 d } \geq 1 - \frac { 1 } { \mathbb { P } ( B ) } e ^ { - 2 d ( \frac { 2 - \sqrt { 3 } } { 3 } ) \epsilon ^ { 2 } }
+$$
+
+where $\begin{array} { r } { \delta _ { \ell _ { 2 } } ( \epsilon ) = 1 - \sqrt { 1 - \frac { \epsilon ^ { 2 } } { 4 } } } \end{array}$ and $\Phi$ is the standard normal cumulative distribution function.
+
+Based on Theorem 2.1 we can now show that under some circumstances, no algorithm that achieves can perfect clean accuracy can also achieve a good robust accuracy.
+
+Example 2 (Vulnerability Guarantee). Consider the joint distribution $\mathbb { P } ( x , y )$ , where the input data $x$ is uniformly distributed on $[ 0 , 1 ] ^ { d }$ and label $y$ has $I O$ classes. Further assume the marginal distribution of $y$ is also uniform3. Theorem 2.1 implies that under $\ell _ { 2 }$ adversarial attack with $\epsilon = 0 . 5$ , at least $94 \%$ of the samples are ether wrongly classified or can be successfully attacked for a classifier with perfect clean accuracy.
+
+Furthermore, if $d = 3 \times 3 2 \times 3 2$ , A parallel calculation for $\mathbb { P } ( x , y )$ on the $B ^ { d }$ domain gives: under $\ell _ { 2 }$ adversarial attack with $\epsilon = 0 . 0 9$ , at least $97 \%$ of the the samples are ether wrongly classified or can be successfully attacked for a classifier with perfect clean accuracy.
+
+On the one hand, Theorem 2.1 and Example 2 suggest that the uniform distribution on $[ 0 , 1 ] ^ { d }$ enjoys more robustness than the uniform distribution on ${ \bar { B } } ^ { d }$ , and it is not affected by the high dimensionality. This may partially explain why MNIST is more adversarially robust than CIFAR10, as the distribution of $x$ in CIFAR10 is “closer” to $B ^ { d }$ than to $[ 0 , 1 ] ^ { d }$ . On the other hand, while not completely sharp, they also suggest the intrinsic difficulty in achieving good robust accuracy.
+
+Note that one limit of Theorem 2.1 and Example 2 is the uniform distribution assumption, which is surely not true for natural images. Indeed, although rigorously developed, Theorem 2.1 and Example 2 do not explain certain empirical observations. Following Wong and Kolter (2018), we train a provably4 robust model on a binarized MNIST dataset (bMNIST) 5. Our experiments shows that the learned model achieves $3 . 0 0 \%$ provably robust error on bMNIST test data, while maintaining $9 7 . 6 5 \%$ clean accuracy. Details of this experiment in described in Appendix B.2.
+
+The above MNIST experiment and Example 2 suggest the essential role of the data distribution in achieving good robust and clean accuracies. While it is hard to completely answer the question what geometric properties differentiate the concentration rates between the ball/cube in high dimension and the distribution of bMNIST, we remark that one obvious difference is the distance distributions in both spaces. Could the distance distributions explain the differences in clean and robust accuracies? Note that the same method can only achieve $3 7 . 7 0 \%$ robust error on original MNIST data, and even higher error on CIFAR10, which further supports this hypothesis. In the rest of this paper, we further investigate the dependence of robust accuracy on the distribution of real data.
+
+# 3 ROBUSTNESS ON DATASETS VARIANTS WITH DIFFERENT INPUT DISTRIBUTIONS
+
+Section 2.2 clearly suggests that the data distribution plays an essential role in the achievable robust accuracy. In this section we carefully design a series of datasets and experiments to further study its influence. One important property of our new datasets is that they have different $\mathbb { P } ( x )$ ’s while keep $\mathbb { P } ( y | x )$ reasonably fixed, thus these datasets are only different in a “semantic-lossless” shift. Our experiments reveal an unexpected phenomenon that while standard learning methods manage to achieve stable clean accuracies across different data distributions under “semantic-lossless” shifts, however, adversarial training, arguably the most popular method to achieve robust models, loses this desirable property, in that its robust accuracy becomes unstable even under a “semantic-lossless” shift on the data distribution.
+
+We emphasize that different from preprocessing steps or transfer learning, here we treat the shifted data distribution as a new underlying distribution. We both train the models and test the robust accuracies on the same new distribution.
+
+# 3.1 SMOOTHING AND SATURATION
+
+We now explain how the new datasets are generated under “semantic-lossless” shifts. In general, MNIST has a more binary distribution of pixels, while CIFAR10 has a more continuous spectrum of pixel values, as shown in Figure 1a and 1b. To bridge the gap between these two datasets that have completely different robust accuracies, we propose two operations to modify their distribution on $x$ : smoothing and saturation, as described below. We apply different levels of “smoothing” on MNIST to create more CIFAR-like datasets, and different levels of “saturation” on CIFAR10 to create more “binary” ones. Note that we would like to maintain the semantic information of the original data, which means that such operations should be semantics-lossless and not arbitrarily wide.
+
+Smoothing is applied on MNIST images, to make images “less binary”. Given an image $x _ { i }$ , its smoothed version $\tilde { x _ { i } } ^ { ( s ) }$ is generated by first applying average filter of kernel size $s$ to $x _ { i }$ to generate an intermediate smooth image, and then take pixel-wise maximum between $x _ { i }$ and the intermediate smooth image. Our MNIST variants include the binarized MNIST and smoothed MNIST with different kernel sizes. As shown in Figure 1c, all MNIST variants still maintain the semantic information in MNIST, which indicates that $\mathbb { P } ( y | \tilde { x } ^ { ( s ) } )$ should be similar to $\mathbb { P } ( y \mid x )$ . It is thus reasonable to assume that $y _ { i }$ is approximately sampled from $\mathbb { P } ( y | \tilde { x } ^ { ( s ) } )$ , and as such we assign $y _ { i }$ as the label of $\tilde { x } ^ { ( s ) }$ . Note that all the data points in the binarized MNIST are on the corners of the unit cube. For the smoothed versions, pixels on the digit boundaries are pushed off the corner of the unit cube.
+
+Saturation of the image $x$ is denoted by ${ \widehat x } ^ { ( p ) }$ , and the procedure is defined as below:
+
+$$
+\widehat { x } ^ { ( p ) } = \mathrm { s i g n } ( 2 x - 1 ) \frac { | 2 x - 1 | ^ { \frac { 2 } { p } } } { 2 } + \frac { 1 } { 2 } ,
+$$
+
+where all the operations are pixel-wise and each element of ${ \widehat { x } } ^ { ( p ) }$ is guaranteed to be in $[ 0 , 1 ]$ . Saturabtion is used to generate variants of the CIFAR10 dataset with less centered pixel values. For different saturation level $p$ ’s, one can see from Figure 1d that ${ \widehat { x } } ^ { ( p ) }$ is still semantically similar to $x$ in the same classification task. Similarly we assign $y _ { i }$ bas the label of $\widehat { x } _ { i } ^ { \left( p \right) }$ . One immediate property about ${ \widehat { x } } ^ { ( p ) }$ is that it pushes $x$ b b to the corners of the data domain where the pixel values are either 0 or 1 when $p \geq 2$ , and pull the data to the center of 0.5 when $p \leq 2$ . When $p = 2$ it does not change the image, and when $p = \infty$ it becomes binarization.
+
+# 3.2 EXPERIMENTAL SETUPS
+
+In this section we use the smoothing and saturation operations to manipulate the data distributions of MNIST and CIFAR10, and show empirical results on how data distributions affects robust accuracies of neural networks trained on them. Since we are only concerned with the intrinsic robustness of neural networks models, we do not consider methods like preprocessing that tries to remove perturbations or randomizing inputs. We perform standard neural network training on clean data to measure the difficulty of the classification task, and projected gradient descent (PGD) based adversarial training (Madry et al., 2017) to measure the difficulty to achieve robustness.
+
+By default, we use LeNet5 on all the MNIST variants, and use wide residual networks (Zagoruyko and Komodakis, 2016) with widen factor 4 for all the CIFAR10 variants. Unless otherwise specified, PGD training on MNIST variants and CIFAR10 variants all follows the settings in Madry et al. (2017). Details of network structures and training hyperparameters can be found in Appendix B.
+
+We evaluate the classification performance using the test accuracy of standardly trained models on clean unperturbed examples, and the robustness using the robust accuracy of PGD trained model, which is the accuracy on adversarially perturbed examples. Although not directly indicating robustness, we report the clean accuracy on PGD trained models to indicate the tradeoff between being accurate and robust. To understand whether low robust accuracy is due to low clean accuracy or vulnerability of model, we also report robustness w.r.t. predictions, where the attack is used to perturb against the model’s clean prediction, instead of the true label. We use $\ell _ { \infty }$ untargeted PGD attacks (Madry et al., 2017) as our adversary, since it is the strongest attack in general based on our
+
+![](images/bdff08ab7f75546f666c0d5dd72181f21f812bab056c6513b74989ae66778845.jpg)
+
+![](images/8e69cad757f6d29249ead26c8f89fad34bdda9eb9af0a3ba8f126b832f552e99.jpg)
+
+(a) Pixel value histogram (log scale in y) of MNIST variants, from left to right: original, smoothed with kernel size 2, 3, 4, 5
+
+(b) Pixel value histogram (log scale in y) of CIFAR10 variants, from left to right: original, saturation level 4, 8, 16, 64
+
+![](images/e6e205f6ec39a237ce6137785cd2a766f729d86890f3f530c9ba43b1e3cb21f0.jpg)
+
+![](images/d6e0206a941c08bbdbb2d15db34af904fdad02c93198114b217864457999432d.jpg)
+
+(c) MNIST variants, from left to right: binarized, original, smoothed with kernel size 2, 3, 4, 5
+
+(d) CIFAR10 variants, from left to right, original, saturation level 4, 8, 16, 64, ∞
+
+![](images/dc060fe6eb669b1fea763bc3dad8f6c018e84a905fe9bbf97cd61ef1cb457c78.jpg)  
+Figure 1: Variants of smoothed MNIST and saturated CIFAR10 datasets.   
+Figure 2: Accuracy, Robust Accuracy and Robustness w.r.t. Predictions on different data variants
+
+experiments. Unless otherwise specified, PGD attacks on MNIST variants run with $\epsilon = 0 . 3$ , step size of 0.01 and 40 iterations, and runs with $\epsilon = 8 / 2 5 5$ , step size of $2 / 2 5 5$ and 10 iterations on CIFAR10 variants , same as in Madry et al. (2017). We use the PGD attack implementation from the AdverTorch toolbox (Ding et al., 2019).
+
+# 3.3 SENSITIVITY OF ROBUST ACCURACY TO DATA TRANSFORMATIONS
+
+Results on MNIST variants are presented in Figure $\cdot$ . The clean accuracy of standard training is very stable across different MNIST variants. This indicates that their classification tasks have similar difficulties, if the training has no robust considerations. When performing PGD adversarial training, clean accuracy drops only slightly. However, both robust accuracy and robustness w.r.t. predictions drop significantly. This indicates that as smooth level goes up, it is significantly harder to achieve robustness. Note that for binarized MNIST with adversarial training, the clean accuracy and the robust accuracy are almost the same. Indicating that getting high robust accuracy on binarized MNIST does not conflict with achieving high clean accuracy. This result conforms with results of provably robust model having high robustness on binarized MNIST described in Section 2.
+
+CIFAR10 result tell a similar story, as reported in Figure $\cdot$ . For standard training, the clean accuracy maintains almost at the original level until saturation level 16, despite that it is already perceptually very saturated. In contrast, PGD training has a different trend. Before level 16, the robust accuracy significantly increases from $4 3 . 2 \%$ until $7 9 . 7 \%$ , while the clean test accuracy drops only in a comparatively small range, from $8 5 . 4 \%$ to $8 0 . 0 \%$ . After level 16, PGD training has almost the same clean accuracy and robust accuracy. However, robustness w.r.t. predictions still keeps increasing, which again indicates the instability of the robustness. On the other hand, if the saturation level is smaller than 2, we get worse robust accuracy after PGD training, e.g. at saturation level 1 the robust accuracy is $3 3 . 0 \%$ . Simultaneously, the clean accuracy maintains almost the same.
+
+Note that after saturation level 64 the standard training accuracies starts to drop significantly. This is likely due to that high degree of saturation has caused “information loss” of the images. Models trained on highly saturated CIFAR10 are quite robust and the gap between robust accuracy and robustness w.r.t. predictions is due to lower clean accuracy. In contrast, In MNIST variants, the robustness w.r.t. predictions is always almost the same as robust accuracy, indicating that drops in robust accuracy is due to adversarial vulnerability.
+
+From these results, we can conclude that robust accuracy under PGD training is much more sensitive than clean accuracy under standard training to the differences in input data distribution. More importantly, a semantically-lossless shift on the data transformation, while not introducing any unexpected risk for the clean accuracy of standard training, can lead to large variations in robust accuracy. Such previously unnoticed sensitivity raised serious concerns in practice, as discussed in the next section.
+
+# 4 PRACTICAL IMPLICATIONS
+
+Given adversarial robustness’ sensitivity to input distribution, we further demonstrate two practical implications: 1) Robust accuracy could be sensitive to image acquisition condition and preprocessing. This leads to unreliable benchmarks in practice; 2) When introducing new dataset for benchmarking adversarial robustness, we need to carefully choose datasets with the right characteristics.
+
+# 4.1 ROBUST ACCURACY IS SENSITIVE TO GAMMA CORRECTION
+
+The natural images are acquired under different lighting conditions, with different cameras and different camera settings. They are usually preprocessed in different ways. All these factors could lead to mild shifts on the input distribution. Therefore, we might get very different performance measures when performing adversarial training on images taken under different conditions. In this section, we demonstrate this phenomenon on variants of CIFAR10 images under different gamma mappings. These variants are then used to represent image dataset acquired under different conditions. Gamma mapping is a simple element-wise operation that takes the original image $x$ , and output the gamma mapped image $\tilde { x } ^ { ( \gamma ) }$ by performing $\tilde { x } ^ { ( \gamma ) } = x ^ { \gamma }$ . Gamma mapping is commonly used to adjust the exposure of an images. We refer the readers to Szeliski (2010) on more details about gamma mappings. Figure 3a shows variants of the same image processed with different gamma values. Lower gamma value leads to brighter images and higher gamma values gives darker images, since pixel values range from 0 to 1. Despite the changes in brightness, the semantic information is preserved.
+
+We perform the same experiments as in the saturated CIFAR10 variants experiment in Section 3. The results are displayed in Figure 3a. Accuracies on clean data almost remain the same across different gamma values. However, under PGD training, both accuracy and robust accuracy varies largely following different gamma values.
+
+These results should raise practitioners’ attention on how to interpret robustness benchmark “values”. For the same adversarial training setting, the robustness measure might change drastically between image datasets with different “exposures”. In other words, if a training algorithm achieves good robustness on one image dataset, it doesn’t necessarily achieve similar robustness on another semantically-identical but slightly varied datasets. Therefore, the actual robustness could either be significantly underestimated or overestimated.
+
+This raises the questions on whether we are evaluating image classifier robustness in a reliable way, and how we choose benchmark settings that can match the real robustness requirements in practice. This is an important open question and we defer it to future research.
+
+# 4.2 CHOICE OF DATASETS FOR EVALUATING ROBUSTNESS
+
+As discussed, evaluating robustness on a suitable dataset is important. Here we use fashion-MNIST (fMNIST) (Xiao et al., 2017) and edge-fashion-MNIST (efMNIST) as examples to analyze characteristics of “harder” datasets. The edge-fashion MNIST is generated by running Canny edge detector (Canny, 1986) with $\sigma = 1$ on the fashion MNIST images. Figure 3b shows examples of fMNIST and efMNIST. We performed the same standard training and PGD training experiments on both fMNIST and efMNIST as we did on MNIST. Figure 3b shows the results. We can see that fMNIST exhibit similar behavior to CIFAR10, where the test accuracy is significantly affected by PGD training and the gap between robust accuracy and accuracy is large. On the other hand, efMNIST is closer to the binarized MNIST: the accuracy is affected very little by PGD training, along with an insignificant difference between robust accuracy and accuracy.
+
+Both fMNIST and efMNIST can be seen as a “harder” MNIST, but they are harder in different ways. One one hand, since efMNIST results from the edge detection run on fMNIST, it contains less information. It is therefore harder to achieve higher accuracy on efMNIST than on fMNIST, where richer semantics is accessible. However, fMNIST’s richer semantics makes it better resembles natural images’ pixel value distribution, which could lead to increased difficulty in achieving
+
+![](images/79911c1cc60ff1f9de0a1c058d92c0671e2624779ea9fdd352fb411c9ba3bdbb.jpg)
+
+![](images/fef9b258c3121a3c28ab87ecea5c13ba2e7a2a84333e0b6b48292a522c3cf213.jpg)  
+Figure 3: Illustrations on Practical Implications
+
+fMNIST: accuracy, standard training, $9 2 . 7 \%$ accuracy, PGD training, $8 1 . 2 \%$ robust accuracy, PGD training, $6 5 . 3 \%$   
+efMNIST: accuracy, standard training, $8 8 . 3 \%$ accuracy, PGD training, $8 7 . 2 \%$ robust accuracy, PGD training, $8 6 . 6 \%$
+
+(a) Top: Gamma mapped images from left to right 0.6, 0.8, 1.0 (original image), 1.2 , 1.4; Bottom: Robustness results on gamma mapped CIFAR10 variant
+
+(b) Top: Examples of fashion-MNIST images and edge-fashion-MNIST; bottom: Robustness results on fMNIST and efMNIST
+
+adversarial robustness. efMNIST, on the other hand, can be viewed as a set of “more complex binary symbols” compared to MNIST or binarized MNIST. It is harder to classify these more complex symbols. However, it is easy to achieve high robustness due to the binary pixel value distribution.
+
+To sum up, when introducing new dataset for adversarial robustness, we should not only look for a “harder” one, but we also need to consider whether the dataset is “harder in the right way”.
+
+# 5 ATTEMPTS TO UNDERSTAND THE PHENOMENON
+
+In this section, we make initial attempts to understand the sensitivity of adversarial robustness. We use CIFAR10 variants as the running example, but these analyses apply to MNIST variants as well. Saturation pushes pixel values towards 0 or 1, i.e. towards the corner of unit cube, which naturally suggests two potential factors for the change in robustness. 1) the “perturbable volume” decreases; 2) distances between data examples increases. Intuitively, both could be related to the increasd robustness. We analyze them and show that although they are correlated with robustness change, none of them can fully explain the observed phenomena. We then further examine the possibility of increasing robust accuracy on less robust datasets by having larger models and more data.
+
+# 5.1 ON THE INFLUENCE OF PERTURBABLE VOLUME
+
+Saturation moves the pixel values towards 0 and 1, therefore pushing the data points to the corners of the unit cube input domain. This makes the valid perturbation space to be smaller, since the space of perturbation is the intersection between the $\epsilon \mathrm { - } \ell _ { \infty }$ ball and the input domain. Due to high dimensionality, the volume of “perturbable region” changes drastically across different saturation levels. For example, the average log perturbable volume 7 of original CIFAR10 images are -12354, and the average log perturbable volume of $\infty$ -saturated CIFAR10 is -15342, which means that the perturbable volume differs by a factor of $2 ^ { 2 9 9 0 } = 2 ^ { ( - 1 2 3 5 2 - ( - 1 5 3 4 2 ) ) }$ . If the differences in perturbable volume is a key factor on the robustness’ sensitivity, then by allowing the attack to go beyond the domain boundary 8, the robust accuracies across different saturation levels should behave similarly again, or at least significantly differ from the case of box constrained attacks. We performed PGD attack allowing the perturbation to be outside of the data domain boundary, and compare the robust accuracy to what we get for normal PGD attack within domain boundary. We found that the expected difference is not observed, which serves as evidence that differences in perturbable volume are not causing the differences in robustness on the tested MNIST and CIFAR10 variants.
+
+# 5.2 ON THE INFLUENCE OF INTER-CLASS DISTANCE
+
+When saturation pushes data points towards data domain boundaries, the distances between data points increase too. Therefore, the margin, the distance from data point to the decision boundary, could also increase. We use the “inter-class distance” as an approximation. Inter-class distance 9 characterizes the distances between each class to rest of classes in each dataset. Intuitively, if the distances between classes are larger, then it should be easier to achieve robustness. We also observed (in Appendix D.2.1 Figure 5) that inter-class distances are positively correlated with robust accuracy. However, we also find counter examples where datasets having the same inter-class distance exhibit different robust accuracies. Specifically, We construct scaled variants of original MNIST and binarized MNIST, such that their inter-class distances are the same as smooth-3, smooth-4, smooth-5 MNIST. The scaling operation is defined as $\tilde { x } ^ { ( \alpha ) } = \alpha ( x - 0 . 5 ) + 0 . 5$ , where $\alpha$ is the scaling coefficient. When $\alpha < 1$ . each dimension of $x$ is pushed towards the center with the same rate. Table 1 shows the results. We can see that although having the same interclass distances, the smoothed MNIST is still less robust than the their correspondents of scaled binarized MNIST and original MNIST. This indicates the complexity of the problem, such that a simple measure like inter-class distance cannot fully characterize robustness property of datasets, at least on the variants of MNIST.
+
+Table 1: Different robust accuracies on datasets with same inter-class distances   
+
+<table><tr><td>INTER-CLASS DISTANCES</td><td>SMOOTH LEVEL OF SMOOTHED MNIST</td><td>RESILIENCE OF SMOOTHED MNIST</td><td>SCALE FACTOR OF SCALED ORIGINAL MNIST</td><td>RESILIENCE OF SCALED ORIGINAL MNIST</td><td>SCALE FACTOR OF SCALED BINARIZED MNIST</td><td>RESILIENCE OF SCALED BINARIZED MNIST</td></tr><tr><td>7.12</td><td>3</td><td>91.3 %</td><td>0.970</td><td>94.6 %</td><td>0.821</td><td>98.6%</td></tr><tr><td>7.01</td><td>4</td><td>90.3 %</td><td>0.955</td><td>95.5%</td><td>0.809</td><td>98.6%</td></tr><tr><td>6.85</td><td>5</td><td>89.6%</td><td>0.932</td><td>94.9 %</td><td>0.790</td><td>98.5%</td></tr></table>
+
+# 5.3 ON THE REQUIRED MODEL CAPACITY AND SAMPLE COMPLEXITY
+
+In practice, it is unclear how far robust accuracy of PGD trained model is from adversarial Bayes error $R R ^ { * }$ for the given data distribution. In the case $R R ^ { * }$ is not yet achieved, there is a nonexhaustive list that we can improve upon: 1) use better training/learning algorithms; 2) increase the model capacity; 3) train on more data. Finding a better learning algorithm is beyond the scope of this paper. Here we inspect 2) and 3) to see if it is possible to improve robustness by having larger model and more data. For model capacity, we use differently sized LeNet5 by multiplying the number of channels at each layer with different widen factors. These factors include 0.125, 0.25, 0.5, 1, 2, 4. On CIFAR10 variants, we use WideResNet with widen factors 0.25, 1 and 4. For sample complexity, we follow the practice in Section 3 except that we use a weight decay value of 0.002 to prevent overfitting. For both MNIST and CIFAR10, we test on 1000, 3000, 9000, 27000 and entire training set. Both model capacity and sample complexity results are shown in Figure 4.
+
+For MNIST, both training and test accuracies of clean training are invariant to model sizes, even we only use a model with widen factor 0.125. In slight contrast, both the training and test accuracy of PGD training increase as the model capacity increases, but it plateaus after widen factor 1 at an almost $100 \%$ accuracy. For robust accuracy, training robust accuracy kept increasing as model gets larger until the value is close to $100 \%$ . However, test robust accuracy stops increasing after widen factor 1, additional model capacity leads to larger (robust) generalization gap. When we vary the size of training set, the model can always fit the training set well to almost $100 \%$ clean training accuracy under standard training. The clean test accuracy grows as the training set size get larger. Training set size has more significant impact on robust accuracies of PGD trained models. For most MNIST variants except for binarized MNIST, training robust accuracy gradually drops, and test robust accuracy gradually increases as the training set size increases. This shows that when training set size is small, PGD training overfits to the training set. As training set gets larger, the generalization gap becomes smaller. Both training and test robust accuracies plateau after training set size reaches 27000. Indicating that increasing the training set size might not help in this setting. In conclusion, for MNIST variants, increasing training set size and model capacity does not seem to help beyond a certain point. Therefore, it is not obvious on how to improve robustness on MNIST variants with higher smoothing levels.
+
+CIFAR10 variants exhibit similar trends in general. One notable difference is that for PGD training, the training robust accuracy does not plateau as model size increases. However the test robust accuracy plateaus after widen factor 1. Also when training set size increases, the training robust accuracy drops and test robust accuracy increases with no plateau present. These together suggest that having more training data and training a larger model could potentially improve the robust accuracies on CIFAR10 variants. One interesting phenomenon is that binarized MNIST and $\infty$ -saturated CIFAR10 has different sample complexity property, despite both being “cornered” datasets. This indicates that the although binarization can largely influence robustness, it does not decide every aspect of it, such as sample complexity. This complex interaction between the classification task and input data distribution is still to be understood further.
+
+![](images/835b9a14d017696db04701d201e02b222dc5738011e15eb478fc905c8dd4b2da.jpg)  
+Figure 4: Model capacity and training set size’s influences on accuracy and robust accuracy. In each subfigure, the top row contains accuracy and robust accuracy measured on training set, the bottom row contains results measured on test set.
+
+# 6 CONCLUSION
+
+In this paper we provided theoretical analyses to show the significance of input data distribution in adversarial robustness, which further motivated our systematic experiments on MNIST and CIFAR10 variants. We discovered that, counter-intuitively, robustness of adversarial trained models are sensitive to semantically-preserving transformations on data. We demonstrated the practical implications of our finding that the existence of such sensitivity questions the reliability in evaluating robust learning algorithms on particular datasets. Finally, we made initial attempts to understand this sensitivity.
+
+Acknowledgement We thank Marcus Brubaker for many helpful discussions. We also thank Junfeng Wen and Avishek (Joey) Bose for useful feedbacks on early drafts of the paper.
+
+REFERENCES   
+Athalye, A., Carlini, N., and Wagner, D. (2018). Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In International Conference on Machine Learning, pages 274–283.   
+Athalye, A., Engstrom, L., Ilyas, A., and Kwok, K. (2017). Synthesizing robust adversarial examples. arXiv preprint arXiv:1707.07397.   
+Ball, K. (1997). An elementary introduction to modern convex geometry. Flavors of geometry, 31:1–58.   
+Biggio, B., Corona, I., Maiorca, D., Nelson, B., Šrndic, N., Laskov, P., Giacinto, G., and Roli, F. ´ (2013). Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pages 387–402. Springer.   
+Canny, J. (1986). A computational approach to edge detection. IEEE Transactions on pattern analysis and machine intelligence, (6):679–698.   
+Carlini, N. and Wagner, D. (2016). Defensive distillation is not robust to adversarial examples. arXiv preprint arXiv:1607.04311.   
+Carlini, N. and Wagner, D. (2017). Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pages 39–57. IEEE.   
+Ding, G. W., Wang, L., and Jin, X. (2019). AdverTorch v0.1: An adversarial robustness toolbox based on pytorch. arXiv preprint arXiv:1902.07623.   
+Erraqabi, A., Baratin, A., Bengio, Y., and Lacoste-Julien, S. (2018). A3t: Adversarially augmented adversarial training. arXiv preprint arXiv:1801.04055.   
+Fawzi, A., Fawzi, O., and Frossard, P. (2015). Analysis of classifiers’ robustness to adversarial perturbations. arXiv preprint arXiv:1502.02590.   
+Gastaldi, X. (2017). Shake-shake regularization. arXiv preprint arXiv:1705.07485.   
+Gilmer, J., Metz, L., Faghri, F., Schoenholz, S. S., Raghu, M., Wattenberg, M., and Goodfellow, I. (2018). Adversarial spheres. arXiv preprint arXiv:1801.02774.   
+Goodfellow, I. J., Shlens, J., and Szegedy, C. (2014). Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572.   
+Huang, R., Xu, B., Schuurmans, D., and Szepesvári, C. (2015). Learning with a strong adversary. arXiv preprint arXiv:1511.03034.   
+Kingma, D. P. and Ba, J. (2014). Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.   
+Kurakin, A., Goodfellow, I., and Bengio, S. (2016). Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236.   
+Ledoux, M. (2005). The concentration of measure phenomenon. Number 89. American Mathematical Soc.   
+Madry, A., Makelov, A., Schmidt, L., Tsipras, D., and Vladu, A. (2017). Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083.   
+Moosavi-Dezfooli, S.-M., Fawzi, A., and Frossard, P. (2016). Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2574–2582.   
+Raghunathan, A., Steinhardt, J., and Liang, P. (2018). Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344.   
+Schmidt, L., Santurkar, S., Tsipras, D., Talwar, K., and M ˛adry, A. (2018). Adversarially robust generalization requires more data. arXiv preprint arXiv:1804.11285.   
+Sinha, A., Namkoong, H., and Duchi, J. (2017). Certifiable distributional robustness with principled adversarial training. arXiv preprint arXiv:1710.10571.   
+Szegedy, C., Zaremba, W., Sutskever, I., Bruna, J., Erhan, D., Goodfellow, I., and Fergus, R. (2013). Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199.   
+Szeliski, R. (2010). Computer vision: algorithms and applications. Springer Science & Business Media.   
+Tsipras, D., Santurkar, S., Engstrom, L., Turner, A., and Madry, A. (2019). Robustness may be at odds with accuracy. In International Conference on Learning Representations.   
+Warde-Farley, D. and Goodfellow, I. (2016). 11 adversarial perturbations of deep neural networks. page 311.   
+Wong, E. and Kolter, Z. (2018). Provable defenses against adversarial examples via the convex outer adversarial polytope. In International Conference on Machine Learning, pages 5283–5292.   
+Xiao, H., Rasul, K., and Vollgraf, R. (2017). Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747.   
+Xu, H., Caramanis, C., and Mannor, S. (2009). Robustness and regularization of support vector machines. Journal of Machine Learning Research, 10(Jul):1485–1510.   
+Zagoruyko, S. and Komodakis, N. (2016). Wide residual networks. arXiv preprint arXiv:1605.07146.
+
+# Appendix
+
+A PROOFS
+
+A.1 PROOF FOR EXAMPLE 1
+
+Proposition A.1 (Existence of Non-Adversarially Robust Decision Boundary). Let x be uniformly distributed on $[ 0 , 1 ] ^ { d }$ and $y = 1$ , for all $x$ such that $x ^ { \top } I > \frac { d } { 2 }$ and $y = 0$ otherwise. Consider adversarial attack under budget $\| \delta \| _ { \infty } < \epsilon$ . Then for zero-one loss $L$ :
+
+$$
+R R ^ { * } = \mathbb { E } _ { \mathbb { P } ( x , y ) } \operatorname* { m a x } _ { \| \delta \| _ { \infty } < \epsilon } L ( Y ; h ^ { * } ( x + \delta ) ) \ge 1 - \frac { 1 } { 4 d \epsilon ^ { 2 } }
+$$
+
+Proof. The argument is well-known in concentration of measure. We provide here for the sake of completeness and adapt it to the context. The hyperplane $\begin{array} { r } { H P _ { 2 } = \{ x \in [ 0 , 1 ] ^ { d } : X ^ { \top } \mathbf { 1 } = \frac { d } { 2 } \} } \end{array}$ defines the decision boundary. We first compute the orthogonal distance of a given point $y =$ $( y _ { 1 } , y _ { 2 } , \cdot \cdot \cdot , y _ { d } ) = ( x _ { 1 } + \delta _ { 1 } , x _ { 2 } + \delta _ { 2 } , \cdot \cdot \cdot , x _ { d } + \delta _ { d } )$ to $H P _ { 2 }$ . The point $y$ is the perturbed point within budget $\| \delta \| _ { \infty } < \epsilon$ . The vector 1 is orthogonal to $H P _ { 2 }$ . Pick any point $x \ \in \ H P _ { 2 }$ , the orthogonal distance from $y$ to $H P _ { 2 }$ is:
+
+$$
+\begin{array} { r l } & { \ell _ { 2 } ( y , H P _ { 2 } ) = \| P r o j _ { \mathbf { 1 } } ( y - x ) \| = \| \mathbf { 1 } \frac { \left( y - x \right) ^ { \top } \mathbf { 1 } } { \mathbf { 1 } ^ { \top } \mathbf { 1 } } \| } \\ & { \qquad = | \frac { y ^ { \top } \mathbf { 1 } - x ^ { \top } \mathbf { 1 } } { \| \mathbf { 1 } \| } | } \\ & { \qquad = | \frac { \delta ^ { \top } \mathbf { 1 } } { \| \mathbf { 1 } \| } | } \\ & { \qquad = | \frac { y ^ { \top } \mathbf { 1 } } { \| \mathbf { 1 } \| } | } \\ & { \qquad = | \frac { y ^ { \top } \mathbf { 1 } - \frac { d } { 2 } } { \sqrt { d } } | } \end{array}
+$$
+
+The last two equations show that the $\ell _ { 2 }$ distance under an $\ell _ { \infty }$ attack can grow at the rate of $\epsilon \sqrt { d }$ , for this particular hyperplane $H P _ { 2 }$ .
+
+Now we take the expectation over $[ 0 , 1 ] ^ { d }$ , and note that expectation of the uniform distribution over a product space $[ 0 , \dot { 1 } ] ^ { d }$ is the same as taking expectation on each dimension (Fubini’s theorem), picking each random variable coordinatewise uniformly from $[ 0 , 1 ]$ .
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ \ell _ { 2 } ^ { 2 } ( y , H P _ { 2 } ) ] = \mathbb { E } [ ( \frac { y ^ { \top } \mathbf { 1 } - \frac { d } { 2 } } { d } ) ^ { 2 } ] = \frac { 1 } { d } \mathbb { E } [ ( \sum _ { i = 1 } ^ { d } y _ { i } - \frac { d } { 2 } ) ^ { 2 } ] } \\ & { \qquad = \frac { 1 } { d } \mathbb { V } [ \sum _ { i = 1 } ^ { d } y _ { i } ] = \frac { 1 } { d } \sum _ { i = 1 } ^ { d } \mathbb { V } [ y _ { i } ] = \frac { 1 } { 4 } } \end{array}
+$$
+
+Then we apply Markov’s inequality, for all real number $t > 0$ :
+
+$$
+\mathbb { P } ( \ell _ { 2 } ( x , H ) \geq \sqrt { t } ) = \mathbb { P } ( \ell _ { 2 } ( x , H ) ^ { 2 } \geq t ) \leq \frac { 1 } { 4 t }
+$$
+
+Finally, we observe that the longest (in terms of $\ell _ { 2 }$ norm) such √ $\epsilon \ell _ { \infty }$ attacks vector to $H P _ { 2 }$ are parallel to the normal vector 1 to $H P _ { 2 }$ . They have $\ell _ { 2 }$ distance $\epsilon \sqrt { d }$ . The set these attacks cover is characterized by $\{ x \in [ 0 , 1 ] ^ { d } : \ell _ { \infty } ( x , H ) \leq \epsilon \} = \{ x \in [ 0 , 1 ] ^ { d } : \ell _ { 2 } ( x , H ) \leq \epsilon { \sqrt { d } } \} .$
+
+Let $t = \epsilon ^ { 2 } d$ , we have:
+
+$$
+\mathbb { P } ( \ell _ { 2 } ( x , H ) \ge \sqrt { t } ) = \mathbb { P } ( \ell _ { 2 } ( x , H ) ^ { 2 } \ge t ) \le \frac { 1 } { 4 t } = \frac { 1 } { 4 \epsilon ^ { 2 } d }
+$$
+
+In the case of zero-one loss, $\begin{array} { r } { R R ^ { * } = \mathbb { P } ( \ell _ { 2 } ( x , H ) \le \epsilon \sqrt { d } ) \ge 1 - \frac { 1 } { 4 \epsilon ^ { 2 } d } . } \end{array}$
+
+# A.2 PROOF FOR THEOREM 2.1
+
+Proof. (First Inequality for Cube) The proof here follows that of Ledoux (2005), but we track of the tight constants so as to give tighter adversarial robustness calculations.
+
+Let $\Phi$ be one dimensional standard normal cumulative distribution function and let $\mu _ { d }$ denote $d$ dimensional Gaussian measures. Consider the map $T : \mathbb { R } ^ { d } \longrightarrow ( 0 , 1 ) ^ { d }$ :
+
+$$
+T ( x _ { 1 } , \cdot \cdot \cdot , x _ { d } ) = ( \Phi ( x _ { 1 } ) , \cdot \cdot \cdot , \Phi ( x _ { d } ) )
+$$
+
+$T$ pushes forward $\mu _ { d }$ defined on $\mathbb { R } ^ { d }$ into a probability measure $\mathbb { P }$ on $( 0 , 1 ) ^ { d }$ :
+
+$$
+\mathbb { P } ( A ) = \mu _ { d } ( T ^ { - 1 } ( A ) )
+$$
+
+for $A \ \subset \ ( 0 , 1 ) ^ { d }$ . Next we have the following Gaussian isoperimetric/concentration inequality (Ledoux, 2005):
+
+$$
+\mu _ { d } ( B _ { \epsilon } ) \geq \Phi ( \Phi ^ { - 1 } ( \mu _ { d } ( B ) ) + \epsilon )
+$$
+
+for all $B \subset \mathbb { R } ^ { d }$ measureable.
+
+Now for $A \subset ( 0 , 1 ) ^ { d }$ , we have:
+
+$$
+\begin{array} { r } { \mathbb { P } ( A _ { \epsilon } ) = \mu _ { d } ( T ^ { - 1 } ( A _ { \epsilon } ) ) \geq \mu _ { d } ( T ^ { - 1 } ( A ) _ { \epsilon \sqrt { 2 \pi } } ) \geq \Phi ( \Phi ^ { - 1 } ( \mu _ { d } ( T ^ { - 1 } ( A ) ) + \sqrt { 2 \pi } \epsilon ) ) } \end{array}
+$$
+
+where the first inequality follows from that $T$ has Lipschitz constant √12π , and thus T −1 has Lipschitz constant $\sqrt { 2 \pi }$ ; and the second one follows from Gaussian isoperimetric inequality.
+
+When $\mathbb { P } ( A ) \geq 1 / 2$ ,
+
+$$
+\Phi ( \Phi ^ { - 1 } ( \mu _ { d } ( T ^ { - 1 } ( A ) ) + { \sqrt { 2 \pi } } \epsilon ) ) \geq \Phi ( \Phi ^ { - 1 } ( { \sqrt { 2 \pi } } \epsilon ) )
+$$
+
+Additionally, the inequality $\Phi ( x ) \geq 1 - e ^ { \frac { x ^ { 2 } } { 2 } }$ implies the last inequality in the theorem.
+
+# (Second Inequality for Ball)
+
+We first define the notion of modulus of convexity for a normed space, in this case $\ell _ { 2 }$ :
+
+$$
+\begin{array} { l } { \displaystyle \delta _ { \ell _ { 2 } } ( \epsilon ) = \operatorname* { i n f } \{ 1 - \| \frac { x + y } { 2 } \| : \| x \| = \| y \| = 1 , \| x - y \| \ge \epsilon \} } \\ { \displaystyle = 1 - \sqrt { 1 - \frac { \epsilon ^ { 2 } } { 4 } } } \end{array}
+$$
+
+The important property about $\delta _ { \ell _ { 2 } } ( \epsilon )$ is that there is a constant $C$ such that:
+
+$$
+\delta _ { \ell _ { 2 } } ( \epsilon ) \geq C \epsilon ^ { 2 }
+$$
+
+By elementary algebraic calculuation, We can take C = 2− 33 .
+
+By Equation (2.25) in (Ledoux, 2005),
+
+$$
+\mathbb { P } ( A _ { \epsilon } ) \geq 1 - \frac { 1 } { \mathbb { P } ( B ) } ( 1 - \delta _ { \ell _ { 2 } } ( \epsilon ) ) ^ { 2 d } \geq 1 - \frac { 1 } { \mathbb { P } ( A ) } e ^ { - 2 d \delta _ { \ell _ { 2 } } ( \epsilon ) } = 1 - \frac { 1 } { \mathbb { P } ( A ) } e ^ { - 2 d ( \frac { 2 - \sqrt { 3 } } { 3 } ) \epsilon ^ { 2 } }
+$$
+
+# B DETAILED SETTINGS FOR TRAINING
+
+# B.1 DETAILED SETTINGS OF ADVERSARIAL TRAINING
+
+The LeNet5 (widen factor 1) is composed of 32-channel conv filter $\mathbf { \Sigma } + \operatorname { R e L U } + \operatorname { s i z e } 2 \operatorname* { m a x } { \mathrm { p o o l i n g } } +$ 64-channel conv filter $^ +$ ReLU $^ +$ size 2 max pooling $^ +$ fc layer with 1024 units $+ { \mathrm { R e L U } } +$ fc layer with 10 output classes. We do not preprocess MNIST images before feeding into the model.
+
+For training LeNet5 on MNIST variants, we use the Adam optimizer with an initial learning rate of 0.0001 and train for 100000 steps with batch size 50.
+
+Table 2: Performance and Robustness of models trained on MNIST variants.   
+
+<table><tr><td></td><td>STANDARD TRAINING</td><td colspan="3">PGD TRAINING</td></tr><tr><td>MNIST VARIANTS</td><td>TEST ACC</td><td>TEST ACC</td><td>ROBUST ACCURACY ∈=0.3</td><td>ROBUSTNESS W.R.T. PREDICTIONS ∈=0.3</td></tr><tr><td></td><td></td><td></td><td>98.1%</td><td></td></tr><tr><td>BINARIZED ORIGINAL</td><td>98.5% 99.3%</td><td>98.9 % 99.2 %</td><td>95.1%</td><td>98.5% 95.1%</td></tr><tr><td>SMOOTH 2</td><td></td><td></td><td>93.0%</td><td></td></tr><tr><td>SMOOTH3</td><td>99.3% 99.2%</td><td>98.9% 99.0%</td><td>91.3 %</td><td>93.1%</td></tr><tr><td>SMOOTH 4</td><td>99.1 %</td><td>98.8%</td><td>90.3%</td><td>91.4 %</td></tr><tr><td></td><td></td><td>98.7%</td><td>89.6%</td><td>90.4 %</td></tr><tr><td>SMOOTH5 SMOOTH 6</td><td>99.0% 99.1%</td><td>98.5%</td><td>87.6%</td><td>89.7%</td></tr><tr><td>SMOOTH7</td><td>99.0%</td><td>98.3%</td><td>85.4 %</td><td>87.7% 85.5%</td></tr><tr><td>SMOOTH8</td><td>99.0%</td><td>97.9%</td><td>83.1%</td><td>83.3%</td></tr></table>
+
+Table 3: Performance and Robustness of models trained on CIFAR10 variants.   
+
+<table><tr><td></td><td>STANDARD TRAINING</td><td colspan="3">PGD TRAINING</td></tr><tr><td>CIFAR10 VARIANTS</td><td>TEST ACC</td><td>TEST ACC</td><td>ROBUST ACCURACY ∈=8/255</td><td>ROBUSTNESS W.R.T. PREDICTIONS e=8/255</td></tr><tr><td>SATURATE 1</td><td>93.8%</td><td>77.5%</td><td>33.0%</td><td>33.6%</td></tr><tr><td>SATURATE 1.5</td><td>94.7 %</td><td>83.7%</td><td>38.7%</td><td>39.1%</td></tr><tr><td>SATURATE 1.75</td><td>95.2%</td><td>84.9%</td><td>41.1 %</td><td>41.5 %</td></tr><tr><td>ORIGINAL</td><td>95.0%</td><td>85.4%</td><td>43.2 %</td><td>43.6%</td></tr><tr><td>SATURATE 2.25</td><td>94.8 %</td><td>85.4%</td><td>44.4 %</td><td>44.9 %</td></tr><tr><td>SATURATE 2.5</td><td>94.8%</td><td>84.8 %</td><td>46.4 %</td><td>47.0 %</td></tr><tr><td>SATURATE3</td><td>94.5%</td><td>82.9%</td><td>51.7%</td><td>52.9 %</td></tr><tr><td>SATURATE 4</td><td>93.8%</td><td>80.4%</td><td>64.0%</td><td>68.7%</td></tr><tr><td>SATURATE8</td><td>93.3%</td><td>80.4%</td><td>78.1%</td><td>93.8%</td></tr><tr><td>SATURATE 16</td><td>92.9 %</td><td>79.9 %</td><td>79.4 %</td><td>98.4%</td></tr><tr><td>SATURATE 64</td><td>89.6%</td><td>79.5 %</td><td>79.3%</td><td>99.1 %</td></tr><tr><td>SATURATE 128</td><td>85.3%</td><td>80.2%</td><td>79.9%</td><td>99.1%</td></tr><tr><td>SATURATE 256</td><td>83.0%</td><td>80.0%</td><td>79.7%</td><td>99.2 %</td></tr><tr><td>SATURATE INF</td><td>80.3%</td><td>80.0%</td><td>79.7%</td><td>99.2%</td></tr></table>
+
+We use the WideResNet-28-4 as described in Zagoruyko and Komodakis (2016) for our experiments, where 28 is the depth and 4 is the widen factor. We use “per image standardization” 10 to preprocess CIFAR10 images, following Madry et al. (2017).
+
+For training WideResNet on CIFAR10 variants, we use stochastic gradient descent with momentum 0.9 and weight decay 0.0002. We train 80000 steps in total with batch size 128. The learning rate is set to 0.1 at step 0, 0.01 at step 40000, and 0.001 at step 60000.
+
+We performed manual hyperparameter search for our initial experiment and do not observe improvements over the above settings. Therefore we used these settings throughout the all the experiments in the paper unless otherwise indicated.
+
+# B.2 LP ROBUST MODEL DESCRIBED IN SECTION 2
+
+For the linear programming based provably robust model (Wong and Kolter, 2018) (LP-robust model). We trained a ConvNet identical to the one in the original paper. It has 2 convolutional layers, with 16 and 32 channels, each with a stride of 2; and 2 fully connected layers, the first one maps the flattened convolution features to hidden dimension 100, the second maps to 10 logit units. We use ReLUs as the nonlinear activation and there is no max pooling in the network.
+
+We train for 100 epochs with batch size 50. The first 50 epochs are warm start epochs where epsilon increases from 0.01 to 0.3 linearly. We use Adam optimizer (Kingma and Ba, 2014) with a constant learning rate of 0.001.
+
+# C DETAILED EXPERIMENTAL RESULTS
+
+We listed exact numbers of experiments involved in the main body in Table 2, 3, 4 and 5.
+
+Table 4: Performance and robustness of different sized LeNet5 models on MNIST variants   
+
+<table><tr><td colspan="10">STANDARD TRAINING,ACCURACY</td><td colspan="3">TEST SET</td></tr><tr><td>WIDEN FACTOR 0.125</td><td>0.25</td><td></td><td>0.5</td><td>1</td><td>2</td><td>4</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>4</td></tr><tr><td></td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>99.6%</td><td>100.0%</td><td>100.0%</td><td>98.7%</td><td>99.0%</td><td>99.2%</td><td>98.5%</td><td>99.4%</td><td>99.2%</td></tr><tr><td>BINARIZED ORIGINAL</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.8%</td><td>99.2%</td><td>99.2%</td><td>99.3%</td><td>99.4%</td><td>99.3%</td></tr><tr><td>SMOOTH 2</td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.8%</td><td>99.0%</td><td>99.1%</td><td>99.3%</td><td>99.3%</td><td>99.4%</td></tr><tr><td>SMOOTH 3</td><td>99.9%</td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.8%</td><td>98.8%</td><td>99.2%</td><td>99.2%</td><td>99.1%</td><td>99.3%</td></tr><tr><td>SMOOTH 4</td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.7%</td><td>99.0%</td><td>99.0%</td><td>99.1%</td><td>99.4%</td><td>99.4%</td></tr><tr><td>SMOOTH 5</td><td>99.8%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.5%</td><td>99.0%</td><td>99.2%</td><td>99.0%</td><td>99.3%</td><td>99.3%</td></tr><tr><td>SMOOTH 6</td><td>99.8%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.4%</td><td>98.9%</td><td>99.0%</td><td>99.1%</td><td>99.2%</td><td>99.3%</td></tr><tr><td>SMOOTH7</td><td>99.8%</td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.5%</td><td>98.8%</td><td>99.0%</td><td>99.0%</td><td>99.3%</td><td>99.3%</td></tr><tr><td>SMOOTH8</td><td>99.7%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>98.4%</td><td>98.9%</td><td>98.9%</td><td>99.0%</td><td>99.2%</td><td>99.0%</td></tr><tr><td></td><td></td><td colspan="9"></td><td></td></tr><tr><td>TRAINING SET</td><td colspan="4"></td><td colspan="3">PGD TRAINING,ACCURACY</td><td colspan="4">TEST SET</td></tr><tr><td>WIDEN FACTOR</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>4</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>4</td></tr><tr><td>BINARIZED</td><td>97.8%</td><td>99.6%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>97.4%</td><td>98.3%</td><td>98.8%</td><td>98.9%</td><td>99.0%</td><td>99.2%</td></tr><tr><td>ORIGINAL</td><td>97.0%</td><td>98.4%</td><td>99.8%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>97.0%</td><td>98.2%</td><td>98.9%</td><td>99.2%</td><td>99.1%</td><td>99.2%</td></tr><tr><td>SMOOTH 2</td><td>96.1%</td><td>98.1%</td><td>99.0%</td><td>99.9%</td><td>100.0%</td><td>100.0%</td><td>96.1%</td><td>97.8%</td><td>98.5%</td><td>98.9%</td><td>99.0%</td><td>99.0%</td></tr><tr><td>SMOOTH 3</td><td>96.3%</td><td>97.8%</td><td>98.9%</td><td>99.7%</td><td>99.9%</td><td>100.0%</td><td>96.5%</td><td>97.6%</td><td>98.6%</td><td>99.0%</td><td>99.1%</td><td>99.1%</td></tr><tr><td>SMOOTH 4</td><td>95.3%</td><td>97.3%</td><td>98.5%</td><td>99.5%</td><td>99.8%</td><td>99.9%</td><td>95.4%</td><td>97.2%</td><td>98.1%</td><td>98.8%</td><td>99.0%</td><td>99.0%</td></tr><tr><td>SMOOTH 5</td><td>94.9%</td><td>96.5%</td><td>98.0%</td><td>99.3%</td><td>99.6%</td><td>99.8%</td><td>95.0%</td><td>96.5%</td><td>97.9%</td><td>98.7%</td><td>98.9%</td><td>98.9%</td></tr><tr><td>SMOOTH 6</td><td>93.2% 91.9%</td><td>95.6%</td><td>97.4%</td><td>99.0%</td><td>99.5%</td><td>99.7%</td><td>93.5%</td><td>95.7%</td><td>97.1%</td><td>98.5%</td><td>98.7%</td><td>98.7%</td></tr><tr><td>SMOOTH 7 SMOOTH8</td><td>89.4%</td><td>95.0% 94.2%</td><td>97.5%</td><td>98.7% 98.4%</td><td>99.2%</td><td>99.4%</td><td>92.4%</td><td>95.2% 94.4%</td><td>97.2%</td><td>98.3% 97.9%</td><td>98.5% 98.2%</td><td>98.7% 98.4%</td></tr><tr><td></td><td></td><td>96.5%</td><td></td><td>99.0%</td><td>99.3%</td><td>89.7%</td><td></td><td>96.4%</td><td></td><td></td><td></td><td></td></tr><tr><td colspan="9">PGD TRAINING,ROBUST ACCURACY TRAINING SET</td><td colspan="4"></td></tr><tr><td>WIDEN FACTOR 0.125</td><td></td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>4</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>4</td></tr><tr><td>BINARIZED</td><td>95.2%</td><td>98.5%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>94.5%</td><td>96.5%</td><td>98.0%</td><td>98.1%</td><td>98.0%</td><td>98.0%</td></tr><tr><td>ORIGINAL</td><td>86.9%</td><td>90.8%</td><td>97.9%</td><td>99.3%</td><td>99.6%</td><td>99.8%</td><td>87.1%</td><td>89.9%</td><td>95.2%</td><td>95.1%</td><td>94.8%</td><td>94.9%</td></tr><tr><td>SMOOTH 2</td><td>80.5%</td><td>87.6%</td><td>90.9%</td><td>98.0%</td><td>99.1%</td><td>99.5%</td><td>81.2%</td><td>87.0%</td><td>88.7%</td><td>93.0%</td><td>92.3%</td><td>92.1%</td></tr><tr><td>SMOOTH 3</td><td>75.2%</td><td>82.0%</td><td>90.3%</td><td>95.5%</td><td>97.8%</td><td>98.7%</td><td>75.7%</td><td>81.5%</td><td>88.5%</td><td>91.3%</td><td>91.6%</td><td>90.8%</td></tr><tr><td>SMOOTH 4</td><td>71.9%</td><td>77.6%</td><td>87.5%</td><td>93.9%</td><td>96.8%</td><td>97.9%</td><td>72.7%</td><td>77.7%</td><td>86.3%</td><td>90.3%</td><td>90.6%</td><td>90.0%</td></tr><tr><td>SMOOTH5</td><td>65.7%</td><td>77.1%</td><td>85.7%</td><td>92.5%</td><td>94.6%</td><td>95.0%</td><td>66.2%</td><td>77.1%</td><td>85.1%</td><td>89.6%</td><td>89.8%</td><td>88.4%</td></tr><tr><td>SMOOTH 6</td><td>58.0%</td><td>71.5%</td><td>80.5%</td><td>90.6%</td><td>93.1%</td><td>93.8%</td><td>59.3%</td><td>72.0%</td><td>80.2%</td><td>87.6%</td><td>88.0%</td><td>87.2%</td></tr><tr><td>SMOOTH7</td><td>61.7%</td><td>74.2%</td><td>83.3%</td><td>87.6%</td><td>90.5%</td><td>92.6%</td><td>62.8%</td><td>75.3%</td><td>83.0%</td><td>85.4%</td><td>86.7%</td><td>87.8%</td></tr><tr><td>SMOOTH 8</td><td>70.3%</td><td>72.4%</td><td>80.3%</td><td>85.3%</td><td>90.5%</td><td>88.7%</td><td>71.7%</td><td>73.2%</td><td>80.3%</td><td>83.1%</td><td>86.9%</td><td>83.8%</td></tr></table>
+
+# D DETAILED ANALYSES
+
+# D.1 DETAILED ANALYSIS OF EFFECTS OF DATA DOMAIN BOUNDARY
+
+One natural hypothesis about the reason of achieving better robustness could be that it is the effect of the boundaries. Indeed, if the data distribution is closer to the data domain boundary, the valid perturbation space, the $\epsilon \mathrm { - } \ell _ { \infty }$ ball may be restricted since it will intersect with the boundary. We then test the correlation between “how close the data distribution is to the boundary” and its achievable robustness, by examining the volume of the allowed perturbed box across different datasets.
+
+The intersection of the data domain, unit cube $[ 0 , 1 ] ^ { d }$ , with the allowed perturbation space, $\epsilon \mathrm { - } \ell _ { \infty }$ ball $[ x _ { i } - \epsilon , x _ { i } + \epsilon ] ^ { d }$ , is the hyperrectangle $[ \operatorname* { m a x } \{ \bar { x } _ { i } - \epsilon , 0 \} , \operatorname* { m i n } \{ x _ { i } + \epsilon , 1 \} ] ^ { d }$ , where $i = 1 , \cdots , d$ are the indexes over input dimensions. The size of the available perturbation space at $x$ and $\epsilon$ is defined by the volume of this hyperrectangle:
+
+$$
+\mathrm { V o l } ( x , \epsilon ) = \prod _ { i = 1 } ^ { d } ( \operatorname* { m i n } \{ x _ { i } + \epsilon _ { i } , 1 \} - \operatorname* { m a x } \{ x _ { i } - \epsilon _ { i } , 0 \} )
+$$
+
+In high dimensional space, when $\epsilon$ is fixed, this volume varies greatly based on the location of $x$ . For example, if $x$ is on one of the corners of the unit cube, $\mathrm { V o } \bar { \mathrm { l } } ( x _ { c o r n e r } , \epsilon ) = \epsilon ^ { d }$ . If each dimension of $x$ is at least $\epsilon$ away from all the data boundaries, then the volume of the hyperrectangle is $\mathrm { V o l } ( x _ { i n s i d e } , \epsilon ) = ( 2 \epsilon ) ^ { d }$ . Therefore there can be $2 ^ { d }$ times difference of perturbable space between different data points. As shown in the average log perturbable volumes Table 6, we can see that different variations of datasets has significantly different perturbable volumes, with the same trend with previously described. It is notable that for the original CIFAR10 datasets has log volume -12354, which is very close to the -12270. The different of 84 bits indicates on average, the perturbation space is $2 ^ { 8 4 }$ smaller than the full $\epsilon \mathrm { - } \ell _ { \infty }$ ball if there is no intersection with the data domain boundary. Volume differences between different saturation or smooth level can be interpreted in the similar way. Note that for CIFAR10 images with large saturation, although they appear similar to human, they actually have very large differences in terms of perturbable volumes.
+
+Table 5: Performance and robustness of different sized Wide ResNet models on CIFAR10 variants   
+
+<table><tr><td>TEST SET</td><td colspan="6">STANDARD TRAINING,ACCURACY TRAINING SET</td></tr><tr><td></td><td>0.25</td><td>1</td><td>4</td><td>0.25</td><td>1</td><td>4</td></tr><tr><td>WIDEN FACTOR</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SATURATE1 SATURATE1.5</td><td>85.5% 87.0%</td><td>99.9% 99.9%</td><td>100.0% 100.0%</td><td>82.4% 84.2%</td><td>91.1% 92.1%</td><td>93.8% 94.7%</td></tr><tr><td></td><td>87.4%</td><td>99.9%</td><td>100.0%</td><td>84.5%</td><td>93.0%</td><td>95.2%</td></tr><tr><td>SATURATE 1.75 ORIGINAL</td><td>87.2%</td><td>99.9%</td><td>100.0%</td><td>84.4%</td><td>92.5%</td><td>95.0%</td></tr><tr><td>SATURATE 2.25</td><td>87.3%</td><td>99.9%</td><td>100.0%</td><td>84.5%</td><td>92.5%</td><td>94.8%</td></tr><tr><td>SATURATE 2.5</td><td>86.4%</td><td>99.9%</td><td>100.0%</td><td>83.7%</td><td>92.3%</td><td>94.8%</td></tr><tr><td>SATURATE 3</td><td>86.2%</td><td>99.9%</td><td>100.0%</td><td>84.0%</td><td>92.2%</td><td>94.5%</td></tr><tr><td>SATURATE 4</td><td>85.8%</td><td>99.9%</td><td>100.0%</td><td>83.1%</td><td>91.1%</td><td>93.8%</td></tr><tr><td>SATURATE8</td><td>84.6%</td><td>99.8%</td><td>100.0%</td><td>81.2%</td><td>90.1%</td><td>93.3%</td></tr><tr><td>SATURATE 16</td><td>83.5%</td><td>99.7%</td><td>100.0%</td><td>81.0%</td><td>89.4%</td><td>92.9%</td></tr><tr><td>SATURATE 64</td><td>80.5%</td><td>99.4%</td><td>100.0%</td><td>79.2%</td><td>86.9%</td><td>89.6%</td></tr><tr><td>SATURATE 128</td><td>77.1%</td><td>98.7%</td><td>100.0%</td><td>74.6%</td><td>83.0%</td><td>85.3%</td></tr><tr><td>SATURATE 256</td><td>73.7%</td><td>97.6%</td><td>100.0%</td><td>70.7%</td><td>76.5%</td><td>83.0%</td></tr><tr><td>SATURATE INF</td><td>73.2%</td><td>97.3%</td><td>99.9%</td><td>70.6%</td><td>76.3%</td><td>80.3%</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan="7">PGD TRAINING,ACCURACY</td></tr><tr><td>WIDEN FACTOR</td><td></td><td>TRAINING SET 1</td><td>4</td><td>0.25</td><td>TEST SET</td><td>4</td></tr><tr><td></td><td>0.25</td><td></td><td></td><td></td><td>1</td><td></td></tr><tr><td>SATURATE 1</td><td>45.4% 52.1%</td><td>68.3% 76.5%</td><td>93.1% 98.0%</td><td>46.8% 53.3%</td><td>66.9% 74.1%</td><td>77.5% 83.7%</td></tr><tr><td>SATURATE 1.5 SATURATE 1.75</td><td>53.8%</td><td>79.5%</td><td>99.2%</td><td>55.3%</td><td>77.0%</td><td>84.9%</td></tr><tr><td>ORIGINAL</td><td>56.1%</td><td>81.4%</td><td>99.7%</td><td>57.1%</td><td>78.4%</td><td>85.4%</td></tr><tr><td>SATURATE 2.25</td><td>56.8%</td><td>82.7%</td><td>99.9%</td><td>58.1%</td><td>78.8%</td><td>85.4%</td></tr><tr><td>SATURATE 2.5</td><td>57.6%</td><td>83.9%</td><td>100.0%</td><td>58.3%</td><td>79.1%</td><td>84.8%</td></tr><tr><td>SATURATE 3</td><td>60.0%</td><td>86.3%</td><td>100.0%</td><td>60.8%</td><td>79.5%</td><td>82.9%</td></tr><tr><td>SATURATE 4</td><td>62.8%</td><td>91.3%</td><td>100.0%</td><td>63.7%</td><td>77.9%</td><td>80.4%</td></tr><tr><td>SATURATE8</td><td>67.7%</td><td>96.1%</td><td>100.0%</td><td>67.0%</td><td>76.6%</td><td>80.4%</td></tr><tr><td>SATURATE 16</td><td>67.2%</td><td>96.1%</td><td>99.9%</td><td>66.0%</td><td>76.4%</td><td>79.9%</td></tr><tr><td>SATURATE 64</td><td>70.0%</td><td>96.5%</td><td>99.9%</td><td>68.6%</td><td>75.8%</td><td>79.5%</td></tr><tr><td></td><td>71.4%</td><td>96.4%</td><td>99.9%</td><td>68.9%</td><td>76.6%</td><td>80.2%</td></tr><tr><td>SATURATE 128</td><td>68.6%</td><td>96.9%</td><td>99.9%</td><td></td><td></td><td></td></tr><tr><td>SATURATE 256 SATURATE INF</td><td>71.5%</td><td>96.9%</td><td></td><td>65.7%</td><td>76.6%</td><td>80.0%</td></tr><tr><td></td><td></td><td></td><td>99.9%</td><td>69.7%</td><td>76.1%</td><td>80.0%</td></tr><tr><td colspan="7">PGD TRAINING,ROBUST ACCURACY</td></tr><tr><td></td><td></td><td>TRAINING SET</td><td></td><td></td><td>TEST SET</td><td></td></tr><tr><td>WIDEN FACTOR</td><td>0.25</td><td>1</td><td>4</td><td>0.25</td><td>1</td><td>4</td></tr><tr><td>SATURATE1</td><td>24.0% 29.0%</td><td>36.9%</td><td>71.1%</td><td>25.6%</td><td>34.4%</td><td>33.0% 38.7%</td></tr><tr><td>SATURATE 1.5</td><td>30.9%</td><td>44.4% 47.8%</td><td>81.3% 86.0%</td><td>31.6% 32.7%</td><td>40.7% 44.0%</td><td>41.1%</td></tr><tr><td>SATURATE 1.75</td><td>32.4%</td><td>50.4%</td><td>90.3%</td><td>35.0%</td><td>45.5%</td><td>43.2%</td></tr><tr><td>ORIGINAL SATURATE2.25</td><td>33.9%</td><td>52.9%</td><td>93.4%</td><td>36.1%</td><td>47.3%</td><td>44.4%</td></tr><tr><td>SATURATE 2.5</td><td>35.5%</td><td>55.4%</td><td>96.0%</td><td>37.5%</td><td>49.1%</td><td>46.4%</td></tr><tr><td>SATURATE 3</td><td>38.4%</td><td>61.5%</td><td>98.9%</td><td>40.6%</td><td>52.5%</td><td>51.7%</td></tr><tr><td>SATURATE 4</td><td>44.9%</td><td>77.4%</td><td>99.7%</td><td>46.1%</td><td>60.4%</td><td>64.0%</td></tr><tr><td>SATURATE8</td><td>62.3%</td><td>95.0%</td><td>99.8%</td><td>61.9%</td><td>74.9%</td><td>78.1%</td></tr><tr><td>SATURATE 16</td><td>66.0%</td><td>95.5%</td><td>99.9%</td><td>65.0%</td><td>75.5%</td><td>79.4%</td></tr><tr><td>SATURATE 64</td><td>69.1%</td><td>96.3%</td><td>99.9%</td><td>67.6%</td><td>75.5%</td><td>79.3%</td></tr><tr><td>SATURATE 128</td><td>70.7%</td><td>96.2%</td><td>99.9%</td><td>68.2%</td><td>76.2%</td><td>79.9%</td></tr><tr><td>SATURATE 256</td><td>68.0%</td><td>96.7%</td><td>99.9%</td><td>65.2%</td><td>76.3%</td><td>79.7%</td></tr><tr><td>SATURATE INF</td><td>70.9%</td><td>96.7%</td><td>99.9%</td><td>69.2%</td><td>75.8%</td><td>79.7%</td></tr></table>
+
+Table 6: Perturbable volumes of different variants of MNIST and CIFAR10. Values shown in table are the average log value (in bits) of volumes of test data. For MNIST, $\epsilon = 0 . 3$ , for CIFAR10 $\epsilon = 8 / 2 5 5$ .   
+
+<table><tr><td colspan="5">MNIST(VALID RANGE -1361 TO -577)</td><td colspan="8">CIFAR10 (VALID RANGE -15342 TO -12270)</td></tr><tr><td>BINARY</td><td>ORIGINAL</td><td>3</td><td>5</td><td>ORIGINAL</td><td>4</td><td>8</td><td>16</td><td>64</td><td>256</td><td>512</td><td>INF</td></tr><tr><td>-1361</td><td>-1297</td><td>-1265</td><td>-1234</td><td>-12354</td><td>-12394</td><td>-12477</td><td>-12657</td><td>-13620</td><td>-14747</td><td>-15028</td><td>-15342</td></tr></table>
+
+If the perturbable volume hypothesis holds, then we should observe significantly lower accuracy under PGD attack if we allow perturbation outside of data domain boundary. Since this greatly increases the perturbable volume. We measure the accuracy under PGD attack with and without considering data domain boundary for both MNIST and CIFAR10 variants. The results are shown in Table 7. “With considering boundary” corresponds to regular PGD attacks. We can see that allowing PGD to perturb out of bound do not reduce accuracy under attack. This means that PGD is not able to use the significantly larger additional volumes even for binarized MNIST or highly saturated CIFAR10, whose data points are on or very close to the corner. In some cases, allowing perturbation outside of domain boundary makes the attack slightly less effective. This might be due to that data domain boundary constrained the perturbation to be in an “easier” region. This might seem surprising considering the huge difference in perturbable volumes, these results conform with empirical results in previous research (Goodfellow et al., 2014; Warde-Farley and Goodfellow, 2016) that adversarial examples appears in certain directions instead of being distributed in small pockets across space. Therefore, the perturbable volume hypothesis is rejected.
+
+Table 7: PGD attack results with and without domain boundary constraints on MNIST and CIFAR10   
+
+<table><tr><td colspan="3">MNIST</td><td colspan="3">CIFAR10</td></tr><tr><td>MNIST VARIANTS</td><td>ROBUST ACCURACY W/BOUND</td><td>ROBUST ACCURACY W/O BOUND</td><td>CIFAR10 VARIANTS</td><td>ROBUST ACCURACY W/BOUND</td><td>ROBUST ACCURACY W/O BOUND</td></tr><tr><td>BINARIZED</td><td>98.1%</td><td>96.1 %</td><td>SATURATE 1</td><td>33.0%</td><td>32.7%</td></tr><tr><td>ORIGINAL</td><td>95.1 %</td><td>95.1 %</td><td>ORIGINAL</td><td>43.2 %</td><td>43.0 %</td></tr><tr><td>SMOOTH2</td><td>93.0%</td><td>92.9%</td><td>SATURATE 4</td><td>64.0 %</td><td>64.0 %</td></tr><tr><td>SMOOTH 3</td><td>91.3 %</td><td>91.5%</td><td>SATURATE8</td><td>78.1%</td><td>78.1%</td></tr><tr><td>SMOOTH4</td><td>90.3%</td><td>90.6 %</td><td>SATURATE 16</td><td>79.4 %</td><td>79.4 %</td></tr><tr><td>SMOOTH5</td><td>89.6%</td><td>89.9%</td><td>SATURATE INF</td><td>79.7%</td><td>79.4%</td></tr></table>
+
+# D.2 DETAILED ANALYSES OF INTER-CLASS DISTANCE
+
+# D.2.1 CALCULATION OF INTER-CLASS DISTANCE
+
+We calculate the inter-class distance as follows. Let $D = \{ x _ { i } \}$ denote the set of all the input data points, $D _ { c } = \{ x _ { i } | y _ { i } = c \}$ denote the set of all the data points in class $c$ , and $D _ { \neg c } = \{ x _ { i } \bar { | y _ { i } \neq c \} }$ denote all the data points not in class $c$ . Our goal is to calculate $d ( D _ { c } , D _ { \neg c } )$ for all the classes, where $d ( D _ { c } , D _ { \neg c } )$ approximates the margin between class $c$ and the rest. To estimate $d ( D _ { c } , D _ { \neg c } )$ , we first compute the margin for each data point $x$ in class $c$ . To do that, we calculate the average $\| x - x _ { j } \| _ { 2 }$ , where $x _ { j } \in D _ { \neg c }$ is one of $x$ ’s $10 \%$ nearest neighbors in $D _ { \neg c }$ . Lastly, the inter-class distance of class c, $d ( D _ { c } , \bar { D } _ { \lnot c } )$ , is then calculated as the average of smallest $1 0 \% d \dot { ( } x , D _ { \neg c } )$ for $x \in D _ { c }$ .
+
+Note that we choose $\ell _ { 2 }$ distance for inter-class distance, instead of using the $\ell _ { \infty }$ which measures the robustness. This is because $\ell _ { \infty }$ -distance between data examples is essentially the max over the per pixel differences, which is always very close to 1. Therefore the $\ell _ { \infty }$ -distance between data examples is not really representative / distinguishable.
+
+Figure 5 shows the inter-class distances (averaged over all classes) calculated on MNIST and CIFAR10 variants. The binarized MNIST has a significantly larger inter-class distance. As smoothing kernel size increases, the distance also decrease slightly. On CIFAR10 variants, as the saturation level gets higher, the inter-class distance increases monotonically. We also directly plot inter-class distance vs robust accuracy on MNIST and CIFAR10 variants. In general, inter-class distance shows a strong positive correlation with robust accuracy under these transformations. With one exception that original MNIST has smaller inter-class distance, but is sightly more robust than smooth-2 MNIST. This, together with the counter examples we gave in Table 1, suggests that inter-class distance cannot fully explain the robust variation across different dataset variants.
+
+# D.2.2 INTER-CLASS DISTANCE COULD POTENTIALLY INFLUENCE REQUIRED MODEL CAPACITY
+
+We attempt to understand the relation between the inter-class distance of a dataset and its achievable robustness in this section. We first illustrate our intuition in a synthetic experiment, where a ReLU network is trained to perfectly separate 2 concentric spheres (Gilmer et al., 2018), as shown in Figure 6. Here the inter-class distance is the width of the ring between two spheres. In such example, adversarial training is actually closely related to the inter-class distance of the data. In fact, in the simple setting where the classifier is linear, it has been shown in $\mathrm { X u }$ et al. (2009) that adversarial training, as a particular form of robust optimization, is equivalent to maximizing the classification margins. Following this intuition, one can easily see that the effect of adversarial training is to push two spheres close to each other, and requires the network to perfectly separate the new spheres with much smaller inter-class.
+
+![](images/ca09ad719302b471435be525010b74fc0f43be463f938adacab7cf83652bae40.jpg)  
+Figure 5: Inter-class distance’s influence on robust accuracy on different MNIST and CIFAR10 variants
+
+Intuitively, when the inter-class distance is large, i.e. the gap between two spheres are large, a reasonable model should be able to achieve good standard accuracy. We have also observed such phenomenon on original MNIST and saturated CIFAR10 (say level 16). As the inter-class distance gets smaller, although the model capacity could still be enough for the standard training, it may no longer be enough for adversarial training, upon which we would observe that although the test accuracies stay similar, accuracies under adversarial attack significantly would drop. We have also seen similar behavior on smooth MNIST data and smaller level of saturated CIFAR10 data. Finally, when the inter-class distance is so small such that even a high clean test accuracy may be difficult to achieve.
+
+Considering robust accuracy as the clean accuracy with a smaller gap between the spheres, the next theorem provides a theoretical guarantee in relating together the difficulty of attaining good accuracy under attack and the model capacity (Ball, 1997), verifying our intuition above. Note that one way to measure the capacity of a ReLU network is by counting the number of its induced piece-wise linear region, which is closely related to the number of facets of its decision boundary.
+
+Theorem D.1. Let $d ( K , L )$ between symmetric convex bodies $K$ and $L$ denote the least positive $d$ for which there is a linear image $\tilde { L }$ of $L$ such that $\tilde { L } \subset K \subset d \tilde { L }$ . Let $K$ be a (symmetric) polytope in $\mathbb { R } ^ { n }$ with $d ( K , B _ { 2 } ^ { n } ) = d$ . Then $K$ has at least $e ^ { n / ( 2 d ^ { 2 } ) }$ facets. On the other hand, for each n, there is a polytope with $4 n$ facets whose distance from the ball is at most 2.
+
+![](images/50f649ec146a6777bd0abde830c4ffb5f25b5daebe7ed379166dd0379167ea7b.jpg)  
+Figure 6: Illustration of the relationship between the inter-class distance and the required model capacity. Left: when distance is small, a small capacity polytope classifier could separate original data; middle: when distance is small, the small capacity polytope classifier is not able to separate data points “robustly”, but a more complex nonlinear classifier could; right:when distance is large, the small capacity polytope classifier can separate data points “robustly”.
+
+The above analysis is partially supported by our experiments on model capacity in Section 5.3. However, as we’ve shown in Section 5.2, the nature of the problem is complex and more conclusive statements requires further research.

parse/train/rJehllrtDS/rJehllrtDS.md

@@ -0,0 +1,331 @@
+# RETHINKING DEEP ACTIVE LEARNING: USING UNLABELED DATA AT MODEL TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Active learning typically focuses on training a model on few labeled examples alone, while unlabeled ones are only used for acquisition. In this work we depart from this setting by using both labeled and unlabeled data during model training across active learning cycles. We do so by using unsupervised feature learning at the beginning of the active learning pipeline and semi-supervised learning at every active learning cycle, on all available data. The former has not been investigated before in active learning, while the study of latter in the context of deep learning is scarce and recent findings are not conclusive with respect to its benefit. Our idea is orthogonal to acquisition strategies by using more data, much like ensemble methods use more models. By systematically evaluating on a number of popular acquisition strategies and datasets, we find that the use of unlabeled data during model training brings a spectacular accuracy improvement in image classification, compared to the differences between acquisition strategies. We thus explore smaller label budgets, even one label per class.
+
+# 1 INTRODUCTION
+
+Active learning (Settles, 2009) is an important pillar of machine learning but it has not been explored much in the context of deep learning until recently (Gal et al., 2017; Beluch et al., 2018; Wang et al., 2017; Geifman & El-Yaniv, 2017; Sener & Savarese, 2018). The standard active learning scenario focuses on training a model on few labeled examples alone, while unlabeled data are only used for acquisition, i.e., performing inference and selecting a subset for annotation. This is the opposite of what would normally work well when learning a deep model from scratch, i.e., training on a lot of data with some loss function that may need labels or not. At the same time, evidence is being accumulated that, when training powerful deep models, the difference in performance between acquisition strategies is small (Gissin & Shalev-Shwartz, 2018; Chitta et al., 2019; Beluch et al., 2018).
+
+In this work, focusing on image classification, we revisit active deep learning with the seminal idea of using all data, whether labeled or not, during model training at each active learning cycle. This departs from the standard scenario in that unlabeled data are now directly contributing to the cost function being minimized and to subsequent parameter updates, rather than just being used to perform inference for acquisition, whereby parameters are fixed. We implement our idea using two principles: unsupervised feature learning and semi-supervised learning. While both are well recognized in deep learning in general, we argue that their value has been unexplored or underestimated in the context of deep active learning.
+
+Unsupervised feature learning or self-supervised learning is a very active area of research in deep learning, often taking the form of pre-training on artificial tasks with no human supervision for representation learning, followed by supervised fine-tuning on different target tasks like classification or object detection (Doersch et al., 2015; Wang & Gupta, 2015; Gidaris et al., 2018; Caron et al., 2018). To our knowledge, all deep active learning research so far considers training deep models from scratch. In this work, we perform unsupervised feature learning on all data once at the beginning of the active learning pipeline and use the resulting parameters to initialize the model at each active learning cycle. Relying on Caron et al. (2018), we show that such unsupervised pre-training improves accuracy in many cases at little additional cost.
+
+Semi-supervised learning (Chapelle et al., 2006) and active learning can be seen as two facets of the same problem: the former focuses on most certain model predictions on unlabeled examples, while the latter on least certain ones. Combined approaches appeared quite early (McCallum & Nigam, 1998; Zhu et al., 2003). In the context of deep learning however, such combinations are scarce (Wang et al., 2017) and have even been found harmful in cases (Ducoffe & Precioso, 2018). It has also been argued that the two individual approaches have similar performance, while active learning has lower cost (Gal et al., 2017). In the meantime, research on deep semi-supervised learning is very active, bringing significant progress (Tarvainen & Valpola, 2017; Laine & Aila, 2017; Iscen et al., 2019; Verma et al., 2019). In this work, we use semi-supervised learning on all data at every active learning cycle, replacing supervised learning on labeled examples alone. Relying on Iscen et al. (2019), and contrary to previous findings Wang et al. (2017); Gal et al. (2017), we show that this consistently brings a dramatic accuracy improvement.
+
+Since Iscen et al. (2019) uses label propagation (Zhou et al., 2003a) to explore the manifold structure of the feature space, an important question is whether it is the manifold similarity or the use of unlabeled data during model training that actually helps. We address this question by introducing a new acquisition strategy that is based on label propagation.
+
+In summary, we make the following contributions:
+
+• We systematically benchmark a number of existing acquisition strategies, as well as a new one, on a number of datasets, evaluating the benefit of unsupervised pre-training and semi-supervised learning in all cases.   
+• Contrary to previous findings, we show that using unlabeled data during model training can yield a dramatic gain compared to differences between acquisition strategies.   
+• Armed with this finding, we explore a smaller budget (fewer labeled examples) than prior work, and we find that the random baseline may actually outperform all other acquisition strategies by a large margin in cases.
+
+# 2 RELATED WORK
+
+We focus on deep active and semi-supervised learning as well as their combination.
+
+Active learning. Geometric methods like core sets (Geifman & El-Yaniv, 2017; Sener & Savarese, 2018) select examples based on distances in the feature space. The goal is to select a subset of examples that best approximate the whole unlabeled set. We introduce a similar approach where Euclidean distances are replaced by manifold ranking. There are methods inspired by adversarial learning. For instance, a binary classifier can be trained to discriminate whether an example belongs to the labeled or unlabeled set (Gissin & Shalev-Shwartz, 2018; Sinha et al., 2019). Adversarial examples have been used, being matched to the nearest unlabeled example (Mayer & Timofte, 2018) or added to the labeled pool (Ducoffe & Precioso, 2018).
+
+It has been observed however that deep networks can perform similarly regardless of the acquisition function (Gissin & Shalev-Shwartz, 2018; Chitta et al., 2019), which we further investigate here. Ensemble and Bayesian methods (Gal et al., 2017; Beluch et al., 2018; Chitta et al., 2019) target representing model uncertainty, which than can be used by different acquisition functions. This idea is orthogonal to acquisition strategies. In fact, Beluch et al. (2018); Chitta et al. (2019) show that the gain of ensemble models is more pronounced than the gain of any acquisition strategy. Of course, ensemble and Bayesian methods are more expensive than single models. Approximations include for instance a single model producing different outputs by dropout (Gal et al., 2017). Our idea of using all data during model training is also orthogonal to acquisition strategies. It is also more expensive than using labeled data alone, but the gain is spectacular in this case. This allows the use of much smaller label budget for the same accuracy, which is the essence of active learning.
+
+Semi-supervised active learning has a long history (McCallum & Nigam, 1998; Muslea et al., 2002; Zhu et al., 2003; Zhou et al., 2004; Long et al., 2008). A recent deep learning approach acquires the least certain unlabeled examples for labeling and at the same time assigns predicted pseudo-labels to most certain examples (Wang et al., 2017). This does not always help (Ducoffe & Precioso, 2018). In some cases, semi-supervised algorithms are incorporated as part of an active learning evaluation (Li et al., 2019; Sener & Savarese, 2018). A comparative study suggests that semi-supervised learning does not significantly improve over active learning, despite its additional cost due to training on more data (Gal et al., 2017). We show that this is clearly not the case, using a state of the art semi-supervised method (Iscen et al., 2019) that is an inductive version of label propagation (Zhou et al., 2003a). This is related to Zhu & Ghahramani (2002); Zhu et al. (2003); Long et al. (2008), which however are limited to transductive learning.
+
+Unsupervised feature learning. A number of unsupervised feature learning approaches pair matching images to learn the representation using a siamese architecture. These pairs can come as fragments of the same image (Doersch et al., 2015; Noroozi & Favaro, 2016) or as a result of tracking in video (Wang & Gupta, 2015). Alternatively, the network is trained on an artificial task like image rotation prediction (Gidaris et al., 2018) or even matching images to a noisy target (Bojanowski & Joulin, 2017). The latter is conceptually related to deep clustering (Caron et al., 2018), the approach we use in this work, where the network learns targets resulting from unsupervised clustering. It is interesting that in the context of semi-supervised learning, unsupervised pre-training has been recently investigated by Rebuffi et al. (2019), with results are consistent with ours. However, the use of unsupervised pre-training in deep active learning remains unexplored.
+
+# 3 PROBLEM FORMULATION AND BACKGROUND
+
+Problem. We are given a set $X : = \{ \mathbf { x } _ { i } \} _ { i \in \mathbb { Z } } \subset \mathcal { X }$ of $n$ examples where $\mathcal { T } : = [ n ] : = \{ 1 , \dots , n \}$ and, initially, a collection $\mathbf { y } _ { 0 } : = ( y _ { i } ) _ { i \in L _ { 0 } }$ of $b$ labels $y _ { i } \in C$ for $i \in L _ { 0 }$ , where $C : = [ c ]$ is a set of $c$ classes and $L _ { 0 } \subset \mathcal { T }$ a set of indices with $| L _ { 0 } | = b \ll n$ . The goal of active learning (AL) (Settles, 2009) is to train a classifier in cycles, where in cycle $j = 0 , 1 , \ldots$ we use a collection $\mathbf { y } _ { j }$ of labels for training, and then we acquire (or sample) a new batch $S _ { j }$ of indices with $| S _ { j } | = b$ to label the corresponding examples for the next cycle $j + 1$ . Let $L _ { j } : = L _ { j - 1 } \cup S _ { j - 1 } \subset \mathcal { T }$ be the set of indices of labeled examples in cycle $j \geq 1$ and $U _ { j } : = \mathcal { T } \backslash L _ { j }$ the indices of the unlabeled examples for $j \geq 0$ . Then $\mathbf { y } _ { j } : = ( \overline { { y } } _ { i } ) _ { i \in L _ { j } }$ are the labels in cycle $j$ and ${ \bar { S } } _ { j } \subset U _ { j }$ is selected from the unlabeled examples. To keep notation simple, we will refer to a single cycle in the following, dropping subscripts $j$ .
+
+Classifier learning. The classifier $f _ { \theta } : \mathcal { X }  \mathbb { R } ^ { c }$ with parameters $\theta$ , maps new examples to a vector of probabilities per class. Given $\mathbf { x } \in \mathcal { X }$ , its prediction is the class of maximum probability
+
+$$
+\pi ( \mathbf { p } ) : = \arg \operatorname* { m a x } _ { k \in C } p _ { k } ,
+$$
+
+where $p _ { k }$ is the $k$ -th element of vector $\mathbf { p } : = f _ { \theta } ( \mathbf { x } )$ . As a by-product of learning parameters $\theta$ , we have access to an embedding function $\phi _ { \theta } : \mathcal { X }  \mathbb { R } ^ { d }$ , mapping an example $\mathbf { x } \in \mathcal { X }$ to a feature vector $\phi _ { \theta } ( \mathbf { x } )$ . For instance, $f _ { \theta }$ may be a linear classifier on top of features obtained by $\phi _ { \theta }$ .
+
+In a typical AL scenario, given a set of indices $L$ of labeled examples and labels $\mathbf { y }$ , the parameters $\theta$ of the classifier are learned by minimizing the cost function
+
+$$
+J ( X , L , \mathbf { y } ; \theta ) : = \sum _ { i \in L } \ell ( f _ { \theta } ( \mathbf { x } _ { i } ) , y _ { i } ) ,
+$$
+
+on labeled examples $\mathbf { x } _ { i }$ for $i \in L$ , where cross-entropy $\ell ( \mathbf { p } , y ) : = - \log p _ { y }$ for $\mathbf { p } \in \mathbb { R } _ { + } ^ { c }$ , $y \in C$ .
+
+Acquisition. Given the set of indices $U$ of unlabeled examples and the parameters $\theta$ resulting from training, one typically acquires a new batch by initializing $S \gets \emptyset$ and then greedily updating by
+
+$$
+S \gets S \cup \{ a ( X , L \cup S , U \setminus S , \mathbf { y } ; \theta ) \}
+$$
+
+until $| S | \geq b$ . Here $a$ is an acquisition (or sampling) function, each time selecting one example from $U \backslash S$ . For each $i \in S$ , the corresponding example $\mathbf { x } _ { i }$ is then given as query to an oracle (often a human expert), who returns a label $y _ { i }$ to be used in the next cycle.
+
+Geometry. Given parameters $\theta$ , a simple acquisition strategy is to use the geometry of examples in the feature space $\mathcal { F } _ { \theta } : = \phi _ { \theta } ( \mathcal { X } )$ , without considering the classifier. Each example $\mathbf { x } _ { i }$ is represented by the feature vector $\phi _ { \theta } ( \mathbf { x } _ { i } )$ for $i \in \mathcal { T }$ . One particular example is the function (Geifman & El-Yaniv, 2017; Sener & Savarese, 2018)
+
+$$
+a ( X , L , U , \mathbf { y } ; \theta ) : = \arg \operatorname* { m a x } _ { i \in U } \operatorname* { m i n } _ { k \in L } \left\| \phi _ { \theta } ( \mathbf { x } _ { i } ) , \phi _ { \theta } ( \mathbf { x } _ { k } ) \right\| ,
+$$
+
+each time selecting the unlabeled example in $U$ that is the most distant to its nearest labeled or previously acquired example in $L$ . Such geometric approaches are inherently related to clustering. For instance, $k$ -means $^ { + + }$ (Arthur & Vassilvitskii, 2007) is a probabilistic version of (4).
+
+Uncertainty. A common acquisition strategy that considers the classifier is some measure of uncertainty in its prediction. Given a vector of probabilities $\mathbf { p }$ , one such measure is the entropy
+
+$$
+H ( \mathbf { p } ) : = - \sum _ { k = 1 } ^ { c } p _ { k } \log p _ { k } ,
+$$
+
+taking values in $[ 0 , \log c ]$ . Given parameters $\theta$ , each example $\mathbf { x } _ { i }$ is represented by the vector of probabilities $f _ { \theta } ( \mathbf { x } _ { i } )$ for $i \in \mathcal { Z }$ . Then, acquisition is defined by
+
+$$
+a ( X , L , U , \mathbf { y } ; \theta ) : = \arg \operatorname* { m a x } _ { i \in U } H ( f _ { \theta } ( \mathbf { x } _ { i } ) ) ,
+$$
+
+effectively selecting the $b$ most uncertain unlabeled examples for labeling.
+
+Pseudo-labels. It is possible to use more data than the labeled examples while learning. In Wang et al. (2017) for example, given indices $L , U$ of labeled and unlabeled examples respectively and parameters $\theta$ , one represents example $\mathbf { x } _ { i }$ by $\mathbf { p } _ { i } : = f _ { \theta } ( \mathbf { x } _ { i } )$ , selects the most certain unlabeled examples
+
+$$
+\hat { L } : = \{ i \in U : H ( \mathbf { p } _ { i } ) \leq \epsilon \} ,
+$$
+
+and assigns pseudo-label ${ \hat { y } } _ { i } : = \pi ( \mathbf { p } _ { i } )$ by (1) for $i \in \hat { L }$ . The same cost function $J$ defined by (2) can now be used by augmenting $L$ to $L \cup \hat { L }$ and $\mathbf { y }$ to $( \mathbf { y } , \hat { \mathbf { y } } )$ , where $\hat { \mathbf { y } } : = \left( \hat { y } _ { i } \right) _ { i \in \hat { L } }$ . This augmentation occurs once per cycle in Wang et al. (2017). This is an example of active semi-supervised learning.
+
+Transductive label propagation (Zhou et al., 2003a) refers to graph-based, semi-supervised learning. A nearest neighbor graph of the dataset $X$ is used, represented by a symmetric non-negative $n ~ \times$ $n$ adjacency matrix $W$ with zero diagonal. This matrix is symmetrically normalized as $\mathcal { W } : =$ $D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ , where $D : = \mathrm { d i a g } ( W \mathbf { 1 } )$ is the degree matrix and 1 is the all-ones vector. The given labels $\mathbf { y } : = ( y _ { i } ) _ { i \in L }$ are represented by a $n \times c$ zero-one matrix $Y : = \chi ( L , \mathbf { y } )$ where row $i$ is a $c$ -vector that is a one-hot encoding of label $y _ { i }$ if example $\mathbf { x } _ { i }$ is labeled and zero otherwise,
+
+$$
+\chi ( L , \mathbf { y } ) _ { i k } : = { \left\{ \begin{array} { l l } { 1 , } & { i \in L \land y _ { i } = k , } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+for $i \in \mathcal { T }$ and $k \in C$ . Zhou et al. (2003a) define the $n \times c$ matrix $P : = \eta [ h ( Y ) ] ^ { 1 }$ , where
+
+$$
+h ( Y ) : = ( 1 - \alpha ) ( I - \alpha { \mathcal { W } } ) ^ { - 1 } Y ,
+$$
+
+$I$ is the $n \times n$ identity matrix, and $\alpha \in [ 0 , 1 )$ is a parameter. The $i$ -th row $\mathbf { p } _ { i }$ of $P$ represents a vector of class probabilities of unlabeled example $\mathbf { x } _ { i }$ , and a prediction can be made by $\pi ( \mathbf { p } _ { i } )$ (1) for $i \in U$ This method is transductive because it cannot make predictions on previously unseen data without access to the original data $X$ .
+
+Inductive label propagation. Although the previous methods do not apply to unseen data by themselves, the predictions made on $X$ can again be used as pseudo-labels to train a classifier. This is done in Iscen et al. (2019), applied to semi-supervised learning. Like Wang et al. (2017), a pseudo-label is generated for unlabeled example $\mathbf { x } _ { i }$ as ${ \hat { y } } _ { i } : = \pi ( \mathbf { p } _ { i } )$ by (1), only now $\mathbf { p } _ { i }$ is the $i$ -th row of the result $P$ of label propagation according to (9) rather than the classifier output $f _ { \theta } ( \mathbf { x } _ { i } )$ . Unlike Wang et al. (2017), all unlabeled examples are pseudo-labeled and an additional cost term $\begin{array} { r } { J _ { w } ( X , U , \hat { \mathbf { y } } ; \theta ) : = \sum _ { i \in U } { w _ { i } \ell ( f _ { \theta } ( \mathbf { x } _ { i } ) , \hat { y } _ { i } ) } } \end{array}$ applies to those examples, where $\hat { \mathbf { y } } : = ( \hat { y } _ { i } ) _ { i \in U }$ and $w _ { i } : = \beta ( \mathbf { p } _ { i } )$ is a weight reflecting the certainty in the prediction of $\hat { y } _ { i }$ :
+
+$$
+\beta ( \mathbf { p } ) : = 1 - \frac { H ( \mathbf { p } ) } { \log c } .
+$$
+
+Unlike Wang et al. (2017), the graph and the pseudo-labels are updated once per epoch during learning in Iscen et al. (2019), where there are no cycles.
+
+Unsupervised feature learning. Finally, it is possible to train an embedding function in an unsupervised fashion. A simple method that does not make any assumption on the nature or structure of the data is Caron et al. (2018). Simply put, starting by randomly initialized parameters $\theta$ , the data $\phi _ { \theta } ( X )$ are clustered by $k$ -means, each example is assigned to the nearest centroid, clusters and assignments are treated as classes $C$ and pseudo-labels $\hat { \mathbf { y } }$ respectively, and learning takes place according to $J ( X , { \mathcal { T } } , { \hat { \mathbf { y } } } , \theta )$ (2). By updating the parameters $\theta$ , $\phi _ { \theta } ( X )$ is updated too. The method therefore alternates between clustering/pseudo-labeling and feature learning, typically once per epoch.
+
+# 4 TRAINING THE MODEL ON UNLABELED DATA
+
+We argue that acquiring examples for labeling is not making the best use of unlabeled data: unlabeled data should be used during model training, appearing in the cost function that is being minimized. We choose two ways of doing so: unsupervised feature learning and semi-supervised learning. As outlined in Algorithm 1, we follow the standard active learning setup, adding unsupervised pretraining at the beginning and replacing supervised learning on $L$ by semi-supervised learning on $L \cup U$ at each cycle. The individual components are discussed in more detail below.
+
+Algorithm 1: Semi-supervised active learning   
+
+<table><tr><td colspan="2">Data:dataX,indices of labeled examplesL,labels y,batch size b</td></tr><tr><td>1U←I\L</td><td>&gt;indices of unlabeled examples &gt; unsupervised pre-training</td></tr><tr><td>2 00 ←PRE(X)</td><td>&gt; active learning cycles</td></tr><tr><td>3 forj∈ {0,...} do 0 ← sUP(X,L,y;00) 4</td><td></td></tr><tr><td>fore ∈{i,...}do</td><td>&gt; supervised learning on L only &gt; epochs</td></tr><tr><td>5 (y,w)←LP(X,L,y,0)</td><td>&gt; pseudo-labels y and labels w</td></tr><tr><td>6 7</td><td>θ←SEMI(X,LUU,(y,y),w;0) &gt; semi-supervised learning on all data</td></tr><tr><td>s↑0 8</td><td></td></tr><tr><td>9 while|S|&lt;bdo</td><td>&gt; acquire a batch S C U for labeling</td></tr><tr><td>10</td><td>┌ S←SUa(X,LUS,U\S,y;0)</td></tr><tr><td>y ← (y,LABEL(S)) 11 12 L←LUS;U←U\S</td><td>&gt; obtain true labels on S by oracle update indices</td></tr></table>
+
+Unsupervised pre-training (PRE) takes place at the beginning of the algorithm. We follow Caron et al. (2018), randomly initializing $\theta$ and then alternating between clustering the features $\phi _ { \theta } ( X )$ by $k$ -means and learning on cluster assignment pseudo-labels $\hat { \mathbf { y } }$ of $X$ according to $J ( X , { \mathcal { T } } , { \hat { \mathbf { y } } } , \theta )$ (2). The result is a set of parameters $\theta _ { 0 }$ used to initialize the classifier at every cycle.
+
+Learning per cycle follows inductive label propagation (Iscen et al., 2019). This consists of supervised learning followed by alternating label propagation and semi-supervised learning on all examples $L \cup U$ at every epoch. The supervised learning (SUP) is performed on the labeled examples $L$ only using labels y, according to $J ( X , L , \mathbf { y } , \theta )$ (2), where the parameters $\theta$ are initialized by $\theta _ { 0 }$ .
+
+Label propagation (LP) involves a reciprocal $k$ -nearest neighbor graph on features $\phi _ { \theta } ( X )$ (Iscen et al., 2019). As in Zhou et al. (2003a), the resulting affinity matrix $W$ is normalized as $\mathcal { W } : =$ $D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ . Label propagation is then performed according to $P = \eta [ h ( Y ) ]$ (9), by solving the corresponding linear system using the conjugate gradient (CG) method (Iscen et al., 2019). The label matrix $Y : = { \overset { \vartriangle } { \chi } } ( L , \mathbf { y } )$ (8) is defined on the true labeled examples $L$ that remain fixed over epochs but grow over cycles. With $\mathbf { p } _ { i }$ being the $i$ -th row of $P$ , a pseudo-label ${ \hat { y } } _ { i } = \pi ( \mathbf { p } _ { i } )$ (1) and a weight $w _ { i } = \beta ( \mathbf { p } _ { i } )$ (10) are defined for every $i \in U$ (Iscen et al., 2019).
+
+Semi-supervised learning (SEMI) takes place on all examples $L \cup U = \mathcal { I }$ , where examples in $L$ have true labels y and examples in $U$ pseudo-labels $\hat { \mathbf { y } } : = ( \hat { y } _ { i } ) _ { i \in U }$ . Different than Iscen et al. (2019), we minimize the standard cost function $J ( X , L \cup U , ( \mathbf { y } , { \hat { \mathbf { y } } } ) , \theta )$ (2), but we do take weights $\mathbf { w } : = ( w _ { i } ) _ { i \in U }$ into account in mini-batch sampling, $\ell _ { 1 }$ -normalized as $\eta [ \mathbf { w } ]$ . In particular, part of each mini-batch is drawn uniformly at random from $L$ , while the other part is drawn with replacement from the discrete distribution $\eta [ \dot { \bf w } ]$ on $U$ : an example may be drawn more than once per epoch or never.
+
+<table><tr><td></td><td>Data size train /test</td><td>Image size</td><td>Mini-batch size W/o SEMI/ SEMI</td><td>Budget</td><td>Total labels</td></tr><tr><td>MNIST</td><td>60000 /10000</td><td>28×28</td><td>10/64</td><td>10</td><td>50</td></tr><tr><td>SVHN</td><td>73257/26032</td><td>32×32</td><td>32/128</td><td>100</td><td>500</td></tr><tr><td>CIFAR-10</td><td>50000 /10000</td><td>32×32</td><td>32/128</td><td>100</td><td>500</td></tr><tr><td>CIFAR-10</td><td>50000/10000</td><td>32×32</td><td>32/128</td><td>1000</td><td>5000</td></tr><tr><td>CIFAR-100</td><td>50000 /10000</td><td>32×32</td><td>32/128</td><td>1000</td><td>5000</td></tr></table>
+
+Table 1: Datasets used in this paper, including the mini-batch sizes used in training with and without SEMI, acquisition size at each active learning step and the total number of labeled images.
+
+Discussion. The above probabilistic weighting decouples the size of the epoch from $n$ and indeed we experiment with epochs smaller than $n$ , accelerating learning compared to Iscen et al. (2019). It is similar to importance sampling, which is typically based on loss values (Katharopoulos & Fleuret, 2017; Cheng et al., 2018) or predicted class probabilities (Yang et al., 2015). Acceleration is important as training on all examples is more expensive than just the labeled ones, and is repeated at every cycle. On the contrary, unsupervised pre-trained only occurs once at the beginning.
+
+The particular choice of components is not important: any unsupervised representation learning could replace Caron et al. (2018) in line 2 and any semi-supervised learning could replace Iscen et al. (2019) in lines 4-7 of Algorithm 1. We keep the pipeline as simple as possible, facilitating comparisons with more effective choices in the future.
+
+# 5 INVESTIGATING MANIFOLD SIMILARITY IN THE ACQUISITION FUNCTION
+
+Label propagation (Zhou et al., 2003a; Iscen et al., 2019) is based on the manifold structure of the feature space, as captured by the normalized affinity matrix $\mathcal { W }$ . Rather than just using this information for propagating labels to unlabeled examples, can we use it in the acquisition function as well? This is important in interpreting the effect of semi-supervised learning in Algorithm 1: is any gain due to the use of manifold similarity, or to training the model on more data?
+
+Joint label propagation (jLP), introduced here, is an attempt to answer these questions. It is an acquisition function similar in nature to the geometric approach (4), with Euclidean distance replaced by manifold similarity. In particular, the $n$ -vector $Y \mathbf { 1 } _ { c }$ , the row-wise sum of $Y = \chi ( L , \mathbf { y } )$ (8), can be expressed as $Y \mathbf { 1 } _ { c } = { \overset { \cdot } { \delta } } ( L ) { \overset { \cdot } { \in } } \mathbb { R } ^ { n }$ , where
+
+$$
+\delta ( L ) _ { i } : = { \left\{ \begin{array} { l l } { 1 , } & { i \in L , } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+for $i \in \mathcal { T }$ . Hence, in the terminology of manifold ranking (Zhou et al., 2003b), vector $Y \mathbf { 1 } _ { c }$ represents a set of queries, one for each example $\mathbf { x } _ { i }$ for $i \in L$ , and the $i$ -th element of the $n$ -vector $h ( Y ) \mathbf { 1 } _ { c }$ in (9) expresses the manifold similarity of $\mathbf { x } _ { i }$ to the queries for $i \in \mathcal { T }$ . Similar to (4), we acquire the example in $U$ that is the least similar to examples in $L$ that are labeled or previously acquired:
+
+$$
+a ( X , L , U , \mathbf { y } ; \theta ) : = \arg \operatorname* { m i n } _ { i \in U } ( h ( \delta ( L ) ) ) _ { i } .
+$$
+
+This strategy is only geometric and bears similarities to discriminative active learning (Gissin & Shalev-Shwartz, 2018), which learns a binary classifier to discriminate labeled from unlabeled examples and acquires examples of least confidence in the “labeled” class.
+
+# 6 EXPERIMENTS
+
+# 6.1 EXPERIMENTAL SETUP
+
+Datasets. We conduct experiments on four datasets that are most often used in deep active learning: MNIST (LeCun et al., 1998), SVHN (Netzer et al., 2011), CIFAR-10 and CIFAR-100 (Krizhevsky, 2009). Table 1 presents statistics of the datasets. Following Tarvainen & Valpola (2017); Iscen et al. (2019), we augment input images by $4 \times 4$ random translations and random horizontal flips.
+
+Networks and training. For all experiments we use a 13-layer convolutional network used previously in Laine & Aila (2016). We train the model from scratch at each active learning cycle, using
+
+![](images/c631eb10323603c551e4cb0ef821224f3c5a8d6363dc30753eb9d634caf1a070.jpg)  
+Figure 1: Average accuracy vs. cycle on different setups and acquisition strategies.
+
+![](images/c7545e3d0d3112484ce3b85e770fe9108cdf39e891a219e1a32203998ffc9879.jpg)  
+Figure 2: Average accuracy vs. cycle on different setups and acquisition strategies with PRE.
+
+SGD with momentum of 0.9 for 200 epochs. An initial learning rate of 0.2 is decayed by cosine annealing (Loshchilov & Hutter, 2017), scheduled to reach zero at 210 epochs. The mini-batch size is 32 for standard training and 128 when SEMI is used, except for MNIST where the size of the mini-batch 10 and 64 with SEMI. All other parameters follow Tarvainen & Valpola (2017).
+
+Unsupervised pre-training. We use $k$ -means as the clustering algorithm and follow the settings of Caron et al. (2018). The model is trained for 250 epochs on the respective datasets.
+
+Semi-supervised learning. Following Iscen et al. (2019), we construct a reciprocal $k$ -nearest neighbor graph on features $\phi _ { \theta } ( X )$ , with $k = 5 0$ neighbors and similarity function $s ( \mathbf { \hat { u } } , \mathbf { v } ) : = [ \hat { \mathbf { u } } ^ { \top } \hat { \mathbf { v } } ] _ { + } ^ { 3 }$ for $\mathbf { u } , \mathbf { v } \in \mathbb { R } ^ { d }$ , where $\hat { \bf { u } }$ is the $\ell _ { 2 }$ -normalized counterpart of $\mathbf { u }$ , while $\alpha = 0 . 9 9$ in (9). We follow Iscen et al. (2019) in splitting mini-batches into two parts: 50 examples (10 for MNIST) are labeled and the remaining pseudo-labeled. For the latter, we draw examples using normalized weights as a discrete distribution. The epoch ends when ${ \begin{array} { l } { { \frac { 1 } { 2 } } \left| U \right| } \end{array} }$ pseudo-labels have been drawn, that is the epoch is $50 \%$ compared to Iscen et al. (2019). Given that $| L | \ll | U |$ in most cases, the labeled examples are typically repeated more than once.
+
+Acquisition strategies. We evaluate our new acquisition strategy jLP along with the following baselines: (a) Random; (b) Uncertainty based on entropy (5); (c) CEAL (Wang et al., 2017), combining entropy with pseudo-labels (7); (d) the greedy version of CoreSet (4) (Sener & Savarese, 2018; Geifman & El-Yaniv, 2017).
+
+Baselines. For all acquisition strategies, we show results of the complete Algorithm 1 as well as the the standard baseline, that is without pre-training and only fully supervised on labeled examples $L$ , and unsupervised pre-training (PRE) alone without semi-supervised. In some cases, we show semi-supervised (SEMI) alone. For instance, in the scenario of 100 labels per class, the effect of pre-training is small, especially in the presence of semi-supervised. CEAL (Wang et al., 2017) is a baseline with its own pseudo-labels, so we do not combine it with semi-supervised. The length of the epoch is fixed for Algorithm 1 and increases with each cycle.
+
+Label budget and cycles. We consider three different scenarios, as shown in Table 1. In the first, we use an initial balanced label set $L _ { 0 }$ of 10 labels per class, translating into a total of 100 for CIFAR-10 and SVHN and 1000 for CIFAR-100. We use the same values as label budget $b$ for all cycles. In the second, we use initially 100 labels per class in CIFAR-10 with $b = 1 0 0 0$ per cycle; this is not interesting for CIFAR-100 as it results in complete labeling of the training set after 4 cycles. Finally, we investigate the use of one label per class both as the initial set and the label budget, on MNIST, translating to 10 labels per cycle. All experiments are carried out for 5 cycles and repeated 5 times using different initial label sets $L _ { 0 }$ . We report average accuracy and standard deviation.
+
+![](images/bf1038df82cb573c5b888b081f887a9f01ffe7ba6b8d2a753b864392f836d61f.jpg)  
+Figure 3: Average accuracy vs. cycle on different setups and acquisition strategies.
+
+Table 2: Ablation study. Evaluation of results obtained with Random while adding PRE and/or SEMI.   
+
+<table><tr><td>METHOD</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>BUDGET</td><td>b=100</td><td>b= 1000</td></tr><tr><td>CYCLE0</td><td></td><td></td></tr><tr><td>jLP</td><td>29.17±1.62</td><td>19.63±0.99</td></tr><tr><td>+PRE</td><td>35.20±2.26</td><td>23.71±0.86</td></tr><tr><td>+ SEMI</td><td>36.73±5.70</td><td>25.06±1.44</td></tr><tr><td>+ PRE+ SEMI</td><td>38.05±2.92</td><td>27.04±0.78</td></tr><tr><td>CYCLE1</td><td></td><td></td></tr><tr><td>jLP</td><td>38.86±1.36</td><td>32.16±1.98</td></tr><tr><td>+PRE</td><td>42.07±0.74</td><td>33.48±0.52</td></tr><tr><td>+ SEMI</td><td>46.76±3.27</td><td>37.99±2.47</td></tr><tr><td>+ PRE + SEMI</td><td>48.66±2.64</td><td>40.30±1.53</td></tr><tr><td>CYCLE 2</td><td></td><td></td></tr><tr><td>jLP</td><td>42.30±1.61</td><td>40.65±1.21</td></tr><tr><td>+PRE</td><td>47.99±1.17</td><td>40.81±0.40</td></tr><tr><td>+ SEMI</td><td>51.53±3.02</td><td>46.39±1.49</td></tr><tr><td>+ PRE+ SEMI</td><td>51.18±1.80</td><td>47.03±0.47</td></tr></table>
+
+# 6.2 STANDARD BASELINE RESULTS
+
+We first evaluate acquisition functions without using any unlabeled data. Figure 1 presents results on SVHN, CIFAR-10 and CIFAR-100. The differences between acquisition functions are not significant, except when compared to Random. On SVHN, Random appears to be considerably better than the other acquisition functions and worse on CIFAR-10 with $b = 1 0 0 0$ . All the other acquisition functions give near identical results; in particular, there is no clear winner in the case of 10 labels per class on CIFAR-10 and CIFAR-100 (Figure 1(b) and (d), respectively).
+
+This confirms similar observations made in Gissin & Shalev-Shwartz (2018) and Chitta et al. (2019). Our jLP is no exception, giving similar results to the other acquisition functions. We study this phenomenon in Appendix B. In summary, we find that while the ranks of examples according to different strategies may be uncorrelated, the resulting predictions of label propagation mostly agree. Even in cases of disagreement, the corresponding examples have small weights, hence their contribution to the cost function is small. Since those predictions are used as pseudo-labels in Iscen et al. (2019), this can explain why the performance of the learned model is also similar in the presence of semi-supervised learning.
+
+# 6.3 THE EFFECT OF UNSUPERVISED PRE-TRAINING
+
+As shown in Figure 2, pre-training can be beneficial. PRE by itself brings substantial gain on SVHN and CIFAR-10 with $b = 1 0 0$ , up to $6 \%$ , while the improvements on CIFAR-100 are moderate. In addition, numerical results in Table 2 for our acquisition strategy jLP show that PRE is beneficial with or without SEMI in most cases. Pre-training provides a relatively easy and cost-effective improvement. It is performed only once at the beginning of the active learning process. While Caron et al. (2018) was originally tested on large datasets like ImageNet or YFCC100M, we show that it can be beneficial even on smaller datasets like CIFAR-10 or SVHN.
+
+# 6.4 THE EFFECT OF SEMI-SUPERVISED LEARNING
+
+Figure 4 shows results on different datasets and acquisition strategies like Figure 2, but including both PRE and $\mathrm { P R E } + \mathrm { S E M I }$ . For the purpose of reproducibility, numeric results, including average and standard deviation measurements, are given in Appendix A for all cycles and datasets.
+
+The combination $\mathrm { P R E } + \mathrm { S E M I }$ yields a further significant improvement over PRE and the standard baseline, on all acquisition functions and datasets. For instance, on CIFAR-10 with a budget of 100, the most noticeable improvement comes from Random, where the improvement of $\mathrm { P R E } + \mathrm { S E M I }$ is around $15 \%$ over the standard baseline at all cycles. The improvement is around $10 \%$ in most other cases, which is by far greater than any potential difference between the acquisition methods. Also, noticeably, in the case of SVHN, Random with $\mathrm { P R E } + \mathrm { S E M I }$ reaches nearly the fully supervised accuracy after just 2 cycles (300 labeled examples in total).
+
+![](images/6ad4fa3320a4b13ae9e940ed578da192ae5b9f94138c6d0bbea262b2bfdbabc9.jpg)  
+Figure 4: Average accuracy vs. cycle on different setups and acquisition strategies: Baseline, PRE and PRE $+ \mathrm { S E M I }$ . PRE and $\mathrm { P R E } + \mathrm { S E M I }$ scenarios are represented using different dashed lines as presented in the legend. For reference, the full training accuracy is $9 6 . 9 7 \%$ for SVHN, $9 4 . 8 4 \%$ for CIFAR-10 and $7 6 . 4 3 \%$ for CIFAR-100.
+
+The gain from semi-supervised learning is dramatic in the few-labels regime of CIFAR-10 with $b = 1 0 0$ . A single cycle with $\mathrm { P R E } + \mathrm { S E M I }$ achieves the accuracy of 4 cycles of the standard baseline in this case, which translates to a significant reduction of cost for human annotation.
+
+In Table 2 we present the effect of all four combinations: with/without PRE and with/without SEMI. We focus on our jLP acquisition strategy, which has similar performance as all other strategies and uses manifold similarity just like SEMI. In most cases, PRE improves over SEMI alone by around $2 \%$ . The use of PRE appears to be particularly beneficial in the first cycles, while its impact decreases as the model performance improves.
+
+It is worth noting that CEAL, which makes use of pseudo-labels, has a low performance. This has been observed before (Ducoffe & Precioso, 2018) and can be attributed to the fact that it is using the same set of pseudo-labels in every epoch. By contrast, pseudo-labels are updated in every epoch in our case.
+
+# 6.5 LABEL PROPAGATION WITH ONE LABEL PER CLASS
+
+Since PRE and SEMI have a significant gain in classification accuracy, it is reasonable to attempt even fewer labeled examples than in previous work on active learning. We investigate the extreme case of one label per class using MNIST as a benchmark, that is, label budget at each cycle is equal to the number of classes. Figure 3 shows results on all acquisition strategies with and without SEMI. As in the previous experiments, there is no consistent winner among the selection strategies alone, and accuracy remain below $80 \%$ after 5 cycles (50 labels in total) without SEMI. By contrast, Random with SEMI arrives at $9 0 . 8 9 \%$ accuracy after two cycles (20 labeled examples), which is $40 \%$ better than without SEMI.
+
+# 7 DISCUSSION
+
+In this work, we have shown the benefit of using both labeled and unlabeled data during model training in deep active learning for image classification. This leads to a more accurate model while requiring less labeled data, which is in itself one of the main objectives of active learning. We have used two particular choices for unsupervised feature learning and semi-supervised learning as components in our pipeline. There are several state of the art methods that could be used for the same purpose, for instance Tarvainen & Valpola (2017); Verma et al. (2019); Berthelot et al. (2019); Rebuffi et al. (2019) for semi-supervised learning. Our pipeline is as simple as possible, facilitating comparisons with more effective choices, which can only strengthen our results. While the improvement coming from recent acquisition strategies is marginal in many scenarios, an active learning approach that uses unlabeled data for training and not just acquisition appears to be a very good option for deep network models. Our findings can have an impact on how deep active learning is evaluated in the future. For instance, the relative performance of the random baseline to all other acquisition strategies depends strongly on the label budget, the cycle and the presence of pre-training and semi-supervised learning.
+
+REFERENCES   
+D. Arthur and S. Vassilvitskii. K-means $^ { + + }$ : the advantages of careful seeding. In SODA. Society for Industrial and Applied Mathematics, 2007.   
+William H Beluch, Tim Genewein, Andreas Nürnberger, and Jan M Köhler. The power of ensembles for active learning in image classification. In CVPR, 2018.   
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. arXiv preprint arXiv:1905.02249, 2019.   
+Piotr Bojanowski and Armand Joulin. Unsupervised learning by predicting noise. In ICML, 2017.   
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. arXiv preprint arXiv:1807.05520, 2018.   
+Olivier Chapelle, Bernhard Scholkopf, and Alexander Zien. Semi-Supervised Learning. MIT Press, 2006.   
+Bowen Cheng, Yunchao Wei, Honghui Shi, Shiyu Chang, Jinjun Xiong, and Thomas S. Huang. Revisiting pre-training: An efficient training method for image classification. arXiv preprint arXiv:1811.09347, 2018.   
+Kashyap Chitta, Jose M Alvarez, and Adam Lesnikowski. Large-scale visual active learning with deep probabilistic ensembles. arXiv preprint arXiv:1811.03575, 2019.   
+Carl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In ICCV, 2015.   
+Melanie Ducoffe and Frederic Precioso. Adversarial active learning for deep networks: a margin based approach. arXiv preprint arXiv:1802.09841, 2018.   
+Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. arXiv preprint arXiv:1703.02910, 2017.   
+Yonatan Geifman and Ran El-Yaniv. Deep active learning over the long tail. arXiv preprint arXiv:1711.00941, 2017.   
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. In ICLR, 2018.   
+Daniel Gissin and Shai Shalev-Shwartz. Discriminative active learning. 2018.   
+A. Iscen, G. Tolias, Y. Avrithis, and O. Chum. Label propagation for deep semi-supervised learning. In CVPR, 2019.   
+Angelos Katharopoulos and François Fleuret. Biased importance sampling for deep neural network training. arXiv preprint arXiv:1706.00043, 2017.   
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.   
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In ICLR, 2017.   
+Yann LeCun, Léon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Yanchao Li, Yong li Wang, Dong-Jun Yu, Ye Ning, Peng Hu, and Ruxin Zhao. Ascent: Active supervision for semi-supervised learning. IEEE Transactions on Knowledge and Data Engineering, 2019.   
+Jun Long, Jianping Yin, Wentao Zhao, and En Zhu. Graph-based active learning based on label propagation. In International Conference on Modeling Decisions for Artificial Intelligence, pp. 179–190. Springer, 2008.   
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2017.
+
+Christoph Mayer and Radu Timofte. Adversarial sampling for active learning. arXiv preprint arXiv:1808.06671, 2018.
+
+M McCallum and K Nigam. Employing em in pool-based active learning for text classification, 1998. In ICML, 1998.
+
+Ion Muslea, Steven Minton, and Craig A Knoblock. Active $^ +$ semi-supervised learning $=$ robust multi-view learning. In ICML, 2002.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Ng. Reading digits in natural images with unsupervised feature learning. NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 01 2011.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016.
+
+Sylvestre-Alvise Rebuffi, Sebastien Ehrhardt, Kai Han, Andrea Vedaldi, and Andrew Zisserman. Semi-supervised learning with scarce annotations. arXiv preprint arXiv:1905.08845, 2019.
+
+Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. arXiv preprint arXiv:1708.00489, 2018.
+
+Burr Settles. Active learning literature survey. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 2009.
+
+Samarth Sinha, Sayna Ebrahimi, and Trevor Darrell. Variational adversarial active learning. arXiv preprint arXiv:1904.00370, 2019.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017.
+
+Vikas Verma, Alex Lamb, Juho Kannala, Yoshua Bengio, and David Lopez-Paz. Interpolation consistency training for semi-supervised learning. arXiv preprint arXiv:1903.03825, 2019.
+
+Keze Wang, Dongyu Zhang, Ya Li, Ruimao Zhang, and Liang Lin. Cost-effective active learning for deep image classification. IEEE Trans. CSVT, 27(12):2591–2600, 2017.
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.
+
+Weixin Yang, Lianwen Jin, Dacheng Tao, Zecheng Xie, and Ziyong Feng. Dropsample: A new training method to enhance deep convolutional neural networks for large-scale unconstrained handwritten chinese character recognition. arXiv preprint arXiv:1505.05354, 2015.
+
+Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. In NIPS, 2003a.
+
+Dengyong Zhou, Jason Weston, Arthur Gretton, Olivier Bousquet, and Bernhard SchÖlkopf. Ranking on data manifolds. In NIPS. 2003b.
+
+Zhi-Hua Zhou, Ke-Jia Chen, and Yuan Jiang. Exploiting unlabeled data in content-based image retrieval. In ECML, 2004.
+
+Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. Technical report, 2002.
+
+Xiaojin Zhu, John Lafferty, and Zoubin Ghahramani. Combining active learning and semi-supervised learning using gaussian fields and harmonic functions. In ICML 2003 workshop on the continuum from labeled to unlabeled data in machine learning and data mining, 2003.
+
+# A ALL DETAILED RESULTS
+
+In order to facilitate reproducibility, in this section we present all the detailed results in Table 3 and Table 4. We describe results obtained with the five methods presented before, namely Random, Uncertainty, CEAL, CoreSet and jLP. We evaluate them on CIFAR-10 with 10 and 100 labels per class (budget $b = 1 0 0$ and $b = 1 0 0 0$ respectively), CIFAR-100 with $b = 1 0 0 0$ in Table 3. We present results obtained on MNIST with only 1 label per class $b = 1 0 _ { . }$ ) and SVHN with $b = 1 0 0$ in Table 4.
+
+# B STUDYING THE AGREEMENT OF ACQUISITION STRATEGIES
+
+It has been observed that most acquisition strategies do not provide a significant improvement over standard uncertainty when using deep neural networks; for instance, all strategies perform similarly on CIFAR-10 and CIFAR-100 according to Gissin & Shalev-Shwartz (2018) and Chitta et al. (2019). To better understand the differences, the ranks of examples acquired by different strategies are compared pairwise by Gissin & Shalev-Shwartz (2018). We make a step further in this direction, using label propagation as a tool.
+
+# B.1 MEASURING AGREEMENT
+
+After the classifier is trained at any cycle using any reference acquisition function $a$ , we apply two different acquisition functions, say $a ^ { ( 1 ) }$ and $a ^ { ( 2 ) }$ , followed by labeling of acquired examples and label propagation, obtaining two different sets of predicted pseudo-labels $\hat { \mathbf { y } } ^ { ( 1 ) }$ and $\hat { \mathbf { y } } ^ { ( 2 ) }$ and weights $\mathbf { w } ^ { ( 1 ) }$ and $\bar { \mathbf { w } } ^ { ( 2 ) }$ on the unlabeled examples $U$ . We define the weighted accuracy
+
+$$
+A _ { U , \mathbf { w } } ( \mathbf { z } , \mathbf { z } ^ { \prime } ) = \sum _ { i \in U } \eta [ \mathbf { w } ] _ { i } \delta _ { z _ { i } , z _ { i } ^ { \prime } }
+$$
+
+for $\mathbf { z } , \mathbf { z } ^ { \prime } \in \mathbb { R } ^ { | U | }$ , where $\delta$ is the Kronecker delta function. Using the average weights $\mathbf { w } : = \textstyle \frac 1 2 ( \mathbf { w } ^ { ( 1 ) } +$ $\mathbf { w } ^ { ( 2 ) } ,$ ), we then measure the weighted accuracy ${ \cal A } _ { U , { \bf w } } ( { \bf y } ^ { ( 1 ) } , { \bf y } ^ { ( 2 ) } )$ , expressing the agreement of the two strategies, as well as the weighted accuracy $A _ { U , \mathbf { w } } ( \mathbf { y } ^ { ( k ) } , \mathbf { t } )$ of $a ^ { ( k ) }$ relative to the true labels t on $U$ for $k = 1 , 2$ . More measurements include weighted accuracies relative to true labels on subsets of $U$ where the two strategies agree or disagree. This way, assuming knowledge of the true labels on the entire set $X$ , we evaluate the quality of pseudo-labels used in semi-supervised learning in each cycle, casting label propagation as an efficient surrogate of the learning process.
+
+# B.2 RESULTS
+
+We show results on CIFAR-10 with $b = 1 0 0 0$ in this study. Following the experiments of Gissin & Shalev-Shwartz (2018), we first investigate the correlation of the ranks of unlabeled examples obtained by two acquisition functions. As shown in Figure 5(a), Uncertainty and jLP are not as heavily correlated compared to, for example, CoreSet and Uncertainty in Figure 5(b). The correlation between $j L P$ and CoreSet is also quite low as shown in Figure 5(c).
+
+It may of course be possible that two strategies with uncorrelated ranks still yield models of similar accuracy. To investigate this, we measure agreement as described above. Results are shown in Table 5. Uncertainty is used as a reference strategy, i.e. we train the model for a number of cycles using Uncertainty and then measure agreement and disagreement of another strategy to Uncertainty. After cycle 1, any two methods agree on around $80 \%$ of the pseudo-labels, while the remaining $20 \%$ have on average smaller weights compared to when the methods agree.
+
+We reach the same conclusions from a similar experiment where we actually train the model rather than perform label propagation. Hence, although examples are ranked differently by different strategies, their effect on prediction, either by training or label propagation, is small.
+
+Table 3: Average accuracy and standard deviation for different label budget $b$ and cycle on CIFAR-10 and CIFAR-100. Following Algorithm 1, we show the effect of unsupervised pre-training (PRE) and semi-supervised learning (SEMI) compared to the standard baseline.   
+
+<table><tr><td>METHOD</td><td colspan="3">CIFAR-10,b= 100</td><td colspan="2">CIFAR-10,b= 1000</td><td colspan="3">CIFAR-100,b = 1000</td></tr><tr><td>PRE</td><td></td><td>1</td><td></td><td></td><td></td><td></td><td>√</td><td></td></tr><tr><td>SEMI</td><td></td><td></td><td>广</td><td></td><td>√</td><td></td><td></td><td>?</td></tr><tr><td>CYCLE 0</td><td></td><td>100 LABELS</td><td></td><td colspan="2">1K LABELS</td><td></td><td>1K LABELS</td><td></td></tr><tr><td>Random</td><td>29.17±1.62</td><td>35.20±2.26</td><td>39.84±2.63</td><td>63.61±1.42</td><td>78.85±0.86</td><td>19.63±0.99</td><td>23.71±0.86</td><td>27.46±0.52</td></tr><tr><td>CYCLE1</td><td></td><td>200 LABELS</td><td></td><td colspan="2">2K LABELS</td><td></td><td>2K LABELS</td><td></td></tr><tr><td>Random</td><td>36.66±1.08</td><td>41.76±1.32</td><td>50.69±2.95</td><td>75.09±0.51</td><td>83.49±0.81</td><td>32.44±1.69</td><td>34.88±0.90</td><td>40.65±0.63</td></tr><tr><td>Uncertainty</td><td>37.59±1.93</td><td>40.56±2.21</td><td>46.04±2.78</td><td>76.22±0.68</td><td>84.94±0.35</td><td>32.09±1.50</td><td>34.54±0.70</td><td>38.88±1.11</td></tr><tr><td>CoreSet</td><td>39.23±1.17</td><td>43.04±0.92</td><td>48.08±1.64</td><td>76.44±0.34</td><td>84.98±0.19</td><td>32.05±1.40</td><td>33.95±0.57</td><td>39.63±0.70</td></tr><tr><td>CEAL</td><td>38.92±2.00</td><td>39.74±1.72</td><td></td><td>76.52±0.73</td><td>1</td><td>31.59±0.93</td><td>33.78±0.39</td><td></td></tr><tr><td>jLP (ours)</td><td>38.86±1.36</td><td>42.07±0.74</td><td>48.66±2.64</td><td>75.74±0.39</td><td>84.62±0.47</td><td>32.16±1.98</td><td>33.48±0.52</td><td>40.30±1.53</td></tr><tr><td>CYCLE 2</td><td colspan="2">300 LABELS</td><td></td><td colspan="2">3K LABELS</td><td></td><td>3K LABELS</td><td></td></tr><tr><td>Random</td><td>42.12±1.83</td><td>46.31±1.40</td><td>58.72±4.04</td><td>79.45±0.56</td><td>85.33±0.42</td><td>42.45±0.90</td><td>42.37±0.53</td><td>47.42±0.53</td></tr><tr><td>Uncertainty</td><td>43.66±1.57</td><td>44.02±1.73</td><td>52.04±2.46</td><td>81.26±0.30</td><td>87.65±0.29</td><td>40.43±0.63</td><td>41.04±0.27</td><td>46.30±1.12</td></tr><tr><td>CoreSet</td><td>43.01±2.14</td><td>47.00±2.57</td><td>50.85±4.23</td><td>81.11±0.61</td><td>87.21±0.31</td><td>41.32±0.70</td><td>40.47±0.38</td><td>46.74±1.00</td></tr><tr><td>CEAL</td><td>41.74±1.15</td><td>44.92±2.09</td><td></td><td>81.37±0.54</td><td></td><td>41.19±0.41</td><td>41.55±0.45</td><td></td></tr><tr><td> jLP (ours)</td><td>42.30±1.61</td><td>47.99±1.17</td><td>51.18±1.80</td><td>80.97±0.40</td><td>87.16±0.44</td><td>40.65±1.21</td><td>40.81±0.40</td><td>47.03±0.47</td></tr><tr><td>CYCLE 3</td><td></td><td>400 LABELS</td><td></td><td colspan="2">4K LABELS</td><td></td><td>4K LABELS</td><td></td></tr><tr><td>Random</td><td>45.91±1.63</td><td>50.63±0.59</td><td>62.37±1.41</td><td>82.33±0.21</td><td>86.66±0.21</td><td>47.85±0.84</td><td>47.54±0.63</td><td>50.38±0.25</td></tr><tr><td>Uncertainty</td><td>47.89±1.78</td><td>50.03±1.38</td><td>55.47±2.10</td><td>84.47±0.49</td><td>89.32±0.24</td><td>47.26±0.79</td><td>46.39±0.81</td><td>50.42±0.24</td></tr><tr><td>CoreSet</td><td>46.75±2.41</td><td>51.40±1.99</td><td>56.93±2.90</td><td>84.27±0.36</td><td>88.75±0.45</td><td>46.22±0.39</td><td>46.34±0.92</td><td>50.85±0.32</td></tr><tr><td>CEAL</td><td>45.55±2.39</td><td>49.73±1.82</td><td>一</td><td>84.05±0.44</td><td>一</td><td>46.34±0.44</td><td>46.67±0.38</td><td></td></tr><tr><td>jLP (ours)</td><td>45.49±1.71</td><td>51.54±1.24</td><td>56.67±2.58</td><td>83.82±0.02</td><td>88.85±0.38</td><td>46.52±0.99</td><td>45.94±0.44</td><td>50.90±0.67</td></tr><tr><td>CYCLE 4</td><td colspan="2">500 LABELS</td><td></td><td colspan="2">5K LABELS</td><td colspan="2">5K LABELS</td><td></td></tr><tr><td>Random</td><td>50.94±1.75</td><td>55.31±1.28</td><td>64.35±1.37</td><td>84.10±0.10</td><td>87.23±0.21</td><td>51.43±0.56</td><td>51.40±0.47</td><td>53.58±0.64</td></tr><tr><td>Uncertainty</td><td>49.73±2.29</td><td>53.17±1.52</td><td>60.71±2.77</td><td>86.49±0.19</td><td>90.42±0.28</td><td>50.83±0.31</td><td>49.90±0.82</td><td>52.20±0.50</td></tr><tr><td>CoreSet</td><td>50.11±1.40</td><td>54.17±0.40</td><td>62.94±2.41</td><td>86.39±0.36</td><td>90.33±0.13</td><td>50.48±0.84</td><td>49.54±0.95</td><td>53.67±1.29</td></tr><tr><td>CEAL</td><td>48.14±1.24</td><td>53.46±1.27</td><td></td><td>86.31±0.23</td><td></td><td>50.62±0.28</td><td>50.18±0.60</td><td></td></tr><tr><td>jLP (ours)</td><td>48.93±2.22</td><td>53.89±1.42</td><td>59.83±4.02</td><td>85.94±0.38</td><td>89.91±0.28</td><td>50.24±0.93</td><td>50.20±0.44</td><td>53.37±0.64</td></tr></table>
+
+![](images/633479c7eb8990dbdc7225c41172b0894a00c4167bdd1336a3630cdb30ee5ebb.jpg)  
+Figure 5: Ranks of examples obtained by one acquisition strategy vs. the ranks of another on CIFAR-10 with $b = 1 0 0 0$ after cycle 1. A random $5 \%$ subset of all examples is shown.
+
+<table><tr><td>METHOD</td><td colspan="2">MNIST,b= 10</td><td colspan="3">SVHN,b= 100</td></tr><tr><td>PRE</td><td colspan="2"></td><td colspan="2">√</td><td></td></tr><tr><td>SEMI</td><td colspan="2"></td><td colspan="2"></td><td></td></tr><tr><td>CYCLEO</td><td>10 LABELS</td><td></td><td></td><td>100 LABELS</td><td></td></tr><tr><td>Random</td><td>26.83±4.15</td><td>70.06±12.87</td><td>18.00±2.47</td><td>23.83±4.63</td><td>19.01±5.61</td></tr><tr><td>CYCLE 1</td><td colspan="2">20 LABELS</td><td colspan="2">200 LABELS</td><td></td></tr><tr><td>Random</td><td>51.68±2.72</td><td>90.89±4.84</td><td>45.95±1.97</td><td>53.87±5.43</td><td>81.25±4.82</td></tr><tr><td>Uncertainty</td><td>53.18±5.88</td><td>76.12±11.07</td><td>31.63±8.75</td><td>51.52±2.36</td><td>37.84±21.00</td></tr><tr><td>CoreSet</td><td>57.94±7.16</td><td>86.59±10.98</td><td>35.39±7.16</td><td>52.49±5.76</td><td>51.80±10.62</td></tr><tr><td>CEAL</td><td>51.57±3.18</td><td>一</td><td>38.21±2.70</td><td>44.04±4.56</td><td></td></tr><tr><td>jLP (ours)</td><td>48.60±3.15</td><td>89.16±5.53</td><td>34.04±4.75</td><td>46.78±5.18</td><td>54.88±22.90</td></tr><tr><td>CYCLE2</td><td colspan="2">30 LABELS</td><td colspan="2">300 LABELS</td><td></td></tr><tr><td>Random</td><td>67.31±5.19</td><td>91.86±3.89</td><td>62.05±3.23</td><td>64.88±4.93</td><td>89.05±2.07</td></tr><tr><td>Uncertainty</td><td>63.55±2.67</td><td>80.05±13.29</td><td>44.09±13.49</td><td>63.85±3.55</td><td>64.14±6.36</td></tr><tr><td>CoreSet</td><td>63.66±3.84</td><td>76.28±15.38</td><td>52.59±9.20</td><td>67.23±3.01</td><td>73.88±13.94</td></tr><tr><td>CEAL</td><td>56.62±7.05</td><td></td><td>51.53±5.93</td><td>63.58±2.80</td><td></td></tr><tr><td>jLP (ours)</td><td>62.71±2.82</td><td>80.23±4.11</td><td>44.74±17.50</td><td>58.43±9.82</td><td>66.68±13.91</td></tr><tr><td>CYCLE 3</td><td colspan="2">40 LABELS</td><td colspan="2">400 LABELS</td><td></td></tr><tr><td>Random</td><td>71.05±1.66</td><td>93.38±3.99</td><td>70.28±1.67</td><td>72.50±2.05</td><td>90.69±0.73</td></tr><tr><td>Uncertainty</td><td>67.87±3.26</td><td>93.03±4.88</td><td>66.21±3.68</td><td>70.90±2.48</td><td>56.60±5.69</td></tr><tr><td>CoreSet</td><td>69.79±3.36</td><td>86.93±7.62</td><td>63.53±6.34</td><td>71.79±3.58</td><td>75.88±6.95</td></tr><tr><td>CEAL</td><td>65.24±7.43</td><td></td><td>66.48±2.80</td><td>68.95±2.06</td><td></td></tr><tr><td>jLP (ours)</td><td>65.55±4.01</td><td>90.75±5.76</td><td>63.33±9.59</td><td>71.20±2.93</td><td>73.28±11.69</td></tr><tr><td>CYCLE 4</td><td colspan="2">50 LABELS</td><td colspan="2">500 LABELS</td><td></td></tr><tr><td>Random</td><td>76.81±2.19</td><td>95.20±3.61</td><td>75.78±1.90</td><td>77.93±1.55</td><td>91.44±0.80</td></tr><tr><td>Uncertainty</td><td>72.88±5.82</td><td>83.42±5.93</td><td>68.04±6.58</td><td>76.70±1.11</td><td>55.42±10.49</td></tr><tr><td>CoreSet</td><td>75.76±3.93</td><td>87.04±6.44</td><td>66.17±16.11</td><td>75.11±3.40</td><td>72.51±9.99</td></tr><tr><td>CEAL</td><td>72.02±7.96</td><td>1</td><td>66.14±14.42</td><td>74.48±1.98</td><td>1</td></tr><tr><td>jLP (ours)</td><td>73.36±4.43</td><td>92.37±5.38</td><td>60.12±20.06</td><td>75.33±1.44</td><td>72.98±12.01</td></tr></table>
+
+Table 4: Average accuracy and standard deviation for different label budget $b$ and cycle on MNIST and SVHN. Following Algorithm 1, we show the effect of unsupervised pre-training (PRE) and semi-supervised learning (SEMI) compared to the standard baseline.
+
+Table 5: Agreement results between acquisition strategies on CIFAR-10 with $b = 1 0 0 0$ after cycles 1 and 2. All strategies are compared to Uncertainty as reference, which is also employed in the previous cycles. %agree is percentage of pseudo-labels agreeing to the reference. Accuracy is weighted according to (13) and weights are according to (10). Measurements denoted by $= ( \neq )$ refer to the set of pseudo-labels that agree (disagree) with the reference.   
+
+<table><tr><td>CYCLE</td><td colspan="4">1</td><td colspan="6"></td></tr><tr><td>MEASURE</td><td>%agree</td><td colspan="2">accuracy (13)</td><td colspan="2">avg weights</td><td>%agree</td><td colspan="2">accuracy (13)</td><td colspan="2">avg weights</td></tr><tr><td>AGREE？</td><td></td><td>二</td><td>+</td><td>二</td><td>土</td><td></td><td>二</td><td>+</td><td>二</td><td>牛</td></tr><tr><td>Random</td><td>79.98</td><td>79.97</td><td>38.39</td><td>0.32</td><td>0.17</td><td>86.98</td><td>88.07</td><td>39.77</td><td>0.46</td><td>0.28</td></tr><tr><td>CoreSet</td><td>80.58</td><td>79.52</td><td>44.57</td><td>0.27</td><td>0.16</td><td>87.32</td><td>87.94</td><td>43.80</td><td>0.45</td><td>0.29</td></tr><tr><td> jLP (ours)</td><td>80.24</td><td>80.03</td><td>48.79</td><td>0.27</td><td>0.15</td><td>86.96</td><td>88.12</td><td>45.55</td><td>0.43</td><td>0.27</td></tr></table>

parse/train/rJehllrtDS/rJehllrtDS_content_list.json

@@ -0,0 +1,1599 @@
+[
+    {
+        "type": "text",
+        "text": "RETHINKING DEEP ACTIVE LEARNING: USING UNLABELED DATA AT MODEL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            738,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Active learning typically focuses on training a model on few labeled examples alone, while unlabeled ones are only used for acquisition. In this work we depart from this setting by using both labeled and unlabeled data during model training across active learning cycles. We do so by using unsupervised feature learning at the beginning of the active learning pipeline and semi-supervised learning at every active learning cycle, on all available data. The former has not been investigated before in active learning, while the study of latter in the context of deep learning is scarce and recent findings are not conclusive with respect to its benefit. Our idea is orthogonal to acquisition strategies by using more data, much like ensemble methods use more models. By systematically evaluating on a number of popular acquisition strategies and datasets, we find that the use of unlabeled data during model training brings a spectacular accuracy improvement in image classification, compared to the differences between acquisition strategies. We thus explore smaller label budgets, even one label per class. ",
+        "bbox": [
+            233,
+            270,
+            766,
+            464
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            336,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Active learning (Settles, 2009) is an important pillar of machine learning but it has not been explored much in the context of deep learning until recently (Gal et al., 2017; Beluch et al., 2018; Wang et al., 2017; Geifman & El-Yaniv, 2017; Sener & Savarese, 2018). The standard active learning scenario focuses on training a model on few labeled examples alone, while unlabeled data are only used for acquisition, i.e., performing inference and selecting a subset for annotation. This is the opposite of what would normally work well when learning a deep model from scratch, i.e., training on a lot of data with some loss function that may need labels or not. At the same time, evidence is being accumulated that, when training powerful deep models, the difference in performance between acquisition strategies is small (Gissin & Shalev-Shwartz, 2018; Chitta et al., 2019; Beluch et al., 2018). ",
+        "bbox": [
+            173,
+            534,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, focusing on image classification, we revisit active deep learning with the seminal idea of using all data, whether labeled or not, during model training at each active learning cycle. This departs from the standard scenario in that unlabeled data are now directly contributing to the cost function being minimized and to subsequent parameter updates, rather than just being used to perform inference for acquisition, whereby parameters are fixed. We implement our idea using two principles: unsupervised feature learning and semi-supervised learning. While both are well recognized in deep learning in general, we argue that their value has been unexplored or underestimated in the context of deep active learning. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised feature learning or self-supervised learning is a very active area of research in deep learning, often taking the form of pre-training on artificial tasks with no human supervision for representation learning, followed by supervised fine-tuning on different target tasks like classification or object detection (Doersch et al., 2015; Wang & Gupta, 2015; Gidaris et al., 2018; Caron et al., 2018). To our knowledge, all deep active learning research so far considers training deep models from scratch. In this work, we perform unsupervised feature learning on all data once at the beginning of the active learning pipeline and use the resulting parameters to initialize the model at each active learning cycle. Relying on Caron et al. (2018), we show that such unsupervised pre-training improves accuracy in many cases at little additional cost. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning (Chapelle et al., 2006) and active learning can be seen as two facets of the same problem: the former focuses on most certain model predictions on unlabeled examples, while the latter on least certain ones. Combined approaches appeared quite early (McCallum & Nigam, 1998; Zhu et al., 2003). In the context of deep learning however, such combinations are scarce (Wang et al., 2017) and have even been found harmful in cases (Ducoffe & Precioso, 2018). It has also been argued that the two individual approaches have similar performance, while active learning has lower cost (Gal et al., 2017). In the meantime, research on deep semi-supervised learning is very active, bringing significant progress (Tarvainen & Valpola, 2017; Laine & Aila, 2017; Iscen et al., 2019; Verma et al., 2019). In this work, we use semi-supervised learning on all data at every active learning cycle, replacing supervised learning on labeled examples alone. Relying on Iscen et al. (2019), and contrary to previous findings Wang et al. (2017); Gal et al. (2017), we show that this consistently brings a dramatic accuracy improvement. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since Iscen et al. (2019) uses label propagation (Zhou et al., 2003a) to explore the manifold structure of the feature space, an important question is whether it is the manifold similarity or the use of unlabeled data during model training that actually helps. We address this question by introducing a new acquisition strategy that is based on label propagation. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we make the following contributions: ",
+        "bbox": [
+            176,
+            340,
+            503,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We systematically benchmark a number of existing acquisition strategies, as well as a new one, on a number of datasets, evaluating the benefit of unsupervised pre-training and semi-supervised learning in all cases.   \n• Contrary to previous findings, we show that using unlabeled data during model training can yield a dramatic gain compared to differences between acquisition strategies.   \n• Armed with this finding, we explore a smaller budget (fewer labeled examples) than prior work, and we find that the random baseline may actually outperform all other acquisition strategies by a large margin in cases. ",
+        "bbox": [
+            191,
+            361,
+            826,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            341,
+            516
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We focus on deep active and semi-supervised learning as well as their combination. ",
+        "bbox": [
+            176,
+            532,
+            718,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Active learning. Geometric methods like core sets (Geifman & El-Yaniv, 2017; Sener & Savarese, 2018) select examples based on distances in the feature space. The goal is to select a subset of examples that best approximate the whole unlabeled set. We introduce a similar approach where Euclidean distances are replaced by manifold ranking. There are methods inspired by adversarial learning. For instance, a binary classifier can be trained to discriminate whether an example belongs to the labeled or unlabeled set (Gissin & Shalev-Shwartz, 2018; Sinha et al., 2019). Adversarial examples have been used, being matched to the nearest unlabeled example (Mayer & Timofte, 2018) or added to the labeled pool (Ducoffe & Precioso, 2018). ",
+        "bbox": [
+            174,
+            558,
+            825,
+            669
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It has been observed however that deep networks can perform similarly regardless of the acquisition function (Gissin & Shalev-Shwartz, 2018; Chitta et al., 2019), which we further investigate here. Ensemble and Bayesian methods (Gal et al., 2017; Beluch et al., 2018; Chitta et al., 2019) target representing model uncertainty, which than can be used by different acquisition functions. This idea is orthogonal to acquisition strategies. In fact, Beluch et al. (2018); Chitta et al. (2019) show that the gain of ensemble models is more pronounced than the gain of any acquisition strategy. Of course, ensemble and Bayesian methods are more expensive than single models. Approximations include for instance a single model producing different outputs by dropout (Gal et al., 2017). Our idea of using all data during model training is also orthogonal to acquisition strategies. It is also more expensive than using labeled data alone, but the gain is spectacular in this case. This allows the use of much smaller label budget for the same accuracy, which is the essence of active learning. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised active learning has a long history (McCallum & Nigam, 1998; Muslea et al., 2002; Zhu et al., 2003; Zhou et al., 2004; Long et al., 2008). A recent deep learning approach acquires the least certain unlabeled examples for labeling and at the same time assigns predicted pseudo-labels to most certain examples (Wang et al., 2017). This does not always help (Ducoffe & Precioso, 2018). In some cases, semi-supervised algorithms are incorporated as part of an active learning evaluation (Li et al., 2019; Sener & Savarese, 2018). A comparative study suggests that semi-supervised learning does not significantly improve over active learning, despite its additional cost due to training on more data (Gal et al., 2017). We show that this is clearly not the case, using a state of the art semi-supervised method (Iscen et al., 2019) that is an inductive version of label propagation (Zhou et al., 2003a). This is related to Zhu & Ghahramani (2002); Zhu et al. (2003); Long et al. (2008), which however are limited to transductive learning. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised feature learning. A number of unsupervised feature learning approaches pair matching images to learn the representation using a siamese architecture. These pairs can come as fragments of the same image (Doersch et al., 2015; Noroozi & Favaro, 2016) or as a result of tracking in video (Wang & Gupta, 2015). Alternatively, the network is trained on an artificial task like image rotation prediction (Gidaris et al., 2018) or even matching images to a noisy target (Bojanowski & Joulin, 2017). The latter is conceptually related to deep clustering (Caron et al., 2018), the approach we use in this work, where the network learns targets resulting from unsupervised clustering. It is interesting that in the context of semi-supervised learning, unsupervised pre-training has been recently investigated by Rebuffi et al. (2019), with results are consistent with ours. However, the use of unsupervised pre-training in deep active learning remains unexplored. ",
+        "bbox": [
+            173,
+            184,
+            825,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION AND BACKGROUND",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            581,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Problem. We are given a set $X : = \\{ \\mathbf { x } _ { i } \\} _ { i \\in \\mathbb { Z } } \\subset \\mathcal { X }$ of $n$ examples where $\\mathcal { T } : = [ n ] : = \\{ 1 , \\dots , n \\}$ and, initially, a collection $\\mathbf { y } _ { 0 } : = ( y _ { i } ) _ { i \\in L _ { 0 } }$ of $b$ labels $y _ { i } \\in C$ for $i \\in L _ { 0 }$ , where $C : = [ c ]$ is a set of $c$ classes and $L _ { 0 } \\subset \\mathcal { T }$ a set of indices with $| L _ { 0 } | = b \\ll n$ . The goal of active learning (AL) (Settles, 2009) is to train a classifier in cycles, where in cycle $j = 0 , 1 , \\ldots$ we use a collection $\\mathbf { y } _ { j }$ of labels for training, and then we acquire (or sample) a new batch $S _ { j }$ of indices with $| S _ { j } | = b$ to label the corresponding examples for the next cycle $j + 1$ . Let $L _ { j } : = L _ { j - 1 } \\cup S _ { j - 1 } \\subset \\mathcal { T }$ be the set of indices of labeled examples in cycle $j \\geq 1$ and $U _ { j } : = \\mathcal { T } \\backslash L _ { j }$ the indices of the unlabeled examples for $j \\geq 0$ . Then $\\mathbf { y } _ { j } : = ( \\overline { { y } } _ { i } ) _ { i \\in L _ { j } }$ are the labels in cycle $j$ and ${ \\bar { S } } _ { j } \\subset U _ { j }$ is selected from the unlabeled examples. To keep notation simple, we will refer to a single cycle in the following, dropping subscripts $j$ . ",
+        "bbox": [
+            173,
+            377,
+            826,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Classifier learning. The classifier $f _ { \\theta } : \\mathcal { X }  \\mathbb { R } ^ { c }$ with parameters $\\theta$ , maps new examples to a vector of probabilities per class. Given $\\mathbf { x } \\in \\mathcal { X }$ , its prediction is the class of maximum probability ",
+        "bbox": [
+            173,
+            513,
+            823,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1e756de72393cd64a4c9b8721c774b7f8f95c5036aa333923acc9d97866d633.jpg",
+        "text": "$$\n\\pi ( \\mathbf { p } ) : = \\arg \\operatorname* { m a x } _ { k \\in C } p _ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            549,
+            570,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { k }$ is the $k$ -th element of vector $\\mathbf { p } : = f _ { \\theta } ( \\mathbf { x } )$ . As a by-product of learning parameters $\\theta$ , we have access to an embedding function $\\phi _ { \\theta } : \\mathcal { X }  \\mathbb { R } ^ { d }$ , mapping an example $\\mathbf { x } \\in \\mathcal { X }$ to a feature vector $\\phi _ { \\theta } ( \\mathbf { x } )$ . For instance, $f _ { \\theta }$ may be a linear classifier on top of features obtained by $\\phi _ { \\theta }$ . ",
+        "bbox": [
+            174,
+            579,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a typical AL scenario, given a set of indices $L$ of labeled examples and labels $\\mathbf { y }$ , the parameters $\\theta$ of the classifier are learned by minimizing the cost function ",
+        "bbox": [
+            169,
+            628,
+            823,
+            657
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25e79e90a41b2e44149b8f08426a6e2ad3ba95d22d1f9d1a16e358c787e66897.jpg",
+        "text": "$$\nJ ( X , L , \\mathbf { y } ; \\theta ) : = \\sum _ { i \\in L } \\ell ( f _ { \\theta } ( \\mathbf { x } _ { i } ) , y _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            664,
+            614,
+            698
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "on labeled examples $\\mathbf { x } _ { i }$ for $i \\in L$ , where cross-entropy $\\ell ( \\mathbf { p } , y ) : = - \\log p _ { y }$ for $\\mathbf { p } \\in \\mathbb { R } _ { + } ^ { c }$ , $y \\in C$ . ",
+        "bbox": [
+            171,
+            704,
+            797,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Acquisition. Given the set of indices $U$ of unlabeled examples and the parameters $\\theta$ resulting from training, one typically acquires a new batch by initializing $S \\gets \\emptyset$ and then greedily updating by ",
+        "bbox": [
+            169,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1705634518c4be1d34a51680197264b91451231f58013ae8833cb302bb7089b9.jpg",
+        "text": "$$\nS \\gets S \\cup \\{ a ( X , L \\cup S , U \\setminus S , \\mathbf { y } ; \\theta ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            765,
+            622,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "until $| S | \\geq b$ . Here $a$ is an acquisition (or sampling) function, each time selecting one example from $U \\backslash S$ . For each $i \\in S$ , the corresponding example $\\mathbf { x } _ { i }$ is then given as query to an oracle (often a human expert), who returns a label $y _ { i }$ to be used in the next cycle. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Geometry. Given parameters $\\theta$ , a simple acquisition strategy is to use the geometry of examples in the feature space $\\mathcal { F } _ { \\theta } : = \\phi _ { \\theta } ( \\mathcal { X } )$ , without considering the classifier. Each example $\\mathbf { x } _ { i }$ is represented by the feature vector $\\phi _ { \\theta } ( \\mathbf { x } _ { i } )$ for $i \\in \\mathcal { T }$ . One particular example is the function (Geifman & El-Yaniv, 2017; Sener & Savarese, 2018) ",
+        "bbox": [
+            173,
+            840,
+            825,
+            897
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90e0b639b7a12a496e326ed312f239a8d501a5df9a2314d62d6ca0abbe1db8ea.jpg",
+        "text": "$$\na ( X , L , U , \\mathbf { y } ; \\theta ) : = \\arg \\operatorname* { m a x } _ { i \\in U } \\operatorname* { m i n } _ { k \\in L } \\left\\| \\phi _ { \\theta } ( \\mathbf { x } _ { i } ) , \\phi _ { \\theta } ( \\mathbf { x } _ { k } ) \\right\\| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            904,
+            671,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "each time selecting the unlabeled example in $U$ that is the most distant to its nearest labeled or previously acquired example in $L$ . Such geometric approaches are inherently related to clustering. For instance, $k$ -means $^ { + + }$ (Arthur & Vassilvitskii, 2007) is a probabilistic version of (4). ",
+        "bbox": [
+            173,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Uncertainty. A common acquisition strategy that considers the classifier is some measure of uncertainty in its prediction. Given a vector of probabilities $\\mathbf { p }$ , one such measure is the entropy ",
+        "bbox": [
+            169,
+            156,
+            825,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ff5e8f0b5a91cdff6d881a31297236bb386d4e4dbbadd3c9c9e3835dc269d58.jpg",
+        "text": "$$\nH ( \\mathbf { p } ) : = - \\sum _ { k = 1 } ^ { c } p _ { k } \\log p _ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            190,
+            584,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "taking values in $[ 0 , \\log c ]$ . Given parameters $\\theta$ , each example $\\mathbf { x } _ { i }$ is represented by the vector of probabilities $f _ { \\theta } ( \\mathbf { x } _ { i } )$ for $i \\in \\mathcal { Z }$ . Then, acquisition is defined by ",
+        "bbox": [
+            173,
+            237,
+            825,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2605c01e840c21172c75c1ccc8c9a8881be382462cdda9589ae937ac7d18dc4e.jpg",
+        "text": "$$\na ( X , L , U , \\mathbf { y } ; \\theta ) : = \\arg \\operatorname* { m a x } _ { i \\in U } H ( f _ { \\theta } ( \\mathbf { x } _ { i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            272,
+            632,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "effectively selecting the $b$ most uncertain unlabeled examples for labeling. ",
+        "bbox": [
+            173,
+            301,
+            660,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pseudo-labels. It is possible to use more data than the labeled examples while learning. In Wang et al. (2017) for example, given indices $L , U$ of labeled and unlabeled examples respectively and parameters $\\theta$ , one represents example $\\mathbf { x } _ { i }$ by $\\mathbf { p } _ { i } : = f _ { \\theta } ( \\mathbf { x } _ { i } )$ , selects the most certain unlabeled examples ",
+        "bbox": [
+            173,
+            325,
+            825,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e404a2f1829e48837ed3c403e65eedddee9edd79eedc26250c8ae77863e41f5.jpg",
+        "text": "$$\n\\hat { L } : = \\{ i \\in U : H ( \\mathbf { p } _ { i } ) \\leq \\epsilon \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            378,
+            591,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and assigns pseudo-label ${ \\hat { y } } _ { i } : = \\pi ( \\mathbf { p } _ { i } )$ by (1) for $i \\in \\hat { L }$ . The same cost function $J$ defined by (2) can now be used by augmenting $L$ to $L \\cup \\hat { L }$ and $\\mathbf { y }$ to $( \\mathbf { y } , \\hat { \\mathbf { y } } )$ , where $\\hat { \\mathbf { y } } : = \\left( \\hat { y } _ { i } \\right) _ { i \\in \\hat { L } }$ . This augmentation occurs once per cycle in Wang et al. (2017). This is an example of active semi-supervised learning. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transductive label propagation (Zhou et al., 2003a) refers to graph-based, semi-supervised learning. A nearest neighbor graph of the dataset $X$ is used, represented by a symmetric non-negative $n ~ \\times$ $n$ adjacency matrix $W$ with zero diagonal. This matrix is symmetrically normalized as $\\mathcal { W } : =$ $D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ , where $D : = \\mathrm { d i a g } ( W \\mathbf { 1 } )$ is the degree matrix and 1 is the all-ones vector. The given labels $\\mathbf { y } : = ( y _ { i } ) _ { i \\in L }$ are represented by a $n \\times c$ zero-one matrix $Y : = \\chi ( L , \\mathbf { y } )$ where row $i$ is a $c$ -vector that is a one-hot encoding of label $y _ { i }$ if example $\\mathbf { x } _ { i }$ is labeled and zero otherwise, ",
+        "bbox": [
+            173,
+            457,
+            825,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cccd08f4ec3134f6f35c59d18f44838589bd4fbba37b6883bd169bf9071c23f.jpg",
+        "text": "$$\n\\chi ( L , \\mathbf { y } ) _ { i k } : = { \\left\\{ \\begin{array} { l l } { 1 , } & { i \\in L \\land y _ { i } = k , } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            547,
+            617,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for $i \\in \\mathcal { T }$ and $k \\in C$ . Zhou et al. (2003a) define the $n \\times c$ matrix $P : = \\eta [ h ( Y ) ] ^ { 1 }$ , where ",
+        "bbox": [
+            168,
+            589,
+            748,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04266f2a0009588dbee1d34b8fe46e708ab9d6460a78beafa7857c4fb5910686.jpg",
+        "text": "$$\nh ( Y ) : = ( 1 - \\alpha ) ( I - \\alpha { \\mathcal { W } } ) ^ { - 1 } Y ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            611,
+            607,
+            630
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$I$ is the $n \\times n$ identity matrix, and $\\alpha \\in [ 0 , 1 )$ is a parameter. The $i$ -th row $\\mathbf { p } _ { i }$ of $P$ represents a vector of class probabilities of unlabeled example $\\mathbf { x } _ { i }$ , and a prediction can be made by $\\pi ( \\mathbf { p } _ { i } )$ (1) for $i \\in U$ This method is transductive because it cannot make predictions on previously unseen data without access to the original data $X$ . ",
+        "bbox": [
+            173,
+            635,
+            825,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inductive label propagation. Although the previous methods do not apply to unseen data by themselves, the predictions made on $X$ can again be used as pseudo-labels to train a classifier. This is done in Iscen et al. (2019), applied to semi-supervised learning. Like Wang et al. (2017), a pseudo-label is generated for unlabeled example $\\mathbf { x } _ { i }$ as ${ \\hat { y } } _ { i } : = \\pi ( \\mathbf { p } _ { i } )$ by (1), only now $\\mathbf { p } _ { i }$ is the $i$ -th row of the result $P$ of label propagation according to (9) rather than the classifier output $f _ { \\theta } ( \\mathbf { x } _ { i } )$ . Unlike Wang et al. (2017), all unlabeled examples are pseudo-labeled and an additional cost term $\\begin{array} { r } { J _ { w } ( X , U , \\hat { \\mathbf { y } } ; \\theta ) : = \\sum _ { i \\in U } { w _ { i } \\ell ( f _ { \\theta } ( \\mathbf { x } _ { i } ) , \\hat { y } _ { i } ) } } \\end{array}$ applies to those examples, where $\\hat { \\mathbf { y } } : = ( \\hat { y } _ { i } ) _ { i \\in U }$ and $w _ { i } : = \\beta ( \\mathbf { p } _ { i } )$ is a weight reflecting the certainty in the prediction of $\\hat { y } _ { i }$ : ",
+        "bbox": [
+            173,
+            700,
+            826,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f87e63bf3cbc9bbca3567348054b72aae2c37393977e07410451c9582149cba2.jpg",
+        "text": "$$\n\\beta ( \\mathbf { p } ) : = 1 - \\frac { H ( \\mathbf { p } ) } { \\log c } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            820,
+            568,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unlike Wang et al. (2017), the graph and the pseudo-labels are updated once per epoch during learning in Iscen et al. (2019), where there are no cycles. ",
+        "bbox": [
+            173,
+            859,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised feature learning. Finally, it is possible to train an embedding function in an unsupervised fashion. A simple method that does not make any assumption on the nature or structure of the data is Caron et al. (2018). Simply put, starting by randomly initialized parameters $\\theta$ , the data $\\phi _ { \\theta } ( X )$ are clustered by $k$ -means, each example is assigned to the nearest centroid, clusters and assignments are treated as classes $C$ and pseudo-labels $\\hat { \\mathbf { y } }$ respectively, and learning takes place according to $J ( X , { \\mathcal { T } } , { \\hat { \\mathbf { y } } } , \\theta )$ (2). By updating the parameters $\\theta$ , $\\phi _ { \\theta } ( X )$ is updated too. The method therefore alternates between clustering/pseudo-labeling and feature learning, typically once per epoch. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 TRAINING THE MODEL ON UNLABELED DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            227,
+            580,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We argue that acquiring examples for labeling is not making the best use of unlabeled data: unlabeled data should be used during model training, appearing in the cost function that is being minimized. We choose two ways of doing so: unsupervised feature learning and semi-supervised learning. As outlined in Algorithm 1, we follow the standard active learning setup, adding unsupervised pretraining at the beginning and replacing supervised learning on $L$ by semi-supervised learning on $L \\cup U$ at each cycle. The individual components are discussed in more detail below. ",
+        "bbox": [
+            173,
+            260,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e5d4a5bff4bc5c0535e10393c750f60f252be77cff1765c13593ef25018cea72.jpg",
+        "table_caption": [
+            "Algorithm 1: Semi-supervised active learning "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Data:dataX,indices of labeled examplesL,labels y,batch size b</td></tr><tr><td>1U←I\\L</td><td>&gt;indices of unlabeled examples &gt; unsupervised pre-training</td></tr><tr><td>2 00 ←PRE(X)</td><td>&gt; active learning cycles</td></tr><tr><td>3 forj∈ {0,...} do 0 ← sUP(X,L,y;00) 4</td><td></td></tr><tr><td>fore ∈{i,...}do</td><td>&gt; supervised learning on L only &gt; epochs</td></tr><tr><td>5 (y,w)←LP(X,L,y,0)</td><td>&gt; pseudo-labels y and labels w</td></tr><tr><td>6 7</td><td>θ←SEMI(X,LUU,(y,y),w;0) &gt; semi-supervised learning on all data</td></tr><tr><td>s↑0 8</td><td></td></tr><tr><td>9 while|S|&lt;bdo</td><td>&gt; acquire a batch S C U for labeling</td></tr><tr><td>10</td><td>┌ S←SUa(X,LUS,U\\S,y;0)</td></tr><tr><td>y ← (y,LABEL(S)) 11 12 L←LUS;U←U\\S</td><td>&gt; obtain true labels on S by oracle update indices</td></tr></table>",
+        "bbox": [
+            158,
+            386,
+            826,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised pre-training (PRE) takes place at the beginning of the algorithm. We follow Caron et al. (2018), randomly initializing $\\theta$ and then alternating between clustering the features $\\phi _ { \\theta } ( X )$ by $k$ -means and learning on cluster assignment pseudo-labels $\\hat { \\mathbf { y } }$ of $X$ according to $J ( X , { \\mathcal { T } } , { \\hat { \\mathbf { y } } } , \\theta )$ (2). The result is a set of parameters $\\theta _ { 0 }$ used to initialize the classifier at every cycle. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            664
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning per cycle follows inductive label propagation (Iscen et al., 2019). This consists of supervised learning followed by alternating label propagation and semi-supervised learning on all examples $L \\cup U$ at every epoch. The supervised learning (SUP) is performed on the labeled examples $L$ only using labels y, according to $J ( X , L , \\mathbf { y } , \\theta )$ (2), where the parameters $\\theta$ are initialized by $\\theta _ { 0 }$ . ",
+        "bbox": [
+            174,
+            671,
+            825,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Label propagation (LP) involves a reciprocal $k$ -nearest neighbor graph on features $\\phi _ { \\theta } ( X )$ (Iscen et al., 2019). As in Zhou et al. (2003a), the resulting affinity matrix $W$ is normalized as $\\mathcal { W } : =$ $D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ . Label propagation is then performed according to $P = \\eta [ h ( Y ) ]$ (9), by solving the corresponding linear system using the conjugate gradient (CG) method (Iscen et al., 2019). The label matrix $Y : = { \\overset { \\vartriangle } { \\chi } } ( L , \\mathbf { y } )$ (8) is defined on the true labeled examples $L$ that remain fixed over epochs but grow over cycles. With $\\mathbf { p } _ { i }$ being the $i$ -th row of $P$ , a pseudo-label ${ \\hat { y } } _ { i } = \\pi ( \\mathbf { p } _ { i } )$ (1) and a weight $w _ { i } = \\beta ( \\mathbf { p } _ { i } )$ (10) are defined for every $i \\in U$ (Iscen et al., 2019). ",
+        "bbox": [
+            173,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning (SEMI) takes place on all examples $L \\cup U = \\mathcal { I }$ , where examples in $L$ have true labels y and examples in $U$ pseudo-labels $\\hat { \\mathbf { y } } : = ( \\hat { y } _ { i } ) _ { i \\in U }$ . Different than Iscen et al. (2019), we minimize the standard cost function $J ( X , L \\cup U , ( \\mathbf { y } , { \\hat { \\mathbf { y } } } ) , \\theta )$ (2), but we do take weights $\\mathbf { w } : = ( w _ { i } ) _ { i \\in U }$ into account in mini-batch sampling, $\\ell _ { 1 }$ -normalized as $\\eta [ \\mathbf { w } ]$ . In particular, part of each mini-batch is drawn uniformly at random from $L$ , while the other part is drawn with replacement from the discrete distribution $\\eta [ \\dot { \\bf w } ]$ on $U$ : an example may be drawn more than once per epoch or never. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa78f9db70d977c7a3462935bf3c6c374a000398169570ff74b298a442b86d5a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Data size train /test</td><td>Image size</td><td>Mini-batch size W/o SEMI/ SEMI</td><td>Budget</td><td>Total labels</td></tr><tr><td>MNIST</td><td>60000 /10000</td><td>28×28</td><td>10/64</td><td>10</td><td>50</td></tr><tr><td>SVHN</td><td>73257/26032</td><td>32×32</td><td>32/128</td><td>100</td><td>500</td></tr><tr><td>CIFAR-10</td><td>50000 /10000</td><td>32×32</td><td>32/128</td><td>100</td><td>500</td></tr><tr><td>CIFAR-10</td><td>50000/10000</td><td>32×32</td><td>32/128</td><td>1000</td><td>5000</td></tr><tr><td>CIFAR-100</td><td>50000 /10000</td><td>32×32</td><td>32/128</td><td>1000</td><td>5000</td></tr></table>",
+        "bbox": [
+            282,
+            101,
+            714,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Datasets used in this paper, including the mini-batch sizes used in training with and without SEMI, acquisition size at each active learning step and the total number of labeled images. ",
+        "bbox": [
+            173,
+            196,
+            823,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discussion. The above probabilistic weighting decouples the size of the epoch from $n$ and indeed we experiment with epochs smaller than $n$ , accelerating learning compared to Iscen et al. (2019). It is similar to importance sampling, which is typically based on loss values (Katharopoulos & Fleuret, 2017; Cheng et al., 2018) or predicted class probabilities (Yang et al., 2015). Acceleration is important as training on all examples is more expensive than just the labeled ones, and is repeated at every cycle. On the contrary, unsupervised pre-trained only occurs once at the beginning. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The particular choice of components is not important: any unsupervised representation learning could replace Caron et al. (2018) in line 2 and any semi-supervised learning could replace Iscen et al. (2019) in lines 4-7 of Algorithm 1. We keep the pipeline as simple as possible, facilitating comparisons with more effective choices in the future. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 INVESTIGATING MANIFOLD SIMILARITY IN THE ACQUISITION FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            415,
+            808,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Label propagation (Zhou et al., 2003a; Iscen et al., 2019) is based on the manifold structure of the feature space, as captured by the normalized affinity matrix $\\mathcal { W }$ . Rather than just using this information for propagating labels to unlabeled examples, can we use it in the acquisition function as well? This is important in interpreting the effect of semi-supervised learning in Algorithm 1: is any gain due to the use of manifold similarity, or to training the model on more data? ",
+        "bbox": [
+            174,
+            445,
+            825,
+            516
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Joint label propagation (jLP), introduced here, is an attempt to answer these questions. It is an acquisition function similar in nature to the geometric approach (4), with Euclidean distance replaced by manifold similarity. In particular, the $n$ -vector $Y \\mathbf { 1 } _ { c }$ , the row-wise sum of $Y = \\chi ( L , \\mathbf { y } )$ (8), can be expressed as $Y \\mathbf { 1 } _ { c } = { \\overset { \\cdot } { \\delta } } ( L ) { \\overset { \\cdot } { \\in } } \\mathbb { R } ^ { n }$ , where ",
+        "bbox": [
+            173,
+            522,
+            825,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/237196a3900cfec91a87acb33e96054f8950ae8e819cf56f3c1efd4f843a7d0c.jpg",
+        "text": "$$\n\\delta ( L ) _ { i } : = { \\left\\{ \\begin{array} { l l } { 1 , } & { i \\in L , } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            583,
+            584,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for $i \\in \\mathcal { T }$ . Hence, in the terminology of manifold ranking (Zhou et al., 2003b), vector $Y \\mathbf { 1 } _ { c }$ represents a set of queries, one for each example $\\mathbf { x } _ { i }$ for $i \\in L$ , and the $i$ -th element of the $n$ -vector $h ( Y ) \\mathbf { 1 } _ { c }$ in (9) expresses the manifold similarity of $\\mathbf { x } _ { i }$ to the queries for $i \\in \\mathcal { T }$ . Similar to (4), we acquire the example in $U$ that is the least similar to examples in $L$ that are labeled or previously acquired: ",
+        "bbox": [
+            173,
+            621,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/81bbb3e3036af0917ccbdb84c9bed438b5414d5b28d2bacff26e11f5a49fa51d.jpg",
+        "text": "$$\na ( X , L , U , \\mathbf { y } ; \\theta ) : = \\arg \\operatorname* { m i n } _ { i \\in U } ( h ( \\delta ( L ) ) ) _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            680,
+            630,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This strategy is only geometric and bears similarities to discriminative active learning (Gissin & Shalev-Shwartz, 2018), which learns a binary classifier to discriminate labeled from unlabeled examples and acquires examples of least confidence in the “labeled” class. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            326,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            374,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We conduct experiments on four datasets that are most often used in deep active learning: MNIST (LeCun et al., 1998), SVHN (Netzer et al., 2011), CIFAR-10 and CIFAR-100 (Krizhevsky, 2009). Table 1 presents statistics of the datasets. Following Tarvainen & Valpola (2017); Iscen et al. (2019), we augment input images by $4 \\times 4$ random translations and random horizontal flips. ",
+        "bbox": [
+            173,
+            829,
+            826,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Networks and training. For all experiments we use a 13-layer convolutional network used previously in Laine & Aila (2016). We train the model from scratch at each active learning cycle, using ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c631eb10323603c551e4cb0ef821224f3c5a8d6363dc30753eb9d634caf1a070.jpg",
+        "image_caption": [
+            "Figure 1: Average accuracy vs. cycle on different setups and acquisition strategies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            101,
+            485,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7545e3d0d3112484ce3b85e770fe9108cdf39e891a219e1a32203998ffc9879.jpg",
+        "image_caption": [
+            "Figure 2: Average accuracy vs. cycle on different setups and acquisition strategies with PRE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            102,
+            812,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SGD with momentum of 0.9 for 200 epochs. An initial learning rate of 0.2 is decayed by cosine annealing (Loshchilov & Hutter, 2017), scheduled to reach zero at 210 epochs. The mini-batch size is 32 for standard training and 128 when SEMI is used, except for MNIST where the size of the mini-batch 10 and 64 with SEMI. All other parameters follow Tarvainen & Valpola (2017). ",
+        "bbox": [
+            174,
+            400,
+            825,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised pre-training. We use $k$ -means as the clustering algorithm and follow the settings of Caron et al. (2018). The model is trained for 250 epochs on the respective datasets. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning. Following Iscen et al. (2019), we construct a reciprocal $k$ -nearest neighbor graph on features $\\phi _ { \\theta } ( X )$ , with $k = 5 0$ neighbors and similarity function $s ( \\mathbf { \\hat { u } } , \\mathbf { v } ) : = [ \\hat { \\mathbf { u } } ^ { \\top } \\hat { \\mathbf { v } } ] _ { + } ^ { 3 }$ for $\\mathbf { u } , \\mathbf { v } \\in \\mathbb { R } ^ { d }$ , where $\\hat { \\bf { u } }$ is the $\\ell _ { 2 }$ -normalized counterpart of $\\mathbf { u }$ , while $\\alpha = 0 . 9 9$ in (9). We follow Iscen et al. (2019) in splitting mini-batches into two parts: 50 examples (10 for MNIST) are labeled and the remaining pseudo-labeled. For the latter, we draw examples using normalized weights as a discrete distribution. The epoch ends when ${ \\begin{array} { l } { { \\frac { 1 } { 2 } } \\left| U \\right| } \\end{array} }$ pseudo-labels have been drawn, that is the epoch is $50 \\%$ compared to Iscen et al. (2019). Given that $| L | \\ll | U |$ in most cases, the labeled examples are typically repeated more than once. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Acquisition strategies. We evaluate our new acquisition strategy jLP along with the following baselines: (a) Random; (b) Uncertainty based on entropy (5); (c) CEAL (Wang et al., 2017), combining entropy with pseudo-labels (7); (d) the greedy version of CoreSet (4) (Sener & Savarese, 2018; Geifman & El-Yaniv, 2017). ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. For all acquisition strategies, we show results of the complete Algorithm 1 as well as the the standard baseline, that is without pre-training and only fully supervised on labeled examples $L$ , and unsupervised pre-training (PRE) alone without semi-supervised. In some cases, we show semi-supervised (SEMI) alone. For instance, in the scenario of 100 labels per class, the effect of pre-training is small, especially in the presence of semi-supervised. CEAL (Wang et al., 2017) is a baseline with its own pseudo-labels, so we do not combine it with semi-supervised. The length of the epoch is fixed for Algorithm 1 and increases with each cycle. ",
+        "bbox": [
+            173,
+            702,
+            825,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Label budget and cycles. We consider three different scenarios, as shown in Table 1. In the first, we use an initial balanced label set $L _ { 0 }$ of 10 labels per class, translating into a total of 100 for CIFAR-10 and SVHN and 1000 for CIFAR-100. We use the same values as label budget $b$ for all cycles. In the second, we use initially 100 labels per class in CIFAR-10 with $b = 1 0 0 0$ per cycle; this is not interesting for CIFAR-100 as it results in complete labeling of the training set after 4 cycles. Finally, we investigate the use of one label per class both as the initial set and the label budget, on MNIST, translating to 10 labels per cycle. All experiments are carried out for 5 cycles and repeated 5 times using different initial label sets $L _ { 0 }$ . We report average accuracy and standard deviation. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf1038df82cb573c5b888b081f887a9f01ffe7ba6b8d2a753b864392f836d61f.jpg",
+        "image_caption": [
+            "Figure 3: Average accuracy vs. cycle on different setups and acquisition strategies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            263,
+            113,
+            488,
+            305
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6fd82aa8bb3b812e5601eb9146219df71872374b71deec2293ed1a0f9b88f014.jpg",
+        "table_caption": [
+            "Table 2: Ablation study. Evaluation of results obtained with Random while adding PRE and/or SEMI. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>BUDGET</td><td>b=100</td><td>b= 1000</td></tr><tr><td>CYCLE0</td><td></td><td></td></tr><tr><td>jLP</td><td>29.17±1.62</td><td>19.63±0.99</td></tr><tr><td>+PRE</td><td>35.20±2.26</td><td>23.71±0.86</td></tr><tr><td>+ SEMI</td><td>36.73±5.70</td><td>25.06±1.44</td></tr><tr><td>+ PRE+ SEMI</td><td>38.05±2.92</td><td>27.04±0.78</td></tr><tr><td>CYCLE1</td><td></td><td></td></tr><tr><td>jLP</td><td>38.86±1.36</td><td>32.16±1.98</td></tr><tr><td>+PRE</td><td>42.07±0.74</td><td>33.48±0.52</td></tr><tr><td>+ SEMI</td><td>46.76±3.27</td><td>37.99±2.47</td></tr><tr><td>+ PRE + SEMI</td><td>48.66±2.64</td><td>40.30±1.53</td></tr><tr><td>CYCLE 2</td><td></td><td></td></tr><tr><td>jLP</td><td>42.30±1.61</td><td>40.65±1.21</td></tr><tr><td>+PRE</td><td>47.99±1.17</td><td>40.81±0.40</td></tr><tr><td>+ SEMI</td><td>51.53±3.02</td><td>46.39±1.49</td></tr><tr><td>+ PRE+ SEMI</td><td>51.18±1.80</td><td>47.03±0.47</td></tr></table>",
+        "bbox": [
+            550,
+            101,
+            779,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 STANDARD BASELINE RESULTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            387,
+            429,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate acquisition functions without using any unlabeled data. Figure 1 presents results on SVHN, CIFAR-10 and CIFAR-100. The differences between acquisition functions are not significant, except when compared to Random. On SVHN, Random appears to be considerably better than the other acquisition functions and worse on CIFAR-10 with $b = 1 0 0 0$ . All the other acquisition functions give near identical results; in particular, there is no clear winner in the case of 10 labels per class on CIFAR-10 and CIFAR-100 (Figure 1(b) and (d), respectively). ",
+        "bbox": [
+            174,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This confirms similar observations made in Gissin & Shalev-Shwartz (2018) and Chitta et al. (2019). Our jLP is no exception, giving similar results to the other acquisition functions. We study this phenomenon in Appendix B. In summary, we find that while the ranks of examples according to different strategies may be uncorrelated, the resulting predictions of label propagation mostly agree. Even in cases of disagreement, the corresponding examples have small weights, hence their contribution to the cost function is small. Since those predictions are used as pseudo-labels in Iscen et al. (2019), this can explain why the performance of the learned model is also similar in the presence of semi-supervised learning. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            616
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 THE EFFECT OF UNSUPERVISED PRE-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            539,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2, pre-training can be beneficial. PRE by itself brings substantial gain on SVHN and CIFAR-10 with $b = 1 0 0$ , up to $6 \\%$ , while the improvements on CIFAR-100 are moderate. In addition, numerical results in Table 2 for our acquisition strategy jLP show that PRE is beneficial with or without SEMI in most cases. Pre-training provides a relatively easy and cost-effective improvement. It is performed only once at the beginning of the active learning process. While Caron et al. (2018) was originally tested on large datasets like ImageNet or YFCC100M, we show that it can be beneficial even on smaller datasets like CIFAR-10 or SVHN. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.4 THE EFFECT OF SEMI-SUPERVISED LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            779,
+            527,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows results on different datasets and acquisition strategies like Figure 2, but including both PRE and $\\mathrm { P R E } + \\mathrm { S E M I }$ . For the purpose of reproducibility, numeric results, including average and standard deviation measurements, are given in Appendix A for all cycles and datasets. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The combination $\\mathrm { P R E } + \\mathrm { S E M I }$ yields a further significant improvement over PRE and the standard baseline, on all acquisition functions and datasets. For instance, on CIFAR-10 with a budget of 100, the most noticeable improvement comes from Random, where the improvement of $\\mathrm { P R E } + \\mathrm { S E M I }$ is around $15 \\%$ over the standard baseline at all cycles. The improvement is around $10 \\%$ in most other cases, which is by far greater than any potential difference between the acquisition methods. Also, noticeably, in the case of SVHN, Random with $\\mathrm { P R E } + \\mathrm { S E M I }$ reaches nearly the fully supervised accuracy after just 2 cycles (300 labeled examples in total). ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ad4fa3320a4b13ae9e940ed578da192ae5b9f94138c6d0bbea262b2bfdbabc9.jpg",
+        "image_caption": [
+            "Figure 4: Average accuracy vs. cycle on different setups and acquisition strategies: Baseline, PRE and PRE $+ \\mathrm { S E M I }$ . PRE and $\\mathrm { P R E } + \\mathrm { S E M I }$ scenarios are represented using different dashed lines as presented in the legend. For reference, the full training accuracy is $9 6 . 9 7 \\%$ for SVHN, $9 4 . 8 4 \\%$ for CIFAR-10 and $7 6 . 4 3 \\%$ for CIFAR-100. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            823,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            821,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The gain from semi-supervised learning is dramatic in the few-labels regime of CIFAR-10 with $b = 1 0 0$ . A single cycle with $\\mathrm { P R E } + \\mathrm { S E M I }$ achieves the accuracy of 4 cycles of the standard baseline in this case, which translates to a significant reduction of cost for human annotation. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Table 2 we present the effect of all four combinations: with/without PRE and with/without SEMI. We focus on our jLP acquisition strategy, which has similar performance as all other strategies and uses manifold similarity just like SEMI. In most cases, PRE improves over SEMI alone by around $2 \\%$ . The use of PRE appears to be particularly beneficial in the first cycles, while its impact decreases as the model performance improves. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that CEAL, which makes use of pseudo-labels, has a low performance. This has been observed before (Ducoffe & Precioso, 2018) and can be attributed to the fact that it is using the same set of pseudo-labels in every epoch. By contrast, pseudo-labels are updated in every epoch in our case. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.5 LABEL PROPAGATION WITH ONE LABEL PER CLASS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            568,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since PRE and SEMI have a significant gain in classification accuracy, it is reasonable to attempt even fewer labeled examples than in previous work on active learning. We investigate the extreme case of one label per class using MNIST as a benchmark, that is, label budget at each cycle is equal to the number of classes. Figure 3 shows results on all acquisition strategies with and without SEMI. As in the previous experiments, there is no consistent winner among the selection strategies alone, and accuracy remain below $80 \\%$ after 5 cycles (50 labels in total) without SEMI. By contrast, Random with SEMI arrives at $9 0 . 8 9 \\%$ accuracy after two cycles (20 labeled examples), which is $40 \\%$ better than without SEMI. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            310,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have shown the benefit of using both labeled and unlabeled data during model training in deep active learning for image classification. This leads to a more accurate model while requiring less labeled data, which is in itself one of the main objectives of active learning. We have used two particular choices for unsupervised feature learning and semi-supervised learning as components in our pipeline. There are several state of the art methods that could be used for the same purpose, for instance Tarvainen & Valpola (2017); Verma et al. (2019); Berthelot et al. (2019); Rebuffi et al. (2019) for semi-supervised learning. Our pipeline is as simple as possible, facilitating comparisons with more effective choices, which can only strengthen our results. While the improvement coming from recent acquisition strategies is marginal in many scenarios, an active learning approach that uses unlabeled data for training and not just acquisition appears to be a very good option for deep network models. Our findings can have an impact on how deep active learning is evaluated in the future. For instance, the relative performance of the random baseline to all other acquisition strategies depends strongly on the label budget, the cycle and the presence of pre-training and semi-supervised learning. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nD. Arthur and S. Vassilvitskii. K-means $^ { + + }$ : the advantages of careful seeding. In SODA. Society for Industrial and Applied Mathematics, 2007.   \nWilliam H Beluch, Tim Genewein, Andreas Nürnberger, and Jan M Köhler. The power of ensembles for active learning in image classification. In CVPR, 2018.   \nDavid Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. arXiv preprint arXiv:1905.02249, 2019.   \nPiotr Bojanowski and Armand Joulin. Unsupervised learning by predicting noise. In ICML, 2017.   \nMathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. arXiv preprint arXiv:1807.05520, 2018.   \nOlivier Chapelle, Bernhard Scholkopf, and Alexander Zien. Semi-Supervised Learning. MIT Press, 2006.   \nBowen Cheng, Yunchao Wei, Honghui Shi, Shiyu Chang, Jinjun Xiong, and Thomas S. Huang. Revisiting pre-training: An efficient training method for image classification. arXiv preprint arXiv:1811.09347, 2018.   \nKashyap Chitta, Jose M Alvarez, and Adam Lesnikowski. Large-scale visual active learning with deep probabilistic ensembles. arXiv preprint arXiv:1811.03575, 2019.   \nCarl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In ICCV, 2015.   \nMelanie Ducoffe and Frederic Precioso. Adversarial active learning for deep networks: a margin based approach. arXiv preprint arXiv:1802.09841, 2018.   \nYarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. arXiv preprint arXiv:1703.02910, 2017.   \nYonatan Geifman and Ran El-Yaniv. Deep active learning over the long tail. arXiv preprint arXiv:1711.00941, 2017.   \nSpyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. In ICLR, 2018.   \nDaniel Gissin and Shai Shalev-Shwartz. Discriminative active learning. 2018.   \nA. Iscen, G. Tolias, Y. Avrithis, and O. Chum. Label propagation for deep semi-supervised learning. In CVPR, 2019.   \nAngelos Katharopoulos and François Fleuret. Biased importance sampling for deep neural network training. arXiv preprint arXiv:1706.00043, 2017.   \nAlex Krizhevsky. Learning multiple layers of features from tiny images. 2009.   \nSamuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   \nSamuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In ICLR, 2017.   \nYann LeCun, Léon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nYanchao Li, Yong li Wang, Dong-Jun Yu, Ye Ning, Peng Hu, and Ruxin Zhao. Ascent: Active supervision for semi-supervised learning. IEEE Transactions on Knowledge and Data Engineering, 2019.   \nJun Long, Jianping Yin, Wentao Zhao, and En Zhu. Graph-based active learning based on label propagation. In International Conference on Modeling Decisions for Artificial Intelligence, pp. 179–190. Springer, 2008.   \nIlya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            155,
+            828,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christoph Mayer and Radu Timofte. Adversarial sampling for active learning. arXiv preprint arXiv:1808.06671, 2018. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            131
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "M McCallum and K Nigam. Employing em in pool-based active learning for text classification, 1998. In ICML, 1998. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            166
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ion Muslea, Steven Minton, and Craig A Knoblock. Active $^ +$ semi-supervised learning $=$ robust multi-view learning. In ICML, 2002. ",
+        "bbox": [
+            173,
+            174,
+            823,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Ng. Reading digits in natural images with unsupervised feature learning. NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 01 2011. ",
+        "bbox": [
+            174,
+            209,
+            823,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Sebastien Ehrhardt, Kai Han, Andrea Vedaldi, and Andrew Zisserman. Semi-supervised learning with scarce annotations. arXiv preprint arXiv:1905.08845, 2019. ",
+        "bbox": [
+            174,
+            292,
+            823,
+            320
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. arXiv preprint arXiv:1708.00489, 2018. ",
+        "bbox": [
+            174,
+            328,
+            823,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles. Active learning literature survey. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 2009. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samarth Sinha, Sayna Ebrahimi, and Trevor Darrell. Variational adversarial active learning. arXiv preprint arXiv:1904.00370, 2019. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            433,
+            821,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vikas Verma, Alex Lamb, Juho Kannala, Yoshua Bengio, and David Lopez-Paz. Interpolation consistency training for semi-supervised learning. arXiv preprint arXiv:1903.03825, 2019. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keze Wang, Dongyu Zhang, Ya Li, Ruimao Zhang, and Liang Lin. Cost-effective active learning for deep image classification. IEEE Trans. CSVT, 27(12):2591–2600, 2017. ",
+        "bbox": [
+            173,
+            503,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            566
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weixin Yang, Lianwen Jin, Dacheng Tao, Zecheng Xie, and Ziyong Feng. Dropsample: A new training method to enhance deep convolutional neural networks for large-scale unconstrained handwritten chinese character recognition. arXiv preprint arXiv:1505.05354, 2015. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. In NIPS, 2003a. ",
+        "bbox": [
+            174,
+            622,
+            821,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Jason Weston, Arthur Gretton, Olivier Bousquet, and Bernhard SchÖlkopf. Ranking on data manifolds. In NIPS. 2003b. ",
+        "bbox": [
+            173,
+            657,
+            823,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhi-Hua Zhou, Ke-Jia Chen, and Yuan Jiang. Exploiting unlabeled data in content-based image retrieval. In ECML, 2004. ",
+        "bbox": [
+            173,
+            693,
+            823,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. Technical report, 2002. ",
+        "bbox": [
+            171,
+            728,
+            823,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu, John Lafferty, and Zoubin Ghahramani. Combining active learning and semi-supervised learning using gaussian fields and harmonic functions. In ICML 2003 workshop on the continuum from labeled to unlabeled data in machine learning and data mining, 2003. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            803
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ALL DETAILED RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            413,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In order to facilitate reproducibility, in this section we present all the detailed results in Table 3 and Table 4. We describe results obtained with the five methods presented before, namely Random, Uncertainty, CEAL, CoreSet and jLP. We evaluate them on CIFAR-10 with 10 and 100 labels per class (budget $b = 1 0 0$ and $b = 1 0 0 0$ respectively), CIFAR-100 with $b = 1 0 0 0$ in Table 3. We present results obtained on MNIST with only 1 label per class $b = 1 0 _ { . }$ ) and SVHN with $b = 1 0 0$ in Table 4. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B STUDYING THE AGREEMENT OF ACQUISITION STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            224,
+            694,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "It has been observed that most acquisition strategies do not provide a significant improvement over standard uncertainty when using deep neural networks; for instance, all strategies perform similarly on CIFAR-10 and CIFAR-100 according to Gissin & Shalev-Shwartz (2018) and Chitta et al. (2019). To better understand the differences, the ranks of examples acquired by different strategies are compared pairwise by Gissin & Shalev-Shwartz (2018). We make a step further in this direction, using label propagation as a tool. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            339
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 MEASURING AGREEMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            356,
+            397,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "After the classifier is trained at any cycle using any reference acquisition function $a$ , we apply two different acquisition functions, say $a ^ { ( 1 ) }$ and $a ^ { ( 2 ) }$ , followed by labeling of acquired examples and label propagation, obtaining two different sets of predicted pseudo-labels $\\hat { \\mathbf { y } } ^ { ( 1 ) }$ and $\\hat { \\mathbf { y } } ^ { ( 2 ) }$ and weights $\\mathbf { w } ^ { ( 1 ) }$ and $\\bar { \\mathbf { w } } ^ { ( 2 ) }$ on the unlabeled examples $U$ . We define the weighted accuracy ",
+        "bbox": [
+            174,
+            381,
+            825,
+            441
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f72eecc146c90a661901afe9972bc185175ec31823c67e5a7a106e6c8f39f2c6.jpg",
+        "text": "$$\nA _ { U , \\mathbf { w } } ( \\mathbf { z } , \\mathbf { z } ^ { \\prime } ) = \\sum _ { i \\in U } \\eta [ \\mathbf { w } ] _ { i } \\delta _ { z _ { i } , z _ { i } ^ { \\prime } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            448,
+            598,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "for $\\mathbf { z } , \\mathbf { z } ^ { \\prime } \\in \\mathbb { R } ^ { | U | }$ , where $\\delta$ is the Kronecker delta function. Using the average weights $\\mathbf { w } : = \\textstyle \\frac 1 2 ( \\mathbf { w } ^ { ( 1 ) } +$ $\\mathbf { w } ^ { ( 2 ) } ,$ ), we then measure the weighted accuracy ${ \\cal A } _ { U , { \\bf w } } ( { \\bf y } ^ { ( 1 ) } , { \\bf y } ^ { ( 2 ) } )$ , expressing the agreement of the two strategies, as well as the weighted accuracy $A _ { U , \\mathbf { w } } ( \\mathbf { y } ^ { ( k ) } , \\mathbf { t } )$ of $a ^ { ( k ) }$ relative to the true labels t on $U$ for $k = 1 , 2$ . More measurements include weighted accuracies relative to true labels on subsets of $U$ where the two strategies agree or disagree. This way, assuming knowledge of the true labels on the entire set $X$ , we evaluate the quality of pseudo-labels used in semi-supervised learning in each cycle, casting label propagation as an efficient surrogate of the learning process. ",
+        "bbox": [
+            173,
+            489,
+            826,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            281,
+            626
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show results on CIFAR-10 with $b = 1 0 0 0$ in this study. Following the experiments of Gissin & Shalev-Shwartz (2018), we first investigate the correlation of the ranks of unlabeled examples obtained by two acquisition functions. As shown in Figure 5(a), Uncertainty and jLP are not as heavily correlated compared to, for example, CoreSet and Uncertainty in Figure 5(b). The correlation between $j L P$ and CoreSet is also quite low as shown in Figure 5(c). ",
+        "bbox": [
+            174,
+            636,
+            825,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "It may of course be possible that two strategies with uncorrelated ranks still yield models of similar accuracy. To investigate this, we measure agreement as described above. Results are shown in Table 5. Uncertainty is used as a reference strategy, i.e. we train the model for a number of cycles using Uncertainty and then measure agreement and disagreement of another strategy to Uncertainty. After cycle 1, any two methods agree on around $80 \\%$ of the pseudo-labels, while the remaining $20 \\%$ have on average smaller weights compared to when the methods agree. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We reach the same conclusions from a similar experiment where we actually train the model rather than perform label propagation. Hence, although examples are ranked differently by different strategies, their effect on prediction, either by training or label propagation, is small. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f590528aabd523c1335115b95364068b72c4e985db40ad9391d4747f31c6aea.jpg",
+        "table_caption": [
+            "Table 3: Average accuracy and standard deviation for different label budget $b$ and cycle on CIFAR-10 and CIFAR-100. Following Algorithm 1, we show the effect of unsupervised pre-training (PRE) and semi-supervised learning (SEMI) compared to the standard baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td colspan=\"3\">CIFAR-10,b= 100</td><td colspan=\"2\">CIFAR-10,b= 1000</td><td colspan=\"3\">CIFAR-100,b = 1000</td></tr><tr><td>PRE</td><td></td><td>1</td><td></td><td></td><td></td><td></td><td>√</td><td></td></tr><tr><td>SEMI</td><td></td><td></td><td>广</td><td></td><td>√</td><td></td><td></td><td>?</td></tr><tr><td>CYCLE 0</td><td></td><td>100 LABELS</td><td></td><td colspan=\"2\">1K LABELS</td><td></td><td>1K LABELS</td><td></td></tr><tr><td>Random</td><td>29.17±1.62</td><td>35.20±2.26</td><td>39.84±2.63</td><td>63.61±1.42</td><td>78.85±0.86</td><td>19.63±0.99</td><td>23.71±0.86</td><td>27.46±0.52</td></tr><tr><td>CYCLE1</td><td></td><td>200 LABELS</td><td></td><td colspan=\"2\">2K LABELS</td><td></td><td>2K LABELS</td><td></td></tr><tr><td>Random</td><td>36.66±1.08</td><td>41.76±1.32</td><td>50.69±2.95</td><td>75.09±0.51</td><td>83.49±0.81</td><td>32.44±1.69</td><td>34.88±0.90</td><td>40.65±0.63</td></tr><tr><td>Uncertainty</td><td>37.59±1.93</td><td>40.56±2.21</td><td>46.04±2.78</td><td>76.22±0.68</td><td>84.94±0.35</td><td>32.09±1.50</td><td>34.54±0.70</td><td>38.88±1.11</td></tr><tr><td>CoreSet</td><td>39.23±1.17</td><td>43.04±0.92</td><td>48.08±1.64</td><td>76.44±0.34</td><td>84.98±0.19</td><td>32.05±1.40</td><td>33.95±0.57</td><td>39.63±0.70</td></tr><tr><td>CEAL</td><td>38.92±2.00</td><td>39.74±1.72</td><td></td><td>76.52±0.73</td><td>1</td><td>31.59±0.93</td><td>33.78±0.39</td><td></td></tr><tr><td>jLP (ours)</td><td>38.86±1.36</td><td>42.07±0.74</td><td>48.66±2.64</td><td>75.74±0.39</td><td>84.62±0.47</td><td>32.16±1.98</td><td>33.48±0.52</td><td>40.30±1.53</td></tr><tr><td>CYCLE 2</td><td colspan=\"2\">300 LABELS</td><td></td><td colspan=\"2\">3K LABELS</td><td></td><td>3K LABELS</td><td></td></tr><tr><td>Random</td><td>42.12±1.83</td><td>46.31±1.40</td><td>58.72±4.04</td><td>79.45±0.56</td><td>85.33±0.42</td><td>42.45±0.90</td><td>42.37±0.53</td><td>47.42±0.53</td></tr><tr><td>Uncertainty</td><td>43.66±1.57</td><td>44.02±1.73</td><td>52.04±2.46</td><td>81.26±0.30</td><td>87.65±0.29</td><td>40.43±0.63</td><td>41.04±0.27</td><td>46.30±1.12</td></tr><tr><td>CoreSet</td><td>43.01±2.14</td><td>47.00±2.57</td><td>50.85±4.23</td><td>81.11±0.61</td><td>87.21±0.31</td><td>41.32±0.70</td><td>40.47±0.38</td><td>46.74±1.00</td></tr><tr><td>CEAL</td><td>41.74±1.15</td><td>44.92±2.09</td><td></td><td>81.37±0.54</td><td></td><td>41.19±0.41</td><td>41.55±0.45</td><td></td></tr><tr><td> jLP (ours)</td><td>42.30±1.61</td><td>47.99±1.17</td><td>51.18±1.80</td><td>80.97±0.40</td><td>87.16±0.44</td><td>40.65±1.21</td><td>40.81±0.40</td><td>47.03±0.47</td></tr><tr><td>CYCLE 3</td><td></td><td>400 LABELS</td><td></td><td colspan=\"2\">4K LABELS</td><td></td><td>4K LABELS</td><td></td></tr><tr><td>Random</td><td>45.91±1.63</td><td>50.63±0.59</td><td>62.37±1.41</td><td>82.33±0.21</td><td>86.66±0.21</td><td>47.85±0.84</td><td>47.54±0.63</td><td>50.38±0.25</td></tr><tr><td>Uncertainty</td><td>47.89±1.78</td><td>50.03±1.38</td><td>55.47±2.10</td><td>84.47±0.49</td><td>89.32±0.24</td><td>47.26±0.79</td><td>46.39±0.81</td><td>50.42±0.24</td></tr><tr><td>CoreSet</td><td>46.75±2.41</td><td>51.40±1.99</td><td>56.93±2.90</td><td>84.27±0.36</td><td>88.75±0.45</td><td>46.22±0.39</td><td>46.34±0.92</td><td>50.85±0.32</td></tr><tr><td>CEAL</td><td>45.55±2.39</td><td>49.73±1.82</td><td>一</td><td>84.05±0.44</td><td>一</td><td>46.34±0.44</td><td>46.67±0.38</td><td></td></tr><tr><td>jLP (ours)</td><td>45.49±1.71</td><td>51.54±1.24</td><td>56.67±2.58</td><td>83.82±0.02</td><td>88.85±0.38</td><td>46.52±0.99</td><td>45.94±0.44</td><td>50.90±0.67</td></tr><tr><td>CYCLE 4</td><td colspan=\"2\">500 LABELS</td><td></td><td colspan=\"2\">5K LABELS</td><td colspan=\"2\">5K LABELS</td><td></td></tr><tr><td>Random</td><td>50.94±1.75</td><td>55.31±1.28</td><td>64.35±1.37</td><td>84.10±0.10</td><td>87.23±0.21</td><td>51.43±0.56</td><td>51.40±0.47</td><td>53.58±0.64</td></tr><tr><td>Uncertainty</td><td>49.73±2.29</td><td>53.17±1.52</td><td>60.71±2.77</td><td>86.49±0.19</td><td>90.42±0.28</td><td>50.83±0.31</td><td>49.90±0.82</td><td>52.20±0.50</td></tr><tr><td>CoreSet</td><td>50.11±1.40</td><td>54.17±0.40</td><td>62.94±2.41</td><td>86.39±0.36</td><td>90.33±0.13</td><td>50.48±0.84</td><td>49.54±0.95</td><td>53.67±1.29</td></tr><tr><td>CEAL</td><td>48.14±1.24</td><td>53.46±1.27</td><td></td><td>86.31±0.23</td><td></td><td>50.62±0.28</td><td>50.18±0.60</td><td></td></tr><tr><td>jLP (ours)</td><td>48.93±2.22</td><td>53.89±1.42</td><td>59.83±4.02</td><td>85.94±0.38</td><td>89.91±0.28</td><td>50.24±0.93</td><td>50.20±0.44</td><td>53.37±0.64</td></tr></table>",
+        "bbox": [
+            186,
+            148,
+            810,
+            518
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/633479c7eb8990dbdc7225c41172b0894a00c4167bdd1336a3630cdb30ee5ebb.jpg",
+        "image_caption": [
+            "Figure 5: Ranks of examples obtained by one acquisition strategy vs. the ranks of another on CIFAR-10 with $b = 1 0 0 0$ after cycle 1. A random $5 \\%$ subset of all examples is shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            679,
+            766,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9528c0265979532bfc88ce6390f3bb064ac41061e19f58ba924c2c4eebeadd1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td colspan=\"2\">MNIST,b= 10</td><td colspan=\"3\">SVHN,b= 100</td></tr><tr><td>PRE</td><td colspan=\"2\"></td><td colspan=\"2\">√</td><td></td></tr><tr><td>SEMI</td><td colspan=\"2\"></td><td colspan=\"2\"></td><td></td></tr><tr><td>CYCLEO</td><td>10 LABELS</td><td></td><td></td><td>100 LABELS</td><td></td></tr><tr><td>Random</td><td>26.83±4.15</td><td>70.06±12.87</td><td>18.00±2.47</td><td>23.83±4.63</td><td>19.01±5.61</td></tr><tr><td>CYCLE 1</td><td colspan=\"2\">20 LABELS</td><td colspan=\"2\">200 LABELS</td><td></td></tr><tr><td>Random</td><td>51.68±2.72</td><td>90.89±4.84</td><td>45.95±1.97</td><td>53.87±5.43</td><td>81.25±4.82</td></tr><tr><td>Uncertainty</td><td>53.18±5.88</td><td>76.12±11.07</td><td>31.63±8.75</td><td>51.52±2.36</td><td>37.84±21.00</td></tr><tr><td>CoreSet</td><td>57.94±7.16</td><td>86.59±10.98</td><td>35.39±7.16</td><td>52.49±5.76</td><td>51.80±10.62</td></tr><tr><td>CEAL</td><td>51.57±3.18</td><td>一</td><td>38.21±2.70</td><td>44.04±4.56</td><td></td></tr><tr><td>jLP (ours)</td><td>48.60±3.15</td><td>89.16±5.53</td><td>34.04±4.75</td><td>46.78±5.18</td><td>54.88±22.90</td></tr><tr><td>CYCLE2</td><td colspan=\"2\">30 LABELS</td><td colspan=\"2\">300 LABELS</td><td></td></tr><tr><td>Random</td><td>67.31±5.19</td><td>91.86±3.89</td><td>62.05±3.23</td><td>64.88±4.93</td><td>89.05±2.07</td></tr><tr><td>Uncertainty</td><td>63.55±2.67</td><td>80.05±13.29</td><td>44.09±13.49</td><td>63.85±3.55</td><td>64.14±6.36</td></tr><tr><td>CoreSet</td><td>63.66±3.84</td><td>76.28±15.38</td><td>52.59±9.20</td><td>67.23±3.01</td><td>73.88±13.94</td></tr><tr><td>CEAL</td><td>56.62±7.05</td><td></td><td>51.53±5.93</td><td>63.58±2.80</td><td></td></tr><tr><td>jLP (ours)</td><td>62.71±2.82</td><td>80.23±4.11</td><td>44.74±17.50</td><td>58.43±9.82</td><td>66.68±13.91</td></tr><tr><td>CYCLE 3</td><td colspan=\"2\">40 LABELS</td><td colspan=\"2\">400 LABELS</td><td></td></tr><tr><td>Random</td><td>71.05±1.66</td><td>93.38±3.99</td><td>70.28±1.67</td><td>72.50±2.05</td><td>90.69±0.73</td></tr><tr><td>Uncertainty</td><td>67.87±3.26</td><td>93.03±4.88</td><td>66.21±3.68</td><td>70.90±2.48</td><td>56.60±5.69</td></tr><tr><td>CoreSet</td><td>69.79±3.36</td><td>86.93±7.62</td><td>63.53±6.34</td><td>71.79±3.58</td><td>75.88±6.95</td></tr><tr><td>CEAL</td><td>65.24±7.43</td><td></td><td>66.48±2.80</td><td>68.95±2.06</td><td></td></tr><tr><td>jLP (ours)</td><td>65.55±4.01</td><td>90.75±5.76</td><td>63.33±9.59</td><td>71.20±2.93</td><td>73.28±11.69</td></tr><tr><td>CYCLE 4</td><td colspan=\"2\">50 LABELS</td><td colspan=\"2\">500 LABELS</td><td></td></tr><tr><td>Random</td><td>76.81±2.19</td><td>95.20±3.61</td><td>75.78±1.90</td><td>77.93±1.55</td><td>91.44±0.80</td></tr><tr><td>Uncertainty</td><td>72.88±5.82</td><td>83.42±5.93</td><td>68.04±6.58</td><td>76.70±1.11</td><td>55.42±10.49</td></tr><tr><td>CoreSet</td><td>75.76±3.93</td><td>87.04±6.44</td><td>66.17±16.11</td><td>75.11±3.40</td><td>72.51±9.99</td></tr><tr><td>CEAL</td><td>72.02±7.96</td><td>1</td><td>66.14±14.42</td><td>74.48±1.98</td><td>1</td></tr><tr><td>jLP (ours)</td><td>73.36±4.43</td><td>92.37±5.38</td><td>60.12±20.06</td><td>75.33±1.44</td><td>72.98±12.01</td></tr></table>",
+        "bbox": [
+            282,
+            156,
+            715,
+            527
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Average accuracy and standard deviation for different label budget $b$ and cycle on MNIST and SVHN. Following Algorithm 1, we show the effect of unsupervised pre-training (PRE) and semi-supervised learning (SEMI) compared to the standard baseline. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a541bcbdb95baa6aaa3b17f60279f8df10bf13699dd18a550cca94a4ee83c9d.jpg",
+        "table_caption": [
+            "Table 5: Agreement results between acquisition strategies on CIFAR-10 with $b = 1 0 0 0$ after cycles 1 and 2. All strategies are compared to Uncertainty as reference, which is also employed in the previous cycles. %agree is percentage of pseudo-labels agreeing to the reference. Accuracy is weighted according to (13) and weights are according to (10). Measurements denoted by $= ( \\neq )$ refer to the set of pseudo-labels that agree (disagree) with the reference. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>CYCLE</td><td colspan=\"4\">1</td><td colspan=\"6\"></td></tr><tr><td>MEASURE</td><td>%agree</td><td colspan=\"2\">accuracy (13)</td><td colspan=\"2\">avg weights</td><td>%agree</td><td colspan=\"2\">accuracy (13)</td><td colspan=\"2\">avg weights</td></tr><tr><td>AGREE？</td><td></td><td>二</td><td>+</td><td>二</td><td>土</td><td></td><td>二</td><td>+</td><td>二</td><td>牛</td></tr><tr><td>Random</td><td>79.98</td><td>79.97</td><td>38.39</td><td>0.32</td><td>0.17</td><td>86.98</td><td>88.07</td><td>39.77</td><td>0.46</td><td>0.28</td></tr><tr><td>CoreSet</td><td>80.58</td><td>79.52</td><td>44.57</td><td>0.27</td><td>0.16</td><td>87.32</td><td>87.94</td><td>43.80</td><td>0.45</td><td>0.29</td></tr><tr><td> jLP (ours)</td><td>80.24</td><td>80.03</td><td>48.79</td><td>0.27</td><td>0.15</td><td>86.96</td><td>88.12</td><td>45.55</td><td>0.43</td><td>0.27</td></tr></table>",
+        "bbox": [
+            192,
+            703,
+            802,
+            806
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rke3TJrtPS/rke3TJrtPS.md

@@ -0,0 +1,653 @@
+# PROJECTION-BASED CONSTRAINEDPOLICY OPTIMIZATION
+
+Tsung-Yen Yang Princeton University ty3@princeton.edu
+
+Justinian Rosca Siemens Corporation, Corporate Technology justinian.rosca@siemens.com
+
+Karthik Narasimhan Princeton University karthikn@princeton.edu
+
+Peter J. Ramadge Princeton University ramadge@princeton.edu
+
+# ABSTRACT
+
+We consider the problem of learning control policies that optimize a reward function while satisfying constraints due to considerations of safety, fairness, or other costs. We propose a new algorithm, Projection-Based Constrained Policy Optimization (PCPO). This is an iterative method for optimizing policies in a two-step process: the first step performs a local reward improvement update, while the second step reconciles any constraint violation by projecting the policy back onto the constraint set. We theoretically analyze PCPO and provide a lower bound on reward improvement, and an upper bound on constraint violation, for each policy update. We further characterize the convergence of PCPO based on two different metrics: $L ^ { 2 }$ norm and Kullback-Leibler divergence. Our empirical results over several control tasks demonstrate that PCPO achieves superior performance, averaging more than 3.5 times less constraint violation and around $15 \%$ higher reward compared to state-of-the-art methods.1
+
+# 1 INTRODUCTION
+
+Recent advances in deep reinforcement learning (RL) have demonstrated excellent performance on several domains ranging from games like Go (Silver et al., 2017) and StarCraft (AlphaStar, 2019) to robotic control (Levine et al., 2016). In these settings, agents are allowed to explore the entire state space and experiment with all possible actions during training. However, in many realworld applications such as self-driving cars and unmanned aerial vehicles, considerations of safety, fairness and other costs prevent the agent from having complete freedom to explore. For instance, an autonomous car, while optimizing its driving policies, must not take any actions that could cause harm to pedestrians or property (including itself). In effect, the agent is constrained to take actions that do not violate a specified set of constraints on state-action pairs. In this work, we address the problem of learning control policies that optimize a reward function while satisfying predefined constraints.
+
+The problem of policy learning with constraints is more challenging since directly optimizing for the reward, as in Q-Learning (Mnih et al., 2013) or policy gradient (Sutton et al., 2000), will usually violate the constraints. One approach is to incorporate constraints into the learning process by forming a constrained optimization problem. Then perform policy updates using a conditional gradient descent with line search to ensure constraint satisfaction (Achiam et al., 2017). However, the base optimization problem can become infeasible if the current policy violates the constraints. Another approach is to add a hyperparameter weighted copy of the constraints to the objective function (Tessler et al., 2018). However, this incurs the cost of extensive hyperparameter tuning.
+
+To address the above issues, we propose projection-based constrained policy optimization (PCPO). This is an iterative algorithm that performs policy updates in two stages. The first stage maximizes reward using a trust region optimization method (e.g., TRPO (Schulman et al., 2015a)) without constraints. This might result in a new intermediate policy that does not satisfy the constraints. The second stage reconciles the constraint violation (if any) by projecting the policy back onto the constraint set, i.e., choosing the policy in the constraint set that is closest to the selected intermediate policy. This allows efficient updates to ensure constraint satisfaction without requiring a line search (Achiam et al., 2017) or adjusting a weight (Tessler et al., 2018). Further, due to the projection step, PCPO offers efficient recovery from infeasible (i.e., constraint-violating) states (e.g., due to approximation errors), which existing methods do not handle well.
+
+We analyze PCPO theoretically and derive performance bounds for the algorithm. Specifically, based on information geometry and policy optimization theory, we construct a lower bound on reward improvement, and an upper bound on constraint violations for each policy update. We find that with a relatively small step size for each policy update, the worst-case constraint violation and reward degradation are tolerable. We further analyze two distance measures for the projection step onto the constraint set. We find that the convergence of PCPO is affected by the smallest and largest singular values of the Fisher information matrix used during training. By observing these singular values, we can choose the appropriate projection best suited to the problem.
+
+Empirically, we compare PCPO with state-of-the-art algorithms on four different control tasks, including two Mujoco environments with safety constraints introduced by Achiam et al. (2017) and two traffic management tasks with fairness constraints introduced by Vinitsky et al. (2018). In all cases, the proposed algorithm achieves comparable or superior performance to prior approaches, averaging more reward with fewer cumulative constraint violations. For instance, across the above tasks, PCPO achieves 3.5 times fewer constraint violations and around $15 \%$ more reward. This demonstrates the ability of PCPO robustly learn constraint-satisfying policies, and represents a step towards reliable deployment of RL in real problems.
+
+# 2 PRELIMINARIES
+
+We frame our policy learning as a constrained Markov Decision Process (CMDP) (Altman, 1999), where policies will direct the agent to maximize the reward while minimizing the cost. We define CMDP as the tuple $< S , A , T , R , C >$ , where $s$ is the set of states, $\mathcal { A }$ is the set of actions that the agent can take, $T : S \times A \times S  [ 0 , 1 ]$ is the transition probability of the CMDP, $R : S \times \mathcal { A }  \mathbb { R }$ is the reward function, and $C : S \times \mathcal { A }  \mathbb { R }$ is the cost function. Given the agent’s current state $s$ , the policy $\pi ( a | s ) : { \mathcal { S } } \to A$ selects an action $a$ for the agent to take. Based on $s$ and $a$ , the agent transits to the next state (denoted by $s ^ { \prime }$ ) according to the state transition model $T ( s ^ { \prime } | s , a )$ , and receives the reward and pays the cost, denoted by $R ( s , a )$ and $C ( s , a )$ , respectively.
+
+We aim to learn a policy $\pi$ that maximizes a cumulative discounted reward, denoted by
+
+$$
+J ^ { R } ( \pi ) \doteq \mathbb { E } _ { \tau \sim \pi } \big [ \sum _ { { t = 0 } } ^ { \infty } \gamma ^ { t } R ( s _ { t } , a _ { t } ) \big ] ,
+$$
+
+while satisfying constraints, i.e., making a cumulative discounted cost constraint below a desired threshold $h$ , denoted by
+
+$$
+J ^ { C } ( \pi ) \doteq \mathbb { E } _ { \tau \sim \pi } \big [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } C ( s _ { t } , a _ { t } ) \big ] \le h ,
+$$
+
+where $\gamma$ is the discount factor, $\tau$ is the trajectory $( \tau = ( s _ { 0 } , a _ { 0 } , s _ { 1 } , \cdot \cdot \cdot ) )$ , and $\tau \sim \pi$ is shorthand for showing that the distribution over the trajectory depends on $\pi : s _ { 0 } \sim \mu , a _ { t } \sim \pi ( a _ { t } | s _ { t } ) , s _ { t + 1 } \sim$ $T ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , where $\mu$ is the initial state distribution.
+
+Kakade & Langford (2002) give an identity to express the performance of policy $\pi ^ { \prime }$ in terms of the advantage function over another policy $\pi$ :
+
+$$
+J ^ { R } ( \pi ^ { \prime } ) - J ^ { R } ( \pi ) = \frac { 1 } { 1 - \gamma } { \mathbb E } _ { s \sim d ^ { \pi ^ { \prime } } } [ A _ { R } ^ { \pi } ( s , a ) ] ,
+$$
+
+where $d ^ { \pi }$ is the discounted future state distribution, denoted by $\begin{array} { r } { d ^ { \pi } ( s ) \doteq ( 1 - \gamma ) \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } P ( s _ { t } = } \end{array}$ $s | \pi )$ , and $A _ { R } ^ { \pi } ( s , a )$ is the reward advantage function, denoted by $A _ { R } ^ { \pi } ( s , a ) ~ \doteq ~ Q _ { R } ^ { \pi } ( s , a ) \ -$ $V _ { R } ^ { \pi } ( s )$ R. Here $\begin{array} { r } { Q _ { R } ^ { \pi } ( s , a ) \ \doteq \ \mathbb { E } _ { \tau \sim \pi } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } R ( s _ { t } , a _ { t } ) | s _ { 0 } \ = \ s , a _ { 0 } \ = \ a \right] } \end{array}$ Ris the discounted cumulative reward obtained by the policy $\pi$ given the initial state $s$ and action $a$ , and $V _ { R } ^ { \pi } ( s ) \doteq$ $\begin{array} { r } { \mathbb { E } _ { \tau \sim \pi } \big [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } R ( s _ { t } , a _ { t } ) | s _ { 0 } ~ = ~ s \big ] } \end{array}$ is the discounted cumulative reward obtained by the policy $\pi$ given the initial state $s$ . Similarly, we have the cost advantage function $A _ { C } ^ { \pi } ( s , a ) \ =$ $Q _ { C } ^ { \pi } ( s , a ) - V _ { C } ^ { \pi } ( s )$ , where $\begin{array} { r } { Q _ { C } ^ { \pi } ( s , a ) \doteq \mathbb { E } _ { \tau \sim \pi } \bigl [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } C ( s _ { t } , a _ { t } ) | s _ { 0 } = s , a _ { 0 } = a \bigr ] } \end{array}$ , and $V _ { C } ^ { \pi } ( s ) \doteq$ $\begin{array} { r } { \mathbb { E } _ { \tau \sim \pi } \big [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } C ( s _ { t } , a _ { t } ) | s _ { 0 } = s \big ] } \end{array}$ .
+
+# 3 PROJECTION-BASED CONSTRAINED POLICY OPTIMIZATION
+
+To robustly learn constraint-satisfying policies, we develop PCPO – a trust region method that performs policy updates corresponding to reward improvement, followed by projections onto the constraint set. PCPO, inspired by projected gradient descent, is composed of two steps for each update, a reward improvement step and a projection step (This is illustrated in Fig. 1).
+
+Reward Improvement Step. First, we optimize the reward function by maximizing the reward advantage function $A _ { R } ^ { \pi } ( s , a )$ subject to a Kullback-Leibler (KL) divergence constraint. This constraints the intermediate policy $\pi ^ { k + \frac { 1 } { 2 } }$ to be within a $\delta$ -neighbourhood of $\mathit { \Pi } _ { \pi ^ { k } }$ :
+
+![](images/f25ff2e3ac6de162d798439c64cb2c19429cab89b550212bfe25d78ce6593115.jpg)  
+Figure 1: Update procedures for PCPO. In step one (red arrow), PCPO follows the reward improvement direction in the trust region (light green). In step two (blue arrow), PCPO projects the policy onto the constraint set (light orange).
+
+$$
+\begin{array} { r l } { \pi ^ { k + \frac { 1 } { 2 } } = \arg \operatorname* { m a x } } & { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } [ A _ { R } ^ { \pi ^ { k } } ( s , a ) ] } \\ { \mathrm { s . t . ~ } } & { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi | | \pi ^ { k } ) [ s ] \right] \le \delta . } \end{array}
+$$
+
+This update rule with the trust region, $\{ \pi : \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \big [ D _ { \mathrm { K L } } ( \pi | | \pi ^ { k } ) [ s ] \big ] \leq \delta \}$ , is called Trust Region Policy Optimization (TRPO) (Schulman et al., 2015a). It constraints the policy changes to a divergence neighborhood and guarantees reward improvement.
+
+Projection Step. Second, we project the intermediate policy $\pi ^ { k + \frac { 1 } { 2 } }$ onto the constraint set by minimizing a distance measure $D$ between $\pi ^ { k + \frac { 1 } { 2 } }$ and $\pi$ :
+
+$$
+\begin{array} { r l } { \pi ^ { k + 1 } = \underset { \pi } { \arg \operatorname* { m i n } } } & { D ( \pi , \pi ^ { k + \frac { 1 } { 2 } } ) } \\ { \mathrm { s . t . } } & { J ^ { C } ( \pi ^ { k } ) + \mathbb { E } _ { \underset { a \sim \pi } { s \sim d ^ { \pi ^ { k } } } } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] \leq h . } \end{array}
+$$
+
+The projection step ensures that the constraint-satisfying policy $\pi ^ { k + 1 }$ is close to $\pi ^ { k + \frac { 1 } { 2 } }$ . We consider two distance measures $D$ : $L ^ { 2 }$ norm and KL divergence. In contrast, using KL divergence projection in the probability distribution space allows us to provide provable guarantees for PCPO.
+
+# 3.1 PERFORMANCE BOUND FOR PCPO WITH KL DIVERGENCE PROJECTION
+
+In safety-critical applications such as autonomous cars, one cares about how worse the performance of a system evolves when applying a learning algorithm. To this end, for PCPO with KL divergence projection, we analyze the worst-case performance degradation for each policy update when the current policy $\pi ^ { k }$ satisfies the constraint. The following theorem provides a lower bound on reward improvement, and an upper bound on constraint violation for each policy update.
+
+Theorem 3.1 (Worst-case Bound on Updating Constraint-satisfying Policies). Define $\epsilon _ { R } ^ { \pi ^ { k + 1 } } \doteq$ max $\left| \mathbb { E } _ { a \sim \pi ^ { k + 1 } } \left[ A _ { R } ^ { \pi ^ { k } } ( s , a ) \right] \right|$ , a nd $\epsilon _ { C } ^ { \pi ^ { k + 1 } } \doteq \operatorname* { m a x } _ { s } \left| \mathbb { E } _ { a \sim \pi ^ { k + 1 } } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] \right|$ . If the current policy $\pi ^ { k }$ satisfies the constraint, then under $K L$ divergence projection, the lower bound on reward improvement, and upper bound on constraint violation for each policy update are
+
+$$
+J ^ { R } ( \pi ^ { k + 1 } ) - J ^ { R } ( \pi ^ { k } ) \ge - \frac { \sqrt { 2 \delta } \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } , a n d J ^ { C } ( \pi ^ { k + 1 } ) \le h + \frac { \sqrt { 2 \delta } \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } ,
+$$
+
+where $\delta$ is the step size in the reward improvement step.
+
+Proof. See the supplemental material.
+
+Theorem 3.1 indicates that if $\delta$ is small, the worst-case performance degradation is tolerable.
+
+Due to approximation errors or the random initialization of policies, PCPO may have a constraintviolating update. Theorem 3.1 does not give the guarantee on updating a constraint-violating policy. Hence we analyze worst-case performance degradation for each policy update when the current policy $\pi ^ { k }$ violates the constraint. The following theorem provides a lower bound on reward improvement, and an upper bound on constraint violation for each policy update.
+
+Themax $\epsilon _ { R } ^ { \pi ^ { k + 1 } } \dot { = }$ $\left| \mathbb { E } _ { a \sim \pi ^ { k + 1 } } [ A _ { R } ^ { \pi ^ { k } } ( s , a ) ] \right| , \epsilon _ { C } ^ { \pi ^ { k + 1 } } \doteq \operatorname* { m a x } _ { s } \left| \mathbb { E } _ { a \sim \pi ^ { k + 1 } } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] \right| , b ^ { + } \doteq \operatorname* { m a x } ( 0 , J ^ { C } ( \pi ^ { k } ) + \pi ^ { k + 1 } ) .$ $\alpha _ { \mathrm { { K L } } } \doteq \frac { 1 } { 2 a ^ { T } H ^ { - 1 } a }$ 12aT H−1a , where a is the gradient of the cost advantage function and H is the Hessian of the $K L$ divergence constraint. If the current policy $\pi ^ { k }$ violates the constraint, then under $K L$ divergence projection, the lower bound on reward improvement and the upper bound on constraint violation for each policy update are
+
+$$
+\begin{array} { c } { { J ^ { R } ( \pi ^ { k + 1 } ) - J ^ { R } ( \pi ^ { k } ) \geq - \displaystyle \frac { \sqrt { 2 ( \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } ) } \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } , } } \\ { { a n d J ^ { C } ( \pi ^ { k + 1 } ) \leq h + \displaystyle \frac { \sqrt { 2 ( \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } ) } \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } } } \end{array}
+$$
+
+where $\delta$ is the step size in the reward improvement step.
+
+Proof. See the supplemental material.
+
+Theorem 3.2 indicates that when the policy has greater constraint violation $b ^ { + }$ increases), its worstcase performance degradation increases. Note that Theorem 3.2 reduces to Theorem 3.1 if the current policy $\pi ^ { k }$ satisfies the constraint $\begin{array} { r } { B ^ { + } = 0 } \end{array}$ ). The proofs of Theorem 3.1 and Theorem 3.2 follow from the fact that the projection of the policy is non-expansive, i.e., the distance between the projected policies is smaller than that of the unprojected policies. This allows us to measure it and bound the KL divergence between the current policy and the new policy.
+
+# 4 PCPO UPDATES
+
+For a large neural network policy with many parameters, it is impractical to directly solve for the PCPO update in Problem 2 and Problem 3 due to the computational cost. However, with a small step size $\delta$ , we can approximate the reward function and constraints with a first order expansion, and approximate the KL divergence constraint in the reward improvement step, and the KL divergence measure in the projection step with a second order expansion. We now make several definitions:
+
+$\pmb { g } \doteq \nabla _ { \pmb { \theta } } \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } a \sim \pi } [ A _ { R } ^ { \pi ^ { k } } ( s , a ) ]$ is the gradient of the reward advantage function, $\begin{array} { r } { \pmb { a } \doteq \nabla _ { \pmb { \theta } } \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } a \sim \pi } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] } \end{array}$ is the gradient of the cost advantage function, $\begin{array} { r } { H _ { i , j } \doteq \frac { \partial ^ { 2 } \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \big \lfloor D _ { \mathrm { K L } } ( \pi | | \pi ^ { k } ) [ s ] \big \rfloor } { \partial \pmb { \theta } _ { j } \partial \pmb { \theta } _ { j } } } \end{array}$ is the Hessian of the KL divergence constraint ( $\pmb { H }$ is also called the Fisher information matrix. It is symmetric positive semi-definite), $b \doteq J ^ { C } ( \pi ^ { k } ) - h$ is the constraint violation of the policy $\pi ^ { k }$ , and $\pmb { \theta }$ is the parameter of the policy.
+
+Reward Improvement Step. We linearize the objective function at $\pi ^ { k }$ subject to second order approximation of the KL divergence constraint in order to obtain the following updates:
+
+$$
+\begin{array} { r l } { \pmb { \theta } ^ { k + \frac { 1 } { 2 } } = \underset { \pmb { \theta } } { \arg \operatorname* { m a x } } } & { \pmb { g } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) } \\ { \mathrm { s . t . } } & { \frac { 1 } { 2 } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) ^ { T } \pmb { H } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) \leq \delta . } \end{array}
+$$
+
+# Algorithm 1 Projection-Based Constrained Policy Optimization (PCPO)
+
+Initialize policy $\pi ^ { 0 } = \pi ( \theta ^ { 0 } )$   
+for $k = 0 , 1 , 2 , \cdots$ do Run $\pi ^ { k } = \pi ( \theta ^ { k } )$ and store trajectories in $\mathcal { D }$ Compute ${ \mathbf { } } g , a , H$ , and $b$ using $\mathcal { D }$ Obtain $\pmb { \theta } ^ { k + 1 }$ using update in Eq. (6) Empty $\mathcal { D }$
+
+Projection Step. If the projection is defined in the parameter space, we can directly use $L ^ { 2 }$ norm projection. On the other hand, if the projection is defined in the probability space, we can use KL divergence projection. This can be approximated through the second order expansion. Again, we linearize the cost constraint at $\pi ^ { k }$ . This gives the following update for the projection step:
+
+$$
+\begin{array} { r l } { \pmb { \theta } ^ { k + 1 } = \underset { \pmb { \theta } } { \arg \operatorname* { m i n } } } & { \frac { 1 } { 2 } ( \pmb { \theta } - \pmb { \theta } ^ { k + \frac { 1 } { 2 } } ) ^ { T } \pmb { L } ( \pmb { \theta } - \pmb { \theta } ^ { k + \frac { 1 } { 2 } } ) } \\ { \mathrm { s . t . } } & { \pmb { a } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) + b \leq 0 , } \end{array}
+$$
+
+where $L = I$ for $L ^ { 2 }$ norm projection, and ${ L = H }$ for KL divergence projection. One may argue that using linear approximation to the constraint set is not enough to ensure constraint satisfaction since the real constraint set is maybe non-convex. However, if the step size $\delta$ is small, then the linearization of the constraint set is accurate enough to locally approximate it.
+
+We solve Problem (4) and Problem (5) using convex programming (See the supplemental material for the derivation). For each policy update, we have
+
+$$
+\pmb { \theta } ^ { k + 1 } = \pmb { \theta } ^ { k } + \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } H ^ { - 1 } g - \operatorname* { m a x } \left( 0 , \frac { \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } a ^ { T } H ^ { - 1 } g + b } { a ^ { T } L ^ { - 1 } a } \right) L ^ { - 1 } a .
+$$
+
+We assume that $\pmb { H }$ does not have 0 as an eigenvalue and hence it is invertible. PCPO requires to invert $\pmb { H }$ , which is impractical for huge neural network policies. Hence we use the conjugate gradient method (Schulman et al., 2015a). Algorithm 1 shows the pseudocode. (See supplemental material for a discussion of the tradeoff between the approximation error and computational efficiency of the conjugate gradient method.)
+
+Analysis of PCPO Update Rule. For a problem including multiple constraints, we can extend the update in Eq. (6) by using alternating projections. This approach finds a solution in the intersection of multiple constraint sets by sequentially projecting onto each of the sets. The update rule in Eq. (6) shows that the difference between PCPO with KL divergence and $L ^ { 2 }$ norm projections is the cost update direction, leading to a difference in reward improvement. These two projections converge to different stationary points with different convergence rates related to the smallest and largest singular values of the Fisher information matrix shown in Theorem 4.1. For our analysis, we make the following assumptions: we minimize the negative reward objective function $f : \mathbb { R } ^ { n }  \mathbb { R }$ (We follow the convention of the literature that authors typically minimize the objective function). The function $f$ is $L$ -smooth and twice continuously differentiable over the closed and convex constraint set $\mathcal { C }$ .
+
+Theorem 4.1 (Reward Improvement Under $L ^ { 2 }$ Norm and KL Divergence Projections). Let $\eta \doteq \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } }$ in Eq. (6), where $\delta$ is the step size for reward improvement, $\textbf {  { g } }$ is the gradient of $f$ , and $\pmb { H }$ is the Fisher information matrix. Let $\sigma _ { \mathrm { m a x } } ( H )$ be the largest singular value of $\pmb { H }$ , and $\textbf { \em a }$ be the gradient of cost advantage function in Eq. (6). Then PCPO with $K L$ divergence projection converges to a stationary point either inside the constraint set or in the boundary of the constraint set. In the latter case, the Lagrangian constraint $\mathbf { \delta } _ { \mathbf { \delta g } } = - \alpha \mathbf { \delta a } , \alpha \geq 0$ holds. Moreover, at step $k + 1$ the objective value satisfies
+
+$$
+f ( \pmb { \theta } ^ { k + 1 } ) \leq f ( \pmb { \theta } ^ { k } ) + | | \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } | | _ { - \frac { 1 } { \eta } \pmb { H } + \frac { L } { 2 } \pmb { I } } ^ { 2 } .
+$$
+
+PCPO with $L ^ { 2 }$ norm projection converges to a stationary point either inside the constraint set or in the boundary of the constraint set. In the latter case, the Lagrangian constraint $\pmb { H } ^ { - 1 } \pmb { g } = - \alpha \pmb { a } , \alpha \geq$
+
+0 holds. If $\sigma _ { \mathrm { m a x } } ( \pmb { H } ) \leq 1$ , then a step $k + 1$ objective value satisfies
+
+$$
+f ( \pmb { \theta } ^ { k + 1 } ) \leq f ( \pmb { \theta } ^ { k } ) + ( \frac { L } { 2 } - \frac { 1 } { \eta } ) | | \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } | | _ { 2 } ^ { 2 } .
+$$
+
+Proof. See the supplemental material.
+
+Theorem 4.1 shows that in the stationary point $\textbf {  { g } }$ is a line that points to the opposite direction of $\textbf { \em a }$ . Further, the improvement of the objective value is affected by the singular value of the Fisher information matrix. Specifically, the objective of $\mathrm { K L }$ divergence projection decreases when $\frac { L \eta } { 2 } I \prec$ $\pmb { H }$ , implying that $\begin{array} { r } { \sigma _ { \mathrm { m i n } } ( { \cal H } ) > \frac { L \eta } { 2 } } \end{array}$ . And the objective of $L ^ { 2 }$ norm projection decreases when $\eta \ : <$ $\frac { 2 } { L }$ , implying that condition number of $\pmb { H }$ is upper bounded: $\frac { \sigma _ { \mathrm { m a x } } ( { H } ) } { \sigma _ { \mathrm { m i n } } ( { H } ) } ~ < ~ \frac { 2 | | g | | _ { 2 } ^ { 2 } } { L ^ { 2 } \delta }$ . Observing the singular values of the Fisher information matrix allows us to adaptively choose the appropriate projection and hence achieve objective improvement. In the supplemental material, we further use an example to compare the optimization trajectories and stationary points of KL divergence and $L ^ { 2 }$ norm projections.
+
+# 5 RELATED WORK
+
+Policy Learning with Constraints. Learning constraint-satisfying policies has been explored in the context of safe RL (Garcia & Fernandez, 2015). The agent learns policies either by (1) exploration of the environment (Achiam et al., 2017; Tessler et al., 2018; Chow et al., 2017) or (2) through expert demonstrations (Ross et al., 2011; Rajeswaran et al., 2017; Gao et al., 2018). However, using expert demonstrations requires humans to label the constraint-satisfying behavior for every possible situation. The scalability of these rule-based approaches is an issue since many real autonomous systems such as self-driving cars and industrial robots are inherently complex. To overcome this issue, PCPO uses the first approach in which the agent learns by trial and error. To prevent the agent from having constraint-violating behavior during exploring the environment, PCPO uses the projection onto the constraint set to ensure constraint satisfaction throughout learning.
+
+Constraint satisfaction by Projections. Using a projection onto a constraint set has been explored for general constrained optimization in other contexts. For example, Akrour et al. (2019) projects the policy from a parameter space onto the constraint. This ensures the updated policy stays close to the previous policy. In contrast, we examine constraints that are defined in terms of states and actions. Similarly, Chow et al. (2019) proposes $\theta$ -projection. This approach projects the policy parameters $\theta$ onto the constraint set. However, no provide provable guarantees are provided. Moreover, the
+
+![](images/d10804ff94f153e87f80154e8c5388853254e94fd8fe5ba852f3f40415e168a0.jpg)  
+Figure 2: Update procedures for CPO (Achiam et al., 2017). CPO computes the update by simultaneously considering the trust region (light green) and the constraint set (light orange). CPO becomes infeasible when these two sets do not intersect.
+
+problem is formulated by adding the weighted constraint to the reward objective function. Since the weight must be tuned, this incurs the cost of hyperparameter tuning. In contrast, PCPO eliminates the cost of the hyperparameter tuning, and provides provable guarantees on learning constraintsatisfying policies.
+
+Comparison to CPO (Achiam et al., 2017). Perhaps the closest work to ours is the approach of Achiam et al. (2017), who proposes the constrained policy optimization (CPO) algorithm to solve the following:
+
+$$
+\theta ^ { k + 1 } = \underset { \theta } { \mathrm { a r g } \mathrm { m a x } } g ^ { T } ( \theta - \theta ^ { k } ) \quad \mathrm { s . t . } \frac { 1 } { 2 } ( \theta - \theta ^ { k } ) ^ { T } H ( \theta - \theta ^ { k } ) \leq \delta , \ a ^ { T } ( \theta - \theta ^ { k } ) + b \leq 0 .
+$$
+
+CPO simultaneously considers the trust region and the constraint, and uses the line search to select a step size (This is illustrated in Fig. 2). The update rule of CPO becomes infeasible when the current policy violates the constraint $( b > 0$ ). CPO recovers by replacing Problem (7) with an update to purely decrease the constraint value: $\pmb { \theta } ^ { k + 1 } = \pmb { \theta } ^ { k } - \sqrt { \frac { 2 \delta } { \pmb { a } ^ { T } \pmb { H } ^ { - 1 } \pmb { a } } } \pmb { H } ^ { - 1 } \pmb { a }$ . This update rule may lead to a slow progress in learning constraint-satisfying policies. In contrast, PCPO first optimizes the reward and uses the projection to satisfy the constraint. This ensures a feasible solution, allowing the agent to improve the reward while ensuring constraint satisfaction simultaneously.
+
+![](images/eeadc7ea600eb5f8523a55b138b1d606c73644e14455780e0d4e3027a2b05505.jpg)  
+Figure 3: The gather, circle, grid and bottleneck tasks. (a) Gather task: the agent is rewarded for gathering green apples but is constrained to collect a limited number of red fruit (Achiam et al., 2017). (b) Circle task: the agent is rewarded for moving in a specified wide circle, but is constrained to stay within a safe region smaller than the radius of the circle (Achiam et al., 2017). (c) Grid task: the agent controls the traffic lights in a grid road network and is rewarded for high throughput but constrained to let lights stay red for at most 7 consecutive seconds (Vinitsky et al., 2018). (d) Bottleneck task: the agent controls a set of autonomous vehicles (shown in red) in a traffic merge situation and is rewarded for achieving high throughput but constrained to ensure that human-driven vehicles (shown in white) have low speed for no more than 10 seconds (Vinitsky et al., 2018).
+
+# 6 EXPERIMENTS
+
+Tasks. We compare the proposed algorithm with existing approaches on four control tasks in total: two tasks with safety constraints ((a) and (b) in Fig. 3), and two tasks with fairness constraints ((c) and (d) in Fig. 3). These tasks are briefly described in the caption of Fig. 3. The first two tasks – Gather and Circle – are Mujoco environments with state space constraints introduced by Achiam et al. (2017). The other two tasks – Grid and Bottleneck – are traffic management problems where the agent controls either a traffic light or a fleet of autonomous vehicles. This is especially challenging since the dimensions of state and action spaces are larger, and the dynamics of the environment are inherently complex.
+
+Baselines. We compare PCPO with four baselines outlined below.
+
+(1) Constrained Policy Optimization (CPO) (Achiam et al., 2017).
+
+(2) Primal-dual Optimization (PDO) (Chow et al., 2017). In PDO, the weight (dual variables) is learned based on the current constraint satisfaction. A PDO policy update solves:
+
+$$
+\pmb { \theta } ^ { k + 1 } = \underset { \pmb { \theta } } { \arg \operatorname* { m a x } } \quad \pmb { g } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) + \lambda ^ { k } \pmb { a } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) ,
+$$
+
+where $\lambda ^ { k }$ is updated using $\lambda ^ { k + 1 } = \lambda ^ { k } + \beta ( J ^ { C } ( \pi ^ { k } ) - h )$ . Here $\beta$ is a fixed learning rate.
+
+(3) Fixed-point Policy Optimization (FPO). A variant of PDO that solves Eq. (8) using a constant $\lambda$
+
+(4) Trust Region Policy Optimization (TRPO) (Schulman et al., 2015a). The TRPO policy update is an unconstrained one:
+
+$$
+\begin{array} { r } { \pmb { \theta } ^ { k + 1 } = \pmb { \theta } ^ { k } + \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } H ^ { - 1 } \pmb { g } . } \end{array}
+$$
+
+Note that TRPO ignores any constraints. We include it to serve as an upper bound baseline on the reward performance.
+
+Since the main focus is to compare PCPO with the state-of-the-art algorithm, CPO, PDO and FPO are not shown in the ant circle, ant gather, grid and bottleneck tasks for clarity.
+
+Experimental Details. For the gather and circle tasks we test two distinct agents: a point-mass $( S ~ \overset { \cdot } { \subseteq } ~ \mathbb { R } ^ { 9 } , A ~ \subseteq ~ \mathbb { R } ^ { 2 } )$ , and an ant robot $( S \subseteq \mathbb { R } ^ { 3 2 } , A \subseteq \mathbb { R } ^ { 8 } )$ . The agent in the grid task is $S \subseteq$ $\mathbb { R } ^ { 1 5 6 }$ , $A \subseteq \mathbb { R } ^ { 4 }$ , and the agent in bottleneck task is $S \subseteq \mathbb { R } ^ { 1 4 1 } , A \subseteq \mathbb { R } ^ { \tilde { 2 } 0 }$ . For the simulations in the gather and circle tasks, we use a neural network with two hidden layers of size (64, 32) to represent
+
+![](images/f3c62c5bec466a793b435d2c5705ffb0298913b2cd60685aab1f93198f3dae79.jpg)  
+Figure 4: The values of the discounted reward and the undiscounted constraint value (the total number of constraint violation) along policy updates for the tested algorithms and task pairs. The solid line is the mean and the shaded area is the standard deviation, over five runs. The dashed line in the cost constraint plot is the cost constraint threshold $h$ . The curves for baseline oracle, TRPO, indicate the reward and constraint violation values when the constraint is ignored. (Best viewed in color, and the legend is shared across all the figures.)
+
+Gaussian policies. For the simulations in the grid and bottleneck tasks, we use a neural network with two hidden layers of size (16, 16) and (50,25) to represent Gaussian policies, respectively. In the experiments, since the step size is small, we reuse the Fisher information matrix of the reward improvement step in the KL projection step to reduce the computational cost. The step size $\delta$ is set to $\mathrm { \dot { 1 } 0 ^ { - 4 } }$ for all tasks and all tested algorithms. For each task, we conduct 5 runs to get the mean and standard deviation for both the reward and the constraint value over the policy updates. The experiments are implemented in rllab (Duan et al., 2016), a tool for developing and evaluating RL algorithms. See the supplemental material for the details of the experiments.
+
+![](images/63417dd55dcecc7d3538f9a8f7f5248fe4127465d30e67e7d3116f26fc6742bb.jpg)  
+Figure 5: The value of the discounted reward versus the cumulative constraint value for the tested algorithms and task pairs. See the supplemental material for learning curves in the other tasks. PCPO achieves less constraint violation under the same reward improvement compared to the other algorithms.
+
+Overall Performance. The learning curves of the discounted reward and the undiscounted constraint value (the total number of constraint violation) over policy updates are shown for all tested algorithms and tasks in Fig. 4. The dashed line in the constraint figure is the cost constraint threshold $h$ . The curves for baseline oracle, TRPO, indicate the reward and constraint value when the constraint is ignored. Overall, we find that PCPO is able to improve the reward while having the fastest constraint satisfaction in all tasks. In particular, PCPO is the only algorithm that learns constraintsatisfying policies across all the tasks. Moreover we observe that (1) CPO has more constraint violation than PCPO, (2) PDO is too conservative in optimizing the reward, and (3) FPO requires a significant effort to select a good value of $\lambda$ .
+
+We also observe that in Grid and Bottleneck task, there is slightly more constraint violation than the easier task such as point circle and point gather. This is due to complexity of the policy behavior and non-convexity of the constraint set. However, even with a linear approximation of the constraint set, PCPO still outperforms CPO with $8 5 . 1 5 \%$ and 5.42 times less constraint violation in Grid and Bottleneck task, respectively.
+
+These observations suggest that projection step in PCPO drives the agent to learn the constraintsatisfying policy within few policy updates, giving PCPO an advantage in applications. To show that PCPO achieves the same reward with less constraint violation, we examine the reward versus the cumulative constraint value for the tested algorithms in point circle and point gather task shown in Fig. 5. We observe that PCPO outperforms CPO significantly with 66 times and 15 times less constraint violation under the same reward improvement in point circle and point gather tasks, respectively. This observation suggests that PCPO enables the agent to cautiously explore the environment under the constraints.
+
+Comparison of PCPO with KL Divergence vs. $L ^ { 2 }$ Norm Projections. We observe that PCPO with $\bar { L } ^ { 2 }$ norm projection is more constraint-satisfying than PCPO with KL divergence projection. In addition, PCPO with $L ^ { 2 }$ norm projection tends to have reward fluctuation (point circle, ant circle, and ant gather tasks), while with KL divergence projection tends to have more stable reward improvement (all the tasks).
+
+The above observations indicate that since the gradient of constraint is not multiplied by the Fisher information matrix, the gradient of the constraint is not aligned with the gradient of the reward. This reduces the reward improvement. However, when the Fisher information matrix is ill-conditioned or not well-estimated, especially in a high dimensional policy space, a bad constraint update direction may hinder constraint satisfaction (ant circle, ant gather, grid and bottleneck tasks). In addition, since the stationary points of KL divergence and $L ^ { 2 }$ norm projections are different, they converge to policies with different reward (observe that PCPO with $L ^ { \bar { 2 } }$ norm projection has higher reward than the one with KL divergence projection around 2250 iterations in ant circle task, and has less reward in point gather task).
+
+Discussion of PDO and FPO. For the PDO baseline, we see that its constraint values fluctuate especially in the point circle task. This phenomena suggests that PDO is not able to adjust the weight $\bar { \lambda ^ { k } }$ quickly enough to meet the constraint threshold, which hinders the efficiency of learning constraint-satisfying policies. If the learning rate $\beta$ is too big, the agent will be too conservative in improving the reward. For FPO, we also see that it learns near constraint-satisfying policies with slightly larger reward improvement compared to PDO. However, in practice FPO requires a lot of engineering effort to select a good value of $\lambda$ . Since PCPO requires no hyperparameter tuning, it has the advantage of robustly learning constraint-satisfying policies over PDO and FPO.
+
+# 7 CONCLUSION
+
+We address the problem of finding constraint-satisfying policies. The proposed algorithm – projection-based constrained policy optimization (PCPO) – optimizes for the reward function while using the projections to ensure constraint satisfaction. This update rule allows PCPO to maintain the feasibility of the optimization problem of each update, addressing the issue of state-of-the-art approaches. The algorithm achieves comparable or superior performance to state-of-the-art approaches in terms of reward improvement and constraint satisfaction in all cases. We further analyze the convergence of PCPO, and find that certain tasks may prefer either KL divergence projection or $L ^ { 2 }$ norm projection. Future work will consider the following: (1) examining the Fisher information matrix to iteratively prescribe the choice of projection for policy update, and hence robustly learn constraint-satisfying policies with more reward improvement, and (2) using expert demonstration or other domain knowledge to reduce the sample complexity.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank the anonymous reviewers and the area chair for their comments.   
+Tsung-Yen Yang thanks Siemens Corporation, Corporate Technology for their support.
+
+# REFERENCES
+
+Joshua Achiam, David Held, Aviv Tamar, and Pieter Abbeel. Constrained policy optimization. In Proceedings of International Conference on Machine Learning, pp. 22–31, 2017.
+
+Riad Akrour, Joni Pajarinen, Gerhard Neumann, and Jan Peters. Projections for approximate policy iteration algorithms. In Proceedings of International Conference on Machine Learning, pp. 181– 190, 2019.
+
+AlphaStar. Alphastar: Mastering the real-time strategy game starcraft ii, 2019. URL https://deepmind.com/blog/article/ alphastar-mastering-real-time-strategy-game-starcraft-ii.
+
+Eitan Altman. Constrained Markov decision processes, volume 7. CRC Press, 1999.
+
+Yinlam Chow, Mohammad Ghavamzadeh, Lucas Janson, and Marco Pavone. Risk-constrained reinforcement learning with percentile risk criteria. Journal of Machine Learning Research, 18(1): 6070–6120, 2017.
+
+Yinlam Chow, Ofir Nachum, Aleksandra Faust, Mohammad Ghavamzadeh, and Edgar DuenezGuzman. Lyapunov-based safe policy optimization for continuous control. arXiv preprint arXiv:1901.10031, 2019.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In Proceedings of International Conference on Machine Learning, pp. 1329–1338, 2016.
+
+Yang Gao, Ji Lin, Fisher Yu, Sergey Levine, and Trevor Darrell. Reinforcement learning from imperfect demonstrations. arXiv preprint arXiv:1802.05313, 2018.
+
+Javier Garcia and Fernando Fernandez. A comprehensive survey on safe reinforcement learning. Journal of Machine Learning Research, 16(1):1437–1480, 2015.
+
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Proceedings of International Conference on Machine Learning, pp. 267–274, 2002.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint arXiv:1709.10087, 2017.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of International Conference on Machine Learning, pp. 1889– 1897, 2015a.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015b.
+
+Jonathan R. Shewchuk. An introduction to the conjugate gradient method without the agonizing pain, 1994.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+Richard S. Sutton, David A. McAllester, Satinder P. Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in Neural Information Processing Systems, pp. 1057–1063, 2000.
+
+Chen Tessler, Daniel J. Mankowitz, and Shie Mannor. Reward constrained policy optimization. arXiv preprint arXiv:1805.11074, 2018.
+
+Eugene Vinitsky, Aboudy Kreidieh, Luc Le Flem, Nishant Kheterpal, Kathy Jang, Fangyu Wu, Richard Liaw, Eric Liang, and Alexandre M. Bayen. Benchmarks for reinforcement learning in mixed-autonomy traffic. In Proceedings of Conference on Robot Learning, pp. 399–409, 2018.
+
+# S SUPPLEMENTARY MATERIALS
+
+# S.1 PROOF OF THEOREM 3.1: PERFORMANCE BOUND ON UPDATING THE CONSTRAINT-SATISFYING POLICY
+
+To prove the policy performance bound when the current policy is feasible (i.e., constraintsatisfying), we prove the KL divergence between $\pi ^ { k }$ and $\pi ^ { k + \ 1 }$ for the KL divergence projection. We then prove our main theorem for the worst-case performance degradation.
+
+Lemma S.1. If the current policy $\pi ^ { k }$ satisfies the constraint, the constraint set is closed and convex, the KL divergence constraint for the first step is ${ \mathbb E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + \frac { 1 } { 2 } } | | \pi ^ { k } ) [ s ] \right] \le \delta$ , where $\delta$ is the step size in the reward improvement step, then under $K L$ divergence projection, we have
+
+$$
+\begin{array} { r } { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] \le \delta . } \end{array}
+$$
+
+Proof. By the Bregman divergence projection inequality, $\pi ^ { k }$ being in the constraint set, and $\pi ^ { k + 1 }$ being the projection of the $\pi ^ { k + \frac { 1 } { 2 } }$ onto the constraint set, we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { s \sim d ^ { \pi k } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k } | | \pi ^ { k + \frac { 1 } { 2 } } ) [ s ] \right] \geq \mathbb { E } _ { s \sim d ^ { \pi k } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k } | | \pi ^ { k + 1 } ) [ s ] \right] + \mathbb { E } _ { s \sim d ^ { \pi k } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k + \frac { 1 } { 2 } } ) [ s ] \right] } \\ & { \Rightarrow \delta \geq \mathbb { E } _ { s \sim d ^ { \pi k } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k } | | \pi ^ { k + \frac { 1 } { 2 } } ) [ s ] \right] \geq \mathbb { E } _ { s \sim d ^ { \pi k } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k } | | \pi ^ { k + 1 } ) [ s ] \right] . } \end{array}
+$$
+
+The derivation uses the fact that KL divergence is always greater than zero. We know that KL divergence is asymptotically symmetric when updating the policy within a local neighbourhood. Thus, we have
+
+$$
+\delta \geq \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + \frac { 1 } { 2 } } | | \pi ^ { k } ) [ s ] \right] \geq \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] .
+$$
+
+Now we use Lemma S.1 to prove our main theorem.
+
+Theorem S.2. Define maxs Ea∼πk+1 [AπkR (s, a)], and πk+1C = $\operatorname* { m a x } _ { s } \left| \mathbb { E } _ { a \sim \pi ^ { k + 1 } } \left[ A _ { C } ^ { \pi ^ { k } } ( s , a ) \right] \right|$ . If the current policy $\pi ^ { k }$ satisfies the constraint, then under the $K L$ divergence projection, the lower bound on reward improvement, and upper bound on constraint violation for each policy update are
+
+$$
+J ^ { R } ( \pi ^ { k + 1 } ) - J ^ { R } ( \pi ^ { k } ) \geq - \frac { \sqrt { 2 \delta } \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } , a n d J ^ { C } ( \pi ^ { k + 1 } ) \leq h + \frac { \sqrt { 2 \delta } \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } ,
+$$
+
+where $\delta$ is the step size in the reward improvement step.
+
+Proof. By the theorem in Achiam et al. (2017) and Lemma S.1, we have the following reward degradation bound for each policy update:
+
+$$
+\begin{array} { r l } & { J ^ { R } ( \pi ^ { k + 1 } ) - J ^ { R } ( \pi ^ { k } ) \geq \displaystyle \frac { 1 } { 1 - \gamma } \mathbb { E } _ { \underset { a \sim \pi ^ { k + 1 } } { s \sim d ^ { \pi ^ { k } } } } \left[ A _ { R } ^ { \pi ^ { k } } ( s , a ) - \frac { 2 \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { 1 - \gamma } \sqrt { \frac { 1 } { 2 } D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] } \right] } \\ & { \geq \displaystyle \frac { 1 } { 1 - \gamma } \mathbb { E } _ { \underset { a \sim \pi ^ { k + 1 } } { s \sim d ^ { \pi ^ { k } } } } \left[ - \frac { 2 \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { 1 - \gamma } \sqrt { \frac { 1 } { 2 } D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] } \right] } \\ & { \geq - \frac { \sqrt { 2 \delta } \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } . } \end{array}
+$$
+
+Again, we have the following constraint violation bound for each policy update:
+
+$$
+J ^ { C } ( \pi ^ { k } ) + \frac { 1 } { 1 - \gamma } \mathbb { E } _ { { s \sim } d ^ { \pi ^ { k } } } \Big [ A _ { R } ^ { \pi ^ { k } } ( s , a ) \Big ] \le h ,
+$$
+
+and
+
+$$
+J ^ { C } ( \pi ^ { k + 1 } ) - J ^ { C } ( \pi ^ { k } ) \leq \frac { 1 } { 1 - \gamma } \mathbb { E } _ { \underset { s \sim \pi ^ { k + 1 } } { s \sim d ^ { \pi ^ { k } } } } \left[ A _ { C } ^ { \pi ^ { k } } ( s , a ) + \frac { 2 \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { 1 - \gamma } \sqrt { \frac { 1 } { 2 } D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] } \right] .
+$$
+
+Combining Eq. (9) and Eq. (10), we have
+
+$$
+\begin{array} { r l } & { J ^ { C } ( \pi ^ { k + 1 } ) \leq h + \displaystyle \frac { 1 } { 1 - \gamma } \mathbb { E } _ { { s \sim } d ^ { \pi ^ { k } } } \Big [ \frac { 2 \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { 1 - \gamma } \sqrt { \frac { 1 } { 2 } D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] } \Big ] } \\ & { \quad \quad \leq h + \displaystyle \frac { \sqrt { 2 \delta } \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } . } \end{array}
+$$
+
+# S.2 PROOF OF THEOREM 3.2: PERFORMANCE BOUND ON UPDATING THE CONSTRAINT-VIOLATING POLICY
+
+To prove the policy performance bound when the current policy is infeasible (i.e., constraintviolating), we prove the KL divergence between $\pi ^ { k }$ and $\pi ^ { k + 1 }$ for the $\mathrm { K L }$ divergence projection. We then prove our main theorem for the worst-case performance degradation.
+
+Lemma S.3. If the current policy $\pi ^ { k }$ violates the constraint, the constraint set is closed and convex, the KL divergence constraint for the first step is $\mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \big [ D _ { \mathrm { K L } } ( \pi ^ { k + \frac { 1 } { 2 } } | | \pi ^ { k } ) [ s ] \big ] \le \delta$ , where $\delta$ is the step size in the reward improvement step, then under the $\bar { K L }$ divergence projection, we have
+
+$$
+\begin{array} { r } { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] \le \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } , } \end{array}
+$$
+
+where $\begin{array} { r } { \alpha _ { \mathrm { { K L } } } \doteq \frac 1 { 2 a ^ { T } H ^ { - 1 } a } } \end{array}$ , $\textbf { \em a }$ is the gradient of the cost advantage function, . $\pmb { H }$ is the Hessian of the $K L$ divergence constraint, and $b ^ { + } \doteq \operatorname* { m a x } ( 0 , J ^ { C } ( \pi ^ { k } ) - h )$ .
+
+Proof. We define the sublevel set of cost constraint function for the current infeasible policy $\pi ^ { k }$ :
+
+$$
+\begin{array} { r } { L ^ { \pi ^ { k } } = \{ \pi \mid J ^ { C } ( \pi ^ { k } ) + \mathbb { E } _ { \underset { a \sim \pi } { s \sim d ^ { \pi ^ { k } } } } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] \leq J ^ { C } ( \pi ^ { k } ) \} . } \end{array}
+$$
+
+This implies that the current policy $\pi ^ { k }$ lies in $L ^ { \pi ^ { k } }$ , and $\pi ^ { k + \frac { 1 } { 2 } }$ is projected onto the constraint set: $\{ \pi \mid J ^ { C } ( \pi ^ { k } ) + \mathbb { E } _ { \stackrel { s \sim d ^ { \pi ^ { k } } } { a \sim \pi } } [ A _ { C } ^ { \pi ^ { k } } ( { \bar { s } } , a ) ] { \overset { \cdot } { \leq } } h \}$ . Next, we define the policy $\pi _ { l } ^ { k + 1 }$ as the projection of $\pi ^ { k + \frac { 1 } { 2 } }$ onto $L ^ { \pi ^ { k } }$ .
+
+By the Three-point Lemma, for these three polices $\pi ^ { k } , \pi ^ { k + 1 }$ , and $\pi _ { l } ^ { k + 1 }$ , with $\textstyle \varphi ( { \pmb x } ) \doteq \sum _ { i } x _ { i } \log x _ { i }$ (this is illustrated in Fig. 6), we have
+
+$$
+\begin{array} { r l } { \delta \geq \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi _ { l } ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] = \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] } & { } \\ { - \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi _ { l } ^ { k + 1 } ) [ s ] \right] } & { } \\ { + \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ ( \nabla \varphi ( \pi ^ { k } ) - \nabla \varphi ( \pi _ { l } ^ { k + 1 } ) ) ^ { T } ( \pi ^ { k + 1 } - \pi _ { l } ^ { k + 1 } ) [ s ] \right] } & { } \\ { \Rightarrow \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] \leq \delta + \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi _ { l } ^ { k + 1 } ) [ s ] \right] } & { } \\ { - \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ ( \nabla \varphi ( \pi ^ { k } ) - \nabla \varphi ( \pi _ { l } ^ { k + 1 } ) ) ^ { T } ( \pi ^ { k + 1 } - \pi _ { l } ^ { k + 1 } ) [ s ] \right] . } & { } \end{array}
+$$
+
+The inequality $\mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi _ { l } ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] \le \delta$ comes from that $\pi ^ { k }$ and $\pi _ { l } ^ { k + 1 }$ are in $L ^ { \pi ^ { k } }$ , and Lemma S.1.
+
+If the constraint violation of the current policy $\pi ^ { k }$ is small, i.e., $b ^ { + }$ is small, $\mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi _ { l } ^ { k + 1 } ) [ s ] \right]$ can be approximated by the second order expansion. By the
+
+![](images/894efdcd6d4a7fd415aa405626d746c2a155a8ce9832c0dcabe475792256a51b.jpg)  
+Figure 6: Update procedures for PCPO when the current policy $\pi ^ { k }$ is infeasible. $\pi _ { l } ^ { k + 1 }$ is the projection of $\pi ^ { k + \frac { 1 } { 2 } }$ onto the sublevel set of the constraint set. We find the KL divergence between $\pi ^ { k }$ and $\pi ^ { k + 1 }$ .
+
+update rule in Eq. (6), we have
+
+$$
+\begin{array} { l } { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi _ { l } ^ { k + 1 } ) [ s ] \right] \approx \frac { 1 } { 2 } ( \theta ^ { k + 1 } - \theta _ { l } ^ { k + 1 } ) ^ { T } H ( \theta ^ { k + 1 } - \theta _ { l } ^ { k + 1 } ) } \\ { = \frac { 1 } { 2 } \Big ( \frac { b ^ { + } } { a ^ { T } H ^ { - 1 } a } H ^ { - 1 } a \Big ) ^ { T } H \Big ( \frac { b ^ { + } } { a ^ { T } H ^ { - 1 } a } H ^ { - 1 } a \Big ) } \\ { = \frac { b ^ { + 2 } } { 2 a ^ { T } H ^ { - 1 } a } } \\ { = b ^ { + ^ { 2 } } \alpha _ { \mathrm { K L } } , } \end{array}
+$$
+
+$\begin{array} { r } { \alpha _ { \mathrm { K L } } \doteq \frac { 1 } { 2 a ^ { T } H ^ { - 1 } a } } \end{array}$
+
+And since $\delta$ is small, we have $\nabla \varphi ( \pi ^ { k } ) - \nabla \varphi ( \pi _ { l } ^ { k + 1 } ) \approx \mathbf { 0 }$ given $s$ . Thus, the third term in Eq. (11) can be eliminated.
+
+Combining Eq. (11) and Eq. (12), we have
+
+$$
+\begin{array} { r } { \mathbb { E } _ { s \sim d ^ { \pi ^ { k } } } \left[ D _ { \mathrm { K L } } ( \pi ^ { k + 1 } | | \pi ^ { k } ) [ s ] \right] \le \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } . } \end{array}
+$$
+
+Now we use Lemma S.3 to prove our main theorem.
+
+$\epsilon _ { R } ^ { \pi ^ { k + 1 } } \doteq \operatorname* { m a x } _ { s } \big | \mathbb { E } _ { a \sim \pi ^ { k + 1 } } [ A _ { R } ^ { \pi ^ { k } } ( s , a ) ] \big | , \epsilon _ { C } ^ { \pi ^ { k + 1 } } \doteq \operatorname* { m a x } _ { s } \big | \mathbb { E } _ { a \sim \pi ^ { k + 1 } } [ A _ { C } ^ { \pi ^ { k } } ( s , a ) ] \big | ,$ $b ^ { + } \doteq \operatorname* { m a x } ( 0 , J ^ { C } ( \pi ^ { k } ) - h )$ $\begin{array} { r } { \alpha _ { \mathrm { { K L } } } \doteq \frac 1 { 2 a ^ { T } H ^ { - 1 } a } } \end{array}$ $^ { a }$ function and $\pmb { H }$ is the Hessian of the $K L$ divergence constraint. If the current policy $\pi ^ { k }$ violates the constraint, then under the $K L$ divergence projection, the lower bound on reward improvement and the upper bound on constraint violation for each policy update are
+
+$$
+\begin{array} { r } { J ^ { R } ( \pi ^ { k + 1 } ) - J ^ { R } ( \pi ^ { k } ) \geq - \frac { \sqrt { 2 ( \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } ) } \gamma \epsilon _ { R } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } , } \\ { a n d J ^ { C } ( \pi ^ { k + 1 } ) \leq h + \frac { \sqrt { 2 ( \delta + { b ^ { + } } ^ { 2 } \alpha _ { \mathrm { K L } } ) } \gamma \epsilon _ { C } ^ { \pi ^ { k + 1 } } } { ( 1 - \gamma ) ^ { 2 } } , } \end{array}
+$$
+
+where $\delta$ is the step size in the reward improvement step.
+
+Proof. Following the same proof in Theorem S.2, we complete the proof.
+
+Note that the bounds we obtain for the infeasibe case; to the best of our knowledge, are new results.
+
+S.3 PROOF OF ANALYTICAL SOLUTION TO PCPO
+
+Theorem S.5. Consider the PCPO problem. In the first step, we optimize the reward:
+
+$$
+\begin{array} { r l } { \pmb { \theta } ^ { k + \frac { 1 } { 2 } } = \underset { \pmb { \theta } } { \arg \operatorname* { m a x } } } & { \pmb { g } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) } \\ { s . t . } & { \frac { 1 } { 2 } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) ^ { T } \pmb { H } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) \leq \delta , } \end{array}
+$$
+
+and in the second step, we project the policy onto the constraint set:
+
+$$
+\begin{array} { r l } { \pmb { \theta } ^ { k + 1 } = \underset { \pmb { \theta } } { \arg \operatorname* { m i n } } } & { \frac { 1 } { 2 } ( \pmb { \theta } - \pmb { \theta } ^ { k + \frac { 1 } { 2 } } ) ^ { T } \pmb { L } ( \pmb { \theta } - \pmb { \theta } ^ { k + \frac { 1 } { 2 } } ) } \\ { s . t . } & { \pmb { a } ^ { T } ( \pmb { \theta } - \pmb { \theta } ^ { k } ) + b \leq 0 , } \end{array}
+$$
+
+where $g , a , \theta \in \mathbb { R } ^ { n } , b , \delta \in \mathbb { R } , \delta > 0$ , and $H , L \in \mathbb { R } ^ { n \times n } , L = H$ if using the $K L$ divergence projection, and ${ L = I }$ if using the $L ^ { 2 }$ norm projection. When there is at least one strictly feasible point, the optimal solution satisfies
+
+$$
+\pmb { \theta } ^ { k + 1 } = \pmb { \theta } ^ { k } + \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { H } ^ { - 1 } g - \operatorname* { m a x } ( 0 , \frac { \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { a } ^ { T } \pmb { H } ^ { - 1 } g + b } { \pmb { a } ^ { T } L ^ { - 1 } \pmb { a } } ) L ^ { - 1 } \pmb { a } ,
+$$
+
+assuming that $\pmb { H }$ is invertible to get a unique solution.
+
+Proof. For the first problem, since $\pmb { H }$ is the Fisher Information matrix, which automatically guarantees it is positive semi-definite. Hence it is a convex program with quadratic inequality constraints. Hence if the primal problem has a feasible point, then Slaters condition is satisfied and strong duality holds. Let $\pmb { \theta } ^ { * }$ and $\lambda ^ { * }$ denote the solutions to the primal and dual problems, respectively. In addition, the primal objective function is continuously differentiable. Hence the Karush-Kuhn-Tucker (KKT) conditions are necessary and sufficient for the optimality of $\pmb { \theta } ^ { * }$ and $\lambda ^ { * }$ . We now form the Lagrangian:
+
+$$
+\mathcal { L } ( \pmb \theta , \lambda ) = - \pmb { g } ^ { T } ( \pmb \theta - \pmb \theta ^ { k } ) + \lambda \bigg ( \frac 1 2 ( \pmb \theta - \pmb \theta ^ { k } ) ^ { T } \pmb { H } ( \pmb \theta - \pmb \theta ^ { k } ) - \delta \bigg ) .
+$$
+
+And we have the following KKT conditions:
+
+$$
+\begin{array} { r l } { - g + \lambda ^ { * } H \pmb { \theta } ^ { * } - \lambda ^ { * } H \pmb { \theta } ^ { k } = 0 \quad } & { \nabla _ { \theta } \mathcal { L } ( \pmb { \theta } ^ { * } , \lambda ^ { * } ) = 0 } \\ { \frac { 1 } { 2 } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) ^ { T } H ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) - \delta = 0 \quad } & { \nabla _ { \lambda } \mathcal { L } ( \pmb { \theta } ^ { * } , \lambda ^ { * } ) = 0 } \\ { \frac { 1 } { 2 } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) ^ { T } H ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) - \delta \leq 0 \quad } & { \mathrm { p r i m a l ~ c o n s t r a i n t s } } \\ { \lambda ^ { * } \geq 0 \quad } & { \mathrm { d u a l ~ c o n s t r a i n t s } } \\ { \lambda ^ { * } \left( \frac { 1 } { 2 } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) ^ { T } H ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) - \delta \right) = 0 \quad } & { \mathrm { c o m p l e m e n t a r y ~ s l a c k n e s s } } \end{array}
+$$
+
+By Eq. (13), we have $\pmb { \theta } ^ { * } = \pmb { \theta } ^ { k } + \textstyle \frac { 1 } { \lambda ^ { * } } \pmb { H } ^ { - 1 } \pmb { g }$ . And by plugging Eq. (13) into Eq. (14), we have $\begin{array} { r } { \lambda ^ { * } = \sqrt { \frac { g ^ { T } H ^ { - 1 } g } { 2 \delta } } } \end{array}$ gT H−1g2δ . Hence we have our optimal solution:
+
+$$
+\pmb { \theta } ^ { k + \frac { 1 } { 2 } } = \pmb { \theta } ^ { \ast } = \pmb { \theta } ^ { k } + \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { H } ^ { - 1 } \pmb { g } ,
+$$
+
+which also satisfies Eq. (15), Eq. (16), and Eq. (17).
+
+Following the same reasoning, we now form the Lagrangian of the second problem:
+
+$$
+\mathcal { L } ( \pmb \theta , \lambda ) = \frac { 1 } { 2 } ( \pmb \theta - \pmb \theta ^ { k + \frac { 1 } { 2 } } ) ^ { T } L ( \pmb \theta - \pmb \theta ^ { k + \frac { 1 } { 2 } } ) + \lambda ( \mathbf { \alpha } ^ { T } ( \pmb \theta - \pmb \theta ^ { k } ) + b ) .
+$$
+
+![](images/e771525096f4074d472619f0539c4e3ce316d319460bb79710c81afeaca20202.jpg)  
+Figure 7: The projection onto the convex set with $\pmb { \theta } ^ { \prime } \in \mathcal { C }$ and $\theta ^ { * } = \mathrm { P r o j } _ { \mathcal { C } } ^ { L } ( \theta )$ .
+
+And we have the following KKT conditions:
+
+$$
+\begin{array} { r l } { L \theta ^ { * } - L \theta ^ { k + \frac { 1 } { 2 } } + \lambda ^ { * } \pmb { a } = 0 \quad } & { \nabla _ { \theta } \mathcal { L } ( \pmb { \theta } ^ { * } , \lambda ^ { * } ) = 0 } \\ { \pmb { a } ^ { T } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) + b = 0 \quad } & { \nabla _ { \lambda } \mathcal { L } ( \pmb { \theta } ^ { * } , \lambda ^ { * } ) = 0 } \\ { \pmb { a } ^ { T } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) + b \leq 0 \quad } & { \mathrm { p r i m a l ~ c o n s t r a i n t s } } \\ { \lambda ^ { * } \geq 0 \quad } & { \mathrm { d u a l ~ c o n s t r a i n t s } } \\ { \lambda ^ { * } ( \pmb { a } ^ { T } ( \pmb { \theta } ^ { * } - \pmb { \theta } ^ { k } ) + b ) = 0 \quad } & { \mathrm { c o m p l e m e n t a r y ~ s l a c k n e s s } } \end{array}
+$$
+
+By Eq. (19), we have $\pmb { \theta } ^ { * } = \pmb { \theta } ^ { k + 1 } + \lambda ^ { * } \pmb { L } ^ { - 1 } \pmb { a }$ . And by plugging Eq. (19) into Eq. (20) and Eq. (22), we have $\begin{array} { r } { \lambda ^ { * } = \operatorname* { m a x } ( 0 , \frac { { { a } ^ { T } ( \pmb { \theta } ^ { k + \frac { 1 } { 2 } } - \pmb { \theta } ^ { k } ) } + b } { a { \cal L } ^ { - 1 } a } ) } \end{array}$ . Hence we have our optimal solution:
+
+$$
+\pmb \theta ^ { k + 1 } = \pmb \theta ^ { * } = \pmb \theta ^ { k + \frac { 1 } { 2 } } - \operatorname* { m a x } ( 0 , \frac { \pmb a ^ { T } ( \pmb \theta ^ { k + \frac { 1 } { 2 } } - \pmb \theta ^ { k } ) + b } { \pmb a ^ { T } \pmb L ^ { - 1 } \pmb a ^ { T } } ) \pmb L ^ { - 1 } \pmb a ,
+$$
+
+which also satisfies Eq. (21) and Eq. (23). Hence by Eq. (18) and Eq. (24), we have
+
+$$
+\pmb { \theta } ^ { k + 1 } = \pmb { \theta } ^ { k } + \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { H } ^ { - 1 } g - \operatorname* { m a x } ( 0 , \frac { \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { a } ^ { T } H ^ { - 1 } g + b } { \pmb { a } ^ { T } L ^ { - 1 } \pmb { a } } ) L ^ { - 1 } \pmb { a } .
+$$
+
+# S.4 PROOF OF THEOREM 4.1: STATIONARY POINTS OF PCPO WITH THE KL DIVERGENCE AND $L ^ { 2 }$ NORM PROJECTIONS
+
+For our analysis, we make the following assumptions: we minimize the negative reward objective function $f : \mathbb { R } ^ { n }  \mathbb { R }$ (We follow the convention of the literature that authors typically minimize the objective function). The function $f$ is $L$ -smooth and twice continuously differentiable over the closed and convex constraint set $\mathcal { C }$ . We have the following lemma to characterize the projection and for the proof of Theorem S.7. (See Fig. 7 for semantic illustration.)
+
+Lemma S.6. For any $\pmb \theta$ , $\theta ^ { * } = \mathrm { P r o j } _ { \mathcal { C } } ^ { L } ( \theta )$ if and only $i f ( \pmb \theta - \pmb \theta ^ { * } ) ^ { T } \pmb { L } ( \pmb \theta ^ { \prime } - \pmb \theta ^ { * } ) \leq 0 , \forall \pmb \theta ^ { \prime } \in \mathcal { C }$ , where $\operatorname* { P r o j } _ { \mathcal { C } } ^ { L } ( \pmb { \theta } ) \doteq \arg \operatorname* { m i n } _ { \pmb { \theta } ^ { \prime } \in \mathcal { C } } | | \pmb { \theta } - \pmb { \theta } ^ { \prime } | | _ { L } ^ { 2 }$ , and ${ \pmb { L } } = { \pmb { H } }$ if using the $K L$ divergence projection, and $L = I \ i f$ using the $L ^ { 2 }$ norm projection.
+
+Proof. $( \Rightarrow )$ Let $\theta ^ { * } = \mathrm { P r o j } _ { \mathcal { C } } ^ { L } ( \theta )$ for a given $\pmb \theta \notin \mathcal { C }$ , $\pmb { \theta } ^ { \prime } \in \mathcal { C }$ be such that $\theta ^ { \prime } \neq \theta ^ { * }$ , and $\alpha \in ( 0 , 1 )$ . Then we have
+
+$$
+\begin{array} { c } { | | \theta - \theta ^ { * } | | _ { L } ^ { 2 } \leq | | \theta - \left( \theta ^ { * } + \alpha ( \theta ^ { \prime } - \theta ^ { * } ) \right) | | _ { L } ^ { 2 } } \\ { = | | \theta - \theta ^ { * } | | _ { L } ^ { 2 } + \alpha ^ { 2 } | | \theta ^ { \prime } - \theta ^ { * } | | _ { L } ^ { 2 } - 2 \alpha ( \theta - \theta ^ { * } ) ^ { T } L ( \theta ^ { \prime } - \theta ^ { * } ) } \\ { \Rightarrow ( \theta - \theta ^ { * } ) ^ { T } L ( \theta ^ { \prime } - \theta ^ { * } ) \leq \displaystyle \frac { \alpha } { 2 } | | \theta ^ { \prime } - \theta ^ { * } | | _ { L } ^ { 2 } . } \end{array}
+$$
+
+Since the right hand side of Eq. (25) can be made arbitrarily small for a given $\alpha$ , and hence we have:
+
+$$
+( \pmb \theta - \pmb \theta ^ { * } ) ^ { T } \pmb L ( \pmb \theta ^ { \prime } - \pmb \theta ^ { * } ) \leq 0 , \forall \pmb \theta ^ { \prime } \in \mathcal { C } .
+$$
+
+$( \Leftarrow )$ Let $\theta ^ { \ast } \in \mathcal { C }$ be such that $( \pmb \theta - \pmb \theta ^ { * } ) ^ { T } \pmb L ( \pmb \theta ^ { \prime } - \pmb \theta ^ { * } ) \leq 0 , \forall \pmb \theta ^ { \prime } \in \mathcal { C }$ . We show that $\pmb { \theta } ^ { * }$ must be the optimal solution. Let $\pmb { \theta } ^ { \prime } \in \mathcal { C }$ and $\pmb { \theta } ^ { \prime } \neq \pmb { \theta } ^ { * }$ . Then we have
+
+$$
+\begin{array} { r l } & { \| \theta - \theta ^ { \prime } \| _ { L } ^ { 2 } - \| \theta - \theta ^ { * } \| _ { L } ^ { 2 } = \| \theta - \theta ^ { * } + \theta ^ { * } - \theta ^ { \prime } \| _ { L } ^ { 2 } - \| \theta - \theta ^ { * } \| _ { L } ^ { 2 } } \\ & { \qquad = \| \theta - \theta ^ { * } \| _ { L } ^ { 2 } + \| \theta ^ { \prime } - \theta ^ { * } \| _ { L } ^ { 2 } - 2 ( \theta - \theta ^ { * } ) ^ { T } L ( \theta ^ { \prime } - \theta ^ { * } ) - | | \theta - \theta ^ { * } | | _ { L } ^ { 2 } } \\ & { \qquad > 0 } \\ & { \qquad \Rightarrow \| \theta - \theta ^ { \prime } \| _ { L } ^ { 2 } > \| \theta - \theta ^ { * } \| _ { L } ^ { 2 } . } \end{array}
+$$
+
+Hence, $\pmb { \theta } ^ { * }$ is the optimal solution to the optimization problem, and $\theta ^ { * } = \mathrm { P r o j } _ { \mathcal { C } } ^ { L } ( \theta )$
+
+Based on Lemma S.6, we have the following theorem.
+
+Theorem S.7. Let $\eta \doteq \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } }$ in Eq. (6), where $\delta$ is the step size for reward improvement, $\textbf {  { g } }$ is the gradient of $f$ , $\pmb { H }$ is the Fisher information matrix. Let $\sigma _ { \mathrm { m a x } } ( H )$ be the largest singular value of $\pmb { H }$ , and a be the gradient of cost advantage function in Eq. (6). Then PCPO with the $K L$ divergence projection converges to stationary points with $\mathbf { \Delta } _ { \mathbf { { g } } } \in - \mathbf { \Delta } \mathbf { { a } }$ (i.e., the gradient of $f$ belongs to the negative gradient of the cost advantage function). The objective value changes by
+
+$$
+f ( \pmb { \theta } ^ { k + 1 } ) \leq f ( \pmb { \theta } ^ { k } ) + | | \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } | | _ { - \frac { 1 } { \eta } \pmb { H } + \frac { L } { 2 } \pmb { I } } ^ { 2 } .
+$$
+
+PCPO with the $L ^ { 2 }$ norm projection converges to stationary points with $\pmb { H } ^ { - 1 } \pmb { g } \in \mathbb { - } \pmb { a }$ (i.e., the product of the inverse of $\pmb { H }$ and gradient of $f$ belongs to the negative gradient of the cost advantage function). If $\sigma _ { \operatorname* { m a x } } ( \pmb { H } ) \le 1$ , then the objective value changes by
+
+$$
+f ( \pmb { \theta } ^ { k + 1 } ) \leq f ( \pmb { \theta } ^ { k } ) + ( \frac { L } { 2 } - \frac { 1 } { \eta } ) | | \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } | | _ { 2 } ^ { 2 } .
+$$
+
+Proof. The proof of the theorem is based on working in a Hilbert space and the non-expansive property of the projection. We first prove stationary points for PCPO with the KL divergence and $\bar { L } ^ { 2 }$ norm projections, and then prove the change of the objective value.
+
+When in stationary points $\pmb { \theta } ^ { * }$ , we have
+
+$$
+\begin{array} { r l } & { \pmb { \theta } ^ { * } = \pmb { \theta } ^ { * } - \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { H } ^ { - 1 } \pmb { g } - \operatorname* { m a x } ( 0 , \frac { \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { a } ^ { T } H ^ { - 1 } \pmb { g } + b } { \pmb { a } ^ { T } L ^ { - 1 } \pmb { a } } ) L ^ { - 1 } \pmb { a } . } \\ & { \Leftrightarrow \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { H } ^ { - 1 } \pmb { g } = - \operatorname* { m a x } ( 0 , \frac { \sqrt { \frac { 2 \delta } { g ^ { T } H ^ { - 1 } g } } \pmb { a } ^ { T } H ^ { - 1 } \pmb { g } + b } { \pmb { a } ^ { T } L ^ { - 1 } \pmb { a } } ) L ^ { - 1 } \pmb { a } } \\ & { \Leftrightarrow H ^ { - 1 } \pmb { g } \in - L ^ { - 1 } \pmb { a } . } \end{array}
+$$
+
+For the $\mathrm { K L }$ divergence projection $\mathbf { \nabla } \mathbf { L } = \mathbf { \nabla } H _ { \mathbf { \nabla } }$ ), Eq. (28) boils down to $\pmb { { g } } \in - \pmb { { a } }$ , and for the $L ^ { 2 }$ norm projection $\mathbf { \delta L } = \mathbf { I } .$ ), Eq. (28) is equivalent to $\pmb { H } ^ { - 1 } \pmb { g } \in - \pmb { a }$ .
+
+Now we prove the second part of the theorem. Based on Lemma S.6, for the KL divergence projection, we have
+
+$$
+\begin{array} { r l r } & { } & { ( \pmb { \theta } ^ { k } - \pmb { \theta } ^ { k + 1 } ) ^ { T } \pmb { H } ( \pmb { \theta } ^ { k } - \eta \pmb { H } ^ { - 1 } \pmb { g } - \pmb { \theta } ^ { k + 1 } ) \leq 0 } \\ & { } & { \Rightarrow g ^ { T } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) \leq - \cfrac { 1 } { \eta } \vert \vert \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } \vert \vert _ { \pmb { H } } ^ { 2 } . } \end{array}
+$$
+
+By Eq. (29), and $L$ -smooth continuous function $f$ , we have
+
+$$
+\begin{array} { l } { f ( { \theta } ^ { k + 1 } ) \le f ( { \theta } ^ { k } ) + g ^ { T } ( { \theta } ^ { k + 1 } - { \theta } ^ { k } ) + \displaystyle \frac { L } { 2 } | | { \theta } ^ { k + 1 } - { \theta } ^ { k } | | _ { 2 } ^ { 2 } } \\ { \le f ( { \theta } ^ { k } ) - \displaystyle \frac { 1 } { \eta } | | { \theta } ^ { k + 1 } - { \theta } ^ { k } | | _ { H } ^ { 2 } + \displaystyle \frac { L } { 2 } | | { \theta } ^ { k + 1 } - { \theta } ^ { k } | | _ { 2 } ^ { 2 } } \\ { = f ( { \theta } ^ { k } ) + ( { \theta } ^ { k + 1 } - { \theta } ^ { k } ) ^ { T } ( - \displaystyle \frac { 1 } { \eta } H + \displaystyle \frac { L } { 2 } I ) ( { \theta } ^ { k + 1 } - { \theta } ^ { k } ) } \\ { \quad = f ( { \theta } ^ { k } ) + | | { \theta } ^ { k + 1 } - { \theta } ^ { k } | | _ { - \frac { 1 } { \eta } H + \frac { L } { 2 } I } ^ { 2 } . } \end{array}
+$$
+
+For the $L ^ { 2 }$ norm projection, we have
+
+$$
+\begin{array} { r } { ( \pmb \theta ^ { k } - \pmb \theta ^ { k + 1 } ) ^ { T } ( \pmb \theta ^ { k } - \eta \pmb H ^ { - 1 } \pmb g - \pmb \theta ^ { k + 1 } ) \leq 0 } \\ { \Rightarrow g ^ { T } \pmb H ^ { - 1 } ( \pmb \theta ^ { k + 1 } - \pmb \theta ^ { k } ) \leq - \displaystyle \frac { 1 } { \eta } | | \pmb \theta ^ { k + 1 } - \pmb \theta ^ { k } | | _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+By Eq. (30), $L$ -smooth continuous function $f$ , and if $\sigma _ { \mathrm { m a x } } ( \pmb { H } ) \leq 1$ , we have
+
+$$
+\begin{array} { l } { f ( \pmb \theta ^ { k + 1 } ) \leq f ( \pmb \theta ^ { k } ) + \pmb g ^ { T } ( \pmb \theta ^ { k + 1 } - \pmb \theta ^ { k } ) + \displaystyle \frac { L } { 2 } | | \pmb \theta ^ { k + 1 } - \pmb \theta ^ { k } | | _ { 2 } ^ { 2 } } \\ { \leq f ( \pmb \theta ^ { k } ) + ( \displaystyle \frac { L } { 2 } - \frac { 1 } { \eta } ) | | \pmb \theta ^ { k + 1 } - \pmb \theta ^ { k } | | _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+To see why we need the assumption of $\sigma _ { \mathrm { m a x } } ( \pmb { H } ) \leq 1$ , we define $\pmb { H } = \pmb { U } \pmb { \Sigma } \pmb { U } ^ { T }$ as the singular value decomposition of $\pmb { H }$ with $\mathbf { \Delta } \mathbf { u } _ { i }$ being the column vector of $U$ . Then we have
+
+$$
+\begin{array} { r l } {  { g ^ { T } H ^ { - 1 } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) = \pmb { g } ^ { T } U \Sigma ^ { - 1 } U ^ { T } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) } } \\ & { \quad = \pmb { g } ^ { T } ( \sum _ { i } \frac { 1 } { \sigma _ { i } ( H ) } \pmb { u } _ { i } \pmb { u } _ { i } ^ { T } ) ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) } \\ & { \quad = \sum _ { i } \frac { 1 } { \sigma _ { i } ( H ) } \pmb { g } ^ { T } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) . } \end{array}
+$$
+
+If we want to have
+
+$$
+g ^ { T } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) \leq g ^ { T } H ^ { - 1 } ( \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } ) \leq - \frac { 1 } { \eta } | | \pmb { \theta } ^ { k + 1 } - \pmb { \theta } ^ { k } | | _ { 2 } ^ { 2 } ,
+$$
+
+then every singular value $\sigma _ { i } ( H )$ of $\pmb { H }$ needs to be smaller than 1, and hence $\sigma _ { \operatorname* { m a x } } ( \pmb { H } ) \le 1$ , which justifies the assumption we use to prove the bound. □
+
+To make the objective value for PCPO with the KL dside of Eq. (26) needs to be negative. Hence we hav ${ \frac { L \eta } { 2 } } I \prec H$ jection improv, implying that $\begin{array} { r } { \sigma _ { \mathrm { m i n } } ( \mathbf { H } ) > \frac { L \eta } { 2 } } \end{array}$ d. $L ^ { 2 }$ norm projection improves, the right hand side of Eq. (27) needs to be negative. Hence we have $\begin{array} { r } { \eta < { \frac { 2 } { L } } } \end{array}$ , implying that
+
+$$
+\begin{array} { r l } & { \eta = \sqrt { \frac { 2 \hat { g } } { g ^ { \prime } H ^ { - 1 } - g } } < \frac { 2 } { L } } \\ & {  \frac { 2 \hat { g } } { g ^ { \prime } H ^ { - 1 } - g } < \frac { 4 } { L ^ { 2 } } } \\ & {  \frac { g ^ { \prime } H ^ { - 1 } - g } { 2 } > \frac { 2 } { L ^ { 2 } } } \\ & {  \frac { 2 ^ { 2 } H ^ { - 1 } - g } { 2 } > \frac { 2 } { L ^ { 2 } } } \\ & {  \frac { L ^ { 2 } \hat { g } } { 2 } < g ^ { \prime } H ^ { - 1 } . } \\ & { \leq | | g | | _ { L ^ { 1 } } | | H ^ { - 1 } g | | _ { L ^ { 1 } } } \\ & { \leq | | g | | | _ { L ^ { 1 } } | | H ^ { - 1 } g | | | _ { L ^ { 1 } } } \\ & { = c _ { \mathrm { m a x } } ( H ^ { - 1 } ) | | g | | _ { L ^ { 2 } } ^ { 2 } } \\ & { = { \mathcal { O } } _ { \mathrm { m a x } } ( H ^ { 1 } ) | | ^ { 2 } . } \\ & {  { \mathcal { O } } _ { \mathrm { m a x } } ( H ^ { 1 } ) > \frac { 2 } { 2 } | g | | _ { L ^ { 2 } } ^ { 2 } . } \end{array}
+$$
+
+By the definition of the condition number and Eq. (31), we have
+
+$$
+\begin{array} { r l } & { \qquad \frac { 1 } { \sigma _ { \mathrm { m i n } } ( H ) } < \frac { 2 | | g | | _ { 2 } ^ { 2 } } { L ^ { 2 } \delta } } \\ & { \Rightarrow \frac { \sigma _ { \mathrm { m a x } } ( H ) } { \sigma _ { \mathrm { m i n } } ( H ) } < \frac { 2 | | g | | _ { 2 } ^ { 2 } \sigma _ { \mathrm { m a x } } ( H ) } { L ^ { 2 } \delta } } \\ & { \qquad \leq \frac { 2 | | g | | _ { 2 } ^ { 2 } } { L ^ { 2 } \delta } , } \end{array}
+$$
+
+which justifies what we discuss.
+
+# S.5 ADDITIONAL COMPUTATIONAL EXPERIMENTS
+
+# S.5.1 IMPLEMENTATION DETAILS
+
+For detailed explanation of the task in Achiam et al. (2017), please refer to the appendix of Achiam et al. (2017). For detailed explanation of the task in Vinitsky et al. (2018), please refer to Vinitsky et al. (2018).
+
+We use neural networks that take the input of state, and output the mean and variance to be the Gaussian policy in all experiments. For the simulations in the gather and circle tasks, we use a neural network with two hidden layers of size (64, 32). For the simulations in the grid and bottleneck tasks, we use a neural network with two hidden layers of size (16, 16) and (50, 25), respectively. We use tanh as the activation function of the neural network.
+
+We use GAE- $\lambda$ approach (Schulman et al., 2015b) to estimate $A _ { R } ^ { \pi } ( s , a )$ and $A _ { C } ^ { \pi } ( s , a )$ . For the simulations in the gather and circle tasks, we use neural network baselines with the same architecture and activation functions as the policy networks. For the simulations in the grid and bottleneck tasks, we use linear baselines.
+
+The hyperparameters of each task for all algorithms are as follows (PC: point circle, PG: point gather, AC: ant circle, AG: ant gather, Gr: grid, and BN: bottleneck tasks):
+
+<table><tr><td>Parameter</td><td>PC</td><td>PG</td><td>AC</td><td>AG</td><td>Gr</td><td>BN</td></tr><tr><td>discount factor y</td><td>0.995</td><td>0.995</td><td>0.995</td><td>0.995</td><td>0.999</td><td>0.999</td></tr><tr><td>step size δ</td><td>10-4</td><td>10-4</td><td>10-4</td><td>10-4</td><td>10-4</td><td>10-4</td></tr><tr><td>AGAE</td><td>0.95</td><td>0.95</td><td>0.95</td><td>0.95</td><td>0.97</td><td>0.97</td></tr><tr><td>BAE</td><td>1.0</td><td>1.0</td><td>0.5</td><td>0.5</td><td>0.5</td><td>1.0</td></tr><tr><td>Batch size</td><td>50,000</td><td>50,000</td><td>100,000</td><td>100,000</td><td>10,000</td><td>25.000</td></tr><tr><td>Rollout length</td><td>50</td><td>15</td><td>500</td><td>500</td><td>400</td><td>500</td></tr><tr><td>Cost constraint threshold h</td><td>5</td><td>0.1</td><td>10</td><td>0.2</td><td>0</td><td>0</td></tr></table>
+
+Note that we do not use a learned model to predict the probability of entering an undesirable state within a fixed time horizon as CPO did for cost shaping.
+
+# S.5.2 EXPERIMENT RESULTS
+
+To examine the performance of the algorithms with different metrics, we provide the learning curves of the cumulative constraint value over policy update, and the reward versus the cumulative constraint value for the tested algorithms and task pairs in Section 6 shown in Fig. 8. The second metric enables us to compare the reward difference under the same number of cumulative constraint violation.
+
+Overall, we find that,
+
+(a) CPO has more cumulative constraint violation than PCPO.   
+(b) PCPO with $L ^ { 2 }$ norm projection has less cumulative constraint violation than KL divergence projection except for the point circle and point gather tasks. This observation suggests that the Fisher information matrix is not well-estimated in the high dimensional policy space, leading to have more constraint violation.   
+(c) PCPO has more reward improvement compared to CPO under the same number of cumulative constraint violation in point circle, point gather, ant circle, ant gather, and bottleneck task.
+
+# S.5.3 CPO WITHOUT LINE SEARCH
+
+Due to approximation errors, CPO performs line search to check whether the updated policy satisfies the trust region and cost constraints. To understand the necessity of line search in CPO, we conducted the experiment with and without line search shown in Fig. 9. The step size $\delta$ is set to 0.01. We find that CPO without line search tends to (1) have large reward variance especially in the point circle task, and (2) learn constraint-satisfying policies slightly faster. These observations suggest that line search is more conservative in optimizing the policies since it usually take smaller steps. However, we conjecture that if using smaller $\delta$ , the effect of line search is not significant.
+
+![](images/37ad4266b21d54b5c5b738ff40a062a288b6dfcdbe526dfd836334fd30f75fbf.jpg)  
+Figure 8: The values of the cumulative constraint value over policy update, and the reward versus the cumulative constraint value for the tested algorithms and task pairs. The solid line is the mean and the shaded area is the standard deviation, over five runs. The curves for baseline oracle, TRPO, indicate the performance when the constraint is ignored. (Best viewed in color, and the legend is shared across all the figures.)
+
+# S.5.4 THE TASKS WITH HARDER CONSTRAINTS
+
+To understand the stability of PCPO and CPO when deployed in more constraint-critical tasks, we increase the difficulty of the task by setting the constraint threshold to zero and reduce the safe area. The learning curve of discounted reward and constraint value over policy updates are shown in Fig. 10.
+
+We observe that even with more difficult constraint, PCPO still has more reward improvement and constraint satisfaction than CPO, whereas CPO needs more feasible recovery steps to satisfy the constraint. In addition, we observe that PCPO with $L ^ { 2 }$ norm projection has high constraint variance in point circle task, suggesting that the reward update direction is not well aligned with the cost update direction. We also observe that PCPO with $L ^ { 2 }$ norm projection converges to a bad local optimum in terms of reward in point gather task, suggesting that in order to satisfy the constraint, the cost update direction destroys the reward update direction.
+
+![](images/174b189a860339c0957bf61ffe16f556fe006169aac2a6d7014f6494d083ab00.jpg)  
+Figure 9: The values of the reward and the constraint value for the tested algorithms and task pairs. The solid line is the mean and the shaded area is the standard deviation, over five runs. The dash line in the cost constraint plot is the cost constraint threshold $h$ . Line search helps to stabilize the training. (Best viewed in color)
+
+![](images/d573c164cbdfbb17c5a5c05cf9cab30a0ae78d5decbb0cc638dbf69582a1b791.jpg)  
+Figure 10: The values of the reward and the constraint value for the tested algorithms and task pairs. The solid line is the mean and the shaded area is the standard deviation, over five runs. The dash line in the cost constraint plot is the cost constraint threshold $h$ . PCPO with KL divergence projection is the only one that can satisfy the constraint with the highest reward. (Best viewed in color)
+
+![](images/5ca119ec38f008b21bb3559d5d83641ff958c279b7c59487ae13c28eab7a5a8f.jpg)  
+Figure 11: The values of the reward and the constraint value for the tested algorithms and task pairs. The solid line is the mean and the shaded area is the standard deviation, over five runs. The dash line in the cost constraint plot is the cost constraint threshold $h$ . The curves for baseline oracle, TRPO, indicate the reward and constraint violation values when the constraint is ignored. We only use $1 \%$ of samples compared to the previous simulations for each policy update. PCPO still satisfies the constraints quickly even when the constraint set is not well-estimated. (Best viewed in color)
+
+# S.5.5 SMALLER BATCH SAMPLES
+
+To learn policies under constraints, PCPO and CPO require to have a good estimation of the constraint set. However, PCPO may project the policy onto the space that violates the constraint due to the assumption of approximating the constraint set by linear half space constraint. To understand whether the estimation accuracy of the constraint set affects the performance, we conducted the experiments with batch sample size reducing to $1 \%$ of the previous experiments (only 500 samples for each policy update) shown in Fig. 11.
+
+We find that smaller training samples affects the performance of the algorithm, creating more reward and cost fluctuation. However, we observe that even with smaller training samples, PCPO still has more reward improvement and constraint satisfaction than CPO.
+
+# S.6 ANALYSIS OF THE APPROXIMATION ERROR AND THE COMPUTATIONAL COST OF THE CONJUGATE GRADIENT METHOD
+
+In the Grid task, we observe that PCPO with KL divergence projection does worse in reward than TRPO, which is expected since TRPO ignores constraints. However, TRPO actually outperforms PCPO with KL divergence projection in terms of constraint, which is unexpected since by trying to consider the constraint, PCPO with KL divergence projection has made constraint satisfaction worse.
+
+The reason for this observation is that the Fisher information matrix is ill-conditioned, i.e., the condition number $\lambda _ { \operatorname* { m a x } } ( { H } ) / \lambda _ { \operatorname* { m i n } } ( { H } )$ $\lambda _ { \mathrm { m a x } }$ is the largest eigenvalue of the matrix) of the Fisher information matrix is large, causing conjugate gradient method that computes constraint update direction ${ \pmb { H } } ^ { - 1 } { \pmb { a } }$ with small number of iteration output the inaccurate approximation. Hence the inaccurate approximation of ${ \pmb { H } } ^ { - 1 } { \pmb { a } }$ cause PCPO with KL divergence projection have more constraint violation than TRPO.
+
+![](images/79ca02aad6d27112e7dda7a7dd6557da2285bfb0f9316d12eb12d3effe067bd1.jpg)  
+Figure 12: (1) The values of the reward and the constraint, (2) the condition number of the Fisher information matrix, and (3) the approximation error of the constraint update direction over training epochs with the conjugate gradient method’s iteration of 10 and 20, respectively. The one with larger number of iteration has more constraint satisfaction since it has more accurate approximation. (Best viewed in color)
+
+To solve this issue, one can have more epochs of conjugate gradient method. This is because that the convergence of conjugate gradient method is controlled by the condition number (Shewchuk, 1994); the larger the condition number is, the more epochs the algorithm needs to get accurate approximation. In our experiments, we set the number of iteration of conjugate gradient method to be 10 to tradeoff between the computational efficiency and the accuracy across all tested algorithms and task pairs.
+
+To verify our observation, we compare the condition number of the Fisher information matrix, and the approximation error of the constraint update direction over training epochs with different number of iteration of the conjugate gradient method shown in Fig. 12.
+
+We observe that the Fisher information matrix is ill-conditioned, and the one with larger number of iteration has less error and more constraint satisfaction. This observation confirms our discussion.
+
+# S.7 COMPARISON OF OPTIMIZATION PATHS OF PCPO WITH KL DIVERGENCE AND $L ^ { 2 }$ NORM PROJECTIONS
+
+Theorem 4.1 states that a stationary point of PCPO with KL divergence projection is different from the one of PCPO with $L ^ { 2 }$ norm projection. See Fig. 13 for illustration. To compare both stationary points, we consider the following example shown in Fig. 14. We maximize a non-convex function ${ \bf \dot { \boldsymbol { f } } } ( { \bf \boldsymbol { x } } ) = { \bf \boldsymbol { x } } ^ { T } \mathrm { d i a g } ( { \bf y } ) { \bf x }$ subject to the constraint ${ \pmb x } ^ { T } { \bf 1 } \leq - 1$ , where $\pmb { y } = [ 5 , - 1 ] ^ { T }$ , and 1 is an all-one vector. An optimal solution to this constrained optimization problem is infinity. Fig. 14(a) shows the update direction that combines the objective and the cost constraint update directions for both projections. It shows that PCPO with KL divergence projection has stationary points with $\mathbf { \pmb { g } } \in - { \pmb { a } }$ in the boundary of the constraint set (observe that the update direction is zero for PCPO with KL divergence projection at $\pmb { x } = [ 0 . 7 5 , - 1 . 7 5 ] ^ { T }$ , $[ 0 . 2 5 , - 1 . 2 \bar { 5 } ] ^ { T }$ , and $[ - 0 . 2 5 , - 0 . 7 5 ] ^ { T } )$ ), whereas PCPO with $\overline { { L } } ^ { 2 }$ norm projection does not have stationary points in the boundary of the constraint set. Furthermore, Fig. 14(b) shows the optimization paths for both projections with one initial starting point. It shows that starting at the initial point $[ 0 . 5 , - 2 . 0 ] ^ { T }$ , PCPO with KL divergence projection with the initial point $[ 0 . 5 , - \bar { 2 } . 0 ] ^ { T }$ converges to a local optimum, whereas $L ^ { 2 }$ norm projection converges to infinity. However, the above example does not necessary means that PCPO with $L ^ { 2 }$ norm projection always find a better optimum. For example, if the gradient direction of the objective is zero in the constraint set or in the boundary, then both projections may converge to the same stationary point.
+
+![](images/e470c596df6fc1a9c09eef5ac8d29e523b4d8f36ee7ab682de848b438a0b9f25.jpg)  
+Figure 13: The semantic overview of stationery points of PCPO. The red dashed lines are negative directions of normal cones, and the green dashed lines are objective update directions. The objective update direction in an stationary point is belong to the negative normal cone.
+
+![](images/fd496ecca917830ef3a37bd1b33bbe017837aca407e4ea96a6b9e7a20fbdd8f5.jpg)  
+Figure 14: The policy update direction that combines the objective and the constraint update directions of each point (top), and the optimization path of PCPO with KL divergence and $\bar { L } ^ { 2 }$ norm projections with the initial point $[ 0 . 5 , \dot { - } 2 . 0 ] ^ { T }$ (below). The red star is the initial point, the red arrows are the optimization paths, and the region that is below to the black line is the constraint set. We see that both projections converge to different solutions.

parse/train/rkxjnjA5KQ/rkxjnjA5KQ.md

@@ -0,0 +1,219 @@
+# TRANSFER LEARNING FOR RELATED REINFORCEMENT LEARNING TASKS VIA IMAGE-TO-IMAGE TRANSLATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep Reinforcement Learning has managed to achieve state-of-the-art results in learning control policies directly from raw pixels. However, despite its remarkable success, it fails to generalize, a fundamental component required in a stable Artificial Intelligence system. Using the Atari game Breakout, we demonstrate the difficulty of a trained agent in adjusting to simple modifications in the raw image, ones that a human could adapt to trivially. In transfer learning, the goal is to use the knowledge gained from the source task to make the training of the target task faster and better. We show that using various forms of fine-tuning, a common method for transfer learning, is not effective for adapting to such small visual changes. In fact, it is often easier to re-train the agent from scratch than to fine-tune a trained agent. We suggest that in some cases transfer learning can be improved by adding a dedicated component whose goal is to learn to visually map between the known domain and the new one. Concretely, we use Unaligned Generative Adversarial Networks (GANs) to create a mapping function to translate images in the target task to corresponding images in the source task. These mapping functions allow us to transform between various variations of the Breakout game, as well as between different levels of a Nintendo game, Road Fighter. We show that learning this mapping is substantially more efficient than re-training. A visualization of a trained agent playing Breakout and Road Fighter, with and without the GAN transfer, can be seen in https://streamable.com/msgtm and https://streamable.com/5e2ka.
+
+# 1 INTRODUCTION
+
+Transferring knowledge from previous occurrences to new circumstances is a fundamental human capability and is a major challenge for deep learning applications. A plausible requirement for artificial general intelligence is that a network trained on one task can reuse existing knowledge instead of learning from scratch for another task. For instance, consider the task of navigation during different hours of the day. A human that knows how to get from one point to another on daylight will quickly adjust itself to do the same task during night time, while for a machine learning system making a decision based on an input image it might be a harder task. That is because it is easier for us to make analogies between similar situations, especially in the things we see, as opposed to a robot that does not have this ability and its knowledge is based mainly on what it already saw.
+
+Deep reinforcement learning has caught the attention of researchers in the past years for its remarkable success in achieving human-level performance in a wide variety of tasks. One of the field’s famous achievements was on the Atari 2600 games where an agent was trained to play video games directly from the screen pixels and information received from the game (Mnih et al., 2013). However, this approach depends on interacting with the environment a substantial number of times during training. Moreover, it struggles to generalize beyond its experience, the training process of a new task has to be performed from scratch even for a related one. Recent works have tried to overcome this inefficiency with different approaches such as, learning universal policies that can generalize between related tasks (Schaul et al., 2015), as well as other transfer approaches (Fernando et al., 2017; Rusu et al., 2016).
+
+![](images/9312d7050f07823b64c2291ddecff231ee12b6b640febae61664fab496f7bd06.jpg)  
+Figure 1: Various variations of the Breakout game: (a) Standard version, (b) A Constant Rectangle - a rectangle in the same size as the bricks is added to the background in a predefined location, (c) A Moving Square - a square is added to the background and its location changes to one of three predefined locations every 1000 steps, (d) Green Lines - green lines in different sizes are drawn in the background, (e) Diagonals - diagonals are drawn in the left side of the background.
+
+In this work, we first focus on the Atari game Breakout, in which the main concept is moving the paddle towards the ball in order to maximize the score of the game. We modify the game by introducing visual changes such as adding a rectangle in the middle of the image or diagonals in the background. From a human perspective, it appears that making visual changes that are not significant to the game’s dynamics should not influence the score of the game, a player who mastered the original game should be able to trivially adapt to such visual variants. We show that the agent fails to transfer. Furthermore, fine-tuning, the main transfer learning method used today in neural networks, also fails to adapt to the small visual change: the information learned in the source task does not benefit the learning process of the very related target task, and can even decelerate it. The algorithm behaves as if these are entirely new tasks.
+
+Our second focus is attempting to transfer agent behavior across different levels of a video game: can an agent trained on the first level of a game use this knowledge and perform adequately on subsequent levels? We explore the Nintendo game Road Fighter, a car racing game where the goal is to finish the track before the time runs out without crashing. The levels all share the same dynamics, but differ from each other visually and in aspects such as road width. Similar to the Breakout results, an agent trained to play the first level fails to correctly adapt its past experience, causing the learned policy to completely fail on the new levels.
+
+To address the generalization problem, we propose a zero-shot generalization approach, in which the agent learns to transfer between related tasks by learning to visually map images from the target task back to familiar corresponding images from the source task. Such mapping is naturally achieved using Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), one of the most popular methods for the image-to-image translation that is being used in computer vision tasks such as style transfer (Zhu et al., 2017; Kim et al., 2017), object transfiguration (Zhou et al., 2017), photo enhancement (Ledig et al., 2016) and more recently, video game level generation (Volz et al., 2018). In our setup, it is not realistic to assume paired images in both domains, calling for the use of Unaligned GANs (Liu et al., 2017; Zhu et al., 2017; Kim et al., 2017; Yi et al., 2017). Using this approach we manage to transfer between similar tasks with no additional learning.
+
+Contributions This work presents three main contributions. First, in Section 2, we demonstrate how an agent trained with deep reinforcement learning algorithms fails to adapt to small visual changes, and that the common transfer method of fine-tuning fails as well. Second, in Section 3, we propose to separate the visual mapping from the game dynamics, resulting in a new transfer learning approach for related tasks based on visual input mapping. We evaluate this approach on Breakout and Road Fighter, and present the results comparing to different baselines. We show that our visual transfer approach is much more sample efficient then the alternatives. Third, in section 5, we suggest an evaluation setup for unaligned GAN architectures, based on their achieved performance on concrete down-stream tasks.
+
+# 2 GENERALIZATION FAILURES OF DEEP RL
+
+Many Breakout variations can be constructed that involve the same dynamics. The main idea is to make modifications that are not critical for a human playing the game but are for the algorithm that
+
+relies on visual inputs. We demonstrate the difficulty of deep reinforcement learning to generalize using 4 types of modifications as presented in Figure 1.
+
+# 2.1 SETUP
+
+For all the experiments in this section forward we use the Asynchronous Advantage Actor-Critic (A3C) algorithm (Mnih et al., 2016), taking advantage of being faster than Deep Q-Network (DQN) (Mnih et al., 2013). The A3C learns the policy and the state-value function using parallel actor-learners exploring different policies for the acceleration and stability of the training.
+
+We rescale the image to $8 0 \times 8 0$ and keep the RGB colors for more realistic images. We use 32 actor learners, a discount rate of 0.99, learning rate of 0.0001, 20-step returns, and entropy regularization weight of 0.01. The A3C variation we choose is the LSTM-A3C network. We use the standard high-performance architecture implemented in (Kostrikov, 2018).
+
+# 2.2 TRANSFER-LEARNING VIA FINE-TUNING
+
+The setup mentioned in 2.1 successfully trains on Breakout, reaching a score of over 400 points. However, when a network trained on the original game is presented with the game variants, it fails completely, reaching to a maximum score of only 3 points. This shows that the network does not necessarily learn the game’s concepts and heavily relies on the images it receives.
+
+The common approach for transferring knowledge across tasks is fine-tuning. We experiment with common techniques used in deep learning models. In each setting, we have a combination of frozen and fine-tuned layers (Partial/Full) as well as layers that are initialized with the target’s parameters and layers that are initialized with random values (Random). Our settings are inspired by (Yosinski et al., 2014). We train each one of the tasks (before and after the transformation) for 60 million frames, and our evaluation metric is the total reward the agents collect in an episode averaged by the number of episodes, where an episode ends when the game is terminated or when a number of maximum steps is reached. We periodically compute the average during training. We consider the following settings:
+
+• From-Scratch: The game is being trained from scratch on the target game.   
+• Full-FT: All of the layers are initialized with the weights of the source task and are fine-tuned on the target task.   
+• Random-Output: The convolutional layers and the LSTM layer are initialized with the weights of the source task and are fine-tuned on the target task. The output layers are initialized randomly. Partial-FT: All of the layers are initialized with the weights of the source task. The three first convolutional layers are kept frozen, and the rest are fine-tuned on the target task.   
+• Partial-Random-FT: The three first convolutional layers are initialized with the weights of the source task and are kept frozen, and the rest are initialized randomly.
+
+# 2.3 RESULTS
+
+The results presented in Figure 2 show a complete failure of all the fine-tuning approaches to transfer to the target tasks. In the best scenarios the transfer takes just as many epochs as training from scratch, while in other cases starting from a trained network makes it harder for the network to learn the target task. As the graphs show, some of the modification influenced more than others. For example, Figure 2a shows that adding a simple rectangle can be destructive for a trained agent: while training from scratch consistently and reliably achieves scores over 300, the settings starting from a trained agent struggle to pass the 200 points mark within the same number of iterations, and have a very high variance. We noticed that during training the agent learns a strategy to maximize the score with a minimum number of actions. None of the experiments we performed showed better results when the layers in the network were fine-tuned, and some showed negative transfer which is a clear indication of an overfitting problem. The A3C model learned the detail and noise in the training data to the extent that it negatively impacted the performance of the model on new data. Our results and conclusions drawn from them are consistent with the results shown when a similar approach was used on Pong (Rusu et al., 2016). In addition to Breakout, we also experimented transfer between the first and advanced level of Road Fighter, where the backgrounds change but the dynamics remains the same. This experiments resulted with 0 points on each of the levels, a complete failure of the agent to re-use the driving techniques learned on the first levels on the next ones.
+
+![](images/3df2a95ed22f63b94d55662705bf9d09d452dd5d6b0df15bdf6357a78e01a2c9.jpg)  
+Figure 2: A comparison between the different baselines on Breakout. The y-axis on each one of the plots shows the average reward per episode of Breakout during training. The $\mathbf { X }$ -axis shows the total number of training epochs where an epoch corresponds to 1 million frames. The plots are averaged on 3 runs with different random seeds. Each curve is the average and its background is the standard deviation.
+
+# 3 ANALOGY-BASED ZERO-SHOT GENERALIZATION
+
+An agent capable of performing a task in a source domain is now presented with a new domain. Fine-tuning the agent on the target domain fails to transfer knowledge from the source domain. We propose to separate the visual transfer from the dynamics transfer. To perform well, the agent can try and make analogies from the new domain to the old one: after observing a set of states (images) in the new domain, the agent can learn to map them to similar, familiar states from the source domain, and act according to its source domain policy on the mapped state.
+
+More concretely, given a trained policy $\pi ( a | s ; \theta )$ with trained parameters $\theta$ proposing an action $a$ for source domain states $s \in S$ , we wish to learn a mapping function $G : { \mathcal { T } } \mapsto S$ from target domain states $t \in \tau$ such that interacting with the environment $\tau$ by applying the policy $\pi ( a | G ( t ) ; \theta )$ will result in a good distribution of actions for the states $\tau$ , as indicated by high overall scores. In other words, we seek a mapping function $G$ that allows us to re-use the same policy $\pi _ { \theta }$ learned for source environment $s$ when interacting with the target environment $\tau$ .
+
+As both the source and target domain items are images, we heuristically learn the function $G$ by collecting sets of images from $s$ and $\tau$ and learning to visually map between them using Unaligned GAN (Liu et al., 2017; Zhu et al., 2017; Kim et al., 2017; Yi et al., 2017). We use the scores obtained from interacting with the environment via $\pi ( a | G ( t ) ; \theta )$ for the GAN model selection and stopping criteria.
+
+# 3.1 UNSUPERVISED IMAGE-TO-IMAGE TRANSLATION
+
+In this work, we focus on learning setups that receive only raw image data, without additional domain knowledge about objects or game dynamics. This prohibits us from using supervised paired GANs Isola et al. (2016) for learning the mapping function $G$ : we cannot collect the needed supervision of corresponding $( s , t )$ pairs. Instead, we use unaligned GANs (Zhu et al., 2017; Liu et al., 2017; Kim et al., 2017; Yi et al., 2017), in which the learner observes two sets of images, one from each domain, with the goal of learning to translate images in one domain to images in another.
+
+All major approaches to the unaligned image-to-image translation use the Cycle-Consistency principle. We have two mapping (encoding) functions $G _ { 1 } : T \mapsto S$ and $G _ { 2 } : S \mapsto T$ where $S = \stackrel { \cdot } { \{ s _ { i } \} } _ { i = 1 } ^ { N }$ is a set of images collected from the source task and $T = \{ t _ { j } \} _ { j = 1 } ^ { M }$ is a set of images collected from the target task. The goal is to generate an image $s ^ { \prime }$ , for any given $t \in T$ where $G _ { 1 } ( t ) = s ^ { \prime }$ , that is indistinguishable from $s \in S$ . The cycle consistency principle relies on the assumption that the two functions, $G _ { 1 }$ and $G _ { 2 }$ are inverses of each other. It encourages unsupervised mapping by forcing $G _ { 2 } ( G _ { 1 } ( t ) ) = t$ and $G _ { 1 } ( G _ { 2 } ( s ) ) = s$ where $s$ and $t$ are the input images. The second component of the GAN architecture are the discriminators $D _ { 1 }$ and $D _ { 2 }$ aiming to distinguish between images generated by $G _ { 1 }$ and $G _ { 2 }$ and the real images from the target and source distributions respectively.
+
+In the following experiments, we use the UNIT framework (Liu et al., 2017), which we found to perform well for the Breakout tasks (in section 5 we explicitly compare the UNIT and CycleGAN approaches on both the Breakout and Road Fighter transfer tasks). A distinguishing element in the UNIT framework is the shared-latent space assumption, according to which there is a shared-latent space consisting a shared latent code $z$ for any pair of images $s$ and $t$ that can be recovered from this code. This share-latent space is represented as the weights of the last few layers of the encoding network and the few first layers of the decoding networks, and is learned by using Variational Autoencoders (VAEs). This sharing strongly ties the images in the source and target domain to each other, encouraging mappings that preserve similarities across domains. In contrast, the CycleGAN architecture (Zhu et al., 2017) does not make the shared space assumption and instead the generators are trained independently with two separate networks. For further information of the unaligned GAN architectures, see the original papers.
+
+# 3.2 GAN TRAINING
+
+Datasets. The Unaligned GAN training dataset requires images from both domains. We collect images from the source domain by running an untrained agent and collecting the observed images, and we do similarly for the target domain. The number of collected images should balance between two objectives: On the one hand, we want to take a small number of images, and on the other hand, it is essential for us to have a diverse dataset. We repeat this procedure for every target task, and create a source-target dataset for each. During training, we further ensure the images pairs are not aligned by randomly picking an image from each set at each iteration.
+
+Setup and Analysis. For our experiments we use the same architecture and hyper-parameters proposed in the UNIT paper. We initialize the weights with Xavier initialization (Glorot & Bengio, 2010), set the batch size to 1 and train the network for a different number of iterations on each task. Some tasks are harder than others, the more changes exist in the frames the harder it is for the GAN to learn the mapping between the domains. However, our evaluation metric, testing the agent with the generated images, is a clear indication of how hard each task is and the number of iterations needed is based on the results of this evaluation.
+
+Evaluation. We use GAN training to learn a mapping function $G$ . GAN training, and unaligned GANs training in particular, are unstable and it challenging to find a good loss-based stopping criteria for them. A major issue with GANs is the lack of an evaluation metric that works well for all models and architectures, and which can assist in model selection. Different works use different methods that were suitable for their types of data. Our setup suggests a natural evaluation criteria: we run the source agent without any further training while using the model to translate each image of the target task back to the source task and collect the rewards the agent receives during the game when presented with the translated image. We use the total accumulated rewards (the score) the agent collects during the game as our model accuracy.
+
+# 4 EXPERIMENTS
+
+We examine how well the agent does when receiving translated frames generated by the generator trained with GANs. Since we initialized the layers with the values of the trained network, we assume that the success of the agent is dependent on the similarity between the generated and the source task’s frames. We first test our approach on Breakout, evaluating its ability to remove the changes added in the images. Second, we challenge our method even more on Road Fighter, where the goal is to transfer between different environments.
+
+# 4.1 BREAKOUT
+
+Our goal in Breakout is removing the modifications in each one of the target tasks and transfer between each to the original game. Although the variations share many similarities, some tasks were more challenging than others, e.g., the lines of the Green Lines variation hide parts of the ball in some frames. On the opposite side, the Rectangle variation requires less training since the number of pixels changed in the image is small.
+
+Table 1: The score and number of frames needed for it of: the source task (Source), target task when initialized with the source task’ network parameters with no additional training (Target) and the target task when initialized with the source task’ network parameters where every frame is translated to a frame from the source task (Target with GANs).   
+
+<table><tr><td colspan="2">Source</td><td>Target Task</td><td colspan="2">Target</td><td colspan="2">Target with GANs</td></tr><tr><td>Frames</td><td>Score</td><td></td><td>Frames</td><td>Score</td><td>GAN iterations</td><td>Score</td></tr><tr><td>43M</td><td>302</td><td>A Constant Rectangle</td><td>0</td><td>3</td><td>260K</td><td>362</td></tr><tr><td>43M</td><td>302</td><td>A Moving Square</td><td>0</td><td>0</td><td>384K</td><td>300</td></tr><tr><td>43M</td><td>302</td><td>Green Lines</td><td>0</td><td>2</td><td>288K</td><td>300</td></tr><tr><td>43M</td><td>302</td><td>Diagonals</td><td>0</td><td>0</td><td>380K</td><td>338</td></tr></table>
+
+![](images/496f6668096108513cee7e7579eefa1576c4a74015204a176da02a9e9d2df1a6.jpg)  
+Figure 3: Illustration of a frame taken from the target task (left) and its matching frame of the source task generated with GANs (right) for each one of the Breakout variations. (a)-(d) demonstrate successes, while (e) and (f) show failure modes of the unaligned GAN. In (e) the ball in the input image is not generated in the output and in (f) not all bricks are generated, and some of the generated bricks appear smudged.
+
+During testing, we encountered problems with the images generation that we did not observe during the GAN training. The translation task we attempted to perform was supposedly simple – search for the differences between the domains shared by all images, change them to the way they are in the opposite domain and leave everything else the same. Unfortunately, since the network does not have any prior information about objects in the image, it struggles to generate them even if they were not changed. The most common problem we had was that the generator generated bricks that were supposed to be removed from the game, and in some cases, they were very noisy in the generated image (Fig. 3f). Another problem was the ball generation and more specifically, the location of the generated ball. Since the ball is small and changes its position often, it was hard for the generator, trained with unaligned pairs, to decide if and where to locate it in the generated image (Fig. 3e). These issues and others eventually caused the agent to fail in following the policies it learned on the source task. We found that more training leads to better results for some of the variations and so the number of iterations needed was different for each variation.
+
+In Table 1 we show the results of a test game played by the agent with and without GANs. We stop the training after reaching 300 points, which we consider to be a high score. As the results show, the source game trained from scratch requires ten of millions of images to achieve such score comparing to the target task trained with GANs that only needs a few hundreds of thousands—a 100x fold increase in sample efficiency. Moreover, the frames the GAN was trained on were limited to the first games in which the A3C network was not trained, and yet it managed to generalize to more advanced stages of the game.
+
+# 4.2 ROAD FIGHTER
+
+![](images/5a5787db2b134a642a0a8587534f8ce38b259e14189fe290cc876a6647d418e0.jpg)  
+Figure 4: Road Fighter levels from left to right: Level 1, Level 2, Level 3 and Level 4.
+
+While the Breakout variants work well to demonstrate transfer failure cases, they can be considered as “toy examples”. We proceed to demonstrate the effectiveness of our transfer method on a “real” task: learning to transfer between different levels of the Road Fighter game. Road Fighter contains 4 different levels (Fig. 4), each with a different background where some are more difficult than others. The levels mostly differ visually and all have the same rules and require the same driving techniques. Thus, we believe that these techniques should sustain when playing a new level. We start by training an RL agent to play the first level of the game. To maximize the score, the agent has to acquire 3 main capabilities: driving fast, avoiding collision with obstacles, and if a car collision occurs reacting fast to avoid crashing. We use the A2C algorithm, the synchronous version of the Advantage Actor-Critic which performs better on this game than A3C, reaching over 10, 000 game points on level 1.
+
+For the GAN training, we collect $1 0 0 k 8 4 x 8 4$ frames from each of levels 2, 3 and 4 by running an untrained agent repeatedly until we have collected sufficient samples (training an RL agent to reach a score of 10,000 points on Level 1 required observing above 100M frames.). Using the collected images we train a mapping function for each task to map the new level (target task) to the first one (source task). We use the same GAN architecture used for Breakout, but initialize the weights with Orthogonal initialization. Compared to Breakout, these tasks introduce new challenges: rather than removing a mostly static element, the GAN has to be able to change the background and road size while keeping the cars in the right position on the road. On the other hand, this setup may be closer to the one unaligned GANs are usually applied in. We restrict ourselves to collecting images from the beginning of the game, before the agent had any training. This restricts the phenomena the GAN can observe, and some target tasks’ images do not have a clear corresponding situation in the first level, potentially causing unpredictable behaviors. For example, the generator matches the diagonal shaped roads to one of the first rare and unique images of level 1 (Fig. 5e).
+
+Our experiments presented in Table 2 demonstrate how an agent trained to master the first level of the game fails to follow the optimal policies on new levels, reaching 0 points. However, with the GAN-based visual analogies the agent is able to apply some of the abilities it gained when training on the first level, most notably driving fast, staying on the road, avoiding some cars, and, most importantly, recovering from car crashes. The resulting agent achieves impressive scores on levels 2, 3 and 4 (5350, 5350 and 2050 points, respectively), with no additional RL training and while observing only a fraction of the frames required for training a corresponding RL agent from scratch for these levels.
+
+Limitations. While the GAN works well in generating objects it has seen before, such as the agent’s car, it does have limitations on objects it has not seen. As a result, it ends up generating differently colored cars all in red, or not generating them at all, as shown in Fig. 5a, 5d and 5f. Colorful cars can be “collected” by the agent and are worth 1000 points each. Generating them in red makes the agent avoid them, losing these extra points and achieving overall lower scores even if finishing the track. When cars are not fully generated, the agent is less likely to avoid them, and eventually crashes.
+
+Data Efficiency. We measure the number of frames of game-interaction needed for the analogytransfer method. We collect $1 0 0 \mathrm { k }$ frames, and then train the GAN for up to $5 0 0 k$ iterations, evaluating it every 10, 000 iterations by running the game and observing the score, and pick the best scoring model. This amounts to $1 0 0 k + 5 0 * F$ frames, where $F = 3 0 0 0$ is roughly the average number of frames in a game. This amounts to about $2 5 0 k$ frames of game interaction for each transfered level, an order of magnitude fewer interaction frames than training an RL agent to achieve a comparable score.
+
+![](images/19c0801025f1974dd869deaee99d81768f9cdf1ce87b418db7a91076e4ce53c9.jpg)  
+Figure 5: Left: the original frame. Right: GAN generated. Upper row shows the success cases of the GAN while the lower row shows representative failures: in (d) and (f) the only object generated on the road is the player’s car and in (e) the diagonal shaped road of level 2 in matched to the starting point of level 1.
+
+Discussion. The approach is successfully transferring to most tasks, achieving the best scores on levels 2 and 3. In general, as the game progresses, the more obstacles are presented making it harder to play. One of our best results is achieved on level 2 where the road is identical to level 1’s, reaching the best score after $3 2 0 k$ GAN iterations. On level 3, the challenge increases as the road is very narrow, making it harder for a player to avoid crashing. However, the GAN manages to generate the road in the right shape in most frames and position the cars in the matching ratio. Moreover, despite the challenges, due to the agent’s ability to avoid crashing when colliding with cars it gets over 5000 points after $4 5 0 k$ GAN iterations. In level 4 we get the maximum after $2 7 0 k$ iterations. This level is also the most challenging one to play, which might be the reason for the score being the lowest out of all tasks. The main obstacles are the sudden turns in the road causing the car to be very close to the sideways and the increasing dangers a player has to avoid. Theses difficulties make this level much harder than level 1 and might require more training even from a human player.
+
+Overall, the agent performs quite well by successfully applying 2 out of 3 main capabilities it gained during training. It is missing the third capability, avoiding collisions and collecting bonus cars, mainly because of bad generation. We believe that these tasks and results demonstrate a success of the analogy transfer method for zero-short generalization across different levels of a video game. They also suggest a potential of performing well on additional real world tasks in which visual analogies can be made.
+
+# 5 TOWARDS TASK-ORIENTED GAN EVALUATION
+
+Evaluating GAN models and comparing them to each other is a major challenge: working with images and without well-defined objectives, testing the quality of the generator is delegated to human judgment, often using crowdsourcing to evaluate the generated images Isola et al. (2016); Donahue et al. (2017). This metric is not stable and can be unreliable due to changing human factors. Others use a linear classifier to evaluate the image representations the GAN learned on supervised datasets, e.g., MNIST and CIFAR-10 (Radford et al., 2015). These approaches and others may be good enough for a limited group of test images but do not necessarily reflect the performance of a model in the real world.
+
+We note that while unaligned GANs are known to achieve impressive results with only few training examples, our seemingly trivial translation cases proved to be quite challenging for the unaligned GAN architectures: producing valid translations that work in the game require training on a substantial number of images. During training, the GAN sees images from the early stages of the game where only a few bricks are missing in Breakout and there are no obstacles in Road Fighter. Our task requires it to generalize by translating images where objects are removed, added or in a different locations. This requires levels of generalization that may not be reflected in existing test-sets. We argue that using simple, well defined yet diverse test cases, situated in the context of a concrete down-stream task like we do here, is an important step forward in the evaluation of GAN models.
+
+We propose to evaluate GAN by running a game in which the trained Deep RL network that learned policies based on images is now receiving images from the same domain generated with GAN, and equate a successful GAN model with one resulting in a high game score. We use the approach to compare Cycle-GAN (Zhu et al., 2017) and UNIT-GAN (Liu et al., 2017).
+
+We examine both methods by running the RL agent with each every 1000 GAN training iterations and considering the maximum score after $5 0 0 k$ iterations. We present the results in Table 3. The UNIT GAN performs better than Cycle-GAN in most Breakout tasks, while Cycle-GAN outperforms UNIT in most Road Fighter tasks while requiring fewer iterations. The main difference between the two methods is the weight-sharing constraint applied in UNIT, making the domains dependent on each other by sharing and updating the weights of one or several decoders and encoders layers. We hypothesize this constraint is an advantage in tasks where the representation of the images in the different domains are similar. Thus, in Breakout, where most pixels are identical in the source and target images, Cycle-GAN often fails where UNIT succeed. However, in tasks such as Road Fighter’s where most pixels are different, the agent could benefit from architectures such as Cycle-GAN where the two domains are independent of each other.
+
+# 6 RELATED WORK
+
+Transfer Learning (TL) is a machine learning technique used to improve the training speed of a target task with knowledge learned in a source task. Pretraining and fine-tuning was proposed in Hinton & Salakhutdinov (2006) and applied to TL in Bengio (2012) and Dauphin et al. (2012). In this procedure, the approach is to train the base network and then copy its first $n$ layers to the first $n$ layers of a target network. One can choose to update the feature layers transferred to the new task with the error backpropagated from its output, or they can be left frozen, meaning that they do not change during training on the new task. Unfortunately, as we have shown, while fine-tuning might have the ability to accelerate the training process is some cases, it can also have a damaging impact on others.
+
+Generalization is a key element in training deep learning models with time or data size constraints. Recent discussions on overfitting in Deep RL algorithms (Zhang et al., 2018) encouraged better evaluation (e.g. OpenAI Retro Contest 1) and generalization methods. In Atari, there are many similarities between the goals and the mechanism of the games. For this reason, there have been many works attempting to transfer between games or between different variations of the same game, one approach trying to do both is the progressive networks (Rusu et al., 2016). A progressive network is constructed by successively training copies of A3C on each task of interest. In that work, they transferred between different games as well as from different variations of the game Pong. The drawback of this approach is the number of parameters growing quadratically with the number of tasks. However, even if this growth rate was improved, different tasks may require different adjustments and the predefinition of the number of layers and network representation is preventing it.
+
+Zero-shot generalization is a discussed and researched topic nowadays. One work transferring between modified versions of the same game using zero-shot transfer is the schema networks (Kansky et al., 2017). Like us, they also chose to demonstrate their method on the game Breakout, using
+
+Table 3: The scores accumulated by an Actor-Critic RL agent using UNIT and Cycle-GAN.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">UNIT</td><td colspan="2">CycleGAN</td></tr><tr><td>Frames</td><td>Score</td><td>Frames</td><td>Score</td></tr><tr><td>A Constant Rectangle</td><td>333K</td><td>399</td><td>358K</td><td>26</td></tr><tr><td>A Moving Square</td><td>384K</td><td>300</td><td>338K</td><td>360</td></tr><tr><td>Green Lines</td><td>378K</td><td>314</td><td>172K</td><td>273</td></tr><tr><td>Diagonals</td><td>380K</td><td>338</td><td>239K</td><td>253</td></tr><tr><td>Road Fighter - Level 2</td><td>274K</td><td>5750</td><td>51K</td><td>6000</td></tr><tr><td>Road Fighter - Level 3</td><td>450K</td><td>5350</td><td>20K</td><td>3200</td></tr><tr><td>Road Fighter - Level 4</td><td>176K</td><td>2300</td><td>102K</td><td>2700</td></tr></table>
+
+Object Oriented Markov Decision Process. In contrast, we do not use the representation of the objects in the game, and we wish to preserve the accomplishments of DQN and transfer using only raw data. Other attempted to achieve robust policies using learned disentangled representation of the image (Higgins et al., 2017), analogies between sets of instructions (Oh et al., 2017), interactive replay (Bruce et al., 2017) while training and learn general policies by training on multiple tasks in parallel (Espeholt et al., 2018; Sohn et al., 2018).
+
+Finally, the idea of using GANs for transfer learning and domain adaptation was explored for supervised image classification and robotics applications by several authors (Bousmalis et al., 2016; Hoffman et al., 2017; Liu & Tuzel, 2016; Bousmalis et al., 2017). In these methods, there is supervised source domain data $( x _ { i } ^ { s } , y _ { i } ^ { s } )$ and unlabeled target domain data, and the GAN variant $G$ is trained to map source samples $\boldsymbol { x } _ { i } ^ { s }$ to target-like samples $G ( x _ { i } ^ { s } )$ . Then, a classifier is trained on the generated data $( G ( x _ { i } ^ { s } ) , y _ { i } ^ { s } )$ . Our RL-based setup is different: first, our coverage of target-domain data is very limited (we can only observe states which are reachable by the un-adapted or untrained agent). Second, we do not have access to supervised gold labels on the source domain, but only to a learned policy network. Third, interactions with the game environment provide very indirect rewards, so using this reward signal to influence the GAN training will be very inefficient. We thus opt for a different strategy: rather than mapping the source to the target domain and training on the projected signal, which is unrealistic an costly in the RL setup, we instead take a pre-trained source model and train an unaligned GAN to map from the target domain back to the source domain, in order to re-use the source model’s knowledge and apply it to the target domain data. We believe this form of usage of GAN for transfer learning is novel.
+
+# 7 CONCLUSIONS AND FUTURE WORK
+
+We demonstrated the lack of generalization by looking at artificially constructed visual variants of a game (Breakout), and different levels of a game (Road Fighter). We further show that transfer learning by fine-tuning fails. The policies learned using model-free RL algorithms on the original game are not directly transferred to the modified games even when the changes are irrelevant to the game’s dynamics.
+
+We present a new approach for transfer learning between related RL environments using GANs without the need for any additional training of the RL agent, and while requiring orders of magnitude less interactions with the environment. We further suggest this setup as a way to evaluate GAN architectures by observing their behavior on concrete tasks, revealing differences between the CycleGAN and UNIT-GAN architectures. We believe our approach is applicable to cases involving both direct and less direct mapping between environments, as long as an image-to-image translation exist. While we report a success in analogy transfer using Unaligned GANs, we also encountered limitations in the generation process that made it difficult for the agent to maximize the results on the Road Fighter’s tasks. In future work, we plan to explore a tighter integration between the analogy transfer method and the RL training process, to facilitate better performance where dynamic adjustments are needed in addition to the visual mapping.
+
+# REFERENCES
+
+Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In Isabelle Guyon, Gideon Dror, Vincent Lemaire, Graham Taylor, and Daniel Silver (eds.), Proceedings of ICML Workshop on Unsupervised and Transfer Learning, volume 27 of Proceedings of Machine Learning Research, pp. 17–36, Bellevue, Washington, USA, 02 Jul 2012. PMLR. URL http: //proceedings.mlr.press/v27/bengio12a.html.
+
+Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. CoRR, abs/1612.05424, 2016. URL http://arxiv.org/abs/1612.05424.
+
+Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using simulation and domain adaptation to improve efficiency of deep robotic grasping. CoRR, abs/1709.07857, 2017. URL http://arxiv.org/abs/1709.07857.
+
+Jake Bruce, Niko Sunderhauf, Piotr Mirowski, Raia Hadsell, and Michael Milford. One-shot ¨ reinforcement learning for robot navigation with interactive replay. CoRR, abs/1711.10137, 2017. URL http://arxiv.org/abs/1711.10137.
+
+Grgoire Mesnil Yann Dauphin, Xavier Glorot, Salah Rifai, Yoshua Bengio, Ian Goodfellow, Erick Lavoie, Xavier Muller, Guillaume Desjardins, David Warde-Farley, Pascal Vincent, Aaron Courville, and James Bergstra. Unsupervised and transfer learning challenge: a deep learning approach. In Isabelle Guyon, Gideon Dror, Vincent Lemaire, Graham Taylor, and Daniel Silver (eds.), Proceedings of ICML Workshop on Unsupervised and Transfer Learning, volume 27 of Proceedings of Machine Learning Research, pp. 97–110, Bellevue, Washington, USA, 02 Jul 2012. PMLR. URL http://proceedings.mlr.press/v27/mesnil12a.html.
+
+Chris Donahue, Akshay Balsubramani, Julian McAuley, and Zachary C. Lipton. Semantically decomposing the latent spaces of generative adversarial networks. CoRR, abs/1705.07904, 2017. URL http://arxiv.org/abs/1705.07904.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam ´ Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: scalable distributed deep-rl with importance weighted actor-learner architectures. CoRR, abs/1802.01561, 2018. URL http://arxiv.org/abs/1802.01561.
+
+Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701.08734.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS10). Society for Artificial Intelligence and Statistics, 2010.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014. URL http://papers.nips. cc/paper/5423-generative-adversarial-nets.pdf.
+
+Irina Higgins, Arka Pal, Andrei A. Rusu, Lo¨ıc Matthey, Christopher Burgess, Alexander Pritzel, Matthew M Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In ICML, 2017.
+
+G. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006. ISSN 0036-8075. doi: 10.1126/science.1127647. URL http://science.sciencemag.org/content/313/5786/504.
+
+Judy Hoffman, Eric Tzeng, Taesung Park, Jun-Yan Zhu, Phillip Isola, Kate Saenko, Alexei A. Efros, and Trevor Darrell. Cycada: Cycle-consistent adversarial domain adaptation. CoRR, abs/1711.03213, 2017. URL http://arxiv.org/abs/1711.03213.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. CoRR, abs/1611.07004, 2016. URL http://arxiv.org/ abs/1611.07004.
+
+Ken Kansky, Tom Silver, David A. Mely, Mohamed Eldawy, Miguel L ´ azaro-Gredilla, Xinghua ´ Lou, Nimrod Dorfman, Szymon Sidor, D. Scott Phoenix, and Dileep George. Schema networks: Zero-shot transfer with a generative causal model of intuitive physics. CoRR, abs/1706.04317, 2017. URL http://arxiv.org/abs/1706.04317.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. CoRR, abs/1703.05192, 2017. URL http://arxiv.org/abs/1703.05192.
+
+Ilya Kostrikov. Pytorch implementations of asynchronous advantage actor critic. https:// github.com/ikostrikov/pytorch-a3c, 2018.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew P. Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photo-realistic single image super-resolution using a generative adversarial network. CoRR, abs/1609.04802, 2016. URL http://arxiv.org/ abs/1609.04802.
+
+Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. CoRR, abs/1606.07536, 2016. URL http://arxiv.org/abs/1606.07536.
+
+Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. CoRR, abs/1703.00848, 2017. URL http://arxiv.org/abs/1703.00848.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmillera. Playing atari with deep reinforcement learning. CoRR, abs/1312.5602, 2013. URL http://arxiv.org/abs/1312.5602.
+
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. CoRR, abs/1602.01783, 2016. URL http://arxiv.org/abs/1602.01783.
+
+Junhyuk Oh, Satinder P. Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. CoRR, abs/1706.05064, 2017. URL http://arxiv. org/abs/1706.05064.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015. URL http: //arxiv.org/abs/1511.06434.
+
+Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016. URL http://arxiv.org/abs/1606.04671.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952.
+
+Sungryull Sohn, Junhyuk Oh, and Honglak Lee. Multitask reinforcement learning for zero-shot generalization with subtask dependencies. CoRR, abs/1807.07665, 2018.
+
+Vanessa Volz, Jacob Schrum, Jialin Liu, Simon M. Lucas, Adam M. Smith, and Sebastian Risi. Evolving mario levels in the latent space of a deep convolutional generative adversarial network. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO 2018), New York, NY, USA, July 2018. ACM. doi: 10.1145/3205455.3205517. URL http://doi.acm. org/10.1145/3205455.3205517.
+
+Zili Yi, Hao Zhang, Ping Tan, and Minglun Gong. Dualgan: Unsupervised dual learning for imageto-image translation. CoRR, abs/1704.02510, 2017. URL http://arxiv.org/abs/1704. 02510.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Proceedings of the 27th International Conference on Neural Information Processing Systems - Volume 2, NIPS’14, pp. 3320–3328, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/citation.cfm?id $=$ 2969033.2969197.
+
+Chiyuan Zhang, Oriol Vinyals, Remi Munos, and Samy Bengio. A study on overfitting in deep ´ reinforcement learning. CoRR, abs/1804.06893, 2018. URL http://arxiv.org/abs/1804. 06893.
+
+Shuchang Zhou, Taihong Xiao, Yi Yang, Dieqiao Feng, Qinyao He, and Weiran He. Genegan: Learning object transfiguration and attribute subspace from unpaired data. CoRR, abs/1705.04932, 2017. URL http://arxiv.org/abs/1705.04932.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. CoRR, abs/1703.10593, 2017. URL http:// arxiv.org/abs/1703.10593.

parse/train/rkxjnjA5KQ/rkxjnjA5KQ_content_list.json

@@ -0,0 +1,1248 @@
+[
+    {
+        "type": "text",
+        "text": "TRANSFER LEARNING FOR RELATED REINFORCEMENT LEARNING TASKS VIA IMAGE-TO-IMAGE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            826,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            260,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Reinforcement Learning has managed to achieve state-of-the-art results in learning control policies directly from raw pixels. However, despite its remarkable success, it fails to generalize, a fundamental component required in a stable Artificial Intelligence system. Using the Atari game Breakout, we demonstrate the difficulty of a trained agent in adjusting to simple modifications in the raw image, ones that a human could adapt to trivially. In transfer learning, the goal is to use the knowledge gained from the source task to make the training of the target task faster and better. We show that using various forms of fine-tuning, a common method for transfer learning, is not effective for adapting to such small visual changes. In fact, it is often easier to re-train the agent from scratch than to fine-tune a trained agent. We suggest that in some cases transfer learning can be improved by adding a dedicated component whose goal is to learn to visually map between the known domain and the new one. Concretely, we use Unaligned Generative Adversarial Networks (GANs) to create a mapping function to translate images in the target task to corresponding images in the source task. These mapping functions allow us to transform between various variations of the Breakout game, as well as between different levels of a Nintendo game, Road Fighter. We show that learning this mapping is substantially more efficient than re-training. A visualization of a trained agent playing Breakout and Road Fighter, with and without the GAN transfer, can be seen in https://streamable.com/msgtm and https://streamable.com/5e2ka. ",
+        "bbox": [
+            233,
+            294,
+            766,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            336,
+            635
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transferring knowledge from previous occurrences to new circumstances is a fundamental human capability and is a major challenge for deep learning applications. A plausible requirement for artificial general intelligence is that a network trained on one task can reuse existing knowledge instead of learning from scratch for another task. For instance, consider the task of navigation during different hours of the day. A human that knows how to get from one point to another on daylight will quickly adjust itself to do the same task during night time, while for a machine learning system making a decision based on an input image it might be a harder task. That is because it is easier for us to make analogies between similar situations, especially in the things we see, as opposed to a robot that does not have this ability and its knowledge is based mainly on what it already saw. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning has caught the attention of researchers in the past years for its remarkable success in achieving human-level performance in a wide variety of tasks. One of the field’s famous achievements was on the Atari 2600 games where an agent was trained to play video games directly from the screen pixels and information received from the game (Mnih et al., 2013). However, this approach depends on interacting with the environment a substantial number of times during training. Moreover, it struggles to generalize beyond its experience, the training process of a new task has to be performed from scratch even for a related one. Recent works have tried to overcome this inefficiency with different approaches such as, learning universal policies that can generalize between related tasks (Schaul et al., 2015), as well as other transfer approaches (Fernando et al., 2017; Rusu et al., 2016). ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/9312d7050f07823b64c2291ddecff231ee12b6b640febae61664fab496f7bd06.jpg",
+        "image_caption": [
+            "Figure 1: Various variations of the Breakout game: (a) Standard version, (b) A Constant Rectangle - a rectangle in the same size as the bricks is added to the background in a predefined location, (c) A Moving Square - a square is added to the background and its location changes to one of three predefined locations every 1000 steps, (d) Green Lines - green lines in different sizes are drawn in the background, (e) Diagonals - diagonals are drawn in the left side of the background. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            99,
+            808,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we first focus on the Atari game Breakout, in which the main concept is moving the paddle towards the ball in order to maximize the score of the game. We modify the game by introducing visual changes such as adding a rectangle in the middle of the image or diagonals in the background. From a human perspective, it appears that making visual changes that are not significant to the game’s dynamics should not influence the score of the game, a player who mastered the original game should be able to trivially adapt to such visual variants. We show that the agent fails to transfer. Furthermore, fine-tuning, the main transfer learning method used today in neural networks, also fails to adapt to the small visual change: the information learned in the source task does not benefit the learning process of the very related target task, and can even decelerate it. The algorithm behaves as if these are entirely new tasks. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our second focus is attempting to transfer agent behavior across different levels of a video game: can an agent trained on the first level of a game use this knowledge and perform adequately on subsequent levels? We explore the Nintendo game Road Fighter, a car racing game where the goal is to finish the track before the time runs out without crashing. The levels all share the same dynamics, but differ from each other visually and in aspects such as road width. Similar to the Breakout results, an agent trained to play the first level fails to correctly adapt its past experience, causing the learned policy to completely fail on the new levels. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address the generalization problem, we propose a zero-shot generalization approach, in which the agent learns to transfer between related tasks by learning to visually map images from the target task back to familiar corresponding images from the source task. Such mapping is naturally achieved using Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), one of the most popular methods for the image-to-image translation that is being used in computer vision tasks such as style transfer (Zhu et al., 2017; Kim et al., 2017), object transfiguration (Zhou et al., 2017), photo enhancement (Ledig et al., 2016) and more recently, video game level generation (Volz et al., 2018). In our setup, it is not realistic to assume paired images in both domains, calling for the use of Unaligned GANs (Liu et al., 2017; Zhu et al., 2017; Kim et al., 2017; Yi et al., 2017). Using this approach we manage to transfer between similar tasks with no additional learning. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions This work presents three main contributions. First, in Section 2, we demonstrate how an agent trained with deep reinforcement learning algorithms fails to adapt to small visual changes, and that the common transfer method of fine-tuning fails as well. Second, in Section 3, we propose to separate the visual mapping from the game dynamics, resulting in a new transfer learning approach for related tasks based on visual input mapping. We evaluate this approach on Breakout and Road Fighter, and present the results comparing to different baselines. We show that our visual transfer approach is much more sample efficient then the alternatives. Third, in section 5, we suggest an evaluation setup for unaligned GAN architectures, based on their achieved performance on concrete down-stream tasks. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 GENERALIZATION FAILURES OF DEEP RL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            550,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many Breakout variations can be constructed that involve the same dynamics. The main idea is to make modifications that are not critical for a human playing the game but are for the algorithm that ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "relies on visual inputs. We demonstrate the difficulty of deep reinforcement learning to generalize using 4 types of modifications as presented in Figure 1. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            150,
+            261,
+            162
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For all the experiments in this section forward we use the Asynchronous Advantage Actor-Critic (A3C) algorithm (Mnih et al., 2016), taking advantage of being faster than Deep Q-Network (DQN) (Mnih et al., 2013). The A3C learns the policy and the state-value function using parallel actor-learners exploring different policies for the acceleration and stability of the training. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We rescale the image to $8 0 \\times 8 0$ and keep the RGB colors for more realistic images. We use 32 actor learners, a discount rate of 0.99, learning rate of 0.0001, 20-step returns, and entropy regularization weight of 0.01. The A3C variation we choose is the LSTM-A3C network. We use the standard high-performance architecture implemented in (Kostrikov, 2018). ",
+        "bbox": [
+            174,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 TRANSFER-LEARNING VIA FINE-TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            501,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The setup mentioned in 2.1 successfully trains on Breakout, reaching a score of over 400 points. However, when a network trained on the original game is presented with the game variants, it fails completely, reaching to a maximum score of only 3 points. This shows that the network does not necessarily learn the game’s concepts and heavily relies on the images it receives. ",
+        "bbox": [
+            176,
+            338,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The common approach for transferring knowledge across tasks is fine-tuning. We experiment with common techniques used in deep learning models. In each setting, we have a combination of frozen and fine-tuned layers (Partial/Full) as well as layers that are initialized with the target’s parameters and layers that are initialized with random values (Random). Our settings are inspired by (Yosinski et al., 2014). We train each one of the tasks (before and after the transformation) for 60 million frames, and our evaluation metric is the total reward the agents collect in an episode averaged by the number of episodes, where an episode ends when the game is terminated or when a number of maximum steps is reached. We periodically compute the average during training. We consider the following settings: ",
+        "bbox": [
+            174,
+            401,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• From-Scratch: The game is being trained from scratch on the target game.   \n• Full-FT: All of the layers are initialized with the weights of the source task and are fine-tuned on the target task.   \n• Random-Output: The convolutional layers and the LSTM layer are initialized with the weights of the source task and are fine-tuned on the target task. The output layers are initialized randomly. Partial-FT: All of the layers are initialized with the weights of the source task. The three first convolutional layers are kept frozen, and the rest are fine-tuned on the target task.   \n• Partial-Random-FT: The three first convolutional layers are initialized with the weights of the source task and are kept frozen, and the rest are initialized randomly. ",
+        "bbox": [
+            215,
+            537,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            279,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The results presented in Figure 2 show a complete failure of all the fine-tuning approaches to transfer to the target tasks. In the best scenarios the transfer takes just as many epochs as training from scratch, while in other cases starting from a trained network makes it harder for the network to learn the target task. As the graphs show, some of the modification influenced more than others. For example, Figure 2a shows that adding a simple rectangle can be destructive for a trained agent: while training from scratch consistently and reliably achieves scores over 300, the settings starting from a trained agent struggle to pass the 200 points mark within the same number of iterations, and have a very high variance. We noticed that during training the agent learns a strategy to maximize the score with a minimum number of actions. None of the experiments we performed showed better results when the layers in the network were fine-tuned, and some showed negative transfer which is a clear indication of an overfitting problem. The A3C model learned the detail and noise in the training data to the extent that it negatively impacted the performance of the model on new data. Our results and conclusions drawn from them are consistent with the results shown when a similar approach was used on Pong (Rusu et al., 2016). In addition to Breakout, we also experimented transfer between the first and advanced level of Road Fighter, where the backgrounds change but the dynamics remains the same. This experiments resulted with 0 points on each of the levels, a complete failure of the agent to re-use the driving techniques learned on the first levels on the next ones. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3df2a95ed22f63b94d55662705bf9d09d452dd5d6b0df15bdf6357a78e01a2c9.jpg",
+        "image_caption": [
+            "Figure 2: A comparison between the different baselines on Breakout. The y-axis on each one of the plots shows the average reward per episode of Breakout during training. The $\\mathbf { X }$ -axis shows the total number of training epochs where an epoch corresponds to 1 million frames. The plots are averaged on 3 runs with different random seeds. Each curve is the average and its background is the standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ANALOGY-BASED ZERO-SHOT GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            614,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An agent capable of performing a task in a source domain is now presented with a new domain. Fine-tuning the agent on the target domain fails to transfer knowledge from the source domain. We propose to separate the visual transfer from the dynamics transfer. To perform well, the agent can try and make analogies from the new domain to the old one: after observing a set of states (images) in the new domain, the agent can learn to map them to similar, familiar states from the source domain, and act according to its source domain policy on the mapped state. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More concretely, given a trained policy $\\pi ( a | s ; \\theta )$ with trained parameters $\\theta$ proposing an action $a$ for source domain states $s \\in S$ , we wish to learn a mapping function $G : { \\mathcal { T } } \\mapsto S$ from target domain states $t \\in \\tau$ such that interacting with the environment $\\tau$ by applying the policy $\\pi ( a | G ( t ) ; \\theta )$ will result in a good distribution of actions for the states $\\tau$ , as indicated by high overall scores. In other words, we seek a mapping function $G$ that allows us to re-use the same policy $\\pi _ { \\theta }$ learned for source environment $s$ when interacting with the target environment $\\tau$ . ",
+        "bbox": [
+            174,
+            523,
+            825,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As both the source and target domain items are images, we heuristically learn the function $G$ by collecting sets of images from $s$ and $\\tau$ and learning to visually map between them using Unaligned GAN (Liu et al., 2017; Zhu et al., 2017; Kim et al., 2017; Yi et al., 2017). We use the scores obtained from interacting with the environment via $\\pi ( a | G ( t ) ; \\theta )$ for the GAN model selection and stopping criteria. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            684
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNSUPERVISED IMAGE-TO-IMAGE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            705,
+            558,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on learning setups that receive only raw image data, without additional domain knowledge about objects or game dynamics. This prohibits us from using supervised paired GANs Isola et al. (2016) for learning the mapping function $G$ : we cannot collect the needed supervision of corresponding $( s , t )$ pairs. Instead, we use unaligned GANs (Zhu et al., 2017; Liu et al., 2017; Kim et al., 2017; Yi et al., 2017), in which the learner observes two sets of images, one from each domain, with the goal of learning to translate images in one domain to images in another. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            816
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All major approaches to the unaligned image-to-image translation use the Cycle-Consistency principle. We have two mapping (encoding) functions $G _ { 1 } : T \\mapsto S$ and $G _ { 2 } : S \\mapsto T$ where $S = \\stackrel { \\cdot } { \\{ s _ { i } \\} } _ { i = 1 } ^ { N }$ is a set of images collected from the source task and $T = \\{ t _ { j } \\} _ { j = 1 } ^ { M }$ is a set of images collected from the target task. The goal is to generate an image $s ^ { \\prime }$ , for any given $t \\in T$ where $G _ { 1 } ( t ) = s ^ { \\prime }$ , that is indistinguishable from $s \\in S$ . The cycle consistency principle relies on the assumption that the two functions, $G _ { 1 }$ and $G _ { 2 }$ are inverses of each other. It encourages unsupervised mapping by forcing $G _ { 2 } ( G _ { 1 } ( t ) ) = t$ and $G _ { 1 } ( G _ { 2 } ( s ) ) = s$ where $s$ and $t$ are the input images. The second component of the GAN architecture are the discriminators $D _ { 1 }$ and $D _ { 2 }$ aiming to distinguish between images generated by $G _ { 1 }$ and $G _ { 2 }$ and the real images from the target and source distributions respectively. ",
+        "bbox": [
+            174,
+            823,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we use the UNIT framework (Liu et al., 2017), which we found to perform well for the Breakout tasks (in section 5 we explicitly compare the UNIT and CycleGAN approaches on both the Breakout and Road Fighter transfer tasks). A distinguishing element in the UNIT framework is the shared-latent space assumption, according to which there is a shared-latent space consisting a shared latent code $z$ for any pair of images $s$ and $t$ that can be recovered from this code. This share-latent space is represented as the weights of the last few layers of the encoding network and the few first layers of the decoding networks, and is learned by using Variational Autoencoders (VAEs). This sharing strongly ties the images in the source and target domain to each other, encouraging mappings that preserve similarities across domains. In contrast, the CycleGAN architecture (Zhu et al., 2017) does not make the shared space assumption and instead the generators are trained independently with two separate networks. For further information of the unaligned GAN architectures, see the original papers. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 GAN TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            327,
+            328,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets. The Unaligned GAN training dataset requires images from both domains. We collect images from the source domain by running an untrained agent and collecting the observed images, and we do similarly for the target domain. The number of collected images should balance between two objectives: On the one hand, we want to take a small number of images, and on the other hand, it is essential for us to have a diverse dataset. We repeat this procedure for every target task, and create a source-target dataset for each. During training, we further ensure the images pairs are not aligned by randomly picking an image from each set at each iteration. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            452
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setup and Analysis. For our experiments we use the same architecture and hyper-parameters proposed in the UNIT paper. We initialize the weights with Xavier initialization (Glorot & Bengio, 2010), set the batch size to 1 and train the network for a different number of iterations on each task. Some tasks are harder than others, the more changes exist in the frames the harder it is for the GAN to learn the mapping between the domains. However, our evaluation metric, testing the agent with the generated images, is a clear indication of how hard each task is and the number of iterations needed is based on the results of this evaluation. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluation. We use GAN training to learn a mapping function $G$ . GAN training, and unaligned GANs training in particular, are unstable and it challenging to find a good loss-based stopping criteria for them. A major issue with GANs is the lack of an evaluation metric that works well for all models and architectures, and which can assist in model selection. Different works use different methods that were suitable for their types of data. Our setup suggests a natural evaluation criteria: we run the source agent without any further training while using the model to translate each image of the target task back to the source task and collect the rewards the agent receives during the game when presented with the translated image. We use the total accumulated rewards (the score) the agent collects during the game as our model accuracy. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            714,
+            326,
+            729
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We examine how well the agent does when receiving translated frames generated by the generator trained with GANs. Since we initialized the layers with the values of the trained network, we assume that the success of the agent is dependent on the similarity between the generated and the source task’s frames. We first test our approach on Breakout, evaluating its ability to remove the changes added in the images. Second, we challenge our method even more on Road Fighter, where the goal is to transfer between different environments. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 BREAKOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            853,
+            294,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our goal in Breakout is removing the modifications in each one of the target tasks and transfer between each to the original game. Although the variations share many similarities, some tasks were more challenging than others, e.g., the lines of the Green Lines variation hide parts of the ball in some frames. On the opposite side, the Rectangle variation requires less training since the number of pixels changed in the image is small. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/faf357b12d96a8068955faa6d2367da4634967a59f43a195038b0060381a53f2.jpg",
+        "table_caption": [
+            "Table 1: The score and number of frames needed for it of: the source task (Source), target task when initialized with the source task’ network parameters with no additional training (Target) and the target task when initialized with the source task’ network parameters where every frame is translated to a frame from the source task (Target with GANs). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Source</td><td>Target Task</td><td colspan=\"2\">Target</td><td colspan=\"2\">Target with GANs</td></tr><tr><td>Frames</td><td>Score</td><td></td><td>Frames</td><td>Score</td><td>GAN iterations</td><td>Score</td></tr><tr><td>43M</td><td>302</td><td>A Constant Rectangle</td><td>0</td><td>3</td><td>260K</td><td>362</td></tr><tr><td>43M</td><td>302</td><td>A Moving Square</td><td>0</td><td>0</td><td>384K</td><td>300</td></tr><tr><td>43M</td><td>302</td><td>Green Lines</td><td>0</td><td>2</td><td>288K</td><td>300</td></tr><tr><td>43M</td><td>302</td><td>Diagonals</td><td>0</td><td>0</td><td>380K</td><td>338</td></tr></table>",
+        "bbox": [
+            174,
+            165,
+            825,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/496f6668096108513cee7e7579eefa1576c4a74015204a176da02a9e9d2df1a6.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of a frame taken from the target task (left) and its matching frame of the source task generated with GANs (right) for each one of the Breakout variations. (a)-(d) demonstrate successes, while (e) and (f) show failure modes of the unaligned GAN. In (e) the ball in the input image is not generated in the output and in (f) not all bricks are generated, and some of the generated bricks appear smudged. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            297,
+            818,
+            493
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During testing, we encountered problems with the images generation that we did not observe during the GAN training. The translation task we attempted to perform was supposedly simple – search for the differences between the domains shared by all images, change them to the way they are in the opposite domain and leave everything else the same. Unfortunately, since the network does not have any prior information about objects in the image, it struggles to generate them even if they were not changed. The most common problem we had was that the generator generated bricks that were supposed to be removed from the game, and in some cases, they were very noisy in the generated image (Fig. 3f). Another problem was the ball generation and more specifically, the location of the generated ball. Since the ball is small and changes its position often, it was hard for the generator, trained with unaligned pairs, to decide if and where to locate it in the generated image (Fig. 3e). These issues and others eventually caused the agent to fail in following the policies it learned on the source task. We found that more training leads to better results for some of the variations and so the number of iterations needed was different for each variation. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 we show the results of a test game played by the agent with and without GANs. We stop the training after reaching 300 points, which we consider to be a high score. As the results show, the source game trained from scratch requires ten of millions of images to achieve such score comparing to the target task trained with GANs that only needs a few hundreds of thousands—a 100x fold increase in sample efficiency. Moreover, the frames the GAN was trained on were limited to the first games in which the A3C network was not trained, and yet it managed to generalize to more advanced stages of the game. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ROAD FIGHTER",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            323,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a5787db2b134a642a0a8587534f8ce38b259e14189fe290cc876a6647d418e0.jpg",
+        "image_caption": [
+            "Figure 4: Road Fighter levels from left to right: Level 1, Level 2, Level 3 and Level 4. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            135,
+            820,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While the Breakout variants work well to demonstrate transfer failure cases, they can be considered as “toy examples”. We proceed to demonstrate the effectiveness of our transfer method on a “real” task: learning to transfer between different levels of the Road Fighter game. Road Fighter contains 4 different levels (Fig. 4), each with a different background where some are more difficult than others. The levels mostly differ visually and all have the same rules and require the same driving techniques. Thus, we believe that these techniques should sustain when playing a new level. We start by training an RL agent to play the first level of the game. To maximize the score, the agent has to acquire 3 main capabilities: driving fast, avoiding collision with obstacles, and if a car collision occurs reacting fast to avoid crashing. We use the A2C algorithm, the synchronous version of the Advantage Actor-Critic which performs better on this game than A3C, reaching over 10, 000 game points on level 1. ",
+        "bbox": [
+            173,
+            311,
+            826,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the GAN training, we collect $1 0 0 k 8 4 x 8 4$ frames from each of levels 2, 3 and 4 by running an untrained agent repeatedly until we have collected sufficient samples (training an RL agent to reach a score of 10,000 points on Level 1 required observing above 100M frames.). Using the collected images we train a mapping function for each task to map the new level (target task) to the first one (source task). We use the same GAN architecture used for Breakout, but initialize the weights with Orthogonal initialization. Compared to Breakout, these tasks introduce new challenges: rather than removing a mostly static element, the GAN has to be able to change the background and road size while keeping the cars in the right position on the road. On the other hand, this setup may be closer to the one unaligned GANs are usually applied in. We restrict ourselves to collecting images from the beginning of the game, before the agent had any training. This restricts the phenomena the GAN can observe, and some target tasks’ images do not have a clear corresponding situation in the first level, potentially causing unpredictable behaviors. For example, the generator matches the diagonal shaped roads to one of the first rare and unique images of level 1 (Fig. 5e). ",
+        "bbox": [
+            174,
+            458,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments presented in Table 2 demonstrate how an agent trained to master the first level of the game fails to follow the optimal policies on new levels, reaching 0 points. However, with the GAN-based visual analogies the agent is able to apply some of the abilities it gained when training on the first level, most notably driving fast, staying on the road, avoiding some cars, and, most importantly, recovering from car crashes. The resulting agent achieves impressive scores on levels 2, 3 and 4 (5350, 5350 and 2050 points, respectively), with no additional RL training and while observing only a fraction of the frames required for training a corresponding RL agent from scratch for these levels. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Limitations. While the GAN works well in generating objects it has seen before, such as the agent’s car, it does have limitations on objects it has not seen. As a result, it ends up generating differently colored cars all in red, or not generating them at all, as shown in Fig. 5a, 5d and 5f. Colorful cars can be “collected” by the agent and are worth 1000 points each. Generating them in red makes the agent avoid them, losing these extra points and achieving overall lower scores even if finishing the track. When cars are not fully generated, the agent is less likely to avoid them, and eventually crashes. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Data Efficiency. We measure the number of frames of game-interaction needed for the analogytransfer method. We collect $1 0 0 \\mathrm { k }$ frames, and then train the GAN for up to $5 0 0 k$ iterations, evaluating it every 10, 000 iterations by running the game and observing the score, and pick the best scoring model. This amounts to $1 0 0 k + 5 0 * F$ frames, where $F = 3 0 0 0$ is roughly the average number of frames in a game. This amounts to about $2 5 0 k$ frames of game interaction for each transfered level, an order of magnitude fewer interaction frames than training an RL agent to achieve a comparable score. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/19c0801025f1974dd869deaee99d81768f9cdf1ce87b418db7a91076e4ce53c9.jpg",
+        "image_caption": [
+            "Figure 5: Left: the original frame. Right: GAN generated. Upper row shows the success cases of the GAN while the lower row shows representative failures: in (d) and (f) the only object generated on the road is the player’s car and in (e) the diagonal shaped road of level 2 in matched to the starting point of level 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            150,
+            838,
+            431
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            525,
+            823,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Discussion. The approach is successfully transferring to most tasks, achieving the best scores on levels 2 and 3. In general, as the game progresses, the more obstacles are presented making it harder to play. One of our best results is achieved on level 2 where the road is identical to level 1’s, reaching the best score after $3 2 0 k$ GAN iterations. On level 3, the challenge increases as the road is very narrow, making it harder for a player to avoid crashing. However, the GAN manages to generate the road in the right shape in most frames and position the cars in the matching ratio. Moreover, despite the challenges, due to the agent’s ability to avoid crashing when colliding with cars it gets over 5000 points after $4 5 0 k$ GAN iterations. In level 4 we get the maximum after $2 7 0 k$ iterations. This level is also the most challenging one to play, which might be the reason for the score being the lowest out of all tasks. The main obstacles are the sudden turns in the road causing the car to be very close to the sideways and the increasing dangers a player has to avoid. Theses difficulties make this level much harder than level 1 and might require more training even from a human player. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, the agent performs quite well by successfully applying 2 out of 3 main capabilities it gained during training. It is missing the third capability, avoiding collisions and collecting bonus cars, mainly because of bad generation. We believe that these tasks and results demonstrate a success of the analogy transfer method for zero-short generalization across different levels of a video game. They also suggest a potential of performing well on additional real world tasks in which visual analogies can be made. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 TOWARDS TASK-ORIENTED GAN EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            596,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluating GAN models and comparing them to each other is a major challenge: working with images and without well-defined objectives, testing the quality of the generator is delegated to human judgment, often using crowdsourcing to evaluate the generated images Isola et al. (2016); Donahue et al. (2017). This metric is not stable and can be unreliable due to changing human factors. Others use a linear classifier to evaluate the image representations the GAN learned on supervised datasets, e.g., MNIST and CIFAR-10 (Radford et al., 2015). These approaches and others may be good enough for a limited group of test images but do not necessarily reflect the performance of a model in the real world. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We note that while unaligned GANs are known to achieve impressive results with only few training examples, our seemingly trivial translation cases proved to be quite challenging for the unaligned GAN architectures: producing valid translations that work in the game require training on a substantial number of images. During training, the GAN sees images from the early stages of the game where only a few bricks are missing in Breakout and there are no obstacles in Road Fighter. Our task requires it to generalize by translating images where objects are removed, added or in a different locations. This requires levels of generalization that may not be reflected in existing test-sets. We argue that using simple, well defined yet diverse test cases, situated in the context of a concrete down-stream task like we do here, is an important step forward in the evaluation of GAN models. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose to evaluate GAN by running a game in which the trained Deep RL network that learned policies based on images is now receiving images from the same domain generated with GAN, and equate a successful GAN model with one resulting in a high game score. We use the approach to compare Cycle-GAN (Zhu et al., 2017) and UNIT-GAN (Liu et al., 2017). ",
+        "bbox": [
+            174,
+            299,
+            825,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We examine both methods by running the RL agent with each every 1000 GAN training iterations and considering the maximum score after $5 0 0 k$ iterations. We present the results in Table 3. The UNIT GAN performs better than Cycle-GAN in most Breakout tasks, while Cycle-GAN outperforms UNIT in most Road Fighter tasks while requiring fewer iterations. The main difference between the two methods is the weight-sharing constraint applied in UNIT, making the domains dependent on each other by sharing and updating the weights of one or several decoders and encoders layers. We hypothesize this constraint is an advantage in tasks where the representation of the images in the different domains are similar. Thus, in Breakout, where most pixels are identical in the source and target images, Cycle-GAN often fails where UNIT succeed. However, in tasks such as Road Fighter’s where most pixels are different, the agent could benefit from architectures such as Cycle-GAN where the two domains are independent of each other. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            344,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning (TL) is a machine learning technique used to improve the training speed of a target task with knowledge learned in a source task. Pretraining and fine-tuning was proposed in Hinton & Salakhutdinov (2006) and applied to TL in Bengio (2012) and Dauphin et al. (2012). In this procedure, the approach is to train the base network and then copy its first $n$ layers to the first $n$ layers of a target network. One can choose to update the feature layers transferred to the new task with the error backpropagated from its output, or they can be left frozen, meaning that they do not change during training on the new task. Unfortunately, as we have shown, while fine-tuning might have the ability to accelerate the training process is some cases, it can also have a damaging impact on others. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generalization is a key element in training deep learning models with time or data size constraints. Recent discussions on overfitting in Deep RL algorithms (Zhang et al., 2018) encouraged better evaluation (e.g. OpenAI Retro Contest 1) and generalization methods. In Atari, there are many similarities between the goals and the mechanism of the games. For this reason, there have been many works attempting to transfer between games or between different variations of the same game, one approach trying to do both is the progressive networks (Rusu et al., 2016). A progressive network is constructed by successively training copies of A3C on each task of interest. In that work, they transferred between different games as well as from different variations of the game Pong. The drawback of this approach is the number of parameters growing quadratically with the number of tasks. However, even if this growth rate was improved, different tasks may require different adjustments and the predefinition of the number of layers and network representation is preventing it. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot generalization is a discussed and researched topic nowadays. One work transferring between modified versions of the same game using zero-shot transfer is the schema networks (Kansky et al., 2017). Like us, they also chose to demonstrate their method on the game Breakout, using ",
+        "bbox": [
+            176,
+            858,
+            823,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6c2bcc1fd7a6fab927bfb5bd54a7fc8917f87e9d968b5c48d02f3ba00f6b8e7.jpg",
+        "table_caption": [
+            "Table 3: The scores accumulated by an Actor-Critic RL agent using UNIT and Cycle-GAN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">UNIT</td><td colspan=\"2\">CycleGAN</td></tr><tr><td>Frames</td><td>Score</td><td>Frames</td><td>Score</td></tr><tr><td>A Constant Rectangle</td><td>333K</td><td>399</td><td>358K</td><td>26</td></tr><tr><td>A Moving Square</td><td>384K</td><td>300</td><td>338K</td><td>360</td></tr><tr><td>Green Lines</td><td>378K</td><td>314</td><td>172K</td><td>273</td></tr><tr><td>Diagonals</td><td>380K</td><td>338</td><td>239K</td><td>253</td></tr><tr><td>Road Fighter - Level 2</td><td>274K</td><td>5750</td><td>51K</td><td>6000</td></tr><tr><td>Road Fighter - Level 3</td><td>450K</td><td>5350</td><td>20K</td><td>3200</td></tr><tr><td>Road Fighter - Level 4</td><td>176K</td><td>2300</td><td>102K</td><td>2700</td></tr></table>",
+        "bbox": [
+            259,
+            123,
+            736,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Object Oriented Markov Decision Process. In contrast, we do not use the representation of the objects in the game, and we wish to preserve the accomplishments of DQN and transfer using only raw data. Other attempted to achieve robust policies using learned disentangled representation of the image (Higgins et al., 2017), analogies between sets of instructions (Oh et al., 2017), interactive replay (Bruce et al., 2017) while training and learn general policies by training on multiple tasks in parallel (Espeholt et al., 2018; Sohn et al., 2018). ",
+        "bbox": [
+            174,
+            316,
+            825,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, the idea of using GANs for transfer learning and domain adaptation was explored for supervised image classification and robotics applications by several authors (Bousmalis et al., 2016; Hoffman et al., 2017; Liu & Tuzel, 2016; Bousmalis et al., 2017). In these methods, there is supervised source domain data $( x _ { i } ^ { s } , y _ { i } ^ { s } )$ and unlabeled target domain data, and the GAN variant $G$ is trained to map source samples $\\boldsymbol { x } _ { i } ^ { s }$ to target-like samples $G ( x _ { i } ^ { s } )$ . Then, a classifier is trained on the generated data $( G ( x _ { i } ^ { s } ) , y _ { i } ^ { s } )$ . Our RL-based setup is different: first, our coverage of target-domain data is very limited (we can only observe states which are reachable by the un-adapted or untrained agent). Second, we do not have access to supervised gold labels on the source domain, but only to a learned policy network. Third, interactions with the game environment provide very indirect rewards, so using this reward signal to influence the GAN training will be very inefficient. We thus opt for a different strategy: rather than mapping the source to the target domain and training on the projected signal, which is unrealistic an costly in the RL setup, we instead take a pre-trained source model and train an unaligned GAN to map from the target domain back to the source domain, in order to re-use the source model’s knowledge and apply it to the target domain data. We believe this form of usage of GAN for transfer learning is novel. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            504,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We demonstrated the lack of generalization by looking at artificially constructed visual variants of a game (Breakout), and different levels of a game (Road Fighter). We further show that transfer learning by fine-tuning fails. The policies learned using model-free RL algorithms on the original game are not directly transferred to the modified games even when the changes are irrelevant to the game’s dynamics. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present a new approach for transfer learning between related RL environments using GANs without the need for any additional training of the RL agent, and while requiring orders of magnitude less interactions with the environment. We further suggest this setup as a way to evaluate GAN architectures by observing their behavior on concrete tasks, revealing differences between the CycleGAN and UNIT-GAN architectures. We believe our approach is applicable to cases involving both direct and less direct mapping between environments, as long as an image-to-image translation exist. While we report a success in analogy transfer using Unaligned GANs, we also encountered limitations in the generation process that made it difficult for the agent to maximize the results on the Road Fighter’s tasks. In future work, we plan to explore a tighter integration between the analogy transfer method and the RL training process, to facilitate better performance where dynamic adjustments are needed in addition to the visual mapping. ",
+        "bbox": [
+            174,
+            770,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In Isabelle Guyon, Gideon Dror, Vincent Lemaire, Graham Taylor, and Daniel Silver (eds.), Proceedings of ICML Workshop on Unsupervised and Transfer Learning, volume 27 of Proceedings of Machine Learning Research, pp. 17–36, Bellevue, Washington, USA, 02 Jul 2012. PMLR. URL http: //proceedings.mlr.press/v27/bengio12a.html. ",
+        "bbox": [
+            174,
+            126,
+            826,
+            195
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. CoRR, abs/1612.05424, 2016. URL http://arxiv.org/abs/1612.05424. ",
+        "bbox": [
+            178,
+            204,
+            823,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using simulation and domain adaptation to improve efficiency of deep robotic grasping. CoRR, abs/1709.07857, 2017. URL http://arxiv.org/abs/1709.07857. ",
+        "bbox": [
+            174,
+            256,
+            826,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jake Bruce, Niko Sunderhauf, Piotr Mirowski, Raia Hadsell, and Michael Milford. One-shot ¨ reinforcement learning for robot navigation with interactive replay. CoRR, abs/1711.10137, 2017. URL http://arxiv.org/abs/1711.10137. ",
+        "bbox": [
+            173,
+            321,
+            826,
+            364
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Grgoire Mesnil Yann Dauphin, Xavier Glorot, Salah Rifai, Yoshua Bengio, Ian Goodfellow, Erick Lavoie, Xavier Muller, Guillaume Desjardins, David Warde-Farley, Pascal Vincent, Aaron Courville, and James Bergstra. Unsupervised and transfer learning challenge: a deep learning approach. In Isabelle Guyon, Gideon Dror, Vincent Lemaire, Graham Taylor, and Daniel Silver (eds.), Proceedings of ICML Workshop on Unsupervised and Transfer Learning, volume 27 of Proceedings of Machine Learning Research, pp. 97–110, Bellevue, Washington, USA, 02 Jul 2012. PMLR. URL http://proceedings.mlr.press/v27/mesnil12a.html. ",
+        "bbox": [
+            173,
+            372,
+            826,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Donahue, Akshay Balsubramani, Julian McAuley, and Zachary C. Lipton. Semantically decomposing the latent spaces of generative adversarial networks. CoRR, abs/1705.07904, 2017. URL http://arxiv.org/abs/1705.07904. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam ´ Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: scalable distributed deep-rl with importance weighted actor-learner architectures. CoRR, abs/1802.01561, 2018. URL http://arxiv.org/abs/1802.01561. ",
+        "bbox": [
+            173,
+            531,
+            826,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701.08734. ",
+        "bbox": [
+            174,
+            595,
+            826,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS10). Society for Artificial Intelligence and Statistics, 2010. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "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 Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014. URL http://papers.nips. cc/paper/5423-generative-adversarial-nets.pdf. ",
+        "bbox": [
+            173,
+            699,
+            826,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Arka Pal, Andrei A. Rusu, Lo¨ıc Matthey, Christopher Burgess, Alexander Pritzel, Matthew M Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In ICML, 2017. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "G. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006. ISSN 0036-8075. doi: 10.1126/science.1127647. URL http://science.sciencemag.org/content/313/5786/504. ",
+        "bbox": [
+            178,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Eric Tzeng, Taesung Park, Jun-Yan Zhu, Phillip Isola, Kate Saenko, Alexei A. Efros, and Trevor Darrell. Cycada: Cycle-consistent adversarial domain adaptation. CoRR, abs/1711.03213, 2017. URL http://arxiv.org/abs/1711.03213. ",
+        "bbox": [
+            174,
+            882,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. CoRR, abs/1611.07004, 2016. URL http://arxiv.org/ abs/1611.07004. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ken Kansky, Tom Silver, David A. Mely, Mohamed Eldawy, Miguel L ´ azaro-Gredilla, Xinghua ´ Lou, Nimrod Dorfman, Szymon Sidor, D. Scott Phoenix, and Dileep George. Schema networks: Zero-shot transfer with a generative causal model of intuitive physics. CoRR, abs/1706.04317, 2017. URL http://arxiv.org/abs/1706.04317. ",
+        "bbox": [
+            174,
+            155,
+            826,
+            213
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. CoRR, abs/1703.05192, 2017. URL http://arxiv.org/abs/1703.05192. ",
+        "bbox": [
+            174,
+            223,
+            823,
+            265
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov. Pytorch implementations of asynchronous advantage actor critic. https:// github.com/ikostrikov/pytorch-a3c, 2018. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew P. Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photo-realistic single image super-resolution using a generative adversarial network. CoRR, abs/1609.04802, 2016. URL http://arxiv.org/ abs/1609.04802. ",
+        "bbox": [
+            174,
+            314,
+            826,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. CoRR, abs/1606.07536, 2016. URL http://arxiv.org/abs/1606.07536. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. CoRR, abs/1703.00848, 2017. URL http://arxiv.org/abs/1703.00848. ",
+        "bbox": [
+            174,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmillera. Playing atari with deep reinforcement learning. CoRR, abs/1312.5602, 2013. URL http://arxiv.org/abs/1312.5602. ",
+        "bbox": [
+            174,
+            458,
+            826,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdom \\` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \\` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. CoRR, abs/1602.01783, 2016. URL http://arxiv.org/abs/1602.01783. ",
+        "bbox": [
+            174,
+            512,
+            826,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Satinder P. Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. CoRR, abs/1706.05064, 2017. URL http://arxiv. org/abs/1706.05064. ",
+        "bbox": [
+            171,
+            564,
+            825,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015. URL http: //arxiv.org/abs/1511.06434. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016. URL http://arxiv.org/abs/1606.04671. ",
+        "bbox": [
+            173,
+            670,
+            828,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            752
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sungryull Sohn, Junhyuk Oh, and Honglak Lee. Multitask reinforcement learning for zero-shot generalization with subtask dependencies. CoRR, abs/1807.07665, 2018. ",
+        "bbox": [
+            171,
+            762,
+            825,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vanessa Volz, Jacob Schrum, Jialin Liu, Simon M. Lucas, Adam M. Smith, and Sebastian Risi. Evolving mario levels in the latent space of a deep convolutional generative adversarial network. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO 2018), New York, NY, USA, July 2018. ACM. doi: 10.1145/3205455.3205517. URL http://doi.acm. org/10.1145/3205455.3205517. ",
+        "bbox": [
+            174,
+            801,
+            828,
+            871
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zili Yi, Hao Zhang, Ping Tan, and Minglun Gong. Dualgan: Unsupervised dual learning for imageto-image translation. CoRR, abs/1704.02510, 2017. URL http://arxiv.org/abs/1704. 02510. ",
+        "bbox": [
+            174,
+            882,
+            828,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Proceedings of the 27th International Conference on Neural Information Processing Systems - Volume 2, NIPS’14, pp. 3320–3328, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/citation.cfm?id $=$ 2969033.2969197. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Oriol Vinyals, Remi Munos, and Samy Bengio. A study on overfitting in deep ´ reinforcement learning. CoRR, abs/1804.06893, 2018. URL http://arxiv.org/abs/1804. 06893. ",
+        "bbox": [
+            174,
+            169,
+            825,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shuchang Zhou, Taihong Xiao, Yi Yang, Dieqiao Feng, Qinyao He, and Weiran He. Genegan: Learning object transfiguration and attribute subspace from unpaired data. CoRR, abs/1705.04932, 2017. URL http://arxiv.org/abs/1705.04932. ",
+        "bbox": [
+            176,
+            219,
+            825,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. CoRR, abs/1703.10593, 2017. URL http:// arxiv.org/abs/1703.10593. ",
+        "bbox": [
+            173,
+            272,
+            828,
+            314
+        ],
+        "page_idx": 12
+    }
+]