Add files using upload-large-folder tool

parse/train/9BpjtPMyDQ/9BpjtPMyDQ.md

@@ -0,0 +1,241 @@
+# Data-Efficient Instance Generation from Instance Discrimination
+
+Ceyuan Yang† Yujun Shen‡ Yinghao $\mathbf { X } \mathbf { u } ^ { \dag }$ Bolei Zhou† †The Chinese University of Hong Kong ‡ByteDance Inc.
+
+# Abstract
+
+Generative Adversarial Networks (GANs) have significantly advanced image synthesis, however, the synthesis quality drops significantly given a limited amount of training data. To improve the data efficiency of GAN training, prior work typically employs data augmentation to mitigate the overfitting of the discriminator yet still learn the discriminator with a bi-classification (i.e., real vs. fake) task. In this work, we propose a data-efficient Instance Generation (InsGen) method based on instance discrimination. Concretely, besides differentiating the real domain from the fake domain, the discriminator is required to distinguish every individual image, no matter it comes from the training set or from the generator. In this way, the discriminator can benefit from the infinite synthesized samples for training, alleviating the overfitting problem caused by insufficient training data. A noise perturbation strategy is further introduced to improve its discriminative power. Meanwhile, the learned instance discrimination capability from the discriminator is in turn exploited to encourage the generator for diverse generation. Extensive experiments demonstrate the effectiveness of our method on a variety of datasets and training settings. Noticeably, on the setting of $2 K$ training images from the FFHQ dataset, we outperform the state-of-the-art approach with $2 3 . 5 \%$ FID improvement.1
+
+# 1 Introduction
+
+Generative Adversarial Network (GAN) [16] has become a popular paradigm to learn the distribution of the observed data. It is formulated as a two-player game, where a generator synthesizes realistic data, while a discriminator distinguishes synthesized samples from real ones. To reach equilibrium in this minimax game, it requires both the generator and the discriminator to be sufficiently trained. In other words, the synthesis capability of the generator will subsequently deteriorate given an inadequate discriminator [24, 39, 49, 51].
+
+Recent success of GANs [22, 23, 25, 4] relies on big data to assure the sufficient training of the discriminator. Prior work [49, 24] has found that reducing the amount of training data leads to the overfitting of the discriminator, which tends to memorize the entire training set. In turn, the backpropagation from the discriminator to the generator damages the synthesis quality of the generator and potentially causes the mode collapse problem [1, 44]. Data augmentation is one of the most widely used methods to alleviate the overfitting issue in deep learning algorithms [45, 11, 10]. Some recent attempts [24, 39, 49, 51, 44] have been made to apply data augmentation to GAN training. It is found that the discriminator can be improved by augmenting not only the real images from the dataset but also the synthesized images by the generator [49, 24]. However, the learning objective of the discriminator remains as categorizing real and fake domains and a substantial performance drop can be observed given limited training data.
+
+The domain bi-classification task could be too easy for the discriminator to gain sufficient discriminative power as an adaptive loss to train the generator, especially when the size of training set is small. In this work, we propose to improve the data efficiency in GAN training by assigning a more challenging task to the discriminator, which is to distinguish every individual image as an independent category. In this way, the discriminator is forced to improve its discriminative capability to accomplish the instance discrimination task [40]. Notably, besides distinguishing real samples, we also demand the discriminator to differentiate fake samples synthesized by the generator. Thus the discriminator can be considered to train with infinite data, preventing it from memorizing the training samples. When distinguishing synthesized data, we design a noise perturbation strategy to increase the difficulty of the task and hence make the discriminator more capable. Meanwhile, we also alter the training objectives from the generator side. Concretely, besides making the generator to fool the discriminator, we expect all the samples produced by the generator to be well identified as different instances with our instance-induced discriminator. This highly matches the goal of diverse generation, which requires every synthesis to be unique. We evaluate our method on a range of datasets and achieve appealing generation performance in terms of image quality, diversity, and data efficiency. Experiments show that our method significantly improves the baselines and outperform previous data-augmentation methods. To be specific, our method improves the FID from 15.60 to 11.92, 7.29 to 4.90, and 3.88 to 3.31 with $2 K$ , $1 0 K$ , and $7 0 K$ training images from FFHQ [23] respectively. We can even learn a large-scale GAN with only 100 in-the-wild images to produce satisfying synthesis.
+
+Our main contributions are summarized as follows: 1) We propose a data-efficient instance generation (InsGen) method which incorporates instance discrimination as an auxiliary task in GAN training. 2) The synthesized data is used as infinite samples for improving the discriminative power of the discriminator, which in turn substantially improves the synthesis quality and diversity of the generator. 3) Under various data-regime settings, our method consistently surpasses existing alternatives by a substantial margin.
+
+# 2 Related Work
+
+Data Augmentation in GANs. Data augmentation makes the maximum use of available data to alleviate the overfitting of deep models that have millions of parameters. It plays an essential role in training discriminative models [45, 11, 10]. Some recent work explores how data augmentation can help the training of GANs [51, 39, 49, 24]. Zhao et al. [51] conduct empirical studies on the effects of different types of augmentations for GAN training. Tran et al. [39] make a theoretical analysis of several data augmentations. Zhao et al. [49] propose a differentiable augmentation method such that the augmenting operations can be applied to both real and synthesized data. Similarly, Karras et al. [24] design augmentations that do not leak and introduce a probability-based adaptive strategy to stabilize the training process. Different from prior work, we focus on introducing the unsupervised representation learning which also requires augmentations into GAN training. Our work shows that the recent instance discrimination task [40] can be used as an auxiliary task for the discriminator, which in turn substantially improves the synthesis quality of the generator.
+
+Self-supervised Learning in GANs. The rationale behind self-supervised learning is to set up various pretext tasks with supervisory-free labels [14, 5, 41, 48, 13, 32, 34, 42, 34, 15, 31, 35]. Similar idea is recently introduced in GAN training as an auxiliary loss to improve the synthesis performance. For instance, Chen et al. [6] assign the rotation prediction task to the discriminator to prevent it from catastrophic forgetting, and Tran et al. [38] propose a multi-class minimax game to encourage the generator to produce diverse samples. Among all self-supervised learning approaches, contrastive learning [40, 17, 7, 18, 3] shows great potential in large-scale representation learning. Many attempts have been made to improve generative models by drawing lessons from contrastive learning, like the consistency regularization for GANs [47, 50], the patch-level contrastive learning for image-to-image translation [33], and the latent-augmented contrastive loss for conditional image synthesis [29]. Akin to supervised contrastive loss [27], some concurrent work [20, 21, 43] reformulates the conventional bi-classification task (i.e., real domain vs. fake domain) with contrastive loss. Differently, we keep the original bi-classification task of the discriminator and introduce contrastive learning as a new one. Specifically, we assign the discriminator a simple auxiliary task, which is to recognize every individual image, no matter it is real or synthesized by the generator. Such instance discrimination task helps sustain the discriminative power of the discriminator under a low-data regime, which in turn improves the synthesis performance significantly.
+
+![](images/b6262b5667d4ec4161877b2eb066ba210154e6c65d5fe47753a8492ece2b34cc.jpg)  
+Figure 1: Illustration of the InsGen method. Besides the bi-classification task to differentiate real and fake domains, the discriminator is assigned an auxiliary task, which aims at maximally distinguishing each image instance as illustrated on the right. $\mathcal { C }$ denotes the training objective for such instance discrimination task. (a) The discriminator is asked to recognize not only every real sample $\mathbf { x } _ { i }$ but also every synthesized sample $G ( \mathbf { z } _ { i } )$ by a frozen generator. (b) With the instance-induced discriminator, the generator is encouraged to make all synthesis recognizable from each other, leading to more diverse generation.
+
+# 3 Methodology
+
+In this section, we introduce the proposed InsGen method. Recall that our method is built based on GAN, which is commonly formulated as a two-player game between a generator and a discriminator. They compete with each other in that the generator tries to produce as realistic data as possible while the discriminator works on recognizing synthesized data from real data. Besides the conventional bi-classification task (i.e., differentiating real and fake domains), we also require the discriminator to distinguish every individual instance. With such a challenging task, the discriminator can mitigate the overfitting problem even with limited training data. We will briefly introduce the image synthesis and instance discrimination mechanisms in Sec. 3.1, followed by our improved training pipeline in Sec. 3.2 and the practical usage of InsGen on the state-of-the-art StyleGAN2-ADA model [24] in Sec. 3.3.
+
+# 3.1 Preliminaries
+
+Our work is highly related to GAN [16] for image synthesis and contrastive learning [40, 17] for instance discrimination. To make the paper self-contained, we shortly describe these two algorithms in the text below.
+
+Synthesizing Images with GANs. GAN is a popular paradigm for image generation. It typically consists of two networks: a generator $G ( \cdot )$ that learns to map a latent variable $\mathbf { z }$ to a photo-realistic image, and a discriminator $D ( \cdot )$ that aims at separating real images $\mathbf { x }$ from synthesized ones $G ( \mathbf { z } )$ These two networks compete with each other [16] and are jointly optimized with
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { D } = - \mathbb { E } _ { \mathbf { x } \in \mathcal { X } } [ \log ( D ( \mathbf { x } ) ) ] - \mathbb { E } _ { \mathbf { z } \in \mathcal { Z } } [ \log ( 1 - D ( G ( \mathbf { z } ) ) ) ] , } \\ & { \mathcal { L } _ { G } = - \mathbb { E } _ { \mathbf { z } \in \mathcal { Z } } [ \log ( D ( G ( \mathbf { z } ) ) ) ] , } \end{array}
+$$
+
+where $\mathcal { Z }$ and $\mathcal { X }$ denote the pre-defined latent distribution and real data distribution respectively. After the training converges, the synthesized images are assumed to be as realistic as real ones to fool the discriminator. From this perspective, the synthesis quality highly depends on the discriminative power of the discriminator. Prior literature [24, 39, 49, 51] has affirmed that GANs will suffer from the insufficient training of the discriminator and proposed to apply a series of data augmentations $\tau ( \cdot )$ to alleviate the overfitting problem. But they do not change the learning objectives of GAN and observe drastic performance drop given limited training data.
+
+Distinguishing Images with Contrastive Learning. It is well-known that image classification tasks usually benefit from more discriminative representations [12]. Unlike supervised training algorithms that optimize the model parameters based on annotated data, contrastive learning [40, 17, 7, 18, 3] is able to extract representative features from images in an unsupervised manner. As shown in Fig. 1a, the rationale behind is to “label” every sample as an individual class, i.e., instance discrimination. Concretely, given an image $\mathbf { x }$ , two random “views” (e.g., through different augmentations) are created as the query $\mathbf { x } _ { q }$ and the key $\mathbf { x } _ { k _ { + } }$ . This query-key pair is regarded as the positive pair while all “views” from other images, $\{ \mathbf { x } _ { k _ { i } } \} _ { i = 1 } ^ { N }$ , are treated as negative pairs with respect to the query. Here, $N$ is the total number of images in addition to the query image. Contrastive learning aims at maximizing the agreement across augmentations (i.e., $\mathbf { x } _ { q }$ and $\mathbf { x } _ { k _ { + } }$ ) and make the query as much dissimilar to a number of negative samples as possible. Accordingly, we can design a pretext task of $( N + 1 )$ -way classification and learn the model with the contrastive loss $\mathcal { C }$ i.e., InfoNCE loss [32]
+
+$$
+\begin{array} { r } { { \mathbf { v } } _ { q } = F ( { \mathbf { x } } _ { q } ) , \quad { \mathbf { v } } _ { k _ { + } } = F ( { \mathbf { x } } _ { k _ { + } } ) , \quad { \mathbf { v } } _ { k _ { i } } = F ( { \mathbf { x } } _ { k _ { i } } ) , i = 1 \dots N , } \end{array}
+$$
+
+$$
+\mathcal { C } _ { F ( \cdot ) , \phi ( \cdot ) } ( \mathbf { x } _ { q } , \mathbf { x } _ { k _ { + } } , \{ \mathbf { x } _ { k _ { i } } \} _ { i = 1 } ^ { N } ) = - \log \frac { \exp ( \phi ( \mathbf { v } _ { q } ) ^ { T } \phi ( \mathbf { v } _ { k _ { + } } ) / \tau ) } { \sum _ { i = 0 } ^ { N } \exp ( \phi ( \mathbf { v } _ { q } ) ^ { T } \phi ( \mathbf { v } _ { k _ { i } } ) / \tau ) } ,
+$$
+
+where $F ( \cdot )$ is the backbone network to extract the representation $\mathbf { v }$ from a given image $\mathbf { x }$ , and $\phi ( \cdot )$ is the head network (e.g., usually implemented with several fully-connected layers) to project the extracted feature onto a unit sphere. $\tau$ stands for the temperature, which is a hyper-parameter. Recall that the primitive goal of the discriminator in GANs can also be viewed as a bi-classification task, which is to recognize real and fake domains. In this work, we demonstrate that introducing the instance discrimination task can help enhance the discriminative power of the discriminator and in turn improve the synthesis quality of the generator significantly.
+
+# 3.2 Generating Diverse Instances from Distinguishing Instances
+
+In this part, we will introduce how instance discrimination is incorporated into the GAN training for data-efficient and diverse image generation. There are four essential components of our InsGen method: 1) distinguishing real images, 2) distinguishing fake images that can be sampled infinitely, 3) a noise perturbation strategy, and 4) a loop-back mechanism to encourage the generator for the diverse generation.
+
+Distinguishing Real Images. As discussed above, the synthesis quality of GAN models not only depends on the training scheme [2, 30, 22, 4] and the architecture design of the generator [46, 23, 25], but more importantly relies on the discriminative capability of the discriminator. That is because the discriminator is the only one (compared to the generator) that can see how real data looks like and further guides the generator accordingly. To make the maximum use of the limited training data and avoid the discriminator from memorizing the entire dataset, we assign it with a more challenging task beyond domain classification, which is to recognize every independent instance from the dataset, as shown in Fig. 1a. For this purpose, we introduce a new task head $\phi ^ { r } ( \cdot )$ beyond the original bi-classification head $\phi ^ { d o m a i n } ( \cdot )$ on top of its backbone $d ( \cdot )$ and train the discriminator with an extra training objective
+
+$$
+\mathcal { C } _ { D } ^ { r } = \mathcal { C } _ { d ( \cdot ) , \phi ^ { r } ( \cdot ) } ( \mathcal { T } _ { q } ( \mathbf { x } _ { q } ) , \mathcal { T } _ { k _ { + } } ( \mathbf { x } _ { q } ) , \{ \mathcal { T } _ { k _ { i } } ( \mathbf { x } _ { k _ { i } } ) \} _ { i = 1 } ^ { N } ) .
+$$
+
+Here, $\mathbf { x } _ { q }$ , $\{ \mathbf { x } _ { k _ { i } } \} _ { i = 1 } ^ { N }$ are all sampled from the real data distribution $\mathcal { X }$ and transformed with various differentiable augmentations $\tau ( \cdot )$ .
+
+Distinguishing Fake Images. However, the amount of training data could be extremely few (like thousands or even hundreds) in practice. In such a case, the improvement of the discriminator gained by differentiating real instances will be also limited. On the other hand, we notice that the number of synthesized samples can be sufficiently large due to the sampling mechanism of GANs. Ideally, different latent codes $\mathbf { z } \in { \mathcal { Z } }$ should lead to different synthesis $G ( \mathbf { z } )$ . Hence, we propose to also ask the discriminator to recognize every individual fake images, as shown in Fig. 1a. Similarly, we introduce another task head $\bar { \phi } ^ { f } ( \cdot )$ into the discriminator. It is worth mentioning that we use separate task heads (i.e., $\phi ^ { r } ( \cdot )$ and $\phi ^ { f } ( \cdot ) )$ for real and fake data. That is because even though the synthesized images can be with high-quality, they still lie in a different distribution from the real ones, especially when the generator starts training from scratch. Meanwhile, the task of discriminating a real instance from a fake instance can be achieved by the native domain classification head $\phi ^ { d o m a i n } ( \cdot )$ .
+
+Noise Perturbation. Prior work has observed the continuity of the latent space [36] such that images synthesized from the latent codes within a neighbourhood are very close to each other. Accordingly, they are more suitable to be treated as positive pairs than negative pairs. From this perspective, we introduce a noise perturbation strategy into fake image discrimination. The objective becomes
+
+$$
+\mathbf { x } _ { q } ^ { \prime } = { \mathcal { T } } _ { q } ( G ( \mathbf { z } _ { q } ) ) , \quad \mathbf { x } _ { k _ { + } } ^ { \prime } = { \mathcal { T } } _ { k _ { + } } ( G ( \mathbf { z } _ { q } + \epsilon ) ) , \quad \mathbf { x } _ { k _ { i } } ^ { \prime } = { \mathcal { T } } _ { k _ { i } } ( G ( \mathbf { z } _ { k _ { i } } ) ) ,
+$$
+
+$$
+\mathcal { C } _ { D } ^ { f } = \mathcal { C } _ { d ( \cdot ) , \phi ^ { f } ( \cdot ) } ( \mathbf { x } _ { q } ^ { \prime } , \mathbf { x } _ { k _ { + } } ^ { \prime } , \{ \mathbf { x } _ { k _ { i } } ^ { \prime } \} _ { i = 1 } ^ { N } ) .
+$$
+
+Concretely, given a query image $\mathbf { x } _ { q } ^ { \prime }$ , the key image $\mathbf { x } _ { k + } ^ { \prime }$ is created with $\mathcal { T } _ { k _ { + } } ( G ( \mathbf { z } _ { q } + \epsilon ) )$ instead of $T _ { k _ { + } } ( G ( \mathbf { z } _ { q } ) )$ . Here, $\epsilon$ stands for the perturbation term, which is sampled from a Gaussian distribution whose variance is sufficiently smaller than that of $\mathcal { Z }$ , and $\mathcal { T } _ { q } ( \cdot )$ and $\tau _ { k + } ( \cdot )$ denote two different augmentations. Such design aims to enforce the discriminator invariant to the small perturbation, which makes the instance discrimination task more challenging.
+
+Toward Diverse Generation. Besides utilizing the instance discrimination task to improve the discriminative power of the discriminator, we further design a loop-back mechanism to in turn use the learned instance discrimination to guide the generator. Recall that image diversity, in addition to image quality, is also an important metric to evaluate generative models. Diverse generation, which requires all generated samples to be distinguishable from each other, exactly matches our goal of instance discrimination. In other words, given a discriminator with the ability to distinguish different instances, we would like all the samples produced by the generator to be recognized as different ones. This idea is illustrated in Fig. 1b. By comparing Fig. 1a and Fig. 1b, we can see that the generator shares the same target as the discriminator yet is trained separately. Hence, the same objective function is added into the generator loss
+
+$$
+\mathbf { x } _ { k _ { + } } ^ { \prime \prime } = \mathcal { T } _ { k _ { + } } ( G ( \mathbf { z } _ { q } ) ) ,
+$$
+
+$$
+\mathcal { C } _ { G } ^ { f } = \mathcal { C } _ { d ( \cdot ) , \phi ^ { f } ( \cdot ) } ( \mathbf { x } _ { q } ^ { \prime } , \mathbf { x } _ { k _ { + } } ^ { \prime \prime } , \{ \mathbf { x } _ { k _ { i } } ^ { \prime } \} _ { i = 1 } ^ { N } ) ,
+$$
+
+where the only difference is that noise perturbation is not applied during the training of the generator.
+
+Complete Objective Function. To summarize, with the purposes of both image synthesis and instance discrimination, the discriminator and the generator in InsGen are optimized with
+
+$$
+\begin{array} { l } { { \mathcal { L } _ { D } ^ { \prime } = \mathcal { L } _ { D } + \lambda _ { D } ^ { r } \mathcal { C } _ { D } ^ { r } + \lambda _ { D } ^ { f } \mathcal { C } _ { D } ^ { f } , } } \\ { { \mathcal { L } _ { G } ^ { \prime } = \mathcal { L } _ { G } + \lambda _ { G } \mathcal { C } _ { G } ^ { f } , } } \end{array}
+$$
+
+where $\lambda _ { G } , \lambda _ { D } ^ { r }$ , and $\lambda _ { D } ^ { f }$ denote the weights for different terms.
+
+# 3.3 Implementation
+
+On top of the adversarial training pipeline in GANs, our InsGen method only inserts an extra loss output on the discriminator network for instance discrimination.Therefore, it can be easily implemented on any GAN framework. In this part, we take the state-of-the-art GAN model, StyleGAN2-ADA [24], as an example to demonstrate how InsGen is implemented in practice.
+
+Generative Model. StyleGAN2-ADA [24] adopts the architecture of StyleGAN2 [25] and proposes the adaptive discriminator augmentation strategy for training with limited data. In particular, it designs a differentiable augmentation pipeline, consisting of 18 transformations, as well as an adaptive hyper-parameter to control the strength of these augmentations. For a fair comparison, in this work, we exactly reuse the network structure, the augmentation pipeline, the adaptive strategy of the augmenting strength, and other hyper-parameters like batch size and learning rate.
+
+Instance Discrimination. We reuse the backbone of the discriminator to perform instance discrimination, so that the extra computing load is extremely small and the training efficiency is barely affected. We treat the last fully-connected layer in the StyleGAN2-ADA discriminator as the domain-classification head $\phi ^ { d o m a i n } \dot { ( } \cdot \dot { } )$ , while all remaining layers serve as the backbone network $d ( \cdot )$ . The real instance discrimination head $\phi ^ { r } ( \cdot )$ and the fake head $\phi ^ { f } ( \cdot )$ are both implemented with 2 fully-connected layers, followed by $\ell _ { 2 }$ normalization. Strictly following MoCo-v2 [8], an extra queue is employed for each task head to store the sample features to save computational cost. The number of samples in $\mathcal { L } _ { D } ^ { r }$ and $\mathcal { L } _ { D } ^ { f }$ is thus equal to the queue size, which usually contains around $5 \%$ data of the whole set. We also introduce the momentum encoder $D ^ { \prime }$ , whose parameters are updated with moving average scheme: $\Theta _ { D ^ { \prime } }  \alpha \Theta _ { D ^ { \prime } } + ( 1 - \alpha ) \Theta _ { D }$ . Here, $\alpha = 0 . 9 9 9$ follows the same setting in MoCo-v2 [8]. The temperature $\tau$ in Eq. (4) is set as 2.
+
+Table 1: Performance on FFHQ. FID (lower is better) is reported as the evaluation metric. $2 K ^ { \ast }$ , $\cdot 1 0 K ^ { \prime }$ , and $" 1 4 0 K "$ stand for the number of samples used for training, where $\mathsf { \Omega } ^ { \bullet } 1 4 0 K ^ { \prime } \ '$ horizontally flips the original FFHQ dataset (with $7 0 K$ samples) to double the size of data. Results with $^ *$ are also achieved with horizontally flipped data, which are slightly better than those reported in [24]. Numbers in blue color indicate our improvements over the baseline [24].   
+
+<table><tr><td>256×256 Resolution</td><td>2K</td><td>10K</td><td>140K</td></tr><tr><td>PA-GAN [44]</td><td>56.49</td><td>27.71</td><td>3.78</td></tr><tr><td>zCR [50]</td><td>71.61</td><td>23.02</td><td>3.45</td></tr><tr><td>Auxiliary rotation [6]</td><td>66.64</td><td>25.37</td><td>4.16</td></tr><tr><td>StyleGAN2 [23]</td><td>78.80</td><td>30.73</td><td>3.66</td></tr><tr><td>w/ Shallow mapping [24]</td><td>71.35</td><td>27.71</td><td>3.59</td></tr><tr><td>w/ Adaptive dropout [24]</td><td>67.23</td><td>23.33</td><td>4.16</td></tr><tr><td>w/DiffAugment [49]</td><td>24.32</td><td>7.86</td><td>1</td></tr><tr><td>w/ ADA [24]</td><td>15.60*</td><td>7.29*</td><td>3.88</td></tr><tr><td>InsGen (Ours)</td><td>11.92 (-3.68)</td><td>4.90 (−2.39)</td><td>3.31 (-0.57)</td></tr></table>
+
+# 4 Experiments
+
+We evaluate the proposed InsGen method on multiple benchmarks. Sec. 4.1 presents the comparison to prior literature on both FFHQ [23] and AFHQ [9] datasets. Our InsGen substantially improves the baselines under multiple data-regime settings and outperforms previous data-augmentation approaches by a significant margin. Moreover, Sec. 4.2 provides a detailed ablation study to show the importance of each component. Lastly Sec. 4.3 discusses about the limitation of data-efficiency.
+
+# 4.1 Main Results
+
+Datasets. We evaluate our InsGen with a number of other approaches on FFHQ [23] and AFHQ [9] datasets. FFHQ contains unique 70,000 high-resolution images $( 1 0 2 4 \times 1 0 2 4 )$ , with large variation regarding age, ethnicity, and background. All images of FFHQ are well aligned [26] and cropped. In order to conduct a fair comparison, we resize images to $2 5 6 \times 2 5 6$ . For the experiments of limited data, we follow ADA [24] to collect a subset of training data by randomly sampling. Moreover, AFHQ consists of around 5000 images per category for dogs, cats, and wild life at $5 1 2 \times 5 1 2$ resolution. Each category is regarded as a dataset and thus we train a different network on each dataset.
+
+Training. We implement our InsGen on the official implementation of StyleGAN2-ADA. The training regularization is preserved, including path length regularization, lazy regularization, and style mixing regularization. Moreover, all parameters share the same learning rate and the minibatch standard deviation layer is adopted at the end of the discriminator. Exponential moving average of generator weights, non-saturating logistic loss with $R _ { 1 }$ regularization, and Adam optimizer [28] is also adopted. In particular, the coefficient of gradient penalty would be decreased correspondingly, according to the official implementation of ADA [24]. All the experiments are conducted on a server with 8 GPUs. Mixed-precision training is also used for faster training.
+
+Hyper-parameters. Empirically, the loss weights $\lambda _ { G }$ , $\lambda _ { D } ^ { f }$ and $\lambda _ { D } ^ { r }$ are 0.1, 1.0 and 1.0 respectively. Besides, the training length is slightly different. For the experiments with less than $1 0 K$ images, the total number of seen images is 10 million rather than 25 million adopted by ADA [24]. Meanwhile, we decrease the loss weight of the gradient penalty due to involving an extra supervision. For example, ADA [24] adopts 1.0 for original StyleGAN2 training while we use 0.8. We also found smaller loss weight of gradient penalty is beneficial to our InsGen on the less data, e.g., 0.3 and 0.5 for $1 0 K$ and $2 K$ experiments respectively.
+
+Evaluation Metric. We use Fréchet Inception Distance (FID) [19] as the metric for quantitative comparison metric since FID tends to reflect the human perception of synthesis quality. As mentioned in Heusel et al. [19], we always calculate the FID between 50,000 fake images and all training images, no matter how much data the training set contains. The official pre-trained Inception network is used to compute the FID.
+
+![](images/eb180c7b26c337f1b7a172c651de11434c6d87dbb1dd03e0e9a7c2b673c37571.jpg)  
+Figure 2: Generated images under various data regimes. The number of training images and the corresponding FID are reported. All images on FFHQ are synthesized with truncation following [24] while those on AFHQ are not.
+
+Results on FFHQ. Tab. 1 presents the comparison on FFHQ. Akin to ADA [24], we compare against PA-GAN [44], zCR [50] and auxiliary rotation [6]. Also, StyleGAN2 together with its variants is also introduced as the baseline methods. For instance, less data is usually required when a shallower mapping network is applied. Besides, dropout [37] is also well-studied to be replaced with the augmentations as the regularization. Note that ∗ means the dataset is amplified by $2 \times$ via the horizontal flip, which is recommended in the official implementation of ADA [24]. Such that, $2 K ^ { , , }$ denotes 2,000 unique images and the dataset is enlarged to 4,000 via the flip operation, leading to a better baseline.
+
+Although ADA [24] has already improved the performance significantly under various low-data regimes, our InsGen continues to improve the low-data image generation by a clear margin, establishing a new state-of-the-art synthesis quality with limited training images. To be specific, our method improves the FID from 15.60 to 11.92, 7.29 to 4.90, and 3.88 to 3.31 with $2 K$ , $1 0 K$ and $7 0 K$ training images from FFHQ [23] respectively. Fig. 2 presents several generated examples under various data regimes. More qualitative results are available in our supplementary material. All images on FFHQ are generated with truncation. It is also worth noting that our approach further improves the synthesis quality when the full dataset is given, even outperforming previous best one i.e., zCR [50]. Namely, the data can be further exploited when it is not the bottleneck for training.
+
+Results on AFHQ. We also evaluate our approach on AFHQ dataset [9] which is divided into cat, dog and wild life, with the number of 5153, 4739 and 4738 images respectively. Therefore, three models are trained on them individually. Note that all models on AFHQ are trained on $5 1 2 \times 5 1 2$ images while the generated samples are resized to present. We involve StyleGAN2 [25], ContraD [20] and ADA [24] as the baseline approaches, compared to our InsGen. Quantitative and qualitative results are shown in Tab. 2 and Fig. 2 respectively.
+
+The synthesis quality on those datasets is substantially improved by our method, which also outperforms previous data-augmentation methods. To be specific, our method improves the FID from 3.55 to 2.60, 7.40 to 5.44, and 3.05 to 1.77 on cat, dog and wild life images respectively. In particular, ContraD [20] introduced stronger augmentations to train a better discriminator via contrastive learning. One term in this method shares the similar motivation that real images could result in powerful representations. In terms of the use of synthesized samples, ContraD turned to focus on the binary classification, (i.e., real vs. fake) with some specific designs like the stop-gradient operation. Differently, our method leverages the generated images as a kind of data complement to produce a stronger representation and guide the learning of the generator. Accordingly, InsGen achieves the new state-of-the-art performances on AFHQ [9].
+
+Table 3: Ablation Study. FID (lower is better) is reported as the evaluation metric. Here, vanilla $\mathcal { C } _ { D } ^ { f }$ means that the noise perturbation is not applied in the fake instance discrimination.   
+
+<table><tr><td>CD</td><td>vanilla Cf</td><td>c</td><td>C</td><td>2K</td><td>10K</td><td>70K</td></tr><tr><td></td><td></td><td></td><td></td><td>15.60</td><td>7.29</td><td>3.76</td></tr><tr><td></td><td></td><td></td><td></td><td>14.15</td><td>5.98</td><td>3.56</td></tr><tr><td></td><td></td><td></td><td></td><td>13.46</td><td>5.68</td><td>3.67</td></tr><tr><td>νvv/</td><td>·</td><td>：</td><td></td><td>12.19</td><td>5.30</td><td>3.49</td></tr><tr><td></td><td>√</td><td></td><td>√</td><td>11.92</td><td>4.90</td><td>3.31</td></tr></table>
+
+# 4.2 Ablation Study
+
+In order to investigate the importance of each component in our InsGen, we conduct an ablation study on FFHQ [23] with the image resolution of $2 5 6 \times 2 5 6$ . FID serves as the main metric for the comparison, and the results on $2 K$ , $1 0 K$ and $7 0 K$ unique images are reported. During training each unique image go through random flip operation to obtain a stronger baseline. Tab. 3 presents the collection of various experiments in the ablation study. We choose the ADA [24] as the baseline.
+
+How important is the instance discrimination? After performing the real image discrimination, the synthesis quality is improved, with the FID consistently decreased by -1.45, -1.31 and -0.20 in Tab. 3, no matter how many unique images the training set includes. To some extent, the discriminator would benefit from the powerful representations derived from the challenging pretext task. Accordingly, the generator is required to produce more photo-realistic images in order to confuse the discriminator.
+
+When adding instance discrimination with fake images, performances could be further boosted. For instance, FID obtains an improvement of -0.69 and -0.30 with $2 K$ and $1 0 K$ images respectively. In particular, the gains rise as the number of real images goes down, verifying one of our motivations that the fake samples can be also regarded as data source for unsupervised representation learning.
+
+How important is the noise perturbation? In Sec. 3.2, a noise perturbation strategy is proposed as a type of latent space augmentation for fake image discrimination. In particular, this latent space augmentation, i.e., the small movement in the latent space always leads to an obvious but semantically consistent change of the original image, which could not easily be implemented by some geometric and color transformations. Meanwhile, the discriminator is required to be invariant to such noise perturbation due to the goal of instance discrimination. Accordingly, the fake images are made best use of to result in stronger representations for the discrimination. As shown in Tab. 3, such strategy further brings consistent gains of -1.27, -0.38 and -0.18 on $2 K$ , $1 0 K$ and $7 0 K$ datasets respectively.
+
+How important is the supervision signal for the generator? The last row of Tab. 3 shows the performances with the gradients which are back-propagated to the generator. Even if we have already obtained quite strong results, such a supervision signal on the generator could also introduce improvements under various data regimes.
+
+The goal of instance discrimination is to distinguish every individual image according to its appearance cues [40]. Assuming this pretext task is well-performed on a fixed dataset, the semantic representation would be derived from this learning process. However, when distinguishing fake images, the fake dataset actually varies dynamically. Namely, we could accomplish this pretext task from the perspective of data, if the engine of this dynamical fake dataset, i.e., the generator could produce as many different images as possible. In general, this pretext task is exploited to encourage the diverse generation directly on the generator.
+
+![](images/5cc4b470ceb0d3fd539a609aa8745e28508b1d4519572d7ab1d6c744fcd91e69.jpg)  
+Figure 3: Effect of the number of synthesized and real images used for instance discrimination. FID (lower is better) in log-scale is reported as the evaluation metric. We can see the consistent performance gain along with the increasing number of instances for discrimination.
+
+![](images/8784a8a0af0ed2b555c45f78ab9be11e4c6136556542d9bdacef1fb4095601c1.jpg)  
+Figure 4: Training progress on FFHQ- $2 K$ . Larger value means that the image is more realistic under the view of the discriminator. Our discriminator can better and more stably differentiate real and fake data compared to ADA [24].
+
+How important is the number of negative samples? We follow the MoCo-v2 [8] to store multiple features in a queue, in order to reduce the computational complexity. Empirically, the length of the feature queue tends to be the $5 \%$ number of the dataset. Therefore, it is 200 when we have $2 K$ unique images and enlarge them via the flip operation. However, there is no any reference number for the synthesized data. Accordingly, we collect as the same amount of fake data as that of the real.
+
+As mentioned in Sec. 3.2, there could be much more synthesized samples than the real samples. Namely, we could leverage infinite samples for the synthesized instance discrimination. Therefore, we investigate the effect of the different number of synthesized samples i.e., the length of the feature queue, shown in Fig. 3a. Obviously, FID gradually decreases with the increasing number of synthesized samples, suggesting that involving more fake images is of great benefit to the synthesis, especially with the limited training data.
+
+Whether the discriminative ability of the discriminator is really enhanced. As is mentioned in our work, it is challenging to gain sufficient discriminative power for the discriminator to train the generator when the size of training set is small. However, introducing instance discrimination is able to improve its discriminative capability, achieving new state-of-the-art synthesis quality. In order to investigate whether the discriminative ability is improved, we plot the logits (derived from the discriminator) of any input image during the training in Fig. 4. To be specific, the logit denotes how much the input image is identified as the real. And the number of training images are 2000.
+
+Obviously, our method produces higher real and lower fake scores throughout the whole training progress, compared to the baseline approach ADA [24]. It indicates that the discriminator of our method performs the domain bi-classification (i.e., real vs. fake) better than that of baseline, showing stronger discriminative ability. It also verifies our motivation that a challenging pretext task which is to distinguish every individual image could indeed enhance the discriminator. Besides, the training progress is much more stable when equipped with our approach.
+
+# 4.3 Towards the Limit of Data-efficiency
+
+Although we have obtained the new state-of-the-art synthesis performances under the standard settings, we also wonder how much data-efficiency our InsGen could achieve. Therefore, the number of real data in the training set is further reduced to 1000, 500, 250 and 100. In order to conduct the apple-to-apple comparison, we remain to train the same model of StyleGAN2 without decreasing its generative capacity by using fewer channels or shallower mapping networks since such designs require less data. Meanwhile, the generated resolution remains $2 5 6 \times 2 5 6$ and the datasets are amplified via the horizontal flip operation as well.
+
+![](images/88e0e79ed25fadd63ef45e5b134b7b7ab2a28613c32de7489b0e648f77e6ce0b.jpg)  
+Figure 5: Qualitative results with different number of training images. The number of training images and the corresponding FID are reported. All images are synthesized with truncation following [24].
+
+The quantitative and qualitative results are shown in Fig. 3b and Fig. 5 respectively. Obviously, FID significantly increases with the decreasing number of training images from 70K to 100. Nevertheless, our InsGen trained with only 100 unique images remains to outperform many approaches like PA-GAN in Fig. 3b with 2K images. Besides, with 500 training samples, our method is able to obtain the competitive performance to those using $1 0 \mathrm { k }$ images. Namely, our InsGen could improve the data-efficiency by more than $2 0 \times$ . Qualitative results suggest that our approach still produces meaningful images without incurring the model collapse no matter how many training images exist in the data collection.
+
+# 5 Conclusion and Discussion
+
+In this work, we develop a novel data-efficient Instance Generation (InsGen) method for training GANs with limited data. With the instance discrimination as an auxiliary task, our method makes the best use of both real and fake images to train the discriminator. In turn the discriminator is exploited to train the generator to synthesize as many diverse images as possible. Experiments under different data regimes show that InsGen brings a substantial improvement over the baseline in terms of both image quality and image diversity, and outperforms previous data augmentation algorithms by a large margin.
+
+Although InsGen significantly improves the data efficiency in training generative models, it leaves some future work to do. One limitation of InsGen is that the performance gain becomes marginal when the training dataset is sufficiently large. This suggests that the discriminator can not benefit from the newly introduced instance discrimination any more. It may require a more challenging task to further improve the performance. Another limitation is that the FID score remains unsatisfying when the training data is extremely limited, say several hundred. It is worth exploring how to fully utilize the fake samples for discriminator training.
+
+Acknowledgments. The project was supported through the Research Grants Council (RGC) of Hong Kong under ECS Grant No.24206219, GRF Grant No.14204521, CUHK FoE RSFS Grant.
+
+# References
+
+[1] M. Arjovsky and L. Bottou. Towards principled methods for training generative adversarial networks. Int. Conf. Learn. Represent., 2017. 1
+
+[2] M. Arjovsky, S. Chintala, and L. Bottou. Wasserstein generative adversarial networks. In Int. Conf. Mach. Learn., 2017. 4   
+[3] P. Bachman, R. D. Hjelm, and W. Buchwalter. Learning representations by maximizing mutual information across views. In Adv. Neural Inform. Process. Syst., 2019. 2, 4   
+[4] A. Brock, J. Donahue, and K. Simonyan. Large scale gan training for high fidelity natural image synthesis. In Int. Conf. Learn. Represent., 2018. 1, 4   
+[5] M. Chen, A. Radford, R. Child, J. Wu, H. Jun, P. Dhariwal, D. Luan, and I. Sutskever. Generative pretraining from pixels. In Int. Conf. Mach. Learn., 2020. 2   
+[6] T. Chen, X. Zhai, M. Ritter, M. Lucic, and N. Houlsby. Self-supervised gans via auxiliary rotation loss. In IEEE Conf. Comput. Vis. Pattern Recog., 2019. 2, 6, 7   
+[7] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In Int. Conf. Mach. Learn., 2020. 2, 4   
+[8] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020. 5, 9   
+[9] Y. Choi, Y. Uh, J. Yoo, and J.-W. Ha. Stargan v2: Diverse image synthesis for multiple domains. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 6, 7, 8   
+[10] E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le. Autoaugment: Learning augmentation policies from data. In IEEE Conf. Comput. Vis. Pattern Recog., 2018. 1, 2   
+[11] E. D. Cubuk, B. Zoph, J. Shlens, and Q. V. Le. Randaugment: Practical automated data augmentation with a reduced search space. In IEEE Conf. Comput. Vis. Pattern Recog. Worksh., 2020. 1, 2   
+[12] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In IEEE Conf. Comput. Vis. Pattern Recog., 2009. 3   
+[13] C. Doersch, A. Gupta, and A. A. Efros. Unsupervised visual representation learning by context prediction. In Int. Conf. Comput. Vis., 2015. 2   
+[14] J. Donahue and K. Simonyan. Large scale adversarial representation learning. In Adv. Neural Inform. Process. Syst., 2019. 2   
+[15] S. Gidaris, P. Singh, and N. Komodakis. Unsupervised representation learning by predicting image rotations. In Int. Conf. Learn. Represent., 2018. 2   
+[16] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. In Adv. Neural Inform. Process. Syst., 2014. 1, 3   
+[17] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 2, 3, 4   
+[18] O. Henaff. Data-efficient image recognition with contrastive predictive coding. In Int. Conf. Mach. Learn., 2020. 2, 4   
+[19] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Adv. Neural Inform. Process. Syst., 2017. 6   
+[20] J. Jeong and J. Shin. Training gans with stronger augmentations via contrastive discriminator. In Int. Conf. Learn. Represent., 2021. 2, 7, 8   
+[21] M. Kang and J. Park. Contragan: Contrastive learning for conditional image generation. In Adv. Neural Inform. Process. Syst., 2020. 2   
+[22] T. Karras, T. Aila, S. Laine, and J. Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In Int. Conf. Learn. Represent., 2018. 1, 4   
+[23] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In IEEE Conf. Comput. Vis. Pattern Recog., 2019. 1, 2, 4, 6, 7, 8   
+[24] T. Karras, M. Aittala, J. Hellsten, S. Laine, J. Lehtinen, and T. Aila. Training generative adversarial networks with limited data. In Adv. Neural Inform. Process. Syst., 2020. 1, 2, 3, 5, 6, 7, 8, 9, 10   
+[25] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of StyleGAN. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 1, 4, 5, 7   
+[26] V. Kazemi and J. Sullivan. One millisecond face alignment with an ensemble of regression trees. In IEEE Conf. Comput. Vis. Pattern Recog., 2014. 6   
+[27] P. Khosla, P. Teterwak, C. Wang, A. Sarna, Y. Tian, P. Isola, A. Maschinot, C. Liu, and D. Krishnan. Supervised contrastive learning. In Adv. Neural Inform. Process. Syst., 2020. 2   
+[28] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Int. Conf. Learn. Represent., 2014. 6   
+[29] R. Liu, Y. Ge, C. L. Choi, X. Wang, and H. Li. Divco: Diverse conditional image synthesis via contrastive generative adversarial network. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   
+[30] T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. In Int. Conf. Learn. Represent., 2018. 4   
+[31] M. Noroozi and P. Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In Eur. Conf. Comput. Vis., 2016. 2   
+[32] A. v. d. Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. 2, 4   
+[33] T. Park, A. A. Efros, R. Zhang, and J.-Y. Zhu. Contrastive learning for unpaired image-to-image translation. In Eur. Conf. Comput. Vis., 2020. 2   
+[34] D. Pathak, P. Krahenbuhl, J. Donahue, T. Darrell, and A. A. Efros. Context encoders: Feature learning by inpainting. In IEEE Conf. Comput. Vis. Pattern Recog., 2016. 2   
+[35] D. Pathak, R. Girshick, P. Dollár, T. Darrell, and B. Hariharan. Learning features by watching objects move. In IEEE Conf. Comput. Vis. Pattern Recog., 2017. 2   
+[36] A. Radford, L. Metz, and S. Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In Int. Conf. Learn. Represent., 2016. 5   
+[37] N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 2014. 7   
+[38] N.-T. Tran, V.-H. Tran, N.-B. Nguyen, L. Yang, and N.-M. Cheung. Self-supervised gan: Analysis and improvement with multi-class minimax game. In Adv. Neural Inform. Process. Syst., 2019. 2   
+[39] N.-T. Tran, V.-H. Tran, N.-B. Nguyen, T.-K. Nguyen, and N.-M. Cheung. On data augmentation for gan training. IEEE Trans. Image Process., 2021. 1, 2, 3   
+[40] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance discrimination. In IEEE Conf. Comput. Vis. Pattern Recog., 2018. 2, 3, 4, 8   
+[41] Y. Xu, Y. Shen, J. Zhu, C. Yang, and B. Zhou. Generative hierarchical features from synthesizing images. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   
+[42] C. Yang, Z. Wu, B. Zhou, and S. Lin. Instance localization for self-supervised detection pretraining. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   
+[43] N. Yu, G. Liu, A. Dundar, A. Tao, B. Catanzaro, L. Davis, and M. Fritz. Dual contrastive loss and attention for gans. arXiv preprint arXiv:2103.16748, 2021. 2   
+[44] D. Zhang and A. Khoreva. Pa-gan: Improving gan training by progressive augmentation. In Adv. Neural Inform. Process. Syst., 2019. 1, 6, 7   
+[45] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization. In Int. Conf. Learn. Represent., 2017. 1, 2   
+[46] H. Zhang, I. Goodfellow, D. Metaxas, and A. Odena. Self-attention generative adversarial networks. In Int. Conf. Mach. Learn., 2019. 4   
+[47] H. Zhang, Z. Zhang, A. Odena, and H. Lee. Consistency regularization for generative adversarial networks. In Int. Conf. Learn. Represent., 2020. 2   
+[48] R. Zhang, P. Isola, and A. A. Efros. Colorful image colorization. In Eur. Conf. Comput. Vis., 2016. 2   
+[49] S. Zhao, Z. Liu, J. Lin, J.-Y. Zhu, and S. Han. Differentiable augmentation for data-efficient gan training. In Adv. Neural Inform. Process. Syst., 2020. 1, 2, 3, 6   
+[50] Z. Zhao, S. Singh, H. Lee, Z. Zhang, A. Odena, and H. Zhang. Improved consistency regularization for gans. In Assoc. Adv. Artif. Intell., 2020. 2, 6, 7   
+[51] Z. Zhao, Z. Zhang, T. Chen, S. Singh, and H. Zhang. Image augmentations for gan training. arXiv preprint arXiv:2006.02595, 2020. 1, 2, 3

parse/train/9BpjtPMyDQ/9BpjtPMyDQ_content_list.json

@@ -0,0 +1,1032 @@
+[
+    {
+        "type": "text",
+        "text": "Data-Efficient Instance Generation from Instance Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            287,
+            122,
+            710,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ceyuan Yang† Yujun Shen‡ Yinghao $\\mathbf { X } \\mathbf { u } ^ { \\dag }$ Bolei Zhou† †The Chinese University of Hong Kong ‡ByteDance Inc. ",
+        "bbox": [
+            289,
+            220,
+            710,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            286,
+            535,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) have significantly advanced image synthesis, however, the synthesis quality drops significantly given a limited amount of training data. To improve the data efficiency of GAN training, prior work typically employs data augmentation to mitigate the overfitting of the discriminator yet still learn the discriminator with a bi-classification (i.e., real vs. fake) task. In this work, we propose a data-efficient Instance Generation (InsGen) method based on instance discrimination. Concretely, besides differentiating the real domain from the fake domain, the discriminator is required to distinguish every individual image, no matter it comes from the training set or from the generator. In this way, the discriminator can benefit from the infinite synthesized samples for training, alleviating the overfitting problem caused by insufficient training data. A noise perturbation strategy is further introduced to improve its discriminative power. Meanwhile, the learned instance discrimination capability from the discriminator is in turn exploited to encourage the generator for diverse generation. Extensive experiments demonstrate the effectiveness of our method on a variety of datasets and training settings. Noticeably, on the setting of $2 K$ training images from the FFHQ dataset, we outperform the state-of-the-art approach with $2 3 . 5 \\%$ FID improvement.1 ",
+        "bbox": [
+            233,
+            319,
+            766,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            310,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Network (GAN) [16] has become a popular paradigm to learn the distribution of the observed data. It is formulated as a two-player game, where a generator synthesizes realistic data, while a discriminator distinguishes synthesized samples from real ones. To reach equilibrium in this minimax game, it requires both the generator and the discriminator to be sufficiently trained. In other words, the synthesis capability of the generator will subsequently deteriorate given an inadequate discriminator [24, 39, 49, 51]. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            713
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent success of GANs [22, 23, 25, 4] relies on big data to assure the sufficient training of the discriminator. Prior work [49, 24] has found that reducing the amount of training data leads to the overfitting of the discriminator, which tends to memorize the entire training set. In turn, the backpropagation from the discriminator to the generator damages the synthesis quality of the generator and potentially causes the mode collapse problem [1, 44]. Data augmentation is one of the most widely used methods to alleviate the overfitting issue in deep learning algorithms [45, 11, 10]. Some recent attempts [24, 39, 49, 51, 44] have been made to apply data augmentation to GAN training. It is found that the discriminator can be improved by augmenting not only the real images from the dataset but also the synthesized images by the generator [49, 24]. However, the learning objective of the discriminator remains as categorizing real and fake domains and a substantial performance drop can be observed given limited training data. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            871
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The domain bi-classification task could be too easy for the discriminator to gain sufficient discriminative power as an adaptive loss to train the generator, especially when the size of training set is small. In this work, we propose to improve the data efficiency in GAN training by assigning a more challenging task to the discriminator, which is to distinguish every individual image as an independent category. In this way, the discriminator is forced to improve its discriminative capability to accomplish the instance discrimination task [40]. Notably, besides distinguishing real samples, we also demand the discriminator to differentiate fake samples synthesized by the generator. Thus the discriminator can be considered to train with infinite data, preventing it from memorizing the training samples. When distinguishing synthesized data, we design a noise perturbation strategy to increase the difficulty of the task and hence make the discriminator more capable. Meanwhile, we also alter the training objectives from the generator side. Concretely, besides making the generator to fool the discriminator, we expect all the samples produced by the generator to be well identified as different instances with our instance-induced discriminator. This highly matches the goal of diverse generation, which requires every synthesis to be unique. We evaluate our method on a range of datasets and achieve appealing generation performance in terms of image quality, diversity, and data efficiency. Experiments show that our method significantly improves the baselines and outperform previous data-augmentation methods. To be specific, our method improves the FID from 15.60 to 11.92, 7.29 to 4.90, and 3.88 to 3.31 with $2 K$ , $1 0 K$ , and $7 0 K$ training images from FFHQ [23] respectively. We can even learn a large-scale GAN with only 100 in-the-wild images to produce satisfying synthesis. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            353
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are summarized as follows: 1) We propose a data-efficient instance generation (InsGen) method which incorporates instance discrimination as an auxiliary task in GAN training. 2) The synthesized data is used as infinite samples for improving the discriminative power of the discriminator, which in turn substantially improves the synthesis quality and diversity of the generator. 3) Under various data-regime settings, our method consistently surpasses existing alternatives by a substantial margin. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            468,
+            321,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation in GANs. Data augmentation makes the maximum use of available data to alleviate the overfitting of deep models that have millions of parameters. It plays an essential role in training discriminative models [45, 11, 10]. Some recent work explores how data augmentation can help the training of GANs [51, 39, 49, 24]. Zhao et al. [51] conduct empirical studies on the effects of different types of augmentations for GAN training. Tran et al. [39] make a theoretical analysis of several data augmentations. Zhao et al. [49] propose a differentiable augmentation method such that the augmenting operations can be applied to both real and synthesized data. Similarly, Karras et al. [24] design augmentations that do not leak and introduce a probability-based adaptive strategy to stabilize the training process. Different from prior work, we focus on introducing the unsupervised representation learning which also requires augmentations into GAN training. Our work shows that the recent instance discrimination task [40] can be used as an auxiliary task for the discriminator, which in turn substantially improves the synthesis quality of the generator. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised Learning in GANs. The rationale behind self-supervised learning is to set up various pretext tasks with supervisory-free labels [14, 5, 41, 48, 13, 32, 34, 42, 34, 15, 31, 35]. Similar idea is recently introduced in GAN training as an auxiliary loss to improve the synthesis performance. For instance, Chen et al. [6] assign the rotation prediction task to the discriminator to prevent it from catastrophic forgetting, and Tran et al. [38] propose a multi-class minimax game to encourage the generator to produce diverse samples. Among all self-supervised learning approaches, contrastive learning [40, 17, 7, 18, 3] shows great potential in large-scale representation learning. Many attempts have been made to improve generative models by drawing lessons from contrastive learning, like the consistency regularization for GANs [47, 50], the patch-level contrastive learning for image-to-image translation [33], and the latent-augmented contrastive loss for conditional image synthesis [29]. Akin to supervised contrastive loss [27], some concurrent work [20, 21, 43] reformulates the conventional bi-classification task (i.e., real domain vs. fake domain) with contrastive loss. Differently, we keep the original bi-classification task of the discriminator and introduce contrastive learning as a new one. Specifically, we assign the discriminator a simple auxiliary task, which is to recognize every individual image, no matter it is real or synthesized by the generator. Such instance discrimination task helps sustain the discriminative power of the discriminator under a low-data regime, which in turn improves the synthesis performance significantly. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6262b5667d4ec4161877b2eb066ba210154e6c65d5fe47753a8492ece2b34cc.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the InsGen method. Besides the bi-classification task to differentiate real and fake domains, the discriminator is assigned an auxiliary task, which aims at maximally distinguishing each image instance as illustrated on the right. $\\mathcal { C }$ denotes the training objective for such instance discrimination task. (a) The discriminator is asked to recognize not only every real sample $\\mathbf { x } _ { i }$ but also every synthesized sample $G ( \\mathbf { z } _ { i } )$ by a frozen generator. (b) With the instance-induced discriminator, the generator is encouraged to make all synthesis recognizable from each other, leading to more diverse generation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            104,
+            795,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            426,
+            313,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the proposed InsGen method. Recall that our method is built based on GAN, which is commonly formulated as a two-player game between a generator and a discriminator. They compete with each other in that the generator tries to produce as realistic data as possible while the discriminator works on recognizing synthesized data from real data. Besides the conventional bi-classification task (i.e., differentiating real and fake domains), we also require the discriminator to distinguish every individual instance. With such a challenging task, the discriminator can mitigate the overfitting problem even with limited training data. We will briefly introduce the image synthesis and instance discrimination mechanisms in Sec. 3.1, followed by our improved training pipeline in Sec. 3.2 and the practical usage of InsGen on the state-of-the-art StyleGAN2-ADA model [24] in Sec. 3.3. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            307,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work is highly related to GAN [16] for image synthesis and contrastive learning [40, 17] for instance discrimination. To make the paper self-contained, we shortly describe these two algorithms in the text below. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Synthesizing Images with GANs. GAN is a popular paradigm for image generation. It typically consists of two networks: a generator $G ( \\cdot )$ that learns to map a latent variable $\\mathbf { z }$ to a photo-realistic image, and a discriminator $D ( \\cdot )$ that aims at separating real images $\\mathbf { x }$ from synthesized ones $G ( \\mathbf { z } )$ These two networks compete with each other [16] and are jointly optimized with ",
+        "bbox": [
+            174,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8904cc815c3ed3de5f2fed2fbd1ddfe4668af6bad1ecad0dfab6e1974ea25921.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { D } = - \\mathbb { E } _ { \\mathbf { x } \\in \\mathcal { X } } [ \\log ( D ( \\mathbf { x } ) ) ] - \\mathbb { E } _ { \\mathbf { z } \\in \\mathcal { Z } } [ \\log ( 1 - D ( G ( \\mathbf { z } ) ) ) ] , } \\\\ & { \\mathcal { L } _ { G } = - \\mathbb { E } _ { \\mathbf { z } \\in \\mathcal { Z } } [ \\log ( D ( G ( \\mathbf { z } ) ) ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            742,
+            684,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { Z }$ and $\\mathcal { X }$ denote the pre-defined latent distribution and real data distribution respectively. After the training converges, the synthesized images are assumed to be as realistic as real ones to fool the discriminator. From this perspective, the synthesis quality highly depends on the discriminative power of the discriminator. Prior literature [24, 39, 49, 51] has affirmed that GANs will suffer from the insufficient training of the discriminator and proposed to apply a series of data augmentations $\\tau ( \\cdot )$ to alleviate the overfitting problem. But they do not change the learning objectives of GAN and observe drastic performance drop given limited training data. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Distinguishing Images with Contrastive Learning. It is well-known that image classification tasks usually benefit from more discriminative representations [12]. Unlike supervised training algorithms that optimize the model parameters based on annotated data, contrastive learning [40, 17, 7, 18, 3] is able to extract representative features from images in an unsupervised manner. As shown in Fig. 1a, the rationale behind is to “label” every sample as an individual class, i.e., instance discrimination. Concretely, given an image $\\mathbf { x }$ , two random “views” (e.g., through different augmentations) are created as the query $\\mathbf { x } _ { q }$ and the key $\\mathbf { x } _ { k _ { + } }$ . This query-key pair is regarded as the positive pair while all “views” from other images, $\\{ \\mathbf { x } _ { k _ { i } } \\} _ { i = 1 } ^ { N }$ , are treated as negative pairs with respect to the query. Here, $N$ is the total number of images in addition to the query image. Contrastive learning aims at maximizing the agreement across augmentations (i.e., $\\mathbf { x } _ { q }$ and $\\mathbf { x } _ { k _ { + } }$ ) and make the query as much dissimilar to a number of negative samples as possible. Accordingly, we can design a pretext task of $( N + 1 )$ -way classification and learn the model with the contrastive loss $\\mathcal { C }$ i.e., InfoNCE loss [32] ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/595c2503e5dc3acaf8960748be578915f06989e7ada2e894e96937efbf899f25.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\mathbf { v } } _ { q } = F ( { \\mathbf { x } } _ { q } ) , \\quad { \\mathbf { v } } _ { k _ { + } } = F ( { \\mathbf { x } } _ { k _ { + } } ) , \\quad { \\mathbf { v } } _ { k _ { i } } = F ( { \\mathbf { x } } _ { k _ { i } } ) , i = 1 \\dots N , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            236,
+            707,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d09f08178a83ce6796b0222d78e6c4d69e7f76949a0938995f4a4a3f3875838.jpg",
+        "text": "$$\n\\mathcal { C } _ { F ( \\cdot ) , \\phi ( \\cdot ) } ( \\mathbf { x } _ { q } , \\mathbf { x } _ { k _ { + } } , \\{ \\mathbf { x } _ { k _ { i } } \\} _ { i = 1 } ^ { N } ) = - \\log \\frac { \\exp ( \\phi ( \\mathbf { v } _ { q } ) ^ { T } \\phi ( \\mathbf { v } _ { k _ { + } } ) / \\tau ) } { \\sum _ { i = 0 } ^ { N } \\exp ( \\phi ( \\mathbf { v } _ { q } ) ^ { T } \\phi ( \\mathbf { v } _ { k _ { i } } ) / \\tau ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            257,
+            727,
+            294
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $F ( \\cdot )$ is the backbone network to extract the representation $\\mathbf { v }$ from a given image $\\mathbf { x }$ , and $\\phi ( \\cdot )$ is the head network (e.g., usually implemented with several fully-connected layers) to project the extracted feature onto a unit sphere. $\\tau$ stands for the temperature, which is a hyper-parameter. Recall that the primitive goal of the discriminator in GANs can also be viewed as a bi-classification task, which is to recognize real and fake domains. In this work, we demonstrate that introducing the instance discrimination task can help enhance the discriminative power of the discriminator and in turn improve the synthesis quality of the generator significantly. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Generating Diverse Instances from Distinguishing Instances ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            629,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this part, we will introduce how instance discrimination is incorporated into the GAN training for data-efficient and diverse image generation. There are four essential components of our InsGen method: 1) distinguishing real images, 2) distinguishing fake images that can be sampled infinitely, 3) a noise perturbation strategy, and 4) a loop-back mechanism to encourage the generator for the diverse generation. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Distinguishing Real Images. As discussed above, the synthesis quality of GAN models not only depends on the training scheme [2, 30, 22, 4] and the architecture design of the generator [46, 23, 25], but more importantly relies on the discriminative capability of the discriminator. That is because the discriminator is the only one (compared to the generator) that can see how real data looks like and further guides the generator accordingly. To make the maximum use of the limited training data and avoid the discriminator from memorizing the entire dataset, we assign it with a more challenging task beyond domain classification, which is to recognize every independent instance from the dataset, as shown in Fig. 1a. For this purpose, we introduce a new task head $\\phi ^ { r } ( \\cdot )$ beyond the original bi-classification head $\\phi ^ { d o m a i n } ( \\cdot )$ on top of its backbone $d ( \\cdot )$ and train the discriminator with an extra training objective ",
+        "bbox": [
+            173,
+            510,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8aab07ff551bf5b5bab763426a04e981bbe1102d6e7103f91f095af85d5ec330.jpg",
+        "text": "$$\n\\mathcal { C } _ { D } ^ { r } = \\mathcal { C } _ { d ( \\cdot ) , \\phi ^ { r } ( \\cdot ) } ( \\mathcal { T } _ { q } ( \\mathbf { x } _ { q } ) , \\mathcal { T } _ { k _ { + } } ( \\mathbf { x } _ { q } ) , \\{ \\mathcal { T } _ { k _ { i } } ( \\mathbf { x } _ { k _ { i } } ) \\} _ { i = 1 } ^ { N } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            655,
+            668,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathbf { x } _ { q }$ , $\\{ \\mathbf { x } _ { k _ { i } } \\} _ { i = 1 } ^ { N }$ are all sampled from the real data distribution $\\mathcal { X }$ and transformed with various differentiable augmentations $\\tau ( \\cdot )$ . ",
+        "bbox": [
+            174,
+            685,
+            823,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Distinguishing Fake Images. However, the amount of training data could be extremely few (like thousands or even hundreds) in practice. In such a case, the improvement of the discriminator gained by differentiating real instances will be also limited. On the other hand, we notice that the number of synthesized samples can be sufficiently large due to the sampling mechanism of GANs. Ideally, different latent codes $\\mathbf { z } \\in { \\mathcal { Z } }$ should lead to different synthesis $G ( \\mathbf { z } )$ . Hence, we propose to also ask the discriminator to recognize every individual fake images, as shown in Fig. 1a. Similarly, we introduce another task head $\\bar { \\phi } ^ { f } ( \\cdot )$ into the discriminator. It is worth mentioning that we use separate task heads (i.e., $\\phi ^ { r } ( \\cdot )$ and $\\phi ^ { f } ( \\cdot ) )$ for real and fake data. That is because even though the synthesized images can be with high-quality, they still lie in a different distribution from the real ones, especially when the generator starts training from scratch. Meanwhile, the task of discriminating a real instance from a fake instance can be achieved by the native domain classification head $\\phi ^ { d o m a i n } ( \\cdot )$ . ",
+        "bbox": [
+            173,
+            719,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Noise Perturbation. Prior work has observed the continuity of the latent space [36] such that images synthesized from the latent codes within a neighbourhood are very close to each other. Accordingly, they are more suitable to be treated as positive pairs than negative pairs. From this perspective, we introduce a noise perturbation strategy into fake image discrimination. The objective becomes ",
+        "bbox": [
+            176,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f39dbf1918c4160c4408d25bc186b910ce85264d3b285f46ac5ca8c7c9835e5a.jpg",
+        "text": "$$\n\\mathbf { x } _ { q } ^ { \\prime } = { \\mathcal { T } } _ { q } ( G ( \\mathbf { z } _ { q } ) ) , \\quad \\mathbf { x } _ { k _ { + } } ^ { \\prime } = { \\mathcal { T } } _ { k _ { + } } ( G ( \\mathbf { z } _ { q } + \\epsilon ) ) , \\quad \\mathbf { x } _ { k _ { i } } ^ { \\prime } = { \\mathcal { T } } _ { k _ { i } } ( G ( \\mathbf { z } _ { k _ { i } } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            148,
+            718,
+            167
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18c0da3ed4ce3d6835985633e69a0b9a1891cb41d443aa2b4cdeefec06ae7209.jpg",
+        "text": "$$\n\\mathcal { C } _ { D } ^ { f } = \\mathcal { C } _ { d ( \\cdot ) , \\phi ^ { f } ( \\cdot ) } ( \\mathbf { x } _ { q } ^ { \\prime } , \\mathbf { x } _ { k _ { + } } ^ { \\prime } , \\{ \\mathbf { x } _ { k _ { i } } ^ { \\prime } \\} _ { i = 1 } ^ { N } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            170,
+            620,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Concretely, given a query image $\\mathbf { x } _ { q } ^ { \\prime }$ , the key image $\\mathbf { x } _ { k + } ^ { \\prime }$ is created with $\\mathcal { T } _ { k _ { + } } ( G ( \\mathbf { z } _ { q } + \\epsilon ) )$ instead of $T _ { k _ { + } } ( G ( \\mathbf { z } _ { q } ) )$ . Here, $\\epsilon$ stands for the perturbation term, which is sampled from a Gaussian distribution whose variance is sufficiently smaller than that of $\\mathcal { Z }$ , and $\\mathcal { T } _ { q } ( \\cdot )$ and $\\tau _ { k + } ( \\cdot )$ denote two different augmentations. Such design aims to enforce the discriminator invariant to the small perturbation, which makes the instance discrimination task more challenging. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Toward Diverse Generation. Besides utilizing the instance discrimination task to improve the discriminative power of the discriminator, we further design a loop-back mechanism to in turn use the learned instance discrimination to guide the generator. Recall that image diversity, in addition to image quality, is also an important metric to evaluate generative models. Diverse generation, which requires all generated samples to be distinguishable from each other, exactly matches our goal of instance discrimination. In other words, given a discriminator with the ability to distinguish different instances, we would like all the samples produced by the generator to be recognized as different ones. This idea is illustrated in Fig. 1b. By comparing Fig. 1a and Fig. 1b, we can see that the generator shares the same target as the discriminator yet is trained separately. Hence, the same objective function is added into the generator loss ",
+        "bbox": [
+            173,
+            270,
+            825,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/570c6b47cd83f158dc012b8e9a6e674ae1896decb92d2cd51425cdc533ead5f9.jpg",
+        "text": "$$\n\\mathbf { x } _ { k _ { + } } ^ { \\prime \\prime } = \\mathcal { T } _ { k _ { + } } ( G ( \\mathbf { z } _ { q } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            410,
+            566,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c52f5cf1779995da2a83b3cf251087920783da76902d20e61197240ad6ded63.jpg",
+        "text": "$$\n\\mathcal { C } _ { G } ^ { f } = \\mathcal { C } _ { d ( \\cdot ) , \\phi ^ { f } ( \\cdot ) } ( \\mathbf { x } _ { q } ^ { \\prime } , \\mathbf { x } _ { k _ { + } } ^ { \\prime \\prime } , \\{ \\mathbf { x } _ { k _ { i } } ^ { \\prime } \\} _ { i = 1 } ^ { N } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            431,
+            620,
+            452
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the only difference is that noise perturbation is not applied during the training of the generator. ",
+        "bbox": [
+            176,
+            453,
+            823,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Complete Objective Function. To summarize, with the purposes of both image synthesis and instance discrimination, the discriminator and the generator in InsGen are optimized with ",
+        "bbox": [
+            174,
+            473,
+            823,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/507b68eec6bfb77b680b3ca3019b36aae83418a65222b16407f5bc00204ae4e8.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\mathcal { L } _ { D } ^ { \\prime } = \\mathcal { L } _ { D } + \\lambda _ { D } ^ { r } \\mathcal { C } _ { D } ^ { r } + \\lambda _ { D } ^ { f } \\mathcal { C } _ { D } ^ { f } , } } \\\\ { { \\mathcal { L } _ { G } ^ { \\prime } = \\mathcal { L } _ { G } + \\lambda _ { G } \\mathcal { C } _ { G } ^ { f } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            502,
+            598,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { G } , \\lambda _ { D } ^ { r }$ , and $\\lambda _ { D } ^ { f }$ denote the weights for different terms. ",
+        "bbox": [
+            173,
+            547,
+            580,
+            564
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            578,
+            325,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On top of the adversarial training pipeline in GANs, our InsGen method only inserts an extra loss output on the discriminator network for instance discrimination.Therefore, it can be easily implemented on any GAN framework. In this part, we take the state-of-the-art GAN model, StyleGAN2-ADA [24], as an example to demonstrate how InsGen is implemented in practice. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generative Model. StyleGAN2-ADA [24] adopts the architecture of StyleGAN2 [25] and proposes the adaptive discriminator augmentation strategy for training with limited data. In particular, it designs a differentiable augmentation pipeline, consisting of 18 transformations, as well as an adaptive hyper-parameter to control the strength of these augmentations. For a fair comparison, in this work, we exactly reuse the network structure, the augmentation pipeline, the adaptive strategy of the augmenting strength, and other hyper-parameters like batch size and learning rate. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instance Discrimination. We reuse the backbone of the discriminator to perform instance discrimination, so that the extra computing load is extremely small and the training efficiency is barely affected. We treat the last fully-connected layer in the StyleGAN2-ADA discriminator as the domain-classification head $\\phi ^ { d o m a i n } \\dot { ( } \\cdot \\dot { } )$ , while all remaining layers serve as the backbone network $d ( \\cdot )$ . The real instance discrimination head $\\phi ^ { r } ( \\cdot )$ and the fake head $\\phi ^ { f } ( \\cdot )$ are both implemented with 2 fully-connected layers, followed by $\\ell _ { 2 }$ normalization. Strictly following MoCo-v2 [8], an extra queue is employed for each task head to store the sample features to save computational cost. The number of samples in $\\mathcal { L } _ { D } ^ { r }$ and $\\mathcal { L } _ { D } ^ { f }$ is thus equal to the queue size, which usually contains around $5 \\%$ data of the whole set. We also introduce the momentum encoder $D ^ { \\prime }$ , whose parameters are updated with moving average scheme: $\\Theta _ { D ^ { \\prime } }  \\alpha \\Theta _ { D ^ { \\prime } } + ( 1 - \\alpha ) \\Theta _ { D }$ . Here, $\\alpha = 0 . 9 9 9$ follows the same setting in MoCo-v2 [8]. The temperature $\\tau$ in Eq. (4) is set as 2. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/2011d05ddcf829efbc47c636accc46420b64b5d3bf99012c2f0bf39999671e37.jpg",
+        "table_caption": [
+            "Table 1: Performance on FFHQ. FID (lower is better) is reported as the evaluation metric. $2 K ^ { \\ast }$ , $\\cdot 1 0 K ^ { \\prime }$ , and $\" 1 4 0 K \"$ stand for the number of samples used for training, where $\\mathsf { \\Omega } ^ { \\bullet } 1 4 0 K ^ { \\prime } \\ '$ horizontally flips the original FFHQ dataset (with $7 0 K$ samples) to double the size of data. Results with $^ *$ are also achieved with horizontally flipped data, which are slightly better than those reported in [24]. Numbers in blue color indicate our improvements over the baseline [24]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>256×256 Resolution</td><td>2K</td><td>10K</td><td>140K</td></tr><tr><td>PA-GAN [44]</td><td>56.49</td><td>27.71</td><td>3.78</td></tr><tr><td>zCR [50]</td><td>71.61</td><td>23.02</td><td>3.45</td></tr><tr><td>Auxiliary rotation [6]</td><td>66.64</td><td>25.37</td><td>4.16</td></tr><tr><td>StyleGAN2 [23]</td><td>78.80</td><td>30.73</td><td>3.66</td></tr><tr><td>w/ Shallow mapping [24]</td><td>71.35</td><td>27.71</td><td>3.59</td></tr><tr><td>w/ Adaptive dropout [24]</td><td>67.23</td><td>23.33</td><td>4.16</td></tr><tr><td>w/DiffAugment [49]</td><td>24.32</td><td>7.86</td><td>1</td></tr><tr><td>w/ ADA [24]</td><td>15.60*</td><td>7.29*</td><td>3.88</td></tr><tr><td>InsGen (Ours)</td><td>11.92 (-3.68)</td><td>4.90 (−2.39)</td><td>3.31 (-0.57)</td></tr></table>",
+        "bbox": [
+            181,
+            165,
+            812,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            353,
+            312,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed InsGen method on multiple benchmarks. Sec. 4.1 presents the comparison to prior literature on both FFHQ [23] and AFHQ [9] datasets. Our InsGen substantially improves the baselines under multiple data-regime settings and outperforms previous data-augmentation approaches by a significant margin. Moreover, Sec. 4.2 provides a detailed ablation study to show the importance of each component. Lastly Sec. 4.3 discusses about the limitation of data-efficiency. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            305,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluate our InsGen with a number of other approaches on FFHQ [23] and AFHQ [9] datasets. FFHQ contains unique 70,000 high-resolution images $( 1 0 2 4 \\times 1 0 2 4 )$ , with large variation regarding age, ethnicity, and background. All images of FFHQ are well aligned [26] and cropped. In order to conduct a fair comparison, we resize images to $2 5 6 \\times 2 5 6$ . For the experiments of limited data, we follow ADA [24] to collect a subset of training data by randomly sampling. Moreover, AFHQ consists of around 5000 images per category for dogs, cats, and wild life at $5 1 2 \\times 5 1 2$ resolution. Each category is regarded as a dataset and thus we train a different network on each dataset. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training. We implement our InsGen on the official implementation of StyleGAN2-ADA. The training regularization is preserved, including path length regularization, lazy regularization, and style mixing regularization. Moreover, all parameters share the same learning rate and the minibatch standard deviation layer is adopted at the end of the discriminator. Exponential moving average of generator weights, non-saturating logistic loss with $R _ { 1 }$ regularization, and Adam optimizer [28] is also adopted. In particular, the coefficient of gradient penalty would be decreased correspondingly, according to the official implementation of ADA [24]. All the experiments are conducted on a server with 8 GPUs. Mixed-precision training is also used for faster training. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameters. Empirically, the loss weights $\\lambda _ { G }$ , $\\lambda _ { D } ^ { f }$ and $\\lambda _ { D } ^ { r }$ are 0.1, 1.0 and 1.0 respectively. Besides, the training length is slightly different. For the experiments with less than $1 0 K$ images, the total number of seen images is 10 million rather than 25 million adopted by ADA [24]. Meanwhile, we decrease the loss weight of the gradient penalty due to involving an extra supervision. For example, ADA [24] adopts 1.0 for original StyleGAN2 training while we use 0.8. We also found smaller loss weight of gradient penalty is beneficial to our InsGen on the less data, e.g., 0.3 and 0.5 for $1 0 K$ and $2 K$ experiments respectively. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metric. We use Fréchet Inception Distance (FID) [19] as the metric for quantitative comparison metric since FID tends to reflect the human perception of synthesis quality. As mentioned in Heusel et al. [19], we always calculate the FID between 50,000 fake images and all training images, no matter how much data the training set contains. The official pre-trained Inception network is used to compute the FID. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb180c7b26c337f1b7a172c651de11434c6d87dbb1dd03e0e9a7c2b673c37571.jpg",
+        "image_caption": [
+            "Figure 2: Generated images under various data regimes. The number of training images and the corresponding FID are reported. All images on FFHQ are synthesized with truncation following [24] while those on AFHQ are not. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            123,
+            820,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on FFHQ. Tab. 1 presents the comparison on FFHQ. Akin to ADA [24], we compare against PA-GAN [44], zCR [50] and auxiliary rotation [6]. Also, StyleGAN2 together with its variants is also introduced as the baseline methods. For instance, less data is usually required when a shallower mapping network is applied. Besides, dropout [37] is also well-studied to be replaced with the augmentations as the regularization. Note that ∗ means the dataset is amplified by $2 \\times$ via the horizontal flip, which is recommended in the official implementation of ADA [24]. Such that, $2 K ^ { , , }$ denotes 2,000 unique images and the dataset is enlarged to 4,000 via the flip operation, leading to a better baseline. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although ADA [24] has already improved the performance significantly under various low-data regimes, our InsGen continues to improve the low-data image generation by a clear margin, establishing a new state-of-the-art synthesis quality with limited training images. To be specific, our method improves the FID from 15.60 to 11.92, 7.29 to 4.90, and 3.88 to 3.31 with $2 K$ , $1 0 K$ and $7 0 K$ training images from FFHQ [23] respectively. Fig. 2 presents several generated examples under various data regimes. More qualitative results are available in our supplementary material. All images on FFHQ are generated with truncation. It is also worth noting that our approach further improves the synthesis quality when the full dataset is given, even outperforming previous best one i.e., zCR [50]. Namely, the data can be further exploited when it is not the bottleneck for training. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on AFHQ. We also evaluate our approach on AFHQ dataset [9] which is divided into cat, dog and wild life, with the number of 5153, 4739 and 4738 images respectively. Therefore, three models are trained on them individually. Note that all models on AFHQ are trained on $5 1 2 \\times 5 1 2$ images while the generated samples are resized to present. We involve StyleGAN2 [25], ContraD [20] and ADA [24] as the baseline approaches, compared to our InsGen. Quantitative and qualitative results are shown in Tab. 2 and Fig. 2 respectively. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The synthesis quality on those datasets is substantially improved by our method, which also outperforms previous data-augmentation methods. To be specific, our method improves the FID from 3.55 to 2.60, 7.40 to 5.44, and 3.05 to 1.77 on cat, dog and wild life images respectively. In particular, ContraD [20] introduced stronger augmentations to train a better discriminator via contrastive learning. One term in this method shares the similar motivation that real images could result in powerful representations. In terms of the use of synthesized samples, ContraD turned to focus on the binary classification, (i.e., real vs. fake) with some specific designs like the stop-gradient operation. Differently, our method leverages the generated images as a kind of data complement to produce a stronger representation and guide the learning of the generator. Accordingly, InsGen achieves the new state-of-the-art performances on AFHQ [9]. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b9bbf7db8b87c49666f1e8c2977bcad7dfac3f91828615107e64d948a143275d.jpg",
+        "table_caption": [
+            "Table 3: Ablation Study. FID (lower is better) is reported as the evaluation metric. Here, vanilla $\\mathcal { C } _ { D } ^ { f }$ means that the noise perturbation is not applied in the fake instance discrimination. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>CD</td><td>vanilla Cf</td><td>c</td><td>C</td><td>2K</td><td>10K</td><td>70K</td></tr><tr><td></td><td></td><td></td><td></td><td>15.60</td><td>7.29</td><td>3.76</td></tr><tr><td></td><td></td><td></td><td></td><td>14.15</td><td>5.98</td><td>3.56</td></tr><tr><td></td><td></td><td></td><td></td><td>13.46</td><td>5.68</td><td>3.67</td></tr><tr><td>νvv/</td><td>·</td><td>：</td><td></td><td>12.19</td><td>5.30</td><td>3.49</td></tr><tr><td></td><td>√</td><td></td><td>√</td><td>11.92</td><td>4.90</td><td>3.31</td></tr></table>",
+        "bbox": [
+            209,
+            127,
+            782,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            247,
+            826,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            316,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to investigate the importance of each component in our InsGen, we conduct an ablation study on FFHQ [23] with the image resolution of $2 5 6 \\times 2 5 6$ . FID serves as the main metric for the comparison, and the results on $2 K$ , $1 0 K$ and $7 0 K$ unique images are reported. During training each unique image go through random flip operation to obtain a stronger baseline. Tab. 3 presents the collection of various experiments in the ablation study. We choose the ADA [24] as the baseline. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How important is the instance discrimination? After performing the real image discrimination, the synthesis quality is improved, with the FID consistently decreased by -1.45, -1.31 and -0.20 in Tab. 3, no matter how many unique images the training set includes. To some extent, the discriminator would benefit from the powerful representations derived from the challenging pretext task. Accordingly, the generator is required to produce more photo-realistic images in order to confuse the discriminator. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When adding instance discrimination with fake images, performances could be further boosted. For instance, FID obtains an improvement of -0.69 and -0.30 with $2 K$ and $1 0 K$ images respectively. In particular, the gains rise as the number of real images goes down, verifying one of our motivations that the fake samples can be also regarded as data source for unsupervised representation learning. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How important is the noise perturbation? In Sec. 3.2, a noise perturbation strategy is proposed as a type of latent space augmentation for fake image discrimination. In particular, this latent space augmentation, i.e., the small movement in the latent space always leads to an obvious but semantically consistent change of the original image, which could not easily be implemented by some geometric and color transformations. Meanwhile, the discriminator is required to be invariant to such noise perturbation due to the goal of instance discrimination. Accordingly, the fake images are made best use of to result in stronger representations for the discrimination. As shown in Tab. 3, such strategy further brings consistent gains of -1.27, -0.38 and -0.18 on $2 K$ , $1 0 K$ and $7 0 K$ datasets respectively. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How important is the supervision signal for the generator? The last row of Tab. 3 shows the performances with the gradients which are back-propagated to the generator. Even if we have already obtained quite strong results, such a supervision signal on the generator could also introduce improvements under various data regimes. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The goal of instance discrimination is to distinguish every individual image according to its appearance cues [40]. Assuming this pretext task is well-performed on a fixed dataset, the semantic representation would be derived from this learning process. However, when distinguishing fake images, the fake dataset actually varies dynamically. Namely, we could accomplish this pretext task from the perspective of data, if the engine of this dynamical fake dataset, i.e., the generator could produce as many different images as possible. In general, this pretext task is exploited to encourage the diverse generation directly on the generator. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5cc4b470ceb0d3fd539a609aa8745e28508b1d4519572d7ab1d6c744fcd91e69.jpg",
+        "image_caption": [
+            "Figure 3: Effect of the number of synthesized and real images used for instance discrimination. FID (lower is better) in log-scale is reported as the evaluation metric. We can see the consistent performance gain along with the increasing number of instances for discrimination. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            823,
+            208
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/8784a8a0af0ed2b555c45f78ab9be11e4c6136556542d9bdacef1fb4095601c1.jpg",
+        "image_caption": [
+            "Figure 4: Training progress on FFHQ- $2 K$ . Larger value means that the image is more realistic under the view of the discriminator. Our discriminator can better and more stably differentiate real and fake data compared to ADA [24]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            279,
+            821,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "How important is the number of negative samples? We follow the MoCo-v2 [8] to store multiple features in a queue, in order to reduce the computational complexity. Empirically, the length of the feature queue tends to be the $5 \\%$ number of the dataset. Therefore, it is 200 when we have $2 K$ unique images and enlarge them via the flip operation. However, there is no any reference number for the synthesized data. Accordingly, we collect as the same amount of fake data as that of the real. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Sec. 3.2, there could be much more synthesized samples than the real samples. Namely, we could leverage infinite samples for the synthesized instance discrimination. Therefore, we investigate the effect of the different number of synthesized samples i.e., the length of the feature queue, shown in Fig. 3a. Obviously, FID gradually decreases with the increasing number of synthesized samples, suggesting that involving more fake images is of great benefit to the synthesis, especially with the limited training data. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Whether the discriminative ability of the discriminator is really enhanced. As is mentioned in our work, it is challenging to gain sufficient discriminative power for the discriminator to train the generator when the size of training set is small. However, introducing instance discrimination is able to improve its discriminative capability, achieving new state-of-the-art synthesis quality. In order to investigate whether the discriminative ability is improved, we plot the logits (derived from the discriminator) of any input image during the training in Fig. 4. To be specific, the logit denotes how much the input image is identified as the real. And the number of training images are 2000. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Obviously, our method produces higher real and lower fake scores throughout the whole training progress, compared to the baseline approach ADA [24]. It indicates that the discriminator of our method performs the domain bi-classification (i.e., real vs. fake) better than that of baseline, showing stronger discriminative ability. It also verifies our motivation that a challenging pretext task which is to distinguish every individual image could indeed enhance the discriminator. Besides, the training progress is much more stable when equipped with our approach. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Towards the Limit of Data-efficiency ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            857,
+            467,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although we have obtained the new state-of-the-art synthesis performances under the standard settings, we also wonder how much data-efficiency our InsGen could achieve. Therefore, the number of real data in the training set is further reduced to 1000, 500, 250 and 100. In order to conduct the apple-to-apple comparison, we remain to train the same model of StyleGAN2 without decreasing its generative capacity by using fewer channels or shallower mapping networks since such designs require less data. Meanwhile, the generated resolution remains $2 5 6 \\times 2 5 6$ and the datasets are amplified via the horizontal flip operation as well. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/88e0e79ed25fadd63ef45e5b134b7b7ab2a28613c32de7489b0e648f77e6ce0b.jpg",
+        "image_caption": [
+            "Figure 5: Qualitative results with different number of training images. The number of training images and the corresponding FID are reported. All images are synthesized with truncation following [24]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            821,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            352,
+            825,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The quantitative and qualitative results are shown in Fig. 3b and Fig. 5 respectively. Obviously, FID significantly increases with the decreasing number of training images from 70K to 100. Nevertheless, our InsGen trained with only 100 unique images remains to outperform many approaches like PA-GAN in Fig. 3b with 2K images. Besides, with 500 training samples, our method is able to obtain the competitive performance to those using $1 0 \\mathrm { k }$ images. Namely, our InsGen could improve the data-efficiency by more than $2 0 \\times$ . Qualitative results suggest that our approach still produces meaningful images without incurring the model collapse no matter how many training images exist in the data collection. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            539
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion and Discussion ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            426,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we develop a novel data-efficient Instance Generation (InsGen) method for training GANs with limited data. With the instance discrimination as an auxiliary task, our method makes the best use of both real and fake images to train the discriminator. In turn the discriminator is exploited to train the generator to synthesize as many diverse images as possible. Experiments under different data regimes show that InsGen brings a substantial improvement over the baseline in terms of both image quality and image diversity, and outperforms previous data augmentation algorithms by a large margin. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Although InsGen significantly improves the data efficiency in training generative models, it leaves some future work to do. One limitation of InsGen is that the performance gain becomes marginal when the training dataset is sufficiently large. This suggests that the discriminator can not benefit from the newly introduced instance discrimination any more. It may require a more challenging task to further improve the performance. Another limitation is that the FID score remains unsatisfying when the training data is extremely limited, say several hundred. It is worth exploring how to fully utilize the fake samples for discriminator training. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments. The project was supported through the Research Grants Council (RGC) of Hong Kong under ECS Grant No.24206219, GRF Grant No.14204521, CUHK FoE RSFS Grant. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            266,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] M. Arjovsky and L. Bottou. Towards principled methods for training generative adversarial networks. Int. Conf. Learn. Represent., 2017. 1 ",
+        "bbox": [
+            181,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[2] M. Arjovsky, S. Chintala, and L. Bottou. Wasserstein generative adversarial networks. In Int. Conf. Mach. Learn., 2017. 4   \n[3] P. Bachman, R. D. Hjelm, and W. Buchwalter. Learning representations by maximizing mutual information across views. In Adv. Neural Inform. Process. Syst., 2019. 2, 4   \n[4] A. Brock, J. Donahue, and K. Simonyan. Large scale gan training for high fidelity natural image synthesis. In Int. Conf. Learn. Represent., 2018. 1, 4   \n[5] M. Chen, A. Radford, R. Child, J. Wu, H. Jun, P. Dhariwal, D. Luan, and I. Sutskever. Generative pretraining from pixels. In Int. Conf. Mach. Learn., 2020. 2   \n[6] T. Chen, X. Zhai, M. Ritter, M. Lucic, and N. Houlsby. Self-supervised gans via auxiliary rotation loss. In IEEE Conf. Comput. Vis. Pattern Recog., 2019. 2, 6, 7   \n[7] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In Int. Conf. Mach. Learn., 2020. 2, 4   \n[8] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020. 5, 9   \n[9] Y. Choi, Y. Uh, J. Yoo, and J.-W. Ha. Stargan v2: Diverse image synthesis for multiple domains. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 6, 7, 8   \n[10] E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le. Autoaugment: Learning augmentation policies from data. In IEEE Conf. Comput. Vis. Pattern Recog., 2018. 1, 2   \n[11] E. D. Cubuk, B. Zoph, J. Shlens, and Q. V. Le. Randaugment: Practical automated data augmentation with a reduced search space. In IEEE Conf. Comput. Vis. Pattern Recog. Worksh., 2020. 1, 2   \n[12] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In IEEE Conf. Comput. Vis. Pattern Recog., 2009. 3   \n[13] C. Doersch, A. Gupta, and A. A. Efros. Unsupervised visual representation learning by context prediction. In Int. Conf. Comput. Vis., 2015. 2   \n[14] J. Donahue and K. Simonyan. Large scale adversarial representation learning. In Adv. Neural Inform. Process. Syst., 2019. 2   \n[15] S. Gidaris, P. Singh, and N. Komodakis. Unsupervised representation learning by predicting image rotations. In Int. Conf. Learn. Represent., 2018. 2   \n[16] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. In Adv. Neural Inform. Process. Syst., 2014. 1, 3   \n[17] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 2, 3, 4   \n[18] O. Henaff. Data-efficient image recognition with contrastive predictive coding. In Int. Conf. Mach. Learn., 2020. 2, 4   \n[19] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Adv. Neural Inform. Process. Syst., 2017. 6   \n[20] J. Jeong and J. Shin. Training gans with stronger augmentations via contrastive discriminator. In Int. Conf. Learn. Represent., 2021. 2, 7, 8   \n[21] M. Kang and J. Park. Contragan: Contrastive learning for conditional image generation. In Adv. Neural Inform. Process. Syst., 2020. 2   \n[22] T. Karras, T. Aila, S. Laine, and J. Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In Int. Conf. Learn. Represent., 2018. 1, 4   \n[23] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In IEEE Conf. Comput. Vis. Pattern Recog., 2019. 1, 2, 4, 6, 7, 8   \n[24] T. Karras, M. Aittala, J. Hellsten, S. Laine, J. Lehtinen, and T. Aila. Training generative adversarial networks with limited data. In Adv. Neural Inform. Process. Syst., 2020. 1, 2, 3, 5, 6, 7, 8, 9, 10   \n[25] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of StyleGAN. In IEEE Conf. Comput. Vis. Pattern Recog., 2020. 1, 4, 5, 7   \n[26] V. Kazemi and J. Sullivan. One millisecond face alignment with an ensemble of regression trees. In IEEE Conf. Comput. Vis. Pattern Recog., 2014. 6   \n[27] P. Khosla, P. Teterwak, C. Wang, A. Sarna, Y. Tian, P. Isola, A. Maschinot, C. Liu, and D. Krishnan. Supervised contrastive learning. In Adv. Neural Inform. Process. Syst., 2020. 2   \n[28] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Int. Conf. Learn. Represent., 2014. 6   \n[29] R. Liu, Y. Ge, C. L. Choi, X. Wang, and H. Li. Divco: Diverse conditional image synthesis via contrastive generative adversarial network. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   \n[30] T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. In Int. Conf. Learn. Represent., 2018. 4   \n[31] M. Noroozi and P. Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In Eur. Conf. Comput. Vis., 2016. 2   \n[32] A. v. d. Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. 2, 4   \n[33] T. Park, A. A. Efros, R. Zhang, and J.-Y. Zhu. Contrastive learning for unpaired image-to-image translation. In Eur. Conf. Comput. Vis., 2020. 2   \n[34] D. Pathak, P. Krahenbuhl, J. Donahue, T. Darrell, and A. A. Efros. Context encoders: Feature learning by inpainting. In IEEE Conf. Comput. Vis. Pattern Recog., 2016. 2   \n[35] D. Pathak, R. Girshick, P. Dollár, T. Darrell, and B. Hariharan. Learning features by watching objects move. In IEEE Conf. Comput. Vis. Pattern Recog., 2017. 2   \n[36] A. Radford, L. Metz, and S. Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In Int. Conf. Learn. Represent., 2016. 5   \n[37] N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 2014. 7   \n[38] N.-T. Tran, V.-H. Tran, N.-B. Nguyen, L. Yang, and N.-M. Cheung. Self-supervised gan: Analysis and improvement with multi-class minimax game. In Adv. Neural Inform. Process. Syst., 2019. 2   \n[39] N.-T. Tran, V.-H. Tran, N.-B. Nguyen, T.-K. Nguyen, and N.-M. Cheung. On data augmentation for gan training. IEEE Trans. Image Process., 2021. 1, 2, 3   \n[40] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance discrimination. In IEEE Conf. Comput. Vis. Pattern Recog., 2018. 2, 3, 4, 8   \n[41] Y. Xu, Y. Shen, J. Zhu, C. Yang, and B. Zhou. Generative hierarchical features from synthesizing images. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   \n[42] C. Yang, Z. Wu, B. Zhou, and S. Lin. Instance localization for self-supervised detection pretraining. In IEEE Conf. Comput. Vis. Pattern Recog., 2021. 2   \n[43] N. Yu, G. Liu, A. Dundar, A. Tao, B. Catanzaro, L. Davis, and M. Fritz. Dual contrastive loss and attention for gans. arXiv preprint arXiv:2103.16748, 2021. 2   \n[44] D. Zhang and A. Khoreva. Pa-gan: Improving gan training by progressive augmentation. In Adv. Neural Inform. Process. Syst., 2019. 1, 6, 7   \n[45] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization. In Int. Conf. Learn. Represent., 2017. 1, 2   \n[46] H. Zhang, I. Goodfellow, D. Metaxas, and A. Odena. Self-attention generative adversarial networks. In Int. Conf. Mach. Learn., 2019. 4   \n[47] H. Zhang, Z. Zhang, A. Odena, and H. Lee. Consistency regularization for generative adversarial networks. In Int. Conf. Learn. Represent., 2020. 2   \n[48] R. Zhang, P. Isola, and A. A. Efros. Colorful image colorization. In Eur. Conf. Comput. Vis., 2016. 2   \n[49] S. Zhao, Z. Liu, J. Lin, J.-Y. Zhu, and S. Han. Differentiable augmentation for data-efficient gan training. In Adv. Neural Inform. Process. Syst., 2020. 1, 2, 3, 6   \n[50] Z. Zhao, S. Singh, H. Lee, Z. Zhang, A. Odena, and H. Zhang. Improved consistency regularization for gans. In Assoc. Adv. Artif. Intell., 2020. 2, 6, 7   \n[51] Z. Zhao, Z. Zhang, T. Chen, S. Singh, and H. Zhang. Image augmentations for gan training. arXiv preprint arXiv:2006.02595, 2020. 1, 2, 3 ",
+        "bbox": [
+            171,
+            74,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            85,
+            830,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            92,
+            826,
+            189
+        ],
+        "page_idx": 12
+    }
+]

parse/train/PmVfnB0nkqr/PmVfnB0nkqr.md

@@ -0,0 +1,607 @@
+# AUTONOMOUS LEARNING OF OBJECT-CENTRIC ABSTRACTIONS FOR HIGH-LEVEL PLANNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a method for autonomously learning an object-centric representation of a continuous and high-dimensional environment that is suitable for planning. Such representations can immediately be transferred between tasks that share the same types of objects, resulting in agents that require fewer samples to learn a model of a new task. We first demonstrate our approach on a simple domain where the agent learns a compact, lifted representation that generalises across objects. We then apply it to a series of Minecraft tasks to learn object-centric representations, including object types—directly from pixel data—that can be leveraged to solve new tasks quickly. The resulting learned representations enable the use of a tasklevel planner, resulting in an agent capable of forming complex, long-term plans with considerably fewer environment interactions.1
+
+# 1 INTRODUCTION
+
+Model-based methods are a promising approach to improving sample efficiency in reinforcement learning. However, they require the agent to either learn a highly detailed model—which is infeasible for sufficiently complex problems (Ho et al., 2019)—or to build a compact, high-level model that abstracts away unimportant details while retaining only the information required to plan. This raises the question of how best to build such an abstract model. Fortunately, recent work has shown how to learn an abstraction of a task that is provably suitable for planning with a given set of skills (Konidaris et al., 2018). However, these representations are highly task-specific and must be relearned for any new task, or even any small change to an existing task. This makes them fatally impractical, especially for agents that must solve multiple complex tasks.
+
+We extend these methods by incorporating additional structure—namely, that the world consists of objects, and that similar objects are common amongst tasks. This can substantially improve learning efficiency, because an object-centric model can be reused wherever that same object appears (within the same task, or across different tasks) and can also be generalised across objects that behave similarly—object types. We assume that the agent is able to individuate the objects in its environment, and propose a framework for building portable object-centric abstractions given only the data collected by executing high-level skills. These abstractions specify both the abstract object attributes that support high-level planning, and an object-relative lifted transition model that can be instantiated in a new task. This reduces the number of samples required to learn a new task by allowing the agent to avoid relearning the dynamics of previously seen object types.
+
+We make the following contributions: under the assumption that the agent can individuate objects in its environment, we develop a framework for building portable, object-centric abstractions, and for estimating object types, given only the data collected by executing high-level skills. We also show how to integrate problem-specific information to instantiate these representations in a new task. This reduces the samples required to learn a new task by allowing the agent to avoid relearning the dynamics of previously-seen objects.
+
+We demonstrate our approach on a Blocks World domain, and then apply it to a series of Minecraft tasks where an agent autonomously learns an abstract representation of a high-dimensional task from raw pixel input. In particular, we use the probabilistic planning domain definition language (PPDDL) (Younes & Littman, 2004) to represent our learned abstraction, which allows for the use of existing task-level planners. Our results show that an agent can leverage these portable abstractions to learn a representation of new Minecraft tasks using a diminishing number of samples, allowing it to quickly construct plans consisting of hundreds of low-level actions.
+
+# 2 BACKGROUND
+
+We assume that tasks are modelled as semi-Markov decision processes ${ \mathcal { M } } = \langle { \mathcal { S } } , { \mathcal { O } } , { \mathcal { T } } , { \mathcal { R } } \rangle$ where (i) $s$ is the state space; (ii) $\mathcal { O } ( s )$ is the set of temporally-extended actions known as options available at state $s$ ; (iii) $\tau$ describes the transition dynamics, specifying the probability of arriving in state $s ^ { \prime }$ after option $o$ is executed from $s$ ; and (iv) $\mathcal { R }$ specifies the reward for reaching state $s ^ { \prime }$ after executing option $o$ in state $s$ . An option $o$ is defined by the tuple $\left. I _ { o } , \pi _ { o } ; \beta _ { o } \right.$ , where $I _ { o }$ is the initiation set that specifies the states in which the option can be executed, $\pi _ { o }$ is the option policy which specifies the action to execute, and $\beta _ { o }$ specifies the probability of the option terminating execution in each state (Sutton et al., 1999).
+
+We adopt the object-centric formulation from Ugur & Piater (2015): in a task with $n$ objects, the state is represented by the set $\left\{ \mathbf { f } _ { a } , \mathbf { f } _ { 1 } , \mathbf { f } _ { 2 } , \ldots . . . , \mathbf { f } _ { n } \right\}$ , where ${ \bf f } _ { a }$ is a vector of the agent’s features and $\mathbf { f } _ { i }$ is a vector of features particular to object $i$ . Note that the feature vector describing each object can itself be arbitrarily complex, such as an image or voxel grid—in this work we use pixels.
+
+Our state space representation assumes that individual objects have already been factored into their constituent low-level attributes. Practically, this means that the agent is aware that the world consists of objects, but is unaware of what the objects are, or if there are multiple instantiations of the same object present. It is also easy to see that different tasks will likely have differing numbers of objects with potentially arbitrary ordering; any learned abstract representation should be agnostic to this.
+
+# 2.1 STATE ABSTRACTIONS FOR PLANNING
+
+We intend to learn an abstract representation suitable for planning. Prior work has shown that a sound and complete abstract representation must necessarily be able to estimate the set of initiating and terminating states for each option (Konidaris et al., 2018). In classical planning, this corresponds to the precondition and effect of each high-level action operator (McDermott et al., 1998).
+
+The precondition is defined as ${ \mathrm { P r e } } ( o ) = { \mathrm { P r } } ( s \in I _ { o } )$ , which is a probabilistic classifier that expresses the probability that option $o$ can be executed at state $s$ . Similarly, the effect or image represents the distribution of states an agent may find itself in after executing $o$ from states drawn from distribution $Z$ (Konidaris et al., 2018): $\begin{array} { r } { \mathrm { I m } ( Z , o ) = \frac { 1 } { G } \int _ { \cal S } \mathrm { P r } ( s ^ { \prime } \mid s , \breve { o } ) Z ( s ) \mathrm { P r } ( s \in I _ { o } ) d s , } \end{array}$ , where $\begin{array} { r } { G = \int _ { \mathcal { S } } Z ( s ) \mathrm { P r } ( s \in I _ { o } ) } \end{array}$ . Since the precondition is a probabilistic classifier and the effect is a probabilistic density estimator, they can be learned directly from option execution data.
+
+We can use preconditions and effects to evaluate the probability of a sequence of options—a plan— executing successfully. Given an initial state distribution, the precondition is used to evaluate the probability that the first option can execute, and the effects are used to determine the resulting state distribution. We can apply the same logic to the subsequent options to compute the probability of the entire plan executing successfully. It follows that these representations are sufficient for evaluating the probability of successfully executing any plan (Konidaris et al., 2018).
+
+Partitioned Options For large or continuous state spaces, estimating $\operatorname* { P r } ( s ^ { \prime } \mid s , o )$ is difficult because the worst case requires learning a distribution conditioned on every state. However, if we assume that terminating states are independent of starting states, we can make the simplification $\operatorname* { P r } ( s ^ { \prime } \mid s , o ) = \operatorname* { P r } ( s ^ { \prime } \mid \mathbf { \bar { \phi } } o )$ . These subgoal options (Precup, 2000) are not overly restrictive, since they refer to options that drive an agent to some set of states with high reliability. Nonetheless, many options are not subgoal. It is often possible, however, to partition an option’s initiation set into a finite number of subsets, so that it is approximately subgoal when executed from any of the individual subsets. That is, we partition an option $o$ ’s start states into finite regions $\mathcal { C }$ such that $\operatorname* { P r } ( s ^ { \prime } \mid s , o , c ) \approx \operatorname* { P r } ( s ^ { \prime } \mid o , c ) , \bar { c } \in \mathcal { C }$ (Konidaris et al., 2018). As in prior work (Andersen $\&$ Konidaris, 2017; Konidaris et al., 2018; Ames et al., 2018), we achieve this in practice by clustering options based on their terminating states.
+
+Factors We adopt the frame assumption, which states that aspects of the world not explicitly affected by an agent’s action remain the same (Pasula et al., 2004). Prior work leverages this to learn a factored or STRIPS-like (Fikes & Nilsson, 1971) representation by computing the option’s mask: the state variables explicitly changed by the option (Konidaris et al., 2018). In our formulation, the state space is already factorised into objects, so computing the mask amounts to determining which objects are affected by a given option.
+
+# 3 LEARNING PORTABLE OBJECT-CENTRIC REPRESENTATIONS
+
+Although prior work (Konidaris et al., 2018) allows an agent to autonomously learn an abstract representation supporting fast task-level planning, that representation lacks generalisability—since the symbols are distributions over states in the current task, they cannot be reused in new ones. This approach can be fatally expensive in complex domains, where learning an abstract model may be as hard as solving a task from scratch, and is therefore pointless if we only want to solve a single task. However, an agent able to reuse aspects of its learned representation can amortise the cost of learning over many interactions, accelerating learning in later tasks. The key question is what forms of representation support transfer in this way.
+
+One approach is to assume that the world consists of objects, and that similar objects are shared across tasks. Approaches like object-oriented MDPs (Diuk et al., 2008) exploit the presence of objects by providing the agent with an object-oriented representation, resulting in compact representations that are transferable between tasks sharing the same object classes and dynamics (Guestrin et al., 2003; Diuk et al., 2008; Marom & Rosman, 2018). Similarly, the classical planning literature has long represented problems in terms of the objects that constitute a domain, and operators that can affect their states (McDermott et al., 1998). In both cases, however, the question arises as to the most appropriate way of building an object-oriented representation of a problem, especially one experienced by the agent at the pixel level. This includes deciding which attributes should be chosen to characterise a particular type, as well as which objects should belong to each type.
+
+We now introduce an object-centric generalisation of a learned symbolic representation that admits transfer in tasks when the state space representation consists of features centred on objects in the environment. This is common in robotics, where each object is often isolated from the environment and represented as a point cloud or subsequently a voxelised occupancy grid. We summarise our proposed approach in Figure 1 and the remainder of this section, and provide a detailed pseudocode description in Appendix F.
+
+![](images/711f27f1372f5c1df0f965a0a01940a9dff0dfa64b5db0a5ebd5106d1b48fcc9.jpg)  
+Figure 1: Learning lifted representations from data. Red nodes represent problem-specific representations, while green nodes are abstractions that can be transferred between tasks.
+
+3.1 GENERATING A PROPOSITIONAL MODEL (STEPS 1–2) (AS IN KONIDARIS ET AL., 2018)
+
+The agent begins by executing options using an exploration policy to collect transition data. The first step is to partition the options into approximately subgoal options. For each option $o$ and empirical sets of initial and terminating states $\mathit { \tilde { I } _ { o } }$ and $\tilde { \beta } _ { o }$ , the agent partitions $I _ { o }$ into subsets $K \subseteq \tilde { I } _ { o }$ such that $\mathrm { P r } ( s ^ { \prime } \mid s _ { i } , o ) = \mathrm { P r } ( s ^ { \prime } \mid s _ { j } , o ) \forall s _ { i }$ , $s _ { j } \in K , s ^ { \prime } \in \bar { \tilde { \beta } } _ { o }$ . In practice, this can be achieved by first clustering state transition samples based on terminating states, and then assigning each cluster to a partition. Finally, pairs of partitions whose initiating states overlap are merged to handle probabilistic effects.
+
+The agent next learns a precondition classifier for each approximately partitioned option. Partitions’ initiating states are used as positive examples, and all other states as negative ones. A feature selection procedure determines which objects are relevant to the precondition, and a classifier is fit using only those objects. A density estimator is then used to estimate the effect distribution for each partitioned option. The agent learns distributions over only the objects affected by the option, learning one estimator per object. Together these state distributions form our propositional PPDDL vocabulary $\nu$ .
+
+For each partitioned option $o$ , the agent has learned a precondition classifier $\hat { I _ { o } }$ and effect estimator $\hat { \beta } _ { o }$ . However, to construct a PPDDL representation, both the precondition and effects must be specified in terms of state distributions (propositions) only. Effects are modelled as such, and so pose no problem, but the learned precondition is a classifier rather than a state distribution. The agent must therefore iterate through all possible effect distributions to compute whether the skill can be executed there. This is achieved by replacing $o$ ’s precondition classifier with every ${ \mathcal { P } } \in { \mathcal { C } } ( \nu )$ such that $\begin{array} { r } { \int _ { \mathcal { S } } \hat { I } _ { o } ( s ) \mathcal { G } ( s ) d s > 0 , \mathcal { G } = \prod _ { p \in \mathcal { P } } p , } \end{array}$ , where $\wp ( \nu )$ denotes the powerset of $\nu$ . In other words, the agent considers every combination of effect state distributions and draws samples from their conjunction. If these samples are classified as positive by $\hat { I _ { o } }$ , then the conjunction $\mathcal { P }$ is used to represent the precondition. The preconditions and effects are now specified using distributions over state variables, where each distribution is a proposition. We have now learned a PPDDL representation, which is sound and suitable for planning.
+
+# 3.2 GENERATING A LIFTED, TYPED MODEL (STEPS 3–4)
+
+At this point, the agent has learned an abstract, but task-specific, representation. Unfortunately, there is no opportunity for transfer (both within the task and between different tasks), because each object is treated as unique. To overcome this, we now propose a method for determining object types.
+
+Definition 1. Assume that option $o$ has been partitioned into $n$ subgoal options $o ( 1 ) , \ldots , o ( n )$ . Object $i$ ’s profile under option $o$ is denoted by
+
+$$
+\begin{array} { r } { \mathrm { P r o f l l e } ( i , o ) = \big \{ \{ \mathrm { P r e } _ { i } ^ { o ( 1 ) } , \mathcal { E } _ { i } ^ { o ( 1 ) } \} , \dots , \{ \mathrm { P r e } _ { i } ^ { o ( n ) } , \mathcal { E } _ { i } ^ { o ( n ) } \} \big \} , } \end{array}
+$$
+
+where $\mathrm { P r e } _ { i } ^ { o ( k ) }$ is the distribution over object $i$ ’s states present in the precondition for partition $k$ , and $\mathcal { E } _ { i } ^ { o ( k ) }$ is object ’s effect distribution.2
+
+Definition 2. Two objects $i$ and $j$ are option-equivalent if, for a given option $o$ , Profile $( i , o ) =$ Profile $( j , o )$ . Furthermore, two objects are equivalent if they are option-equivalent for every $o$ in $\mathcal { O }$ .
+
+The above definition implies that objects are equivalent if one object can be substituted for another while preserving every operator’s abstract preconditions and effects. Such objects can be grouped into the same object type, since they are functionally indistinguishable for the purposes of planning. In practice, however, we can use a weaker condition to construct object types. Since an object-centric skill will usually modify only the object being acted upon, and because we have subgoal options that do not depend on the initial state, we can take a similar approach to Ugur & Piater (2015) and group objects by effects only:
+
+Definition 3. Assume that option $o$ has been partitioned into $n$ subgoal options. Object $i$ ’s effect profile under option $o$ is denoted by
+
+$$
+\begin{array} { r } { \operatorname { E f f e c t P r o f i l e } ( i , o ) = \{ \mathcal { E } _ { i } ^ { o ( 1 ) } , \dots , \mathcal { E } _ { i } ^ { o ( n ) } \} , } \end{array}
+$$
+
+where $\mathcal { E } _ { i } ^ { o ( k ) }$ is object $i$ ’s effect distribution. Two objects $i$ and $j$ are effect-equivalent if EffectProfile $( i , o ) = \mathrm { E f f e c t P r o f i l e } ( j , o )$ for every $o$ in $\mathcal { O }$ .
+
+By computing effect profiles using the propositional representation, the agent can determine whether objects $i$ and $j$ are similar (using an appropriate measure of distribution similarity) and, if so, merge them into the same object type. Propositions representing distributions over individual objects can now be replaced with predicates that are parameterised by types. For example, if there are four doors in a domain, then the agent can replace four propositions representing each door closed with a single ClosedDoor predicate parameterised by an object of type door.
+
+# 3.3 PROBLEM-SPECIFIC INSTANTIATION (STEP 5)
+
+If the task dynamics are completely described by the state of each object, as is the case in objectoriented MDPs (Diuk et al., 2008), then our typed representation is sufficient for planning. However, in many domains the object-centric state space is not Markov. For example, in a task where only a particular key opens a particular door, the state of the objects alone is insufficient to describe dynamics—the identities of the key and door are necessary too. A common strategy in this case is to augment an ego- or object-centric state space with problem-specific, allocentric information to preserve the Markov property (Konidaris et al., 2012; James et al., 2020). We denote $\mathcal { X }$ as the space of problem-specific state variables. $s$ remains the original object-centric state space. The above complication does not negate the benefit of learning transferable abstract representations, as our existing operators learned in $s$ can be augmented with propositions over $\mathcal { X }$ on a per-task basis. In general, local information relative to individual objects will transfer between tasks, but problem-specific information, such as an object’s global location, must be relearned each time.
+
+For each partitioned option $o$ with sets of start and end states $I _ { o } , \beta _ { o } \subseteq { \mathcal { S } } \times { \mathcal { X } }$ , the agent re-partitions $I _ { o }$ such that $\operatorname* { P r } ( x ^ { \prime } \mid x _ { i } , o ) = \operatorname* { P r } ( x ^ { \prime } \mid x _ { j } , o ) \forall x _ { i } , x _ { j } \in \kappa , ( \cdot , x ^ { \prime } ) \in \beta _ { o }$ for $\kappa \subseteq I _ { o }$ . This forms partitioned subgoal options in both $s$ and $\mathcal { X }$ . Denoting $\lambda \subseteq { \mathcal { X } }$ as the set of end states after re-partitioning, the agent can ground the operator by appending $\kappa$ to the precondition and $\lambda$ to the effect (if it differs from $\kappa$ ), where $\kappa$ and $\lambda$ are treated as problem-specific propositions. Finally, these problem-specific propositions must be linked with the grounded objects being acted upon. The agent therefore adds a precondition predicate conditioned on the identity of the grounded objects (see Appendix $\mathbf { G }$ for examples).
+
+# 4 EXPERIMENTS
+
+We first demonstrate our framework on the classic Blocks World domain (Section 4.1). While the high-level operators and predicates describing the domain are usually given, we show how such a representation can be learned autonomously from scratch. We then demonstrate that our method scales to significantly harder problems by applying it to a high-dimensional Minecraft task (Section 4.2). Finally, we investigate the transferability of the learned abstractions by transferring them to additional procedurally-generated Minecraft tasks (Section 4.3). Owing to space constraints, we defer the exact implementation and domain details to the appendix.
+
+# 4.1 LEARNING A REPRESENTATION OF BLOCKS WORLD
+
+The Blocks World domain consists of a number of blocks which can be stacked on top of one another by an agent (hand). The agent possesses options that allow it to pick up a block (Pick), put a block back on the table (Put), and stack one block on another (Stack). Blocks cannot be picked up if they are covered or if the hand is occupied, and can only be put down or stacked if already gripped. We consider the task consisting of three blocks A, B and C, where each block is described by whether there is nothing, another block, or a table directly above or below it. This representation allows us to determine whether a given block is on a table, on another block, or grasped in the hand, and similarly whether another block has been stacked upon it. The hand is characterised by a single boolean indicating whether it is holding a block. Thus a state is described by $\{ \mathbf { f } _ { H } , \mathbf { f } _ { A } , \mathbf { f } _ { B } , \mathbf { f } _ { C } \}$ , corresponding to the hand and blocks’ features respectively. Note that the agent is initially unaware that the blocks are functionally identical and can be treated interchangeably.
+
+Generating a Propositional Model (Steps 1–2) Using the approach outlined in Section 3.1, the agent partitions the options using transition data collected from the environment. This results in a total of 15 partitions of the Pick option, 3 partitions of the Put option, and 12 partitions of the Stack option.3 It then fits a classifier to each partition’s initiation states, and a density estimator to its terminating states. Finally, the agent generates a propositional PDDL using these learned preconditions and effects. Figure 2 illustrates a learned propositional operator, while the full PDDL, learned entirely from data, is provided in Appendix B.
+
+Generating a Lifted Typed Model (Steps 3–4) Using the effects from the propositional representation, the agent determines that objects A, B and C all possess the same effect profiles for all options and so can be grouped into a single type, while the hand belongs to its own type. The agent can now lift its representation by replacing the learned propositions with predicates parameterised by
+
+(:action Pick-partition-10   
+:parameters()   
+:precondition (and (symbol_10) (symbol_15) (symbol_6))   
+:effect (and (symbol_3) (symbol_4) (symbol_1) (not symbol_6) (not symbol_10) (not symbol_15))
+
+![](images/c8db93c0c19baa0d1a1efaa8cbf0e0df750cf383a58c18a44536bbb087fe948d.jpg)  
+Figure 2: The learned propositional operator for a Pick action describing picking B off C. In order to execute the action, the hand must be empty (symbol 10), C must be on the table and covered by a block (symbol 15), and B must be on top of a block and uncovered (symbol 6). After execution, B is in the hand (symbol 3), C is on the table and clear (symbol 4), and the hand is full (symbol 1). We visualise the symbols by sampling from the propositional symbol, and randomly sampling the remaining independent state variables (since each symbol is a distribution over a subset of state variables). The transparency is due to the averaging over the independent state variables. Note that we must learn one operator for every pair of blocks.
+
+(g) Propositional PDDL operator for one of the Pick option partitions.
+
+the above types. For example, after generating the model, there are three propositions: AOnTable, BOnTable, and COnTable. Since these are distributions over objects determined to be the same type, the agent can replace them all with a single predicate OnTable(X), which accepts block objects. As a result, the agent can reduce the number of operators from 30 to 6, resulting in a more compact representation with a smaller branching factor. Figure 3 illustrates how the propositional operator in Figure 2 has been lifted to describe picking any block X off any block Y.
+
+The number of learned operators is a function of the number of blocks in the domain. Since the propositional approach treats each block as its own unique object, it must learn the dynamics and interaction of each new block it encounters. For $n$ blocks, this requires $O ( n ^ { 2 } )$ operators. However, once the agent has learned the object types and constructed predicates based on these, it needs at most 6 operators to represent the dynamics for any number of blocks. See Appendix C for the full parameterised PDDL.
+
+![](images/2104918927c04c1deea0dd97d2189fe6c064bdea568a6f572ad4473e8b1a6e1a.jpg)  
+Figure 3: The learned lifted operator for a Pick action describing picking a block off another. In order to pick up block Y, it must be on block X which itself is on the table, and the hand must be empty. As a result, the hand is not empty, Y is now in the hand, and X is on the table and clear. $\tt t y p e 0$ refers to the “hand” type, while $\tt t y p e 1$ refers to the “block” type.
+
+# 4.2 LEARNING A REPRESENTATION OF A MINECRAFT TASK
+
+In the above example, objects were represented using pre-specified features and were sufficient to describe the environment dynamics. However, our approach is capable of scaling beyond this simple case and learning these features from pixels. We now demonstrate this in a complex Minecraft task (Johnson et al., 2016) consisting of five rooms with various items positioned throughout. Rooms are connected with either regular doors which can be opened by direct interaction, or puzzle doors which require the agent to pull a lever to open. The world is described by the state of each of the objects (given directly by each object’s appearance as a $6 0 0 \times 8 0 0$ RGB image), the agent’s view, and current inventory. To simplify learning, we compress the state space by downscaling images and applying PCA (Pearson, 1901) to a greyscaled version, preserving the top 40 principal components.
+
+The agent is given high-level skills, such as ToggleDoor and WalkToItem. Execution is stochastic—opening doors occasionally fails, and the navigation skills are noisy in their execution. To solve the task, an agent must first collect the pickaxe, use it to break the gold and redstone blocks and collect the resulting items. It must then navigate to the crafting table, where it uses the collected items to first craft gold ingots and subsequently a clock. Finally, it must navigate to the chest and open it to complete the task. This requires a long-horizon, hierarchical plan—the shortest plan that solves the task consists of 28 options consisting of hundreds of low-level continuous actions.
+
+Generating a Propositional Model (Steps 1–2) As previously, the agent begins by learning a model using the method outlined in Section 3.1 and in prior work (Konidaris et al., 2018; Ames et al., 2018). The agent partitions options using DBSCAN (Ester et al., 1996) to cluster option data based on terminating states. For each partitioned option, it then fits an SVM (Cortes & Vapnik, 1995) with Platt scaling (Platt, 1999) to estimate the preconditions, and a kernel density estimator (Rosenblatt, 1956) for effects, which are then used to construct the propositional PPDDL.
+
+Generating a Lifted, Typed Model (Steps 3–4) Using the effects from the propositional representation, the agent next groups objects into types based on their effect profiles. This is made easier because certain objects do not undergo effects under certain options. For example, the chest cannot be toggled, while a door can, and thus it is immediately clear that they are not of the same type. Having determined the types, the agent replaces all similar propositions (where similarity is measured using the KL-divergence) with a single predicate parameterised by an object of that type.
+
+Problem-Specific Instantiation (Step 5) The agent now has a representation whose operators can be transferred between tasks. However, unlike Blocks World, a complication arises because the object-centric state space is not Markov. For example, a state where all the doors are closed and the agent is in front of the first door is indistinguishable from a state where the agent is in front of the second door. As described in Section 3.3, the agent must ground the representations in the current task by incorporating additional problem-specific state variables to preserve the Markov property. These state variables are fixed across the family of MDPs; in this case, they are the agent’s $x y z$ -location.
+
+For each partitioned option, the agent again uses DBSCAN to cluster end states $\mathcal { X }$ to form partitioned subgoal options in both $s$ and $\mathcal { X }$ . Each of these clusters in $\mathcal { X }$ is a problem-specific proposition, which can be added to the learned operators to ground the problem. In Figure 4, we illustrate a learned operator for opening a particular door, where the problem-specific symbol has been tied to the door being opened in this manner. Without modifying the operator’s parameter, it would be possible to open any door at that location. The final plan discovered by the agent is illustrated by Figure 5.
+
+# 4.3 INTER-TASK TRANSFER IN MINECRAFT
+
+We next investigate transferring operators between five procedurally-generated tasks, where each task differs in the location of the objects and doors; the agent cannot thus simply use a plan found in one task to solve another. For a given task, the agent transfers all operators learned from previous tasks, and continues to collect samples using uniform random exploration until it produces a model which predicts that the optimal plan can be executed. Figure 6a shows the operators transferred between tasks, while Figure 6b shows the number of interactions required to learn a model in a new task.
+
+The minimum number of samples required to learn a model for a new task is bounded by the exploration strategy, since we must discover all problem-specific symbols to complete the model. Figure 6b shows that the number of samples required to learn a model decreases over time towards this lower bound. Inter-task transfer could be further improved by leveraging the agent’s existing knowledge to perform non-uniform exploration, but we leave this to future work.
+
+(:action Toggle-Door-partition-1a   
+:parameters (?w - type0 ?x - type1)   
+:precondition (and (notfailed) (symbol_37 ?w) (symbol_9 ?x) (= (id ?x) 1) (psymbol_24))   
+:effect (and (symbol_64 ?x) (symbol_65 ?w) (not (symbol_9 ?x)) (not (symbol_37 ?w)))
+
+![](images/240699fa61105df2860e130bbb1cfd1daa84668f87a7f0bb35eb6c005f9f37c5.jpg)  
+Figure 4: Our approach learns that, in order to open a particular door, the agent must be standing in front of a closed door (symbol 37) at a particular location (psymbol 24), and the door must be closed (symbol 9). The effect of the skill is that the agent finds itself in front of an open door (symbol 64) and the door is open (symbol 65). type0 and type1 refer to the “agent” and “door” classes, while id is a fluent specifying the identity of the grounded door object, and is linked to the problem-specific symbol underlined in red.
+
+(f) A learned typed PDDL operator for one partition of the Toggle-Door option. The predicates underlined in red must be relearned for each new task, while the rest of the operator can be safely transferred.
+
+![](images/2ed0d525ed1f0da681fbf89028b1185161449290a8035e59f5485718de6c5609.jpg)  
+Figure 5: Path traced by the agent executing different options while solving the first task.
+
+(a) Orange bars represent the number of operators that must be learned to produce a sufficiently accurate model to solve the task. Blue bars represent the number of operators transferred between tasks. As the number of tasks increases, the number of new operators that must be learned decreases.
+
+![](images/ca1f78bb09615989cf38423a8b652bf8cc019d5f3b7efc525a7b2a3202499218.jpg)  
+(b) Number of samples required to learn sufficiently accurate models as a function of the number of tasks encountered. The red line represents the number of samples required to learn all the operators and the instantiation, while the green line accounts for the instantiation phase only.
+
+Figure 6: Results of learning and transferring high-level abstractions between tasks. We report the mean and standard deviation averaged over 80 runs with random task orderings.
+
+# 5 RELATED WORK AND CONCLUSION
+
+There has been work autonomously learning parameterised, transferable representations of skills. Ugur & Piater (2015) learn object-centric PDDL representations for robotic object manipulation tasks. They are able to learn object types which are similar to ours directly from data, but the object features are specified prior to learning, and discrete relations between object properties such as width and height are given. Similarly, certain predicates are manually inserted to generate a sound representation. Asai (2019) learns object-centric abstractions directly from pixels, but it is unclear how to extend the approach to the stochastic setting. Furthermore, the representations lack soundness guarantees, and cannot be transformed into a language that can be used by existing task-level planners. Finney et al. (2002), Pasula et al. (2004) and Zettlemoyer et al. (2005) are able to learn operators that transfer across tasks, but the high-level symbols that constitute the state space are given. James et al. (2020) learn a PPDDL representation for planning using agent-relative and problem-specific data, but the operators are not lifted and there is no notion of objects or types, which limit generalisability.
+
+Alternatively, object-oriented MDPs (Diuk et al., 2008) specify the state space as a set of objects belonging to classes with associated attributes. The agent must learn the transition dynamics, which are usually restricted to a small number of effects. We show how to learn an object-centric representation along with the object types, as well as the abstract high-level dynamics model.
+
+By contrast, we have shown how to learn the vocabulary and the type system and the model from raw sensory input. Our representations are useful for planning, generalise across objects and can be transferred to new tasks. Although we have injected structure by assuming the existence of objects, this reflects the nature of many environments: fields such as computer vision assume that the world consists of objects, while there is evidence to suggest that infants do the same (Spelke, 1990). This assumption allows us to convert complex, high-dimensional environments to abstract representations that serve as input to task-level planners. Our approach provides an avenue for solving sparse-reward, long-term planning problems—such as the MineRL competition (Guss et al., 2019)—currently beyond the reach of model-free approaches.
+
+# REFERENCES
+
+B. Ames, A. Thackston, and G.D. Konidaris. Learning symbolic representations for planning with parameterized skills. In Proceedings of the 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2018.   
+G. Andersen and G.D. Konidaris. Active exploration for learning symbolic representations. In Advances in Neural Information Processing Systems, pp. 5016–5026, 2017.   
+Masataro Asai. Unsupervised grounding of plannable first-order logic representation from images. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 29, pp. 583–591, 2019.   
+C. Cortes and V. Vapnik. Support-vector networks. Machine Learning, 20(3):273–297, 1995.   
+C. Diuk, A. Cohen, and M.L. Littman. An object-oriented representation for efficient reinforcement learning. In Proceedings of the 25th International Conference on Machine Learning, pp. 240–247, 2008.   
+M. Ester, H. Kriegel, J. Sander, and X. Xu. A density-based algorithm for discovering clusters in large spatial databases with noise. In 2nd International Conference on Knowledge Discovery and Data Mining, volume 96, pp. 226–231, 1996.   
+R.E. Fikes and N.J. Nilsson. STRIPS: A new approach to the application of theorem proving to problem solving. Artificial Intelligence, 2(3-4):189–208, 1971.   
+S. Finney, N.H. Gardiol, L.P. Kaelbling, and T. Oates. The thing that we tried didn’t work very well: deictic representation in reinforcement learning. In Proceedings of the Eighteenth Conference on Uncertainty in Artificial Intelligence, pp. 154–161, 2002.   
+C. Guestrin, D. Koller, C. Gearhart, and N. Kanodia. Generalizing plans to new environments in relational MDPs. In Proceedings of the 18th International Joint Conference on Artificial Intelligence, pp. 1003–1010. Morgan Kaufmann Publishers Inc., 2003.   
+W. Guss, C. Codel, K. Hofmann, B. Houghton, N. Kuno, S. Milani, S. Mohanty, D. Liebana, R. Salakhutdinov, N. Topin, et al. The MineRL competition on sample efficient reinforcement learning using human priors. arXiv preprint arXiv:1904.10079, 2019.   
+Mark K Ho, David Abel, Thomas L Griffiths, and Michael L Littman. The value of abstraction. Current Opinion in Behavioral Sciences, 29:111–116, 2019.   
+S. James, B. Rosman, and G.D. Konidaris. Learning to plan with portable symbols. In International Conference on Machine Learning, 2020.   
+M. Johnson, K. Hofmann, T. Hutton, and D. Bignell. The Malmo platform for artificial intelligence experimentation. In Proceedings of the 25th International Joint Conference on Artificial Intelligence, pp. 4246–4247, 2016.   
+G.D. Konidaris, I. Scheidwasser, and A.G. Barto. Transfer in reinforcement learning via shared features. Journal of Machine Learning Research, 13(May):1333–1371, 2012.   
+G.D. Konidaris, L.P. Kaelbling, and T. Lozano-Perez. From skills to symbols: Learning symbolic ´ representations for abstract high-level planning. Journal of Artificial Intelligence Research, 61 (January):215–289, 2018.   
+O. Marom and B. Rosman. Zero-shot transfer with deictic object-oriented representation in reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2297–2305, 2018.   
+D. McDermott, M. Ghallab, A. Howe, C. Knoblock, A. Ram, M. Veloso, D. Weld, and D. Wilkins. PDDL—the planning domain definition language, 1998.   
+H. Pasula, L.S. Zettlemoyer, and L.P. Kaelbling. Learning probabilistic relational planning rules. In Proceedings of the Fourteenth International Conference on Automated Planning and Scheduling, pp. 73–81, 2004.   
+K. Pearson. On lines and planes of closest fit to systems of points in space. The London, Edinburgh, and Dublin Philosophical Magazine and Journal of Science, 2(11):559–572, 1901.   
+J. Platt. Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods. Advances in Large Margin Classifiers, 10(3):61–74, 1999.   
+D. Precup. Temporal abstraction in reinforcement learning. PhD thesis, University of Massachusetts Amherst, 2000.   
+N. Rosenblatt. Remarks on some nonparametric estimates of a density function. The Annals of Mathematical Statistics, pp. 832–837, 1956.   
+E. Spelke. Principles of object perception. Cognitive Science, 14(1):29–56, 1990.   
+R.S. Sutton, D. Precup, and S. Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1-2):181–211, 1999.   
+E. Ugur and J. Piater. Bottom-up learning of object categories, action effects and logical rules: from continuous manipulative exploration to symbolic planning. In Proceedings of the 2015 IEEE International Conference on Robotics and Automation, pp. 2627–2633, 2015.   
+H.L.S. Younes and M.L. Littman. PPDDL 1.0: An extension to PDDL for expressing planning domains with probabilistic effects. Technical report, 2004.   
+L.S. Zettlemoyer, H. Pasula, and L.P. Kaelbling. Learning planning rules in noisy stochastic worlds. In Proceedings of the Twentieth National Conference on Artificial Intelligence, pp. 911–918, 2005.
+
+# A ENUMERATING SUBGOAL OPTIONS FOR THE BLOCKS WORLD DOMAIN
+
+Given the description of the Blocks World domain in the main text, we must partition the given options (Pick, Put and Stack) so that they adhere to the subgoal condition. When there are three blocks in the environment, we see that there are 30 partitioned options, which are described in the table below
+
+Table 1: Descriptions of the different option partitions. The description of start and end states includes only the relevant information.   
+
+<table><tr><td>Option</td><td># partitions</td><td>Description of start states</td><td>Description of end states</td></tr><tr><td>PickOffTable(X)</td><td>3</td><td>X is on the table, X is clear, and the hand is empty.</td><td>X is grasped in the hand.</td></tr><tr><td>PickOffSingleBlock(X，Y)6</td><td></td><td>X is on block Y which is on the table,X is clear,and the hand is empty.</td><td>X is grasped in the hand and Y is clear and on the table.</td></tr><tr><td>PickOffDoubleBlock(X，Y)6</td><td></td><td>X is on block Y which is on another block, X is clear, and the hand is empty.</td><td>X is grasped in the hand and Y is clear and on another block.</td></tr><tr><td>StackOnSingleBlock(X，Y）6</td><td></td><td>X is in the hand, and Y is clear and on the table.</td><td>X is on block Y which is on the table,and the hand is empty.</td></tr><tr><td>StackOnDoubleBlock(X，Y）6</td><td></td><td>X is in the hand,and Y is clear and on an- other block.</td><td>Xis on block Y which is on another block,and the hand is</td></tr><tr><td>Put (X)</td><td>3</td><td>X is grasped in the hand.</td><td>empty. X is on the table and the hand is empty.</td></tr></table>
+
+# B PROPOSITIONAL PDDL DESCRIPTION FOR THE BLOCKS WORLD TASK
+
+Below is the automatically generated propositional PDDL description of the Blocks World domain with 3 blocks. In practice, the agent generates this description with arbitrary names for the propositions, but for readability purposes we have manually renamed them to match their semantics.
+
+(define (domain BlocksWorld) (:requirements :strips) (:predicates (notfailed) (AInHand) (HandFull) (COnBlock) (BInHand) (COnTable) (AOnTable) (BOnBlock) (AOnBlock) (BOnTable) (CInHand) (HandEmpty) (BOnTable_BCovered) (COnBlock_CCovered) (AOnBlock_ACovered) (BOnBlock_BCovered) (COnTable_CCovered) (AOnTable_ACovered)
+
+(:action Pick_0   
+:parameters() :precondition (and (HandEmpty) (AOnTable) (notfailed))   
+:effect (and (AInHand) (HandFull) (not AOnTable) (not HandEmpty) (not AOnTable) (not HandEmpty))   
+)   
+(:action Pick_1 :parameters() :precondition (and (HandEmpty) (AOnBlock) (COnBlock_CCovered) (notfailed))   
+:effect (and (COnBlock) (AInHand) (HandFull) (not AOnBlock) (not HandEmpty) (not COnBlock_CCovered) (not AOnBlock) (not HandEmpty) (not COnBlock_CCovered))   
+)   
+(:action Pick_2 :parameters() :precondition (and (HandEmpty) (COnTable_CCovered) (BOnBlock) (notfailed)) :effect (and (BInHand) (COnTable) (HandFull) (not BOnBlock) (not HandEmpty) (not COnTable_CCovered) (not BOnBlock) (not HandEmpty) (not COnTable_CCovered))   
+)   
+(:action Pick_3 :parameters()   
+:precondition (and (HandEmpty) (AOnTable_ACovered) (BOnBlock) (notfailed)) :effect (and (BInHand) (AOnTable) (HandFull) (not BOnBlock) (not HandEmpty) (not AOnTable_ACovered) (not BOnBlock) (not HandEmpty) (not AOnTable_ACovered))   
+)   
+(:action Pick_4 :parameters() :precondition (and (HandEmpty) (AOnBlock) (BOnBlock_BCovered) (notfailed)) :effect (and (BOnBlock) (AInHand) (HandFull) (not AOnBlock) (not HandEmpty) (not BOnBlock_BCovered) (not AOnBlock) (not HandEmpty) (not BOnBlock_BCovered))   
+)   
+(:action Pick_5 :parameters() :precondition (and (HandEmpty) (AOnBlock_ACovered) (BOnBlock) (notfailed))   
+:effect (and (BInHand) (AOnBlock) (HandFull) (not BOnBlock) (not HandEmpty) (not AOnBlock_ACovered) (not BOnBlock) (not HandEmpty) (not AOnBlock_ACovered))   
+)   
+(:action Pick_6   
+:parameters() :precondition (and (HandEmpty) (AOnBlock) (BOnTable_BCovered) (notfailed))   
+:effect (and (BOnTable) (AInHand) (HandFull) (not AOnBlock) (not HandEmpty) (not BOnTable_BCovered) (not AOnBlock) (not HandEmpty) (not BOnTable_BCovered))   
+)   
+(:action Pick_7 :parameters() :precondition (and (HandEmpty) (BOnTable) (notfailed)) :effect (and (BInHand) (HandFull) (not BOnTable) (not HandEmpty) (not BOnTable) (not HandEmpty))   
+)   
+(:action Pick_8 :parameters()   
+:precondition (and (HandEmpty) (COnTable) (notfailed)) :effect (and (CInHand) (HandFull) (not COnTable) (not HandEmpty) (not COnTable) (not HandEmpty))   
+)   
+(:action Pick_9 :parameters() :precondition (and (HandEmpty) (AOnTable_ACovered) (COnBlock) (notfailed))   
+:effect (and (CInHand) (AOnTable) (HandFull) (not COnBlock) (not HandEmpty) (not AOnTable_ACovered) (not COnBlock) (not HandEmpty) (not AOnTable_ACovered))   
+)   
+(:action Pick_10 :parameters() :precondition (and (HandEmpty) (AOnBlock) (COnTable_CCovered) (notfailed)) :effect (and (COnTable) (AInHand) (HandFull) (not AOnBlock) (not HandEmpty) (not COnTable_CCovered) (not AOnBlock) (not HandEmpty) (not COnTable_CCovered))   
+)   
+(:action Pick_11 :parameters() :precondition (and (HandEmpty) (AOnBlock_ACovered) (COnBlock) (notfailed))   
+:effect (and (CInHand) (AOnBlock) (HandFull) (not COnBlock) (not HandEmpty) (not AOnBlock_ACovered) (not COnBlock) (not HandEmpty) (not AOnBlock_ACovered))   
+)   
+(:action Pick_12 :parameters() :precondition (and (HandEmpty) (COnBlock) (BOnTable_BCovered) (notfailed)) :effect (and (BOnTable) (CInHand) (HandFull) (not COnBlock) (not HandEmpty) (not BOnTable_BCovered) (not COnBlock) (not HandEmpty) (not BOnTable_BCovered))   
+)   
+(:action Pick_13   
+:parameters() :precondition (and (HandEmpty) (COnBlock_CCovered) (BOnBlock) (notfailed))   
+:effect (and (BInHand) (COnBlock) (HandFull) (not BOnBlock) (not HandEmpty) (not COnBlock_CCovered) (not BOnBlock) (not HandEmpty) (not COnBlock_CCovered))   
+)   
+(:action Pick_14 :parameters() :precondition (and (HandEmpty) (COnBlock) (BOnBlock_BCovered) (notfailed))   
+:effect (and (BOnBlock) (CInHand) (HandFull) (not COnBlock) (not HandEmpty) (not BOnBlock_BCovered) (not COnBlock) (not HandEmpty) (not BOnBlock_BCovered))   
+)   
+(:action Put_15   
+:parameters() :precondition (and (HandFull) (AInHand) (notfailed)) :effect (and (AOnTable) (HandEmpty) (not AInHand) (not HandFull) (not AInHand) (not HandFull))   
+)   
+(:action Put_16 :parameters() :precondition (and (HandFull) (BInHand) (notfailed)) :effect (and (BOnTable) (HandEmpty) (not HandFull) (not BInHand) (not HandFull) (not BInHand))   
+)   
+(:action Put_17 :parameters() :precondition (and (HandFull) (CInHand) (notfailed)) :effect (and (COnTable) (HandEmpty) (not HandFull) (not CInHand) (not HandFull) (not CInHand))   
+)   
+(:action Stack_18 :parameters()   
+:precondition (and (HandFull) (CInHand) (BOnTable) (notfailed)) :effect (and (BOnTable_BCovered) (COnBlock) (HandEmpty) (not HandFull) (not BOnTable) (not CInHand) (not HandFull) (not BOnTable) (not CInHand))   
+)   
+(:action Stack_19 :parameters() :precondition (and (HandFull) (COnBlock) (BInHand) (notfailed))   
+:effect (and (BOnBlock) (COnBlock_CCovered) (HandEmpty) (not HandFull) (not COnBlock) (not BInHand) (not HandFull) (not COnBlock) (not BInHand))   
+)   
+(:action Stack_20   
+:parameters()   
+:precondition (and (HandFull) (AOnBlock) (BInHand) (notfailed)) :effect (and (BOnBlock) (AOnBlock_ACovered) (HandEmpty) (not HandFull) (not BInHand) (not AOnBlock) (not HandFull) (not BInHand) (not AOnBlock))   
+)   
+(:action Stack_21 :parameters() :precondition (and (HandFull) (AInHand) (BOnTable) (notfailed)) :effect (and (BOnTable_BCovered) (AOnBlock) (HandEmpty) (not AInHand) (not HandFull) (not BOnTable) (not AInHand) (not HandFull) (not BOnTable))   
+)   
+(:action Stack_22 :parameters()   
+:precondition (and (HandFull) (CInHand) (BOnBlock) (notfailed)) :effect (and (BOnBlock_BCovered) (COnBlock) (HandEmpty) (not HandFull) (not BOnBlock) (not CInHand) (not HandFull) (not BOnBlock) (not CInHand))   
+)   
+(:action Stack_23 :parameters()   
+:precondition (and (HandFull) (COnTable) (BInHand) (notfailed)) :effect (and (BOnBlock) (COnTable_CCovered) (HandEmpty) (not HandFull) (not BInHand) (not COnTable) (not HandFull) (not BInHand) (not COnTable))   
+)   
+(:action Stack_24 :parameters() :precondition (and (HandFull) (AInHand) (COnBlock) (notfailed)) :effect (and (COnBlock_CCovered) (AOnBlock) (HandEmpty) (not AInHand) (not HandFull) (not COnBlock) (not AInHand) (not HandFull) (not COnBlock))   
+)   
+(:action Stack_25 :parameters() :precondition (and (HandFull) (AOnTable) (CInHand) (notfailed)) :effect (and (COnBlock) (AOnTable_ACovered) (HandEmpty) (not HandFull) (not AOnTable) (not CInHand) (not HandFull) (not AOnTable) (not CInHand))   
+)   
+(:action Stack_26 :parameters() :precondition (and (HandFull) (AInHand) (COnTable) (notfailed)) :effect (and (COnTable_CCovered) (AOnBlock) (HandEmpty) (not AInHand) (not HandFull) (not COnTable) (not AInHand) (not HandFull) (not COnTable))   
+)   
+(:action Stack_27 :parameters() :precondition (and (HandFull) (AOnBlock) (CInHand) (notfailed)) :effect (and (COnBlock) (AOnBlock_ACovered) (HandEmpty) (not HandFull) (not AOnBlock) (not CInHand) (not HandFull) (not AOnBlock) (not CInHand))   
+)   
+(:action Stack_28 :parameters() :precondition (and (HandFull) (AOnTable) (BInHand) (notfailed)) :effect (and (BOnBlock) (AOnTable_ACovered) (HandEmpty) (not HandFull) (not BInHand) (not AOnTable) (not HandFull) (not BInHand) (not AOnTable))   
+)   
+(:action Stack_29 :parameters() :precondition (and (HandFull) (AInHand) (BOnBlock) (notfailed)) :effect (and (BOnBlock_BCovered) (AOnBlock) (HandEmpty) (not AInHand) (not HandFull) (not BOnBlock) (not AInHand) (not HandFull) (not BOnBlock))   
+)
+
+# C LIFTED PDDL DESCRIPTION FOR THE BLOCKS WORLD TASK
+
+In contrast, the lifted representation learned below is far more compact. Here, operators are parameterised by objects, which allows for better generalisation across instances with varying numbers of blocks. Figure 7 shows how the number of partitioned options (and hence number of preconditions and effects) scales with the number of objects in the domain.
+
+![](images/46439a3976ef5e6ac4680effd8cd0c276d95309ac36dcf11dc08f647e5d6481d.jpg)  
+Figure 7: The number of learned action operators as a function of the number of blocks in the domain. Since the propositional approach treats each block as its own, unique object, it must learn the dynamics and interaction of each new block it encounters. For $n$ blocks, this requires $O ( n ^ { 2 } )$ operators. However, if we learn the object types and construct predicates based on these, then we need at most 6 operators to represent the dynamics for any number of blocks.
+
+Below we provide the learned representation for the domain. Again, we manually rename the predicates and types to help with readability.
+
+(define (domain BlocksWorld) (:requirements :strips :typing) (:types hand block) (:predicates (BlockInHand ?w - block) (HandFull ?w - hand) (BlockOnBlock ?w - block) (BlockOnTable ?w - block) (HandEmpty ?w - hand) (BlockOnTable_BlockCovered ?w - block) (BlockOnBlock_BlockCovered ?w - block) (notfailed) ) (:action Pick-partition-0 :parameters (?w - hand ?x - block) :precondition (and (notfailed) (HandEmpty ?w) (BlockOnTable ?x)) :effect (and (BlockInHand ?x) (HandFull ?w) (not (BlockOnTable ?x)) (not (HandEmpty ?w))) ) (:action Pick-partition-1 :parameters (?w - hand ?x - block ?y - block) :precondition (and (notfailed) (HandEmpty ?w) (BlockOnBlock ?x) (BlockOnBlock_BlockCovered ?y)) :effect (and (BlockOnBlock ?y) (BlockInHand ?x) (HandFull ?w) (not (BlockOnBlock ?x)) (not (HandEmpty ?w)) (not (BlockOnBlock_BlockCovered ?y))) ) (:action Pick-partition-10 :parameters (?w - hand ?x - block ?y - block)
+
+:precondition (and (notfailed) (HandEmpty ?w) (BlockOnTable_BlockCovered ?x) (BlockOnBlock ?y)) :effect (and (BlockInHand ?y) (BlockOnTable ?x) (HandFull ?w) (not (BlockOnBlock ?y)) (not (HandEmpty ?w)) (not (BlockOnTable_BlockCovered ?x)))   
+)   
+(:action Put-partition-0   
+:parameters (?w - hand ?x - block)   
+:precondition (and (notfailed) (HandFull ?w) (BlockInHand ?x))   
+:effect (and (BlockOnTable ?x) (HandEmpty ?w) (not (BlockInHand ?x)) (not (HandFull ?w)))   
+(:action Stack-partition-0   
+:parameters (?w - hand ?x - block ?y - block)   
+:precondition (and (notfailed) (HandFull ?w) (BlockInHand ?x) (BlockOnTable ?y))   
+:effect (and (BlockOnTable_BlockCovered ?y) (BlockOnBlock ?x) (HandEmpty ?w) (not (HandFull ?w)) (not (BlockOnTable ?y)) (not (BlockInHand ?x)))   
+)   
+(:action Stack-partition-1   
+:parameters (?w - hand ?x - block ?y - block)   
+:precondition (and (notfailed) (HandFull ?w) (BlockOnBlock ?x) (BlockInHand ?y))   
+:effect (and (BlockOnBlock ?y) (BlockOnBlock_BlockCovered ?x) (HandEmpty ?w) (not (HandFull ?w)) (not (BlockOnBlock ?x)) (not (BlockInHand ?y)))   
+)
+
+)
+
+A task might then be specified as follows:
+
+(define (problem stack) (:domain BlocksWorld) (:objects hand - Hand A B C - Block ) (:init (BlockOnTable A) (BlockOnTable B) (BlockOnTable C) (HandEmpty hand) (notfailed) ) (:goal (and (BlockOnBlock A) (BlockOnBlock_BlockCovered C) (BlockOnTable_BlockCovered B)))
+
+# D MINECRAFT TASK DETAILS
+
+Our Minecraft tasks are procedurally generated, consisting of five rooms with various items positioned throughout. Rooms are connected with either regular doors which can be opened by direct interaction, or puzzle doors which require the agent to pull a lever to open. The world is described by the state of each of the objects (given directly by each object’s appearance as a $6 0 0 \times 8 0 0$ RGB image), the agent’s view, and current inventory. Figure 8 illustrates the state of each object in the world at the beginning of one of the tasks.
+
+![](images/ebb0667ba9114b879f36f6e60eb320ca73add30531e24f4bf78c49978a63ca7f.jpg)  
+Figure 8: The state of each object in the world at the start of the task. From left to right, the images represent the agent’s point of view, the four doors, the pickaxe, the chest, and the redstone and gold blocks. The inventory is not shown here.
+
+The agent is provided with the following high-level skills:
+
+(i) WalkToItem—the agent will approach an item if it is in the same room. (ii) AttackBlock—the agent will break a block, provided it is near the block and holding the pickaxe. (iii) PickupItem—the agent will collect the item if it is standing in front of it. (iv) WalkToNorthDoor—the agent will approach the northern door in the current room. (v) WalkToSouthDoor—the agent will approach the southern door in the current room. (vi) WalkThroughDoor—the agent will walk through a door to the next room, provided the door is open. (vii) CraftItem—the agent will create a new item from ingredients in its inventory, provided it is near the crafting table. (viii) OpenChest—the agent will open the chest, provided it is standing in front of it and possesses the clock. (ix) ToggleDoor—the agent will open or close the door directly in front of it.
+
+Execution is stochastic—opening doors occasionally fails, and the navigation skills are noisy in their execution.
+
+# E LEARNING A PORTABLE REPRESENTATION FOR MINECRAFT
+
+In this section, we describe the exact details for learning a representation of a Minecraft task.   
+Pseudocode for the approach (independent of the domain) is provided in Section F.
+
+In order to learn a high-level representation, we first apply a series preprocessing steps to reduce the dimensionality of the state space. We downscale images to $1 6 0 \times 1 2 0$ and then convert the resulting images to greyscale. We apply principal component analysis (Pearson, 1901) to a batch of images collected from the different tasks and keep the top 40 principal components. This allows us to represent each object (except the inventory, which is a one-hot encoded vector of length 5) as a vector of length 40.
+
+Partitioning We collect data from a task by executing options uniformly at random. We record state transition data as well as, for each state, which options could be executed. We then partition options using the DBSCAN clustering algorithm (Ester et al., 1996) to cluster the terminating states of each option into separate effects. This approximately preserves the subgoal property, as described in Section 2 and previous work (Andersen & Konidaris, 2017; Konidaris et al., 2018; Ames et al., 2018). For each pair of partitioned options, we check whether their is significant overlap in their initiating states (again using DBSCAN). If the initiating states overlap significantly, the partitions are merged to account for probabilistic effects.
+
+Preconditions Next, the agent learns a precondition classifier for each of these approximately partitioned options using an SVM (Cortes & Vapnik, 1995) with Platt scaling (Platt, 1999). We use states initially collected as negative examples, and data from the actual transitions as positive examples. We employ a simple feature selection procedure to determine which objects are relevant to the option’s precondition. We first compute the accuracy of the SVM applied to the object the option operates on, performing a grid search to find the best hyperparameters for the SVM using 3-fold cross validation. Then, for every other object in the environment, we compute the SVM’s accuracy when that object’s features are added to the SVM. Any object that increases the SVM accuracy is kept. Pseudocode for this procedure is outline in Figure 9.
+
+Having determined the relevant objects, we fit a probabilistic SVM to the relevant objects’ data. Note that we learn a single SVM for a given precondition. Thus if the precondition includes two objects, then the SVM will learn a classifier over both objects’ features jointly.
+
+1: procedure FEATURESELECTION   
+2: Given: affected objects Mask , positive start states $p$ , negative start states $n$ , set of objects $\mathcal { M }$   
+3: $\triangleright$ Fit a classifier over only objects in the mask   
+4: classifier $\gets$ FITCLASSIFIER(start, negative, mask)   
+5: initScore $\gets$ classifier .score   
+6: $K e e p  \emptyset$   
+7: for each object $\in \mathcal { M } \setminus M a s k \ : .$ do   
+8: classifier FITCLASSIFIER(start, negative, Mask ∪ {object})   
+9: newScore $\gets$ classifier .score   
+10: if newScore $>$ initScore then   
+11: $\triangleright$ Keep the object if it improves the score   
+12: $K e e p \gets K e e p \cup \{ o b j e c t \}$   
+13: end if   
+14: end for   
+15: return Mask ∪ Keep   
+16: end procedure
+
+Effects A kernel density estimator (KDE) (Rosenblatt, 1956) with Gaussian kernel is used to estimate the effect of each partitioned option. We learn distributions over only the objects affected by the option, learning one KDE for each object. We use a grid search with 3-fold cross validation to find the best bandwidth hyperparameter for each estimator. We fit a single KDE to each object separately, since the state space has already been factored into these objects. Each of these KDEs is an abstract symbol in our propositional PDDL representation.
+
+Propositional PDDL For each partitioned option, we now have a classifier and set of effect distributions (propositions). However, to generate the PDDL, the precondition must be specified in terms of these propositions. We use the same approach as Konidaris et al. (2018) to generate the PDDL: for all combinations of valid effect distributions, we test whether data sampled from their conjunction is evaluated positively by our classifiers. If they are, then that combination of distributions serves as the precondition of the high-level operator. This procedure is described in Figure 10.
+
+1: procedure BUILDPPDDLOPERATOR   
+2: Given: precondition classifier classifier , current effect effect, all effects Effects   
+3: Operators $\gets \emptyset$   
+4: Symbols $ \emptyset$   
+5: for each candidate $\in \wp ( E f f e c t s )$ do . For all possible effect combinations   
+6: samples ← SAMPLE(candidate) $\triangleright$ Sample from the distributions   
+7: prob ← PREDICT(classifier , sample) $\triangleright$ Query the classifier with the data   
+8: if prob $, > 0$ then   
+9: if $p r o b = 1$ then   
+10: $\triangleright$ Construct the new operator with the existing effects   
+11: operator $\mathbf { \beta } \cdot \gets \{ c a n d i d a t e , e f f e c t \}$   
+12: else   
+13: $\triangleright$ Add a probabilistic failure case   
+14: $\begin{array} { r l } & { n e w E f f e c t  \{ \begin{array} { l l } { \pounds \mathrm { a i } 1 , \mathrm { w i t h ~ p r o b a b i l i t y ~ } ( 1 - p r o b ) } \\ { e f f e c t , \mathrm { w i t h ~ p r o b a b i l i t y ~ } p r o b } \end{array}  } \\ & { o p e r a t o r  \{ c a n d i d a t e , n e w E f f e c t \} } \end{array}$   
+15:   
+16: end if   
+17: Operators Operators ∪ {operator}   
+18: $\ 5 y m b o l s \gets S y m b o l s \cup \{ c a n d i d a t e \} \cup \{ e f f e c t \}$   
+19: end if   
+20: end for   
+21: return Operators, Symbols   
+22: end procedure
+
+Type Inference To determine the type of each object, we first assume that they all belong to their own type. For each object, we compute its effect profile by extracting the effect propositions that occur under each option. Figure 11 illustrates this process.
+
+For each pair of objects, we then determine whether the effect profiles are similar. This task is made easier because certain objects do not undergo effects with certain options. For example, the gold block cannot be toggled, while a door can. Thus it is easy to see that they are not of the same type. To determine whether two distributions are similar, we simply check whether the KL-divergence is less than a certain threshold. Having determined the types, we can simply replace all similar propositions with a predicate parameterised by an object of that type, as described by Figure 12.
+
+1: procedure COMPUTEEFFECTS   
+2: Given: object $i$ , option $o$ , PPDDL operators Operators   
+3: $\triangleright$ Get only the operators that model option $o$   
+4: Operators $ \{$ {operator | ∀operator $\in$ Operators, REFERSTO(operator , o)}   
+5: $E f f e c t s \gets \emptyset$   
+6: for each $\left\{ \cdot , e f f e c t \right\} \in$ Operators do   
+7: $\triangleright$ Extract the effect propositions that refer to distributions over object $i$   
+8: Opera $t o r E f f e c t \gets \{ p r o p \ | \ \forall p r o p \in \ e f f e c t , \mathbf { R E F E R S T O } ( p r o p , i ) \}$   
+9: Effects ← Effects ∪ {OperatorEffect}   
+10: end for   
+11: return Effects   
+12: end procedure   
+1: procedure MERGE   
+2: Given: objects $\mathcal { M }$ , type $T$ , PPDDL operators Operators, propositions Propositions   
+3: $\triangleright$ Find the first object matching the type   
+4: archetype $\gets \emptyset$   
+5: for each object $\in \mathcal { M }$ do   
+6: if ISTYPE(object, $T$ ) then   
+7: archetype $\gets$ object   
+8: break   
+9: end if   
+10: end for   
+11: $\triangleright$ Remove propositions with objects of type $T$ that are not the archetype   
+12: $R e m o v e d \gets \{ p r o p \ | \ \forall p r o p \in $ Propositions, ISTYPE(prop, T ),   
+¬REFERSTO(prop, archetype)}   
+13: $\triangleright$ Keep operators that do not contain the removed propositions   
+14: Operators $ \{ o p \mid \forall o p \in ($ Operators, Removed ${ \bar { \cap } } { \bar { o p } } = \emptyset \}$   
+15: return Operators, Propositions \ Removed   
+16: end procedure
+
+Problem-Specific Instantiation Finally, we again use DBSCAN to partition our subgoal options, but this time using problem-specific state variables. Each of these clusters is then added to our representation as a problem-specific proposition. To ground the operators, we add the start and end clusters (problem-specific propositions) to the precondition and effects of the PPDDL operator. We also record the grounded object that appears in the parameter list of each operator, and add a precondition predicate (fluent) to ensure that only those particular objects can be modified. Without this final step, the agent would, for example, believe it can open any door while standing in front of a door at a particular location. We have thus linked the particular door to a particular location in the domain.
+
+# F PSEUDOCODE
+
+Below we present pseudocode describing our approach to building a typed, object-centric PPDDL representation for an arbitrary domain. Some subroutines used in the pseudocode below are outlined in the previous section.
+
+1: procedure LEARNREPRESENTATION   
+2: Given: $T$ state-option transitions $\mathcal { D } = \{ ( s _ { i } , x _ { i } , o _ { i } , s _ { i } ^ { \prime } , x _ { i } ^ { \prime } ) \ | \ 0 \leq i \leq T \}$ , set of objects $\mathcal { M }$   
+3: $\triangleright$ Partition options into subgoal options   
+4: SubgoalOptions ← ∅   
+5: for each $o \in \mathcal { O }$ do   
+6: $\begin{array} { r l } & { I  \{ s \mid ( s , \cdot , o , \cdot , \cdot ) \in \mathcal { D } \} } \\ & { \beta  \{ s ^ { \prime } \mid ( \cdot , \cdot , o , s ^ { \prime } , \cdot ) \in \mathcal { D } \} } \end{array}$ . Set of initial states for option $o$   
+7: . Set of terminating states for option $o$   
+8: for all $K \subseteq I$ such that $\mathrm { P r } ( s ^ { \prime } \mid s _ { i } , o ) = \mathrm { P r } ( s ^ { \prime } \mid s _ { j } , o ) \forall s _ { i } , s _ { j } \in I , s ^ { \prime } \in \beta$ do   
+9: $P  \{ o , K , \{ s ^ { \prime } \mid \forall s \in K , ( s , \cdot , o , s ^ { \prime } , \cdot ) \in \mathcal { D } \} \} \triangleright \mathrm { S t }$ art and end states for a partition   
+10: SubgoalOptions $\gets$ SubgoalOptions $\cup \left\{ P \right\}$   
+11: end for   
+12: end for   
+13: $\triangleright$ Estimate preconditions and effects   
+14: Preconditions, $E f f e c t s \gets \emptyset$   
+15: for each $\{ \cdot$ ·, start, end} ∈ SubgoalOptions do   
+16: mask ← COMPUTEMASK(start, end) . List the objects that change state   
+17: negative $ S$ \ start   
+18: features $\gets$ FEATURESELECTION(mask, start, negative)   
+19: classifier FITCLASSIFIER(start, negative, features)   
+20: Preconditions Preconditions ∪ {classifier}   
+21: estimator $\gets$ FITESTIMATOR(mask, end) $\triangleright$ Fit over only objects that change   
+22: $E f f e c t s \gets E f f e c t s \cup \{ e s t i m a t o r \}$   
+23: end for   
+24: . Build propositional PPDDL   
+25: Operators, Propositions ← ∅   
+26: for each precondition, effect $\in$ (Preconditions × Effects) do   
+27: op, symbols $\gets$ BUILDPPDDLOPERATOR(precondition, effect, Effects)   
+28: Operators $\gets$ Operators ∪ {op}   
+29: Propositions $\gets$ Propositions ∪ symbols   
+30: end for   
+31: $\triangleright$ Infer object types   
+32: $E J \overline { { f P r o f i l e  \emptyset } }$   
+33: for each object $m$ do   
+34: for each $o \in \mathcal { O }$ do   
+35: $\mathit { E f f P r o f i l e } ( m , o ) \gets \mathrm { C O M P U T E E F E C T S } ( m , o , O p e r a t o r s )$   
+36: end for   
+37: end for   
+38: $T y p e s \gets \{ K \mid E f f P r o f l e ( m _ { i } , o ) \approx E f f P r o f l e ( m _ { j } , o ) \forall o \in \mathcal { O } , m _ { i } , m _ { j } \in K , K \subseteq \mathcal { M } \}$   
+39: $\triangleright$ Generate typed PPDDL   
+40: TypedOperators, Predicates ← ∅   
+41: for each type $\in$ Types do   
+42: $\triangleright$ Replace propositions and operators over objects of same type with lifted versions   
+43: ops, predicates ← MERGE( $\mathcal { M }$ , type, Operators, Propositions)   
+44: TypedOperators TypedOperators ∪ ops   
+45: Predicates Predicates $\cup$ predicates   
+46: end for   
+47: $\triangleright$ Instantiate typed PPDDL in new task   
+48: for each $\left\{ o , s t a r t , e n d \right\} \in S u b g o a l O p t$ ions do   
+49: $I _ { \mathcal { X } }  \{ x \mid \forall s \in s t a r t$ , $s ^ { \prime } \in e n d$ , $( s , x , o , s ^ { \prime } , \cdot ) \in \mathcal { D } \}$   
+50: βX ← {x0 | ∀s ∈ start, $s ^ { \prime } \in e n d , x \in I _ { \mathcal { X } } , ( s , x , o , s ^ { \prime } , x ^ { \prime } ) \in \mathcal { D } \}$   
+51: for all $\kappa \subseteq I x$ such that $\mathrm { P r } ( x ^ { \prime } \mid x _ { i } , o ) = \mathrm { P r } ( x ^ { \prime } \mid x _ { j } , o ) \forall x _ { i } , x$ xj ∈ IX , x0 ∈ βX do   
+52: $\lambda  \{ x ^ { \prime } \mid \forall s \in s t a r t$ , $s ^ { \prime } \in e n d , x \in \kappa , ( s , x , o , s ^ { \prime } , x ^ { \prime } ) \in \mathcal { D } \}$   
+53: $P r e d i c a t e s \gets P r e d i c a t e s \cup \{ \kappa \} \cup \{ \lambda \}$ $\triangleright$ Add problem-specific symbols   
+54: mask ← COMPUTEMASK(start, end) $\triangleright$ Computes the affected objects   
+55: $\triangleright$ Link problem-specific symbols in precondition and effect to the affected objects   
+56: TypedOperators $\gets$ GROUND(TypedOperators, κ, λ, mask)   
+57: end for   
+58: end for   
+59: return TypedOperators, Predicates   
+60: end procedure
+
+# G VISUALISING OPERATORS FOR MINECRAFT
+
+Here we illustrate some learned operators for the Minecraft tasks. To see all predicates and operators, please see the following URL: https://sites.google.com/view/mine-pddl.
+
+(:action Open-Chest-partition-0   
+:parameters (?w - type0 ?x - type6 ?y - type9)   
+:precondition (and (notfailed) (symbol_13 ?w) (symbol_4 ?x) (symbol_55 ?y) (psymbol_8))   
+:effect (and (symbol_58 ?x) (symbol_59 ?w) (not (symbol_4 ?x)) (not (symbol_13 ?w)))   
+)
+
+![](images/c87fd614ba647d3a868ea91ebdd730f198d2e7340583671e0747d1a32b364714.jpg)  
+Figure 13: Our approach learns that, in order to open a chest, the agent must be standing in front of a chest (symbol 13), the chest must be closed (symbol 4), the inventory must contain a clock (symbol 55) and the agent must be standing at a certain location (psymbol 8). The result is that the agent finds itself in front of an open chest (symbol 58) and the chest is open (symbol 59). $\tt t y p e 0$ refers to the “agent” type, type6 the “chest” type and type9 the “inventory” type.
+
+(g) A learned typed PDDL operator for the Open-Chest skill. The predicate underlined in red indicates a problem-specific symbol that must be relearned for each new task, while the rest of the operator can be safely transferred.
+
+(:action Walk-to-partition-0-2a   
+:parameters (?w - type0)   
+:precondition (and (notfailed) (symbol_46 ?w) (psymbol_0))   
+:effect (and (symbol_11 ?w) (psymbol_1) (not (symbol_46 ?w)) (not (psymbol_0)))   
+)
+
+(e) Typed PDDL operator for a partition of the $W \mathrm { a l k - T o }$ option. The predicate underlined in red indicates a problem-specific symbol that must be relearned for each new task, while the rest of the operator can be safely transferred.
+
+![](images/1a99282af4d92d58786677c8550ff1c448b20356912a5983f8f7188b3c09f326.jpg)  
+Figure 14: Abstract operator that models the agent walking to the crafting table. In order to do so, the agent must be standing in the middle of a room (symbol 46) at a particular location (psymbol 0). As a result, the agent finds itself in front of the crafting table (symbol 1) at a particular location (psymbol 1).
+
+![](images/01a68dd17b9f57504d874e23e12b08ecd49603c6106079d7f47c1060e419bfae.jpg)  
+Figure 15: Abstract operator that models the agent walking through a door. In order to do so, the agent must be standing in front of an open door (symbol 38) at a particular location (psymbol 24), and the door must be open (symbol 64). As a result, the agent finds itself in the middle of a room (symbol 50) at a particular location (psymbol 12).
+
+(:action Through-Door-partition-3-207a   
+:parameters (?w - type0 ?x - type1)   
+:precondition (and (notfailed) (symbol_38 ?w) (symbol_64 ?x) (= (id ?x) 1) (psymbol_24))   
+:effect (and (symbol_50 ?w) (not (symbol_38 ?w)) (psymbol_12) (not (psymbol_24)))
+
+(f) Typed PDDL operator for a partition of the Through-Door option. The predicate underlined in red indicates a problem-specific symbol that must be relearned for each new task, while the rest of the operator can be safely transferred.
+
+(:action Attack-partition-0-76a   
+:parameters (?w - type0 ?x - type7)   
+:precondition (and (notfailed) (symbol_15 ?w) (symbol_2 ?x) (psymbol_17))   
+:effect (and (symbol_19 ?x) (symbol_20 ?w) (not (symbol_2 ?x)) (not (symbol_15 ?w)))
+
+![](images/8c6fbed2a4ce9554b091628238da81c9f117f165f3dc8e26cb7946cbddd980ae.jpg)  
+Figure 16: Abstract operator that models the agent attacking an object. In order to do so, the agent must be standing in front of a gold block (symbol 15) at a particular location (psymbol 17), and the gold block must be whole (symbol 2). As a result, the agent finds itself in front of a disintegrated block (symbol 20), and the gold block is disintegrated (symbol 19).
+
+(f) Typed PDDL operator for a partition of the Attack option. The predicate underlined in red indicates a problem-specific symbol that must be relearned for each new task, while the rest of the operator can be safely transferred.
+
+# H EXAMPLES OF FAILURE CASES
+
+Below are some examples of errors that occur when constructing our abstract representation. Since there are several phases involving clustering, classification and density estimation, we can expect various learning errors to occur throughout. These errors could have numerous causes, such as insufficient data or suboptimal hyperparameters.
+
+# H.1 PARTITIONING ERRORS
+
+![](images/82db4cdef35db13973f5034c90eb37f4eed85ee7f2b15f4411261862459cff8b.jpg)
+
+![](images/d5dc97fc9f9a90b7c84ce216bdfd4cc4a4b760043431ef6db2c05c8c752040be.jpg)
+
+(a) Set of start states for one partition of the Attack option.
+
+(b) Set of end states for one partition of the Attack option.
+
+![](images/166887bf459d523781417b3ca618a01dd8a4cf180fd7d675dc732c1ed12f75b2.jpg)
+
+![](images/f17b784bc21ab7c7340852e858927163de2d3448ef853f7c3e134c6b4f5df9cd.jpg)  
+(d) Set of end states for another partition of the Attack option.
+
+(c) Set of start states for another partition of the Attack option.
+
+Figure 17: In the above example, the partitioning procedure has generated two partitioned options for breaking the gold block, where there should only be one. They are functionally equivalent, but because of the strange shadows on the left of the image patch and the subsequent PCA representation, the clustering algorithm has produced one extra partition.
+
+![](images/690d1566a90c790edf84d9e568af6b8e6d1d54be6c4cc616b12973e34d2b1f81.jpg)
+
+![](images/82904bcef3c251e92d377f89370357221ecaab20eeb6b10f6d030e603c22dd70.jpg)
+
+(a) Set of start states for one partition of the ToggleDoor option.
+
+(b) Set of end states for one partition of the ToggleDoor option.
+
+![](images/ae7a6370cb6ee2d6ee0528c47e0210888b1b4a285c58aeba60e49f5ecd610dfe.jpg)
+
+![](images/10e81726cdab9580200674cee2a1b8e09d5bd56ed23529bd22ea403d6cc1d588.jpg)  
+(d) Set of end states for another partition of the ToggleDoor option.
+
+(c) Set of start states for another partition of the ToggleDoor option.
+
+Figure 18: In this example, the partitioning has clustered noisy samples into an additional partition of the ToggleDoor option. While the top row shows the case where the state of the door changes from open to closed, the bottom row is a relatively useless noisy operator. We will subsequently learn a precondition and effect for this partition, but it likely will not be used by the planner.
+
+![](images/492485df888c8d3ef26c4f4c03820daf1fb8a9180469613cf70b9d64f41290e4.jpg)  
+(a) The precondition for attacking the gold block. The top image represents the agent’s view (in front of the block) while the bottom image is the state of the block (unbroken).   
+(b) The precondition for walking to a closed door. The top image represents the agent’s view (in a room) while the bottom image is the state of the door (closed) and the state of the inventory.
+
+Figure 19: In the left example, the classifier predicts that the gold block can be broken when the agent is in front of it. However, this is not quite correct, since the agent must also have the pickaxe to break the block. In this case, the issue occurs because the data only included states where the agent reached the gold block with the pickaxe. Therefore, the agent did not observe states where it was in front of the block without the pickaxe, and thus concluded that the pickaxe is irrelevant to the precondition. In the right example, the classifier has overfitted to the data and predicts that the agent can only walk to the door when it has the pickaxe.
+
+# H.3 PPDDL CONSTRUCTION ERROR
+
+The quality of the PPDDL operators depends on how accurately the precondition classifiers and effect estimators are learned. Any error in learning can result in imperfect PPDDL operators, as seen below.
+
+![](images/ae7c612e6f2b4ec9e84e5aa65405997771270a1740e466a640c2268b7d5a4f9a.jpg)  
+Figure 20: Abstract operator that models the agent crafting a gold ingot. In order to do so, the agent must be standing in front of the crafting table (symbol 56) at a particular location (psymbol 1), and must have the gold block in its inventory (symbol 29). As a result, the agent finds itself in front of the crafting table (symbol 11), and now has a gold ingot in its inventory (symbol 57). This option is deterministic; however, due to estimation errors, the PPDDL operator predicts that it will only succeed with probability 0.79.
+
+(:action Craft-partition-1-240a :parameters (?w - type0 ?x - type9) :precondition (and (notfailed) (symbol_56 ?w) (symbol_29 ?x) (psymbol_1)) :effect (probabilistic 0.21 (not (notfailed)) 0.79 (and (symbol_57 ?x) (symbol_11 ?w) (not (symbol_29 ?x)) (not (symbol_56 ?w))))   
+)
+
+(f) Typed PPDDL operator for a partition of the Craft option.
+
+# H.4 TYPE INFERENCE ERROR
+
+We observe that occasionally the procedure will not discover the correct types. In the example below, instead of discovering a single type for all four doors, our approach predicts that one door is different from the others and is placed in its own class
+
+Table 2: A grouping of objects into types. Note that one of the doors is allocated its own type.   
+
+<table><tr><td>Type</td><td> Name</td><td>Object(s)</td></tr><tr><td>0</td><td>Agent</td><td>0</td></tr><tr><td>1</td><td>Pickaxe</td><td>1</td></tr><tr><td>2</td><td>Door1</td><td>2,3,4</td></tr><tr><td>3</td><td>Door2</td><td>5</td></tr><tr><td>4</td><td>Redstone Block</td><td>6</td></tr><tr><td>5</td><td>Gold Block</td><td>7</td></tr><tr><td>6</td><td>Chest</td><td>8</td></tr><tr><td>7</td><td>Inventory</td><td>9</td></tr></table>

parse/train/SklXvs0qt7/SklXvs0qt7.md

@@ -0,0 +1,291 @@
+# CURIOSITY-DRIVEN EXPERIENCE PRIORITIZATION VIA DENSITY ESTIMATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In Reinforcement Learning (RL), an agent explores the environment and collects trajectories into the memory buffer for later learning. However, the collected trajectories can easily be imbalanced with respect to the achieved goal states. The problem of learning from imbalanced data is a well-known problem in supervised learning, but has not yet been thoroughly researched in RL. To address this problem, we propose a novel Curiosity-Driven Prioritization (CDP) framework to encourage the agent to over-sample those trajectories that have rare achieved goal states. The CDP framework mimics the human learning process and focuses more on relatively uncommon events. We evaluate our methods using the robotic environment provided by OpenAI Gym. The environment contains six robot manipulation tasks. In our experiments, we combined CDP with Deep Deterministic Policy Gradient (DDPG) with or without Hindsight Experience Replay (HER). The experimental results show that CDP improves both performance and sampleefficiency of reinforcement learning agents, compared to state-of-the-art methods.
+
+# 1 INTRODUCTION
+
+Reinforcement Learning (RL) (Sutton & Barto, 1998) combined with Deep Learning (DL) (Goodfellow et al., 2016) led to great successes in various tasks, such as playing video games (Mnih et al., 2015), challenging the World Go Champion (Silver et al., 2016), and learning autonomously to accomplish different robotic tasks $\mathrm { N g }$ et al., 2006; Peters & Schaal, 2008; Levine et al., 2016; Chebotar et al., 2017; Andrychowicz et al., 2017).
+
+One of the biggest challenges in RL is to make the agent learn sample-efficiently in applications with sparse rewards. Recent RL algorithms, such as Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015), enable the agent to learn continuous control, such as manipulation and locomotion. Furthermore, to make the agent learn faster in the sparse reward settings, Andrychowicz et al. (2017) introduced Hindsight Experience Replay (HER) that encourages the agent to learn from whatever goal states it has achieved. The combination use of DDPG and HER lets the agent learn to accomplish more complex robot manipulation tasks. However, there is still a huge gap between the learning efficiency of humans and RL agents. In most cases, an RL agent needs millions of samples before it becomes good at the tasks, while humans only need a few samples (Mnih et al., 2015).
+
+One ability of humans is to learn with curiosity. Imagine a boy learning to play basketball and he attempting to shoot the ball into the hoop. After a day of training, he replayed the memory about the moves he practiced. During his recall, he realized that he missed most of his attempts. However, a few made contact with the hoop. These near successful attempts are more interesting to learn from. He will put more focus on learning from these. This kind of curiosity-driven learning might make the learning process more efficient.
+
+Similar curiosity mechanisms could be beneficial for RL agents. We are interested in the RL tasks, in which the goals can be expressed in states. In this case, the agent can analyze the achieved goals and find out which states have been achieved most of the time and which are rare. Based on the analysis, the agent is able to prioritize the trajectories, of which the achieved goal states are novel. For example, the goal states could be the position and the orientation of the target object. We want to encourage the agent to balance the training samples in the memory buffer. The reason is that the policy of the agent could be biased and focuses on a certain group of achieved goal states. This causes the samples to be imbalanced in the memory buffer, which we refer to as memory imbalance.
+
+![](images/5bd285f3b243591ee35e3391cb2c84410124055f5e935b58182a5cd765373124.jpg)  
+Figure 1: Robot arm Fetch and Shadow Dexterous hand environment: FetchPush, FetchPickAndPlace, FetchSlide, HandManipulateEgg, HandManipulateBlock, and HandManipulatePen.
+
+To overcome the class imbalance issue in supervised learning, such as training deep convolutional neural networks with biased datasets, researchers utilized over-sampling and under-sampling techniques (Deng et al., 2009; Felzenszwalb et al., 2008; Buda et al., 2018; Galar et al., 2012). For instance, the number of one image class is significantly higher than another class. They over-sampled the training images in the smaller class to balance the training set and ultimately to improve the classification accuracy. This idea could be combined with experience replay in RL. We investigate into this research direction and propose a novel curiosity-based prioritization framework for reinforcement learning agents.
+
+In this paper, we introduce a framework called Curiosity-Driven Prioritization (CDP) which allows the agent to realize a curiosity-driven learning ability similar to humans. This approach can be combined with any off-policy RL algorithm. It is applicable whenever the achieved goals can be described with state vectors. The pivotal idea of CDP is to first estimate the density of each achieved goal and then prioritize the trajectories with lower density to balance the samples that the agent learns from. To evaluate CDP, we combine CDP with DDPG and DDPG+HER and test them in the robot manipulation environments.
+
+# 2 BACKGROUND
+
+In this section, we introduce the preliminaries, such as the experiment environments, the reinforcement learning approaches and the density estimation algorithm we used in the experiments.
+
+# 2.1 ENVIRONMENTS
+
+The environment we used in our experiments is the robotic simulations provided by OpenAI Gym (Brockman et al., 2016; Plappert et al., 2018), using the MuJoCo physics engine (Todorov et al., 2012). The robotic environment is based on currently existing robotic hardware and is designed as a standard benchmark for Multi-goal RL. The robot agent is required to complete several tasks with different goals in each scenario. There are two kinds of robot agents in the environment. One is a 7-DOF Fetch robotic arm with a two-finger gripper as an end-effector. The other is a 24-DOF Shadow Dexterous robotic hand. We use six challenging tasks for evaluation, including push, slide, pick & place with the robot arm, and hand manipulation of the block, egg, and pen, see Figure 1.
+
+Goals: The goals $g$ are the desired positions and the orientations of the object.
+
+States: The system states $s$ in the simulation consist of positions, orientations, linear and angular velocities of all robot joints and of an object. The state $s$ consists of two sub-vectors, the achieved goal state $s ^ { g }$ and the context state $s ^ { c }$ , i.e. $s = \left( \boldsymbol { x } ^ { g } \| \boldsymbol { x } ^ { c } \right)$ , where $\parallel$ denotes concatenation. In our case, the achieved goal state $s ^ { g }$ represents the positions and the orientations of the object, which has the same dimension as the real goal $g$ . The context state $s ^ { c }$ contains the reset system information, including the linear and angular velocities of all robot joints and of an object. The sate input to the universal value function, see Section 2.2, is the system state $s$ combined with the real goal $g$ , i.e. $( s \| g )$ .
+
+Rewards: In all environments, we consider sparse rewards $r$ . There is a tolerant range between the desired goal states and the achieved goal states. If the object is not in the tolerant range of the real goal, the agent receives a reward signal $^ { - 1 }$ for each transition; otherwise, the reward signal is 0.
+
+# 2.2 REINFORCEMENT LEARNING
+
+Markov Decision Process: We consider an agent interacting with an environment. We assume the environment is fully observable, including a set of state $s$ , a set of action $\mathcal { A }$ , a distribution of initial states $p ( s _ { 0 } )$ , transition probabilities $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , a reward function $r \colon S \times \mathcal { A }  \mathbb { R }$ , and also a discount factor $\gamma \in [ 0 , \bar { 1 } ]$ . These components formulate a Markov decision process represented as a tuple, $( S , \mathcal { A } , p , r , \gamma )$ . A policy $\pi$ maps a state to an action, $\pi : { \mathcal { S } }  A$ .
+
+Deep Deterministic Policy Gradient: The objective, expected return $\mathbb { E } _ { s _ { 0 } } [ R _ { 0 } | s _ { 0 } ]$ , can be maximized using temporal difference learning, policy gradients, or the combination of both, i.e. the actor-critic methods (Sutton & Barto, 1998). For continuous control tasks, Deep Deterministic Policy Gradient (DDPG) shows promising performance, which is essentially an off-policy actor-critic method (Lillicrap et al., 2015).
+
+Universal Value Function Approximators: For multi-goal continuous control tasks, DDPG can be extended with Universal Value Function Approximators (UVFA) (Schaul et al., 2015a). UVFA essentially generalizes the Q-function to multiple goal states $g \in { \mathcal { G } }$ . Now, the Q-value depends not only on the state-action pairs, but also depends on the goals: $Q ^ { \pi } ( s _ { t } , a _ { t } , g ) = \mathbb { E } [ R _ { t } | s _ { t } , a _ { t } , g ]$ .
+
+Hindsight Experience Replay: For robotic tasks, if the goal is challenging and the reward is sparse, then the agent could perform badly for a long time before learning anything. Hindsight Experience Replay (HER) encourages the agent to learn from whatever goal states that it has achieved. Andrychowicz et al. (2017) show that HER makes training possible in challenging robotic environments. However, the episodes are uniformly sampled in the replay buffer, and subsequently, the virtual goals are sampled from the episodes. More sophisticated replay strategies are requested for improving sample-efficiency (Plappert et al., 2018).
+
+# 2.3 DENSITY ESTIMATION METHODS
+
+For estimating the density $\rho$ of the achieved goals in the memory buffer, we use a Gaussian mix  
+ture model because it can be trained reasonably fast for RL agents. GMM is also much faster   
+in inference compared to Kernel Density Estimate (KDE) (Rosenblatt, 1956). Gaussian Mixture   
+Model (GMM) (Duda & Hart, 1973; Murphy, 2012) is a probabilistic model that assumes all the $K$ GaussianEvery Ga tributionsn density parameters, mathematically: is a component of the GMM   
+$\begin{array} { r } { \rho ( \mathbf { x } ) = \sum _ { k = 1 } ^ { K } c _ { k } \mathcal { N } ( \mathbf { x } | \pmb { \mu } _ { k } , \pmb { \Sigma } _ { k } ) } \end{array}$ $\mathcal { N } ( { \bf x } | \mu _ { k } , \Sigma _ { k } )$ $\pmb { \mu } _ { k }$ $\Sigma _ { k }$ $c _ { k }$   
+our experiments, we use Variational Gaussian Mixture Model (V-GMM) (Blei et al., 2006). The   
+reason is that V-GMM has a natural tendency to set some mixing coefficients $c _ { k }$ close to zero and   
+generalizes better. Therefore, we decide to use V-GMM in our framework as a proof of concept.
+
+# 3 METHOD
+
+In this section, we formally describe our method, including the motivation, the framework, a mathematical grounding, and a comparison with prioritized experience replay (Schaul et al., 2015b).
+
+# 3.1 MOTIVATION
+
+The motivation of incorporating curiosity mechanisms into RL agents is motivated by the human brain. Recent neuroscience research (Gruber et al., 2014) has shown that curiosity can enhance learning. They discovered that when curiosity motivated learning was activated, there was increased activity in the hippocampus, a brain region that is important for human memory. To learn a new skill, such as playing basketball, people practice repeatedly in a trial-and-error fashion. During memory replay, people are more curious about the episodes that are relatively different and focus more on those. This curiosity mechanism has been shown to speed up learning.
+
+Secondly, the inspiration of how to design the curiosity mechanism for RL agents comes from the supervised learning community, in particular the class imbalance dataset problem. Real-world datasets commonly show the particularity to have certain classes to be under-represented compared to other classes. When presented with complex imbalanced datasets, standard learning algorithms, including neural networks, fail to properly represent the distributive characteristics of the data and thus provide unfavorable accuracies across the different classes of the data (He & Garcia, 2008; Galar et al., 2012). One of the effective methods to handle this problem is to over-sample the samples in the under-represented class. Therefore, we prioritize the under-represented trajectories with respect to the achieved goals in the agent’s memory buffer to improve the performance.
+
+# 3.2 CURIOSITY-DRIVEN PRIORITIZATION
+
+In this section, we formally describe the Curiosity-Driven Prioritization (CDP) framework. In a nutshell, we first estimate the density of each trajectory according to its achieved goal states, then prioritize the trajectories with lower density for replay.
+
+# 3.2.1 COLLECTING EXPERIENCE
+
+At the beginning of each episode, the agent uses partially random policies, such as $\epsilon$ -greedy, to start to explore the environment and stores the sampled trajectories into a memory buffer for later replay.
+
+A complete trajectory $\tau$ in an episode is represented as a tuple $( S , \mathcal { A } , p , r , \gamma )$ . A trajectory contains a series of continuous states $s _ { t }$ , see Section 2.1, where $t$ is the timestep $t \in \{ 0 , 1 , . . , T \}$ . Each state on the goal states, $s _ { t } \in S$ also includes the state of the achieved goal $s _ { 0 } ^ { g } , s _ { 1 } ^ { g } , . . . , s _ { T } ^ { g }$ . $s _ { t } ^ { g }$ . The density of a trajectory, $\rho$ , only depends
+
+# 3.2.2 DENSITY ESTIMATION
+
+After the agent collected a number of trajectories, we can fit the density model. The density model we use here is the Variational Gaussian Mixture Model (V-GMM) as introduced in Section 2.3. The V-GMM fits on the data in the memory buffer every epoch and refreshes the density for each trajectory in the buffer. During each epoch, when the new trajectory comes in, the density model predicts the density $\rho$ based on the achieved goals of the trajectory as:
+
+$$
+\rho = \mathrm { V } \mathrm { - } \mathrm { G M M } ( \tau ) = \sum _ { k = 1 } ^ { K } c _ { k } \mathcal { N } ( \tau | \pmb { \mu } _ { k } , \pmb { \Sigma } _ { k } )
+$$
+
+where $\tau = ( s _ { 0 } ^ { g } \Vert s _ { 1 } ^ { g } \Vert . . . \Vert s _ { T } ^ { g } )$ and each trajectory $\tau$ has the same length. We normalize the trajectory densities using
+
+$$
+\rho _ { i } = \frac { \rho _ { i } } { \sum _ { n = 1 } ^ { N } \rho _ { n } }
+$$
+
+where $N$ is the number of trajectories in the memory buffer. Now the density $\rho$ is between zero and one, i.e. $0 \leq \rho \leq 1$ , After calculating the trajectory density, the agent stores the density value along with the trajectory in the memory buffer for later prioritization.
+
+# 3.2.3 PRIORITIZATION
+
+During replay, the agent puts more focus on the under-represented achieved states and prioritizes the according trajectories. These under-represented achieved goal states have lower trajectory density. We defined the complementary trajectory density as:
+
+$$
+\bar { \rho } \propto 1 - \rho .
+$$
+
+When the agent replays the samples, it first ranks all the trajectories with respect to their complementary density values $\bar { \rho }$ , and then uses the ranking number (starting from zero) directly as the probability for sampling. This means that the low-density trajectories have high ranking numbers, and equivalently, have higher priorities to be replayed. Here we use the ranking instead of the density directly. The reason is that the rank-based variant is more robust because it is not affected by outliers nor by density magnitudes. Furthermore, its heavy-tail property also guarantees that samples will be diverse (Schaul et al., 2015b). Mathematically, the probability of a trajectory to be replayed after the prioritization is:
+
+$$
+p ( \tau _ { i } ) = \frac { \mathrm { r a n k } ( \bar { \rho } ( \tau _ { i } ) ) } { \sum _ { n = 1 } ^ { N } \mathrm { r a n k } ( ( \bar { \rho } ( \tau _ { n } ) ) }
+$$
+
+where $N$ is the total number of trajectories in the buffer, and $\mathrm { r a n k } ( \cdot ) \in \{ 0 , 1 , . . . , N - 1 \}$
+
+# 3.2.4 COMPLETE ALGORITHM
+
+We summarize the complete training algorithm in Algorithm 1.
+
+# Algorithm 1 Curiosity-Driven Prioritization (CDP)
+
+Given: • an off-policy RL algorithm A $\triangleright$ e.g. DDPG, DDPG+HER $\bullet$ a reward function $r : \mathcal { S } \times \mathcal { A } \times \mathcal { G } \to \mathbb { R }$ . . e.g. $r ( s , a , g ) = - 1$ (fail), 0 (success)   
+Initialize neural networks of A, density model V-GMM, and replay buffer $R$   
+for epoch $= 1$ , $M$ do for episode $= 1$ , $N$ do Sample a goal $g$ and an initial state $s _ { 0 }$ . Sample a trajectory $\tau = ( s _ { t } \| g , a _ { t } , r _ { t } , s _ { t + 1 } \| g ) _ { t = 0 } ^ { T }$ using $\pi _ { b }$ from A Calculate the densities $\rho$ and $\bar { \rho }$ using Equation (1), (2) and (3) $\triangleright$ estimate density Calculate the priority $p ( \tau )$ using Equation (4) Store transitions $( s _ { t } \dot { } \rvert \rvert g , a _ { t } , r _ { t } , s _ { t + 1 } \rvert \rvert g , p , \bar { \rho } ) _ { t = 0 } ^ { T }$ in $R$ Sample trajectory $\tau$ from $R$ based on the priority, $p ( \tau )$ . prioritization Sample transitions $\left( { { s _ { t } } , { a _ { t } } , { s _ { t + 1 } } } \right)$ from $\tau$ Sample virtual goals $g ^ { \prime } \in \{ s _ { t + 1 } , . . . , s _ { T - 1 } \}$ at a future timestep in $\tau$ $r _ { t } ^ { \prime } : = r ( s _ { t } , a _ { t } , g ^ { \prime } )$ $\triangleright$ recalculate reward (HER) Store the transition $\left( s _ { t } \| g ^ { \prime } , a _ { t } , r _ { t } ^ { \prime } , s _ { t + 1 } \| g ^ { \prime } , p , \bar { \rho } \right)$ in $R$ Perform one step of optimization using A end for Train the density model using the collected trajectories in $R$ $\triangleright$ fit density model Update the density in $R$ using the trained model . refresh density   
+end for
+
+# 3.3 AN IMPORTANCE SAMPLING PERSPECTIVE
+
+The mathematical explanation for the efficiency of CDP is based on importance sampling. Importance sampling is a general technique to estimate an integral $\textstyle \int f ( x ) p ( { \bar { x } } ) d x$ of a function $f ( x )$ , with the exact distribution $p ( x )$ (Murphy, 2012; Owen, 2013). Here, we consider using importance sampling to estimate the integral of the loss function $ { \mathcal { L } } ( \tau )$ of the reinforcement learning agent:
+
+$$
+I = \mathbb { E } [ \mathcal { L } ] = \int \mathcal { L } ( \tau ) \frac { p ( \tau ) } { q ( \tau ) } q ( \tau ) d \tau \approx \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \omega _ { i } f ( \tau _ { i } ) = \hat { I } ,
+$$
+
+where $\tau$ is a trajectory, $q ( \tau )$ is a proposal distribution, and $\omega _ { i } = p ( \tau _ { i } ) / q ( \tau _ { i } )$ is an importance weight.
+
+The idea here is to draw samples $\tau$ from the buffer in regions which have a high probability, $p ( \tau )$ , but also where $\mathcal { L } | ( \tau ) |$ is large. Since, $p ( \tau )$ is a uniform distribution, i.e. the agent replays trajectories at random, we only need to draw samples which has large errors $\mathcal { L } | ( \tau ) |$ . The result can be highly efficient, meaning the agent needs less samples than sampling from the uniform distribution $p ( \tau )$ . The CDP framework finds the samples that have large errors based on the ‘surprise’ of the trajectory. The variance of the estimate $\hat { I }$ is: $\mathrm { v a r } _ { q } [ \mathcal { L } ( \tau ) \omega ( \tau ) ) ] = \mathbb { E } _ { q } [ \mathcal { L } ^ { 2 } ( \tau ) \omega ^ { 2 } ( \tau ) ] - I ^ { 2 }$ . Since the last term is independent of $q$ , we can ignore it. Using Jensen’s inequality, we have the following lower bound:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { q } [ \mathcal { L } ^ { 2 } ( \tau ) \omega ^ { 2 } ( \tau ) ] \geqslant ( \mathbb { E } _ { q } [ | \mathcal { L } ( \tau ) \omega ( \tau ) | ] ) ^ { 2 } . } \end{array}
+$$
+
+To reduce the variance, we set the importance weight as a constant $\omega ( \tau ) = 1$ . This bias-variance trade-off also saves computational time and does not lead to instabilities in our experiment. With CDP, the agent estimates the loss function more efficiently and therefore learns faster. Any density estimation method that can approximate the trajectory density can provide a more efficient proposal distribution $q ( \tau )$ than the uniform distribution $p ( \tau )$ .
+
+# 3.4 COMPARISON WITH PRIORITIZED EXPERIENCE REPLAY
+
+To the best our knowledge, the most similar method to CDP is Prioritized Experience Replay (PER) (Schaul et al., 2015b). To combine PER with HER, we calculate the TD-error of each transition based on the randomly selected achieved goals. Then we prioritize the transitions with higher TDerrors for replay. It is known that PER can become very expensive in computational time (Schaul et al., 2015b), especially when the memory size $N$ is very large. The reason is that PER uses TDerrors for prioritization. After each update of the model, the agent needs to update the priorities of the transitions in the replay buffer, which is ${ \cal O } ( \log N )$ . In our experiments, see Section 4, we use the efficient implementation based on the ”sum-tree” data structure, which can be relatively efficiently updated and sampled from (Schaul et al., 2015b).
+
+![](images/1f82ed9d4ac466d2a16cdb666d54e9adb4066e0853470ebcba41622266b34221.jpg)  
+Figure 2: Mean test success rate with standard deviation in all six robot environments
+
+Compared to PER, CDP is much faster in computational time because it only updates the trajectory density once per epoch. Due to this reason, CDP is much more efficient than PER in computational time and can be easily combined with any multi-goal RL methods, such as DDPG and HER. In the experiments, Section 4, we first compare the performance improvement of CDP and PER. Afterwards, we compare the time-complexity of PER and CDP. We show that CDP improves performance with much less computational time than PER. Furthermore, the motivations of PER and CDP are different. The former uses TD-errors, while the latter is based on the density of the trajectories.
+
+# 4 EXPERIMENTS
+
+In this section, we investigate the following questions:
+
+- Does incorporating CDP bring benefits to DDPG or DDPG $^ +$ HER? - Does CDP improve the sample-efficiency in robotic manipulation tasks? - How does the density $\bar { \rho }$ relate to the TD-errors of the trajectory during training?
+
+Performance: To test the performance difference among DDPG, DDPG $^ +$ PER, and DDPG+CDP, we run the experiment in the three robot arm environments. We use the DDPG as the baseline here because the robot arm environment is relatively simple. In the more challenging robot hand environments, we use DDPG $^ +$ HER as the baseline method and test the performance among DDPG $+$ HER, $\mathrm { D D P G + H E R + P E R }$ , and DDPG $+$ HER $^ +$ CDP.
+
+We compare the mean success rates. Each experiment is carried out across 5 random seeds and the shaded area represents the standard deviation. The learning curve with respect to training epochs is shown in Figure 2. For all experiments, we use 19 CPUs and train the agent for 200 epochs. After training, we use the best-learned policy as the final policy and test it in the environment. The testing results are the final mean success rates. A comparison of the final performances along with the training time is shown in Table 1.
+
+Table 1: Final mean success rate $( \% )$ and the training time (hour) for all six environments   
+
+<table><tr><td></td><td colspan="2">Push</td><td colspan="2">Pick&amp;Place</td><td colspan="2">Slide</td></tr><tr><td>Method</td><td>success</td><td>time</td><td>success</td><td>time</td><td>success</td><td>time</td></tr><tr><td>DDPG</td><td>99.90%</td><td>5.52h</td><td>39.34%</td><td>5.61h</td><td>75.67%</td><td>5.47h</td></tr><tr><td>DDPG+PER</td><td>99.94%</td><td>30.66h</td><td>67.19%</td><td>25.73h</td><td>66.33%</td><td>25.85h</td></tr><tr><td>DDPG+CDP</td><td>99.96%</td><td>6.76h</td><td>76.02%</td><td>6.92h</td><td>76.77%</td><td>6.66h</td></tr><tr><td></td><td colspan="2">Egg</td><td colspan="2">Block</td><td colspan="2">Pen</td></tr><tr><td>Method</td><td>success</td><td>time</td><td>success</td><td>time</td><td>success</td><td>time</td></tr><tr><td>DDPG+HER</td><td>76.19%</td><td>7.33h</td><td>20.32%</td><td>8.47h</td><td>27.28%</td><td>7.55h</td></tr><tr><td>DDPG+HER+PER</td><td>75.46%</td><td>79.86h</td><td>18.95%</td><td>80.72h</td><td>27.74%</td><td>81.17h</td></tr><tr><td>DDPG+HER+CDP</td><td>81.30%</td><td>17.00h</td><td>25.00%</td><td>19.88h</td><td>31.88%</td><td>25.36h</td></tr></table>
+
+![](images/82e5af27833112a04cfe6c345f3f72c9fec8fd61627565748d18cffef3611b47.jpg)  
+Figure 3: Number of training samples needed with respect to mean test success rate for all six environments (the lower the better)
+
+From Figure 2, we can see that CDP converges faster in all six tasks than both the baseline and PER. The agent trained with CDP also shows a better performance at the end of the training, as shown in Table 1. In Table 1, we can see that the training time of CDP lies in between the baseline and PER. To be more specific, CDP consumes much less computational time than PER does. For example in the robot arm environments, on average DDPG $^ +$ CDP consumes about 1.2 times the training time of DDPG. In comparison, DDPG $^ +$ PER consumes about 5 times the training time as DDPG does. In this case, CDP is 4 times faster than PER.
+
+Table 1 shows that baseline methods with CDP give a better performance in all six tasks. The improvement goes up to 39.34 percentage points compared to the baseline methods. The average improvement over the six tasks is 9.15 percentage points. We can see that CDP is a simple yet effective method, improves state-of-the-art methods.
+
+Sample-Efficiency: To compare the sample-efficiency of the baseline and CDP, we compare the number of training samples needed for a certain mean test success rate. The comparison is shown in Figure 3. From Figure 3, in the FetchPush-v0 environment, we can see that for the same $9 9 \%$ mean test success rate, the baseline DDPG needs 273,600 samples for training, while $\mathrm { \Delta D D P G + C D P }$ only needs 112,100 samples. In this case, DDPG $^ +$ CDP is more than twice (2.44) as sample-efficient as DDPG. Similarly, in the other five environments, CDP improves sample-efficiency by factors of 2.84, 0.92, 1.37, 1,28 and 2.87, respectively. In conclusion, for all six environments, CDP is able to improve sample-efficiency by an average factor of two (1.95) over the baseline’s sample-efficiency.
+
+![](images/3e11815e7ef8b32a8c85d77ab2c6e0d4aab43821cd86c20426a80d7665af8925.jpg)  
+Figure 4: Pearson correlation between the density $\bar { \rho }$ and TD-errors in the middle of training
+
+Insights: We also investigate the correlation between the complementary trajectory density $\bar { \rho }$ and the TD-errors of the trajectory. The Pearson correlation coefficient, i.e. Pearson’s r (Benesty et al., 2009), between the density $\bar { \rho }$ and the TD-errors of the trajectory is shown in Figure 4. The value of Pearson’s r is between 1 and -1, where 1 is total positive linear correlation, 0 is no linear correlation, -1 is total negative linear correlation. In Figure 4, we can see that the complementary trajectory density is correlated with the TD-errors of the trajectory with an average Pearson’s r of 0.7. This proves that the relatively rare trajectories in the memory buffer are more valuable for learning. Therefore, it is helpful to prioritize the trajectories with lower density during training.
+
+# 5 RELATED WORK
+
+Experience replay was proposed by Lin (1992) and became popular due to the success of DQN (Mnih et al., 2015). In the same year, prioritized experience replay was introduced by Schaul et al. (2015b) as an improvement of the experience replay in DQN. It prioritized the transitions with higher TD-error in the replay buffer to speed up training. Schaul et al. (2015a) also proposed universal function approximators, generalizing not just over states but also over goals. There are also many other research works about multi-task RL (Schmidhuber & Huber, 1990; Caruana, 1998; Da Silva et al., 2012; Kober et al., 2012; Pinto & Gupta, 2017; Foster & Dayan, 2002; Sutton et al., 2011). Hindsight experience replay (Andrychowicz et al., 2017) is a kind of goal-conditioned RL that substitutes any achieved goals as real goals to encourage the agent to learn something instead of nothing.
+
+Curiosity-driven exploration is a well-studied topic in reinforcement learning (Oudeyer & Kaplan, 2009; Oudeyer et al., 2007; Schmidhuber, 1991; 2010; Sun et al., 2011). Pathak et al. (2017) encourage the agent to explore states with high prediction error. The agents are also encouraged to explore ”novel” or uncertain states (Bellemare et al., 2016; Lopes et al., 2012; Poupart et al., 2006; Houthooft et al., 2016; Mohamed & Rezende, 2015; Chentanez et al., 2005; Stadie et al., 2015).
+
+However, we integrate curiosity into prioritization and tackle the problem of data imbalance (Galar et al., 2012) in the memory buffer of RL agents. A recent work (Narasimhan et al., 2015) introduced a form of re-sampling for RL agents based on positive and negative rewards. The idea of our method is complementary and can be combined. The motivation of our method is from the curiosity mechanism in the human brain (Gruber et al., 2014). The essence of our method is to assign priority to the achieved trajectories with lower density, which are relatively more valuable to learn from. In supervised learning, similar tricks are used to mitigate the class imbalance challenge, such as over-sampling the data in the under-represented class (Hinton, 2007; He & Garcia, 2008).
+
+# 6 CONCLUSION
+
+In conclusion, we proposed a simple yet effective curiosity-driven approach to prioritize agent’s experience based on the trajectory density. Curiosity-Driven Prioritization shows promising experimental results in all six challenging robotic manipulation tasks. This method can be combined with any off-policy RL methods, such as DDPG and DDPG $^ +$ HER. We integrated the curiosity mechanism via density estimation into the modern RL paradigm and improved sample-efficiency by a factor of two and the final performance by nine percentage points on top of state-of-the-art methods.
+
+# REFERENCES
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.
+
+Jacob Benesty, Jingdong Chen, Yiteng Huang, and Israel Cohen. Pearson correlation coefficient. In Noise reduction in speech processing, pp. 1–4. Springer, 2009.
+
+David M Blei, Michael I Jordan, et al. Variational inference for dirichlet process mixtures. Bayesian analysis, 1(1):121–143, 2006.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Mateusz Buda, Atsuto Maki, and Maciej A Mazurowski. A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259, 2018.
+
+Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998.
+
+Yevgen Chebotar, Mrinal Kalakrishnan, Ali Yahya, Adrian Li, Stefan Schaal, and Sergey Levine. Path integral guided policy search. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3381–3388. IEEE, 2017.
+
+Nuttapong Chentanez, Andrew G Barto, and Satinder P Singh. Intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 1281–1288, 2005.
+
+Bruno Da Silva, George Konidaris, and Andrew Barto. Learning parameterized skills. arXiv preprint arXiv:1206.6398, 2012.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. Ieee, 2009.
+
+Richard O Duda and Peter E Hart. Pattern classification and scene analysis. A Wiley-Interscience Publication, New York: Wiley, 1973, 1973.
+
+Pedro Felzenszwalb, David McAllester, and Deva Ramanan. A discriminatively trained, multiscale, deformable part model. In Computer Vision and Pattern Recognition, 2008. CVPR 2008. IEEE Conference on, pp. 1–8. IEEE, 2008.
+
+David Foster and Peter Dayan. Structure in the space of value functions. Machine Learning, 49 (2-3):325–346, 2002.
+
+Mikel Galar, Alberto Fernandez, Edurne Barrenechea, Humberto Bustince, and Francisco Herrera. A review on ensembles for the class imbalance problem: bagging-, boosting-, and hybrid-based approaches. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(4):463–484, 2012.
+
+Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning, volume 1. MIT press Cambridge, 2016.
+
+Matthias J Gruber, Bernard D Gelman, and Charan Ranganath. States of curiosity modulate hippocampus-dependent learning via the dopaminergic circuit. Neuron, 84(2):486–496, 2014.
+
+Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Transactions on Knowledge & Data Engineering, (9):1263–1284, 2008.
+
+Geoffrey E Hinton. To recognize shapes, first learn to generate images. Progress in brain research, 165:535–547, 2007.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pp. 1109–1117, 2016.
+
+Jens Kober, Andreas Wilhelm, Erhan Oztop, and Jan Peters. Reinforcement learning to adjust parametrized motor primitives to new situations. Autonomous Robots, 33(4):361–379, 2012.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992.
+
+Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in modelbased reinforcement learning by empirically estimating learning progress. In Advances in Neural Information Processing Systems, pp. 206–214, 2012.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Shakir Mohamed and Danilo Jimenez Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 2125–2133, 2015.
+
+Kevin P Murphy. Machine learning: A probabilistic perspective. adaptive computation and machine learning, 2012.
+
+Karthik Narasimhan, Tejas Kulkarni, and Regina Barzilay. Language understanding for text-based games using deep reinforcement learning. arXiv preprint arXiv:1506.08941, 2015.
+
+Andrew Y Ng, Adam Coates, Mark Diel, Varun Ganapathi, Jamie Schulte, Ben Tse, Eric Berger, and Eric Liang. Autonomous inverted helicopter flight via reinforcement learning. In Experimental Robotics IX, pp. 363–372. Springer, 2006.
+
+Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009.
+
+Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. IEEE transactions on evolutionary computation, 11(2):265–286, 2007.
+
+Art B. Owen. Monte Carlo theory, methods and examples. 2013.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning (ICML), volume 2017, 2017.
+
+Jan Peters and Stefan Schaal. Reinforcement learning of motor skills with policy gradients. Neural networks, 21(4):682–697, 2008.
+
+Lerrel Pinto and Abhinav Gupta. Learning to push by grasping: Using multiple tasks for effective learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 2161– 2168. IEEE, 2017.
+
+Matthias Plappert, Marcin Andrychowicz, Alex Ray, Bob McGrew, Bowen Baker, Glenn Powell, Jonas Schneider, Josh Tobin, Maciek Chociej, Peter Welinder, et al. Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464, 2018.
+
+Pascal Poupart, Nikos Vlassis, Jesse Hoey, and Kevin Regan. An analytic solution to discrete bayesian reinforcement learning. In Proceedings of the 23rd international conference on Machine learning, pp. 697–704. ACM, 2006.
+
+Murray Rosenblatt. Remarks on some nonparametric estimates of a density function. The Annals of Mathematical Statistics, pp. 832–837, 1956.
+
+Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In International Conference on Machine Learning, pp. 1312–1320, 2015a.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015b.
+
+Jurgen Schmidhuber. A possibility for implementing curiosity and boredom in model-building neu- ¨ ral controllers. In Proc. of the international conference on simulation of adaptive behavior: From animals to animats, pp. 222–227, 1991.
+
+Jurgen Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). ¨ IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010.
+
+Jurgen Schmidhuber and Rudolf Huber. ¨ Learning to generate focus trajectories for attentive vision. Institut fur Informatik, 1990. ¨
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015.
+
+Yi Sun, Faustino Gomez, and Jurgen Schmidhuber. Planning to be surprised: Optimal bayesian ¨ exploration in dynamic environments. In International Conference on Artificial General Intelligence, pp. 41–51. Springer, 2011.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
+
+Richard S Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2, pp. 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.

parse/train/SklXvs0qt7/SklXvs0qt7_content_list.json

@@ -0,0 +1,1530 @@
+[
+    {
+        "type": "text",
+        "text": "CURIOSITY-DRIVEN EXPERIENCE PRIORITIZATION VIA DENSITY ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In Reinforcement Learning (RL), an agent explores the environment and collects trajectories into the memory buffer for later learning. However, the collected trajectories can easily be imbalanced with respect to the achieved goal states. The problem of learning from imbalanced data is a well-known problem in supervised learning, but has not yet been thoroughly researched in RL. To address this problem, we propose a novel Curiosity-Driven Prioritization (CDP) framework to encourage the agent to over-sample those trajectories that have rare achieved goal states. The CDP framework mimics the human learning process and focuses more on relatively uncommon events. We evaluate our methods using the robotic environment provided by OpenAI Gym. The environment contains six robot manipulation tasks. In our experiments, we combined CDP with Deep Deterministic Policy Gradient (DDPG) with or without Hindsight Experience Replay (HER). The experimental results show that CDP improves both performance and sampleefficiency of reinforcement learning agents, compared to state-of-the-art methods. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning (RL) (Sutton & Barto, 1998) combined with Deep Learning (DL) (Goodfellow et al., 2016) led to great successes in various tasks, such as playing video games (Mnih et al., 2015), challenging the World Go Champion (Silver et al., 2016), and learning autonomously to accomplish different robotic tasks $\\mathrm { N g }$ et al., 2006; Peters & Schaal, 2008; Levine et al., 2016; Chebotar et al., 2017; Andrychowicz et al., 2017). ",
+        "bbox": [
+            174,
+            512,
+            823,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the biggest challenges in RL is to make the agent learn sample-efficiently in applications with sparse rewards. Recent RL algorithms, such as Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015), enable the agent to learn continuous control, such as manipulation and locomotion. Furthermore, to make the agent learn faster in the sparse reward settings, Andrychowicz et al. (2017) introduced Hindsight Experience Replay (HER) that encourages the agent to learn from whatever goal states it has achieved. The combination use of DDPG and HER lets the agent learn to accomplish more complex robot manipulation tasks. However, there is still a huge gap between the learning efficiency of humans and RL agents. In most cases, an RL agent needs millions of samples before it becomes good at the tasks, while humans only need a few samples (Mnih et al., 2015). ",
+        "bbox": [
+            174,
+            589,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One ability of humans is to learn with curiosity. Imagine a boy learning to play basketball and he attempting to shoot the ball into the hoop. After a day of training, he replayed the memory about the moves he practiced. During his recall, he realized that he missed most of his attempts. However, a few made contact with the hoop. These near successful attempts are more interesting to learn from. He will put more focus on learning from these. This kind of curiosity-driven learning might make the learning process more efficient. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Similar curiosity mechanisms could be beneficial for RL agents. We are interested in the RL tasks, in which the goals can be expressed in states. In this case, the agent can analyze the achieved goals and find out which states have been achieved most of the time and which are rare. Based on the analysis, the agent is able to prioritize the trajectories, of which the achieved goal states are novel. For example, the goal states could be the position and the orientation of the target object. We want to encourage the agent to balance the training samples in the memory buffer. The reason is that the policy of the agent could be biased and focuses on a certain group of achieved goal states. This causes the samples to be imbalanced in the memory buffer, which we refer to as memory imbalance. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bd285f3b243591ee35e3391cb2c84410124055f5e935b58182a5cd765373124.jpg",
+        "image_caption": [
+            "Figure 1: Robot arm Fetch and Shadow Dexterous hand environment: FetchPush, FetchPickAndPlace, FetchSlide, HandManipulateEgg, HandManipulateBlock, and HandManipulatePen. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            821,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome the class imbalance issue in supervised learning, such as training deep convolutional neural networks with biased datasets, researchers utilized over-sampling and under-sampling techniques (Deng et al., 2009; Felzenszwalb et al., 2008; Buda et al., 2018; Galar et al., 2012). For instance, the number of one image class is significantly higher than another class. They over-sampled the training images in the smaller class to balance the training set and ultimately to improve the classification accuracy. This idea could be combined with experience replay in RL. We investigate into this research direction and propose a novel curiosity-based prioritization framework for reinforcement learning agents. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a framework called Curiosity-Driven Prioritization (CDP) which allows the agent to realize a curiosity-driven learning ability similar to humans. This approach can be combined with any off-policy RL algorithm. It is applicable whenever the achieved goals can be described with state vectors. The pivotal idea of CDP is to first estimate the density of each achieved goal and then prioritize the trajectories with lower density to balance the samples that the agent learns from. To evaluate CDP, we combine CDP with DDPG and DDPG+HER and test them in the robot manipulation environments. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            326,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the preliminaries, such as the experiment environments, the reinforcement learning approaches and the density estimation algorithm we used in the experiments. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            328,
+            607
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The environment we used in our experiments is the robotic simulations provided by OpenAI Gym (Brockman et al., 2016; Plappert et al., 2018), using the MuJoCo physics engine (Todorov et al., 2012). The robotic environment is based on currently existing robotic hardware and is designed as a standard benchmark for Multi-goal RL. The robot agent is required to complete several tasks with different goals in each scenario. There are two kinds of robot agents in the environment. One is a 7-DOF Fetch robotic arm with a two-finger gripper as an end-effector. The other is a 24-DOF Shadow Dexterous robotic hand. We use six challenging tasks for evaluation, including push, slide, pick & place with the robot arm, and hand manipulation of the block, egg, and pen, see Figure 1. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Goals: The goals $g$ are the desired positions and the orientations of the object. ",
+        "bbox": [
+            176,
+            742,
+            686,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "States: The system states $s$ in the simulation consist of positions, orientations, linear and angular velocities of all robot joints and of an object. The state $s$ consists of two sub-vectors, the achieved goal state $s ^ { g }$ and the context state $s ^ { c }$ , i.e. $s = \\left( \\boldsymbol { x } ^ { g } \\| \\boldsymbol { x } ^ { c } \\right)$ , where $\\parallel$ denotes concatenation. In our case, the achieved goal state $s ^ { g }$ represents the positions and the orientations of the object, which has the same dimension as the real goal $g$ . The context state $s ^ { c }$ contains the reset system information, including the linear and angular velocities of all robot joints and of an object. The sate input to the universal value function, see Section 2.2, is the system state $s$ combined with the real goal $g$ , i.e. $( s \\| g )$ . ",
+        "bbox": [
+            174,
+            762,
+            825,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Rewards: In all environments, we consider sparse rewards $r$ . There is a tolerant range between the desired goal states and the achieved goal states. If the object is not in the tolerant range of the real goal, the agent receives a reward signal $^ { - 1 }$ for each transition; otherwise, the reward signal is 0. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            416,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Markov Decision Process: We consider an agent interacting with an environment. We assume the environment is fully observable, including a set of state $s$ , a set of action $\\mathcal { A }$ , a distribution of initial states $p ( s _ { 0 } )$ , transition probabilities $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , a reward function $r \\colon S \\times \\mathcal { A }  \\mathbb { R }$ , and also a discount factor $\\gamma \\in [ 0 , \\bar { 1 } ]$ . These components formulate a Markov decision process represented as a tuple, $( S , \\mathcal { A } , p , r , \\gamma )$ . A policy $\\pi$ maps a state to an action, $\\pi : { \\mathcal { S } }  A$ . ",
+        "bbox": [
+            174,
+            128,
+            825,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep Deterministic Policy Gradient: The objective, expected return $\\mathbb { E } _ { s _ { 0 } } [ R _ { 0 } | s _ { 0 } ]$ , can be maximized using temporal difference learning, policy gradients, or the combination of both, i.e. the actor-critic methods (Sutton & Barto, 1998). For continuous control tasks, Deep Deterministic Policy Gradient (DDPG) shows promising performance, which is essentially an off-policy actor-critic method (Lillicrap et al., 2015). ",
+        "bbox": [
+            174,
+            207,
+            823,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Universal Value Function Approximators: For multi-goal continuous control tasks, DDPG can be extended with Universal Value Function Approximators (UVFA) (Schaul et al., 2015a). UVFA essentially generalizes the Q-function to multiple goal states $g \\in { \\mathcal { G } }$ . Now, the Q-value depends not only on the state-action pairs, but also depends on the goals: $Q ^ { \\pi } ( s _ { t } , a _ { t } , g ) = \\mathbb { E } [ R _ { t } | s _ { t } , a _ { t } , g ]$ . ",
+        "bbox": [
+            174,
+            284,
+            823,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hindsight Experience Replay: For robotic tasks, if the goal is challenging and the reward is sparse, then the agent could perform badly for a long time before learning anything. Hindsight Experience Replay (HER) encourages the agent to learn from whatever goal states that it has achieved. Andrychowicz et al. (2017) show that HER makes training possible in challenging robotic environments. However, the episodes are uniformly sampled in the replay buffer, and subsequently, the virtual goals are sampled from the episodes. More sophisticated replay strategies are requested for improving sample-efficiency (Plappert et al., 2018). ",
+        "bbox": [
+            174,
+            345,
+            825,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DENSITY ESTIMATION METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            446,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For estimating the density $\\rho$ of the achieved goals in the memory buffer, we use a Gaussian mix  \nture model because it can be trained reasonably fast for RL agents. GMM is also much faster   \nin inference compared to Kernel Density Estimate (KDE) (Rosenblatt, 1956). Gaussian Mixture   \nModel (GMM) (Duda & Hart, 1973; Murphy, 2012) is a probabilistic model that assumes all the $K$ GaussianEvery Ga tributionsn density parameters, mathematically: is a component of the GMM   \n$\\begin{array} { r } { \\rho ( \\mathbf { x } ) = \\sum _ { k = 1 } ^ { K } c _ { k } \\mathcal { N } ( \\mathbf { x } | \\pmb { \\mu } _ { k } , \\pmb { \\Sigma } _ { k } ) } \\end{array}$ $\\mathcal { N } ( { \\bf x } | \\mu _ { k } , \\Sigma _ { k } )$ $\\pmb { \\mu } _ { k }$ $\\Sigma _ { k }$ $c _ { k }$   \nour experiments, we use Variational Gaussian Mixture Model (V-GMM) (Blei et al., 2006). The   \nreason is that V-GMM has a natural tendency to set some mixing coefficients $c _ { k }$ close to zero and   \ngeneralizes better. Therefore, we decide to use V-GMM in our framework as a proof of concept. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            282,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we formally describe our method, including the motivation, the framework, a mathematical grounding, and a comparison with prioritized experience replay (Schaul et al., 2015b). ",
+        "bbox": [
+            173,
+            678,
+            823,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            305,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The motivation of incorporating curiosity mechanisms into RL agents is motivated by the human brain. Recent neuroscience research (Gruber et al., 2014) has shown that curiosity can enhance learning. They discovered that when curiosity motivated learning was activated, there was increased activity in the hippocampus, a brain region that is important for human memory. To learn a new skill, such as playing basketball, people practice repeatedly in a trial-and-error fashion. During memory replay, people are more curious about the episodes that are relatively different and focus more on those. This curiosity mechanism has been shown to speed up learning. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the inspiration of how to design the curiosity mechanism for RL agents comes from the supervised learning community, in particular the class imbalance dataset problem. Real-world datasets commonly show the particularity to have certain classes to be under-represented compared to other classes. When presented with complex imbalanced datasets, standard learning algorithms, including neural networks, fail to properly represent the distributive characteristics of the data and thus provide unfavorable accuracies across the different classes of the data (He & Garcia, 2008; Galar et al., 2012). One of the effective methods to handle this problem is to over-sample the samples in the under-represented class. Therefore, we prioritize the under-represented trajectories with respect to the achieved goals in the agent’s memory buffer to improve the performance. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 CURIOSITY-DRIVEN PRIORITIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            176,
+            473,
+            190
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we formally describe the Curiosity-Driven Prioritization (CDP) framework. In a nutshell, we first estimate the density of each trajectory according to its achieved goal states, then prioritize the trajectories with lower density for replay. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 COLLECTING EXPERIENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            258,
+            415,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the beginning of each episode, the agent uses partially random policies, such as $\\epsilon$ -greedy, to start to explore the environment and stores the sampled trajectories into a memory buffer for later replay. ",
+        "bbox": [
+            176,
+            282,
+            821,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A complete trajectory $\\tau$ in an episode is represented as a tuple $( S , \\mathcal { A } , p , r , \\gamma )$ . A trajectory contains a series of continuous states $s _ { t }$ , see Section 2.1, where $t$ is the timestep $t \\in \\{ 0 , 1 , . . , T \\}$ . Each state on the goal states, $s _ { t } \\in S$ also includes the state of the achieved goal $s _ { 0 } ^ { g } , s _ { 1 } ^ { g } , . . . , s _ { T } ^ { g }$ . $s _ { t } ^ { g }$ . The density of a trajectory, $\\rho$ , only depends ",
+        "bbox": [
+            174,
+            318,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 DENSITY ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            388,
+            385,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After the agent collected a number of trajectories, we can fit the density model. The density model we use here is the Variational Gaussian Mixture Model (V-GMM) as introduced in Section 2.3. The V-GMM fits on the data in the memory buffer every epoch and refreshes the density for each trajectory in the buffer. During each epoch, when the new trajectory comes in, the density model predicts the density $\\rho$ based on the achieved goals of the trajectory as: ",
+        "bbox": [
+            174,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04cc7ebf2baa82392af42b977bd2ef2fab8aab77e9a14036c37e19b2b1f68c92.jpg",
+        "text": "$$\n\\rho = \\mathrm { V } \\mathrm { - } \\mathrm { G M M } ( \\tau ) = \\sum _ { k = 1 } ^ { K } c _ { k } \\mathcal { N } ( \\tau | \\pmb { \\mu } _ { k } , \\pmb { \\Sigma } _ { k } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            486,
+            633,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau = ( s _ { 0 } ^ { g } \\Vert s _ { 1 } ^ { g } \\Vert . . . \\Vert s _ { T } ^ { g } )$ and each trajectory $\\tau$ has the same length. We normalize the trajectory densities using ",
+        "bbox": [
+            176,
+            534,
+            820,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/103dc6e022a569a0892a4032481044e5099ffa6087790b6dd12305cd0982b295.jpg",
+        "text": "$$\n\\rho _ { i } = \\frac { \\rho _ { i } } { \\sum _ { n = 1 } ^ { N } \\rho _ { n } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            564,
+            552,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $N$ is the number of trajectories in the memory buffer. Now the density $\\rho$ is between zero and one, i.e. $0 \\leq \\rho \\leq 1$ , After calculating the trajectory density, the agent stores the density value along with the trajectory in the memory buffer for later prioritization. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 PRIORITIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            344,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During replay, the agent puts more focus on the under-represented achieved states and prioritizes the according trajectories. These under-represented achieved goal states have lower trajectory density. We defined the complementary trajectory density as: ",
+        "bbox": [
+            174,
+            681,
+            825,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f78b356d84116813e84a7bbdd6ef9d90e9147b356e447800bf7c0e8cca576d4.jpg",
+        "text": "$$\n\\bar { \\rho } \\propto 1 - \\rho .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            460,
+            728,
+            537,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When the agent replays the samples, it first ranks all the trajectories with respect to their complementary density values $\\bar { \\rho }$ , and then uses the ranking number (starting from zero) directly as the probability for sampling. This means that the low-density trajectories have high ranking numbers, and equivalently, have higher priorities to be replayed. Here we use the ranking instead of the density directly. The reason is that the rank-based variant is more robust because it is not affected by outliers nor by density magnitudes. Furthermore, its heavy-tail property also guarantees that samples will be diverse (Schaul et al., 2015b). Mathematically, the probability of a trajectory to be replayed after the prioritization is: ",
+        "bbox": [
+            173,
+            753,
+            825,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5a8c434ab85017d8d6b9703895492c23f61dcc568985082c37bf0d011f4caea0.jpg",
+        "text": "$$\np ( \\tau _ { i } ) = \\frac { \\mathrm { r a n k } ( \\bar { \\rho } ( \\tau _ { i } ) ) } { \\sum _ { n = 1 } ^ { N } \\mathrm { r a n k } ( ( \\bar { \\rho } ( \\tau _ { n } ) ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            868,
+            598,
+            906
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $N$ is the total number of trajectories in the buffer, and $\\mathrm { r a n k } ( \\cdot ) \\in \\{ 0 , 1 , . . . , N - 1 \\}$ ",
+        "bbox": [
+            169,
+            909,
+            756,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.4 COMPLETE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            398,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We summarize the complete training algorithm in Algorithm 1. ",
+        "bbox": [
+            173,
+            127,
+            586,
+            142
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Curiosity-Driven Prioritization (CDP) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            157,
+            513,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given: • an off-policy RL algorithm A $\\triangleright$ e.g. DDPG, DDPG+HER $\\bullet$ a reward function $r : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { G } \\to \\mathbb { R }$ . . e.g. $r ( s , a , g ) = - 1$ (fail), 0 (success)   \nInitialize neural networks of A, density model V-GMM, and replay buffer $R$   \nfor epoch $= 1$ , $M$ do for episode $= 1$ , $N$ do Sample a goal $g$ and an initial state $s _ { 0 }$ . Sample a trajectory $\\tau = ( s _ { t } \\| g , a _ { t } , r _ { t } , s _ { t + 1 } \\| g ) _ { t = 0 } ^ { T }$ using $\\pi _ { b }$ from A Calculate the densities $\\rho$ and $\\bar { \\rho }$ using Equation (1), (2) and (3) $\\triangleright$ estimate density Calculate the priority $p ( \\tau )$ using Equation (4) Store transitions $( s _ { t } \\dot { } \\rvert \\rvert g , a _ { t } , r _ { t } , s _ { t + 1 } \\rvert \\rvert g , p , \\bar { \\rho } ) _ { t = 0 } ^ { T }$ in $R$ Sample trajectory $\\tau$ from $R$ based on the priority, $p ( \\tau )$ . prioritization Sample transitions $\\left( { { s _ { t } } , { a _ { t } } , { s _ { t + 1 } } } \\right)$ from $\\tau$ Sample virtual goals $g ^ { \\prime } \\in \\{ s _ { t + 1 } , . . . , s _ { T - 1 } \\}$ at a future timestep in $\\tau$ $r _ { t } ^ { \\prime } : = r ( s _ { t } , a _ { t } , g ^ { \\prime } )$ $\\triangleright$ recalculate reward (HER) Store the transition $\\left( s _ { t } \\| g ^ { \\prime } , a _ { t } , r _ { t } ^ { \\prime } , s _ { t + 1 } \\| g ^ { \\prime } , p , \\bar { \\rho } \\right)$ in $R$ Perform one step of optimization using A end for Train the density model using the collected trajectories in $R$ $\\triangleright$ fit density model Update the density in $R$ using the trained model . refresh density   \nend for ",
+        "bbox": [
+            176,
+            165,
+            825,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 AN IMPORTANCE SAMPLING PERSPECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            494,
+            513,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The mathematical explanation for the efficiency of CDP is based on importance sampling. Importance sampling is a general technique to estimate an integral $\\textstyle \\int f ( x ) p ( { \\bar { x } } ) d x$ of a function $f ( x )$ , with the exact distribution $p ( x )$ (Murphy, 2012; Owen, 2013). Here, we consider using importance sampling to estimate the integral of the loss function $ { \\mathcal { L } } ( \\tau )$ of the reinforcement learning agent: ",
+        "bbox": [
+            174,
+            521,
+            825,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90058005aeb35a3361dabb3f9056889148c23a8ee500bf7352402c0c9c37b5e3.jpg",
+        "text": "$$\nI = \\mathbb { E } [ \\mathcal { L } ] = \\int \\mathcal { L } ( \\tau ) \\frac { p ( \\tau ) } { q ( \\tau ) } q ( \\tau ) d \\tau \\approx \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\omega _ { i } f ( \\tau _ { i } ) = \\hat { I } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            583,
+            684,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is a trajectory, $q ( \\tau )$ is a proposal distribution, and $\\omega _ { i } = p ( \\tau _ { i } ) / q ( \\tau _ { i } )$ is an importance weight. ",
+        "bbox": [
+            174,
+            632,
+            820,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The idea here is to draw samples $\\tau$ from the buffer in regions which have a high probability, $p ( \\tau )$ , but also where $\\mathcal { L } | ( \\tau ) |$ is large. Since, $p ( \\tau )$ is a uniform distribution, i.e. the agent replays trajectories at random, we only need to draw samples which has large errors $\\mathcal { L } | ( \\tau ) |$ . The result can be highly efficient, meaning the agent needs less samples than sampling from the uniform distribution $p ( \\tau )$ . The CDP framework finds the samples that have large errors based on the ‘surprise’ of the trajectory. The variance of the estimate $\\hat { I }$ is: $\\mathrm { v a r } _ { q } [ \\mathcal { L } ( \\tau ) \\omega ( \\tau ) ) ] = \\mathbb { E } _ { q } [ \\mathcal { L } ^ { 2 } ( \\tau ) \\omega ^ { 2 } ( \\tau ) ] - I ^ { 2 }$ . Since the last term is independent of $q$ , we can ignore it. Using Jensen’s inequality, we have the following lower bound: ",
+        "bbox": [
+            173,
+            654,
+            825,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7bb5532c428c78c3c1ecfcd7ea28db288c465c7fe546adcf3d9407bac0f04438.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { q } [ \\mathcal { L } ^ { 2 } ( \\tau ) \\omega ^ { 2 } ( \\tau ) ] \\geqslant ( \\mathbb { E } _ { q } [ | \\mathcal { L } ( \\tau ) \\omega ( \\tau ) | ] ) ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            758,
+            627,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To reduce the variance, we set the importance weight as a constant $\\omega ( \\tau ) = 1$ . This bias-variance trade-off also saves computational time and does not lead to instabilities in our experiment. With CDP, the agent estimates the loss function more efficiently and therefore learns faster. Any density estimation method that can approximate the trajectory density can provide a more efficient proposal distribution $q ( \\tau )$ than the uniform distribution $p ( \\tau )$ . ",
+        "bbox": [
+            173,
+            782,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 COMPARISON WITH PRIORITIZED EXPERIENCE REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            599,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To the best our knowledge, the most similar method to CDP is Prioritized Experience Replay (PER) (Schaul et al., 2015b). To combine PER with HER, we calculate the TD-error of each transition based on the randomly selected achieved goals. Then we prioritize the transitions with higher TDerrors for replay. It is known that PER can become very expensive in computational time (Schaul et al., 2015b), especially when the memory size $N$ is very large. The reason is that PER uses TDerrors for prioritization. After each update of the model, the agent needs to update the priorities of the transitions in the replay buffer, which is ${ \\cal O } ( \\log N )$ . In our experiments, see Section 4, we use the efficient implementation based on the ”sum-tree” data structure, which can be relatively efficiently updated and sampled from (Schaul et al., 2015b). ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f82ed9d4ac466d2a16cdb666d54e9adb4066e0853470ebcba41622266b34221.jpg",
+        "image_caption": [
+            "Figure 2: Mean test success rate with standard deviation in all six robot environments "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            97,
+            823,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            424,
+            825,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Compared to PER, CDP is much faster in computational time because it only updates the trajectory density once per epoch. Due to this reason, CDP is much more efficient than PER in computational time and can be easily combined with any multi-goal RL methods, such as DDPG and HER. In the experiments, Section 4, we first compare the performance improvement of CDP and PER. Afterwards, we compare the time-complexity of PER and CDP. We show that CDP improves performance with much less computational time than PER. Furthermore, the motivations of PER and CDP are different. The former uses TD-errors, while the latter is based on the density of the trajectories. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            652,
+            326,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the following questions: ",
+        "bbox": [
+            173,
+            688,
+            529,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "- Does incorporating CDP bring benefits to DDPG or DDPG $^ +$ HER? - Does CDP improve the sample-efficiency in robotic manipulation tasks? - How does the density $\\bar { \\rho }$ relate to the TD-errors of the trajectory during training? ",
+        "bbox": [
+            176,
+            702,
+            705,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Performance: To test the performance difference among DDPG, DDPG $^ +$ PER, and DDPG+CDP, we run the experiment in the three robot arm environments. We use the DDPG as the baseline here because the robot arm environment is relatively simple. In the more challenging robot hand environments, we use DDPG $^ +$ HER as the baseline method and test the performance among DDPG $+$ HER, $\\mathrm { D D P G + H E R + P E R }$ , and DDPG $+$ HER $^ +$ CDP. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the mean success rates. Each experiment is carried out across 5 random seeds and the shaded area represents the standard deviation. The learning curve with respect to training epochs is shown in Figure 2. For all experiments, we use 19 CPUs and train the agent for 200 epochs. After training, we use the best-learned policy as the final policy and test it in the environment. The testing results are the final mean success rates. A comparison of the final performances along with the training time is shown in Table 1. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7240fc3d54e80d616b7fb15a500544240eba99e68fda0d350b44b8d9d8e108ee.jpg",
+        "table_caption": [
+            "Table 1: Final mean success rate $( \\% )$ and the training time (hour) for all six environments "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Push</td><td colspan=\"2\">Pick&amp;Place</td><td colspan=\"2\">Slide</td></tr><tr><td>Method</td><td>success</td><td>time</td><td>success</td><td>time</td><td>success</td><td>time</td></tr><tr><td>DDPG</td><td>99.90%</td><td>5.52h</td><td>39.34%</td><td>5.61h</td><td>75.67%</td><td>5.47h</td></tr><tr><td>DDPG+PER</td><td>99.94%</td><td>30.66h</td><td>67.19%</td><td>25.73h</td><td>66.33%</td><td>25.85h</td></tr><tr><td>DDPG+CDP</td><td>99.96%</td><td>6.76h</td><td>76.02%</td><td>6.92h</td><td>76.77%</td><td>6.66h</td></tr><tr><td></td><td colspan=\"2\">Egg</td><td colspan=\"2\">Block</td><td colspan=\"2\">Pen</td></tr><tr><td>Method</td><td>success</td><td>time</td><td>success</td><td>time</td><td>success</td><td>time</td></tr><tr><td>DDPG+HER</td><td>76.19%</td><td>7.33h</td><td>20.32%</td><td>8.47h</td><td>27.28%</td><td>7.55h</td></tr><tr><td>DDPG+HER+PER</td><td>75.46%</td><td>79.86h</td><td>18.95%</td><td>80.72h</td><td>27.74%</td><td>81.17h</td></tr><tr><td>DDPG+HER+CDP</td><td>81.30%</td><td>17.00h</td><td>25.00%</td><td>19.88h</td><td>31.88%</td><td>25.36h</td></tr></table>",
+        "bbox": [
+            181,
+            127,
+            812,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/82e5af27833112a04cfe6c345f3f72c9fec8fd61627565748d18cffef3611b47.jpg",
+        "image_caption": [
+            "Figure 3: Number of training samples needed with respect to mean test success rate for all six environments (the lower the better) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            321,
+            795,
+            578
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Figure 2, we can see that CDP converges faster in all six tasks than both the baseline and PER. The agent trained with CDP also shows a better performance at the end of the training, as shown in Table 1. In Table 1, we can see that the training time of CDP lies in between the baseline and PER. To be more specific, CDP consumes much less computational time than PER does. For example in the robot arm environments, on average DDPG $^ +$ CDP consumes about 1.2 times the training time of DDPG. In comparison, DDPG $^ +$ PER consumes about 5 times the training time as DDPG does. In this case, CDP is 4 times faster than PER. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows that baseline methods with CDP give a better performance in all six tasks. The improvement goes up to 39.34 percentage points compared to the baseline methods. The average improvement over the six tasks is 9.15 percentage points. We can see that CDP is a simple yet effective method, improves state-of-the-art methods. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sample-Efficiency: To compare the sample-efficiency of the baseline and CDP, we compare the number of training samples needed for a certain mean test success rate. The comparison is shown in Figure 3. From Figure 3, in the FetchPush-v0 environment, we can see that for the same $9 9 \\%$ mean test success rate, the baseline DDPG needs 273,600 samples for training, while $\\mathrm { \\Delta D D P G + C D P }$ only needs 112,100 samples. In this case, DDPG $^ +$ CDP is more than twice (2.44) as sample-efficient as DDPG. Similarly, in the other five environments, CDP improves sample-efficiency by factors of 2.84, 0.92, 1.37, 1,28 and 2.87, respectively. In conclusion, for all six environments, CDP is able to improve sample-efficiency by an average factor of two (1.95) over the baseline’s sample-efficiency. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e11815e7ef8b32a8c85d77ab2c6e0d4aab43821cd86c20426a80d7665af8925.jpg",
+        "image_caption": [
+            "Figure 4: Pearson correlation between the density $\\bar { \\rho }$ and TD-errors in the middle of training "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            99,
+            790,
+            248
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Insights: We also investigate the correlation between the complementary trajectory density $\\bar { \\rho }$ and the TD-errors of the trajectory. The Pearson correlation coefficient, i.e. Pearson’s r (Benesty et al., 2009), between the density $\\bar { \\rho }$ and the TD-errors of the trajectory is shown in Figure 4. The value of Pearson’s r is between 1 and -1, where 1 is total positive linear correlation, 0 is no linear correlation, -1 is total negative linear correlation. In Figure 4, we can see that the complementary trajectory density is correlated with the TD-errors of the trajectory with an average Pearson’s r of 0.7. This proves that the relatively rare trajectories in the memory buffer are more valuable for learning. Therefore, it is helpful to prioritize the trajectories with lower density during training. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            412
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            344,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experience replay was proposed by Lin (1992) and became popular due to the success of DQN (Mnih et al., 2015). In the same year, prioritized experience replay was introduced by Schaul et al. (2015b) as an improvement of the experience replay in DQN. It prioritized the transitions with higher TD-error in the replay buffer to speed up training. Schaul et al. (2015a) also proposed universal function approximators, generalizing not just over states but also over goals. There are also many other research works about multi-task RL (Schmidhuber & Huber, 1990; Caruana, 1998; Da Silva et al., 2012; Kober et al., 2012; Pinto & Gupta, 2017; Foster & Dayan, 2002; Sutton et al., 2011). Hindsight experience replay (Andrychowicz et al., 2017) is a kind of goal-conditioned RL that substitutes any achieved goals as real goals to encourage the agent to learn something instead of nothing. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            592
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Curiosity-driven exploration is a well-studied topic in reinforcement learning (Oudeyer & Kaplan, 2009; Oudeyer et al., 2007; Schmidhuber, 1991; 2010; Sun et al., 2011). Pathak et al. (2017) encourage the agent to explore states with high prediction error. The agents are also encouraged to explore ”novel” or uncertain states (Bellemare et al., 2016; Lopes et al., 2012; Poupart et al., 2006; Houthooft et al., 2016; Mohamed & Rezende, 2015; Chentanez et al., 2005; Stadie et al., 2015). ",
+        "bbox": [
+            174,
+            598,
+            825,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "However, we integrate curiosity into prioritization and tackle the problem of data imbalance (Galar et al., 2012) in the memory buffer of RL agents. A recent work (Narasimhan et al., 2015) introduced a form of re-sampling for RL agents based on positive and negative rewards. The idea of our method is complementary and can be combined. The motivation of our method is from the curiosity mechanism in the human brain (Gruber et al., 2014). The essence of our method is to assign priority to the achieved trajectories with lower density, which are relatively more valuable to learn from. In supervised learning, similar tricks are used to mitigate the class imbalance challenge, such as over-sampling the data in the under-represented class (Hinton, 2007; He & Garcia, 2008). ",
+        "bbox": [
+            174,
+            674,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            318,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, we proposed a simple yet effective curiosity-driven approach to prioritize agent’s experience based on the trajectory density. Curiosity-Driven Prioritization shows promising experimental results in all six challenging robotic manipulation tasks. This method can be combined with any off-policy RL methods, such as DDPG and DDPG $^ +$ HER. We integrated the curiosity mechanism via density estimation into the modern RL paradigm and improved sample-efficiency by a factor of two and the final performance by nine percentage points on top of state-of-the-art methods. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016. ",
+        "bbox": [
+            178,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Benesty, Jingdong Chen, Yiteng Huang, and Israel Cohen. Pearson correlation coefficient. In Noise reduction in speech processing, pp. 1–4. Springer, 2009. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David M Blei, Michael I Jordan, et al. Variational inference for dirichlet process mixtures. Bayesian analysis, 1(1):121–143, 2006. ",
+        "bbox": [
+            173,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Buda, Atsuto Maki, and Maciej A Mazurowski. A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259, 2018. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            373
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998. ",
+        "bbox": [
+            174,
+            382,
+            728,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yevgen Chebotar, Mrinal Kalakrishnan, Ali Yahya, Adrian Li, Stefan Schaal, and Sergey Levine. Path integral guided policy search. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3381–3388. IEEE, 2017. ",
+        "bbox": [
+            176,
+            406,
+            823,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nuttapong Chentanez, Andrew G Barto, and Satinder P Singh. Intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 1281–1288, 2005. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bruno Da Silva, George Konidaris, and Andrew Barto. Learning parameterized skills. arXiv preprint arXiv:1206.6398, 2012. ",
+        "bbox": [
+            173,
+            496,
+            823,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. Ieee, 2009. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Richard O Duda and Peter E Hart. Pattern classification and scene analysis. A Wiley-Interscience Publication, New York: Wiley, 1973, 1973. ",
+        "bbox": [
+            173,
+            585,
+            823,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pedro Felzenszwalb, David McAllester, and Deva Ramanan. A discriminatively trained, multiscale, deformable part model. In Computer Vision and Pattern Recognition, 2008. CVPR 2008. IEEE Conference on, pp. 1–8. IEEE, 2008. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Foster and Peter Dayan. Structure in the space of value functions. Machine Learning, 49 (2-3):325–346, 2002. ",
+        "bbox": [
+            169,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikel Galar, Alberto Fernandez, Edurne Barrenechea, Humberto Bustince, and Francisco Herrera. A review on ensembles for the class imbalance problem: bagging-, boosting-, and hybrid-based approaches. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(4):463–484, 2012. ",
+        "bbox": [
+            173,
+            715,
+            826,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning, volume 1. MIT press Cambridge, 2016. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthias J Gruber, Bernard D Gelman, and Charan Ranganath. States of curiosity modulate hippocampus-dependent learning via the dopaminergic circuit. Neuron, 84(2):486–496, 2014. ",
+        "bbox": [
+            171,
+            818,
+            821,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Transactions on Knowledge & Data Engineering, (9):1263–1284, 2008. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton. To recognize shapes, first learn to generate images. Progress in brain research, 165:535–547, 2007. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pp. 1109–1117, 2016. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober, Andreas Wilhelm, Erhan Oztop, and Jan Peters. Reinforcement learning to adjust parametrized motor primitives to new situations. Autonomous Robots, 33(4):361–379, 2012. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            173,
+            232,
+            823,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992. ",
+        "bbox": [
+            173,
+            285,
+            821,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in modelbased reinforcement learning by empirically estimating learning progress. In Advances in Neural Information Processing Systems, pp. 206–214, 2012. ",
+        "bbox": [
+            173,
+            323,
+            826,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. ",
+        "bbox": [
+            176,
+            375,
+            823,
+            419
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shakir Mohamed and Danilo Jimenez Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 2125–2133, 2015. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin P Murphy. Machine learning: A probabilistic perspective. adaptive computation and machine learning, 2012. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karthik Narasimhan, Tejas Kulkarni, and Regina Barzilay. Language understanding for text-based games using deep reinforcement learning. arXiv preprint arXiv:1506.08941, 2015. ",
+        "bbox": [
+            173,
+            517,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Adam Coates, Mark Diel, Varun Ganapathi, Jamie Schulte, Ben Tse, Eric Berger, and Eric Liang. Autonomous inverted helicopter flight via reinforcement learning. In Experimental Robotics IX, pp. 363–372. Springer, 2006. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009. ",
+        "bbox": [
+            173,
+            608,
+            820,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. IEEE transactions on evolutionary computation, 11(2):265–286, 2007. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Art B. Owen. Monte Carlo theory, methods and examples. 2013. ",
+        "bbox": [
+            173,
+            699,
+            599,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning (ICML), volume 2017, 2017. ",
+        "bbox": [
+            173,
+            724,
+            826,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters and Stefan Schaal. Reinforcement learning of motor skills with policy gradients. Neural networks, 21(4):682–697, 2008. ",
+        "bbox": [
+            168,
+            776,
+            825,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto and Abhinav Gupta. Learning to push by grasping: Using multiple tasks for effective learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 2161– 2168. IEEE, 2017. ",
+        "bbox": [
+            173,
+            814,
+            823,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthias Plappert, Marcin Andrychowicz, Alex Ray, Bob McGrew, Bowen Baker, Glenn Powell, Jonas Schneider, Josh Tobin, Maciek Chociej, Peter Welinder, et al. Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464, 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pascal Poupart, Nikos Vlassis, Jesse Hoey, and Kevin Regan. An analytic solution to discrete bayesian reinforcement learning. In Proceedings of the 23rd international conference on Machine learning, pp. 697–704. ACM, 2006. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Murray Rosenblatt. Remarks on some nonparametric estimates of a density function. The Annals of Mathematical Statistics, pp. 832–837, 1956. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In International Conference on Machine Learning, pp. 1312–1320, 2015a. ",
+        "bbox": [
+            169,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015b. ",
+        "bbox": [
+            171,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. A possibility for implementing curiosity and boredom in model-building neu- ¨ ral controllers. In Proc. of the international conference on simulation of adaptive behavior: From animals to animats, pp. 222–227, 1991. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). ¨ IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber and Rudolf Huber. ¨ Learning to generate focus trajectories for attentive vision. Institut fur Informatik, 1990. ¨ ",
+        "bbox": [
+            174,
+            357,
+            820,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            173,
+            395,
+            826,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015. ",
+        "bbox": [
+            171,
+            446,
+            821,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Sun, Faustino Gomez, and Jurgen Schmidhuber. Planning to be surprised: Optimal bayesian ¨ exploration in dynamic environments. In International Conference on Artificial General Intelligence, pp. 41–51. Springer, 2011. ",
+        "bbox": [
+            174,
+            484,
+            821,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998. ",
+        "bbox": [
+            173,
+            536,
+            821,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2, pp. 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            652,
+            821,
+            695
+        ],
+        "page_idx": 10
+    }
+]

parse/train/SkqMSCHxe/SkqMSCHxe.md

@@ -0,0 +1,179 @@
+# PREDICTION OF POTENTIAL HUMAN INTENTION USING SUPERVISED COMPETITIVE LEARNING
+
+Masayoshi Ishikawa, Mariko Okude, Takehisa Nishida & Kazuo Muto   
+Hitachi, Ltd   
+Omika 7-1-1, Hitachi, Ibaraki, JAPAN   
+{masayoshi.ishikawa.gv, mariko.okude.uh}@hitachi.com   
+{takehisa.nishida.cu, kazuo.muto.ny}@hitachi.com
+
+# ABSTRACT
+
+We propose a learning method to quantify human intention. Generally, a human being will imagine several potential actions for a given scene, but only one of these actions will subsequently be taken. This makes it difficult to quantify human intentions.
+
+To solve this problem, we apply competitive learning to human behavior prediction as supervised learning. In our approach, competitive learning generates several outputs that are then associated with several potential situations imagined by a human. We applied the proposed method to human driving behavior and extracted three potential driving patterns. Results showed a squared error is reduced to 1/25 that of a conventional method . We also found that competitive learning can distinguish valid data from disturbance data in order to train a model.
+
+# 1 INTRODUCTION
+
+Progress in advanced driving assistance systems (ADASs) has led to an autonomous driving function applicable for highway driving . The vehicle control logic of ADAS is typically developed by hand. There are a few related works on controlling vehicles comfortably , but the complex nature of vehicle environments prevents development by hand. Therefore, recent research has focused on the application of machine learning to autonomous driving systems. The convolutional neural network (CNN) shows particular promise as a core algorithm (Krizhevsky et al. (2012)). C. Chen & Xiao (2015) estimates affordance for driving directly from a front camera image. They train a CNN to generate key perception indicators from images to easily control a vehicle. Similarly, Bojarski et al. (2016) predict the desired steering command directly from front camera images. They train a CNN with a human command as training data and drive in traffic on local roads with or without lane marking and on highways.
+
+Our objective is to provide drivers with a comfortable trip featuring automatic vehicle control . The above methods provide a uniform control for various scenarios, but drivers have an assortment of preference behaviors, and individuals may drive in different ways even if the scenario or situation is the same. For example, on the highway, one person might drive hard to arrive at a destination quickly while another might drive relatively slowly to arrive at a destination safely. Therefore, we want to provide autonomous driving adapted to each individual to improve ease of driving and to generate control targets that imitate individual behavior. To imitate individual behavior, we predict future vehicle states resulting from an individualfs decision.
+
+There are many studies on the imitation of human behavior within the context of driving. Ma & Andreasson ´ (2006) proposed a vehicle interaction model that predicts future acceleration on the basis of current acceleration, velocity, relative velocity, and relative distance of the preceding vehicle. Moon & Choi (2011) proposed a method to predict human steering behavior. Their model considers path planning, feed-forward steering, and feedback steering. While these methods consider only acceleration or steering, Gindele et al. (2010) proposed a more complex model, the dynamic Bayesian network model, to estimate driver behavior and vehicle trajectory. This model considers vehicle model, trajectory, driver decision, and situation context. Wada et al. (2007) proposed a method to predict braking behavior. This method monitors the size of a preceding vehicle by means of front camera images to detect collision risk.
+
+![](images/2ff027ddbe2c5f82db15c38f1ad9cd6be92e8aa16a7160d49c54aed49b1a4140.jpg)  
+Figure 1: Graphical model of driving behavior.
+
+These methods provide one output for one scene. However, we assume that one output might represent just one part of a driverfs behavior. We assume a driver will imagine several potential situations for one scene and have several potential actions to take associated with each situation. This means the driver is making decisions all the time. Therefore, we want to extract several of the driver’s candidate actions or intentions for the autonomous control of a vehicle while considering various potential situations.
+
+In this paper, we propose a method to extract a driver’s potential intention by utilizing competitive learning (Ahalt et al. (1990), Shinozaki & Naruse (2013), Osoba & Kosko (2013)). Originally, competitive learning was used for unsupervised neural network algorithms and functioned as clustering. In such competitive learning, neural networks have several output layers and only one path that outputs the smallest loss to be trained . Consequently, neural networks predict the cluster with the most activated units .
+
+Ahalt et al. (1990) compare several competitive learning algorithms. In this paper, competitive learning algorithms is dealt as a kind of vector quantization algorithms. Shinozaki & Naruse (2013) utilize competitive learning for pre-training of deep neural networks and they also use competitive learning as unsupervised learning. Osoba & Kosko (2013) consider supervised competitive learning. However, they use also competitive learning as a kind of clustering methods. Therefore, in our best knowledge, competitive learning is dealt as a kind of unsupervised learning algorithms or clustering algorithms.
+
+We apply competitive learning to time series supervised learning, especially, regression task. And we train neural networks to output several patterns associated with a driver’s potential intentions. In this paper, we describe how to model the driving behavior with competitive learning architecture . Additionally, we show the experimental results of tests performed with an actual vehicle.
+
+# 2 DRIVER BEHAVIOR MODEL
+
+Here, we describe how to model driving behavior and how to implement the neural network architecture.
+
+Our driving behavior model is a dynamic system that includes both a driver and a vehicle system. In this model, the driver observes the environment and then decides on a driving action, e.g., steering or pedal operation. The vehicle system then changes its state depending on the driving action and the state of the vehicle at a previous time. Finally, we observe the various vehicle states. For example, the environment observed by the driver is the same as that shown by the front camera and the vehicle states include travel speed, accelerations, gas pedal position, brake pedal position, engine speed, engine load, engine temperature, fuel level, fuel temperature, cooling water temperature, etc.
+
+A graphical model of driving behavior is shown in Fig. 1. Here, $e$ stands for the environment observed by the driver, $d$ stands for the driving action decided by the driver, $s$ stands for vehicle states, and $x$ stands for observed vehicle states. Subscripts $t - 1$ and $t$ refer to time steps. Environment $e$ and parts of vehicle states $x$ are observed. Driving action $d$ and whole vehicle states $s$ are latent variables. We assume a front camera view for environment $e$ . Observed variables $x$ include travel speed, gas pedal position, engine speed, and engine load.
+
+![](images/368046ac29b30176160365c67ef0756dd0cb48eae41b1e61bfce56c1ee2c4391.jpg)  
+Figure 2: Neural network architecture designed to imitate driving model.
+
+To ensure comfortable driving, we estimate the driver’s intention by predicting vehicle states in $\mathbf { k }$ step future . The relations between each variable are shown in the following equations.
+
+$$
+\begin{array} { r c l } { { d _ { t } } } & { { = } } & { { f _ { e } ( e _ { t } ; \theta _ { e } ) } } \\ { { s _ { t } } } & { { = } } & { { f _ { s } ( s _ { t - 1 } ; \theta _ { s } ) + f _ { d } ( , d _ { t } ; \theta _ { d } ) } } \\ { { x _ { t } } } & { { = } } & { { f _ { x } ( s _ { t } ; \theta _ { x } ) } } \\ { { x _ { t + k } } } & { { = } } & { { f _ { x + k } ( s _ { t } ; \theta _ { x + k } ) } } \end{array}
+$$
+
+Additionally, we compensate for latent variable $s _ { t }$ by observable variable $x _ { t }$ . The compensated $s _ { t }$ are shown in Eq. 5:
+
+$$
+s _ { t } = f _ { s } ( s _ { t - 1 } ; \theta _ { s } ) + f _ { d } ( , d _ { t } ; \theta _ { d } ) + f _ { x } ^ { - 1 } ( x _ { t } ; \theta _ { x } ^ { - 1 }
+$$
+
+We design the neural network architecture in accordance with the driving behavior model shown in Fig. 1. The designed architecture is shown in Fig. 2. First, we select convolutional neural network (CNN) layers to approximate driving action $f _ { e }$ , as the driver decides which action to take depending on the front view and CNN is the best layer to process images. The front camera images are resized to $2 5 6 \times 2 5 6$ with RGB channels. Second, we select a recurrent neural network (RNN) layer to approximate vehicle states $f _ { s }$ , as our driver model is a dynamic system (Graves (2013)). Finally, we select a fully connected layer for other layers $f _ { d } , f _ { x } ^ { - 1 } , f _ { x + k }$ because of its usability. This model predicts observed variables and we train the driver behavior model by loss function. We select squared error as loss function $L ( x _ { t + k } , \hat { x } _ { t + k } )$ and update parameters by backpropagation (Hecht-NielsenWerbos (1990)).
+
+$$
+L ( x _ { t + k } , \hat { x } _ { t + k } ) = | x _ { t + k } - \hat { x } _ { t + k } | ^ { 2 }
+$$
+
+The CNN consists of three layers. In the first layer, kernel size is $1 1 \times 1 1$ with 64 channels and stride 4 . In the second layer, kernel size is $5 \times 5$ with 128 channels. In the third layer, kernel size is $3 \times 3$ with 128 channels. After all CNN layers, we apply batch normalization, ReLU, and max pooling (Ioffe & Szegedy (2015)). The RNN layer has 1024 units. We use the ADAM algorithm for optimization (Kingma & Ba (2014)).
+
+The architecture shown in Fig. 2 is a baseline architecture and cannot extract potential driver intentions. In the next section, we introduce a competitive learning architecture that can extract potential intentions and discuss how to train it.
+
+![](images/6ad87973d930c6a8677ff61777eea246abe1608f5d12c7c301c15c5999ea7223.jpg)  
+Figure 3: Competitive learning architecture.
+
+![](images/1b40f23d73f0dd6f17a0ed1519a1f5ec696dafb129d381c990fec9432ec22b79.jpg)  
+Figure 4: Backpropagation in competitive learning architecture.
+
+# 3 COMPETITIVE LEARNING FOR DRIVER BEHAVIOR MODEL
+
+# 3.1 COMPETITIVE LEARNING ARCHITECTURE
+
+The competitive learning architecture is shown in Fig. 3. It has $N _ { o }$ output layers. Additionally, we set up $N _ { o }$ RNN layers, as the driver’s potential intentions are separated depending on the driving actions . Therefore, a separated RNN will be affected by separated intentions. The i-th RNN i and the output layer generate i-th prediction $\hat { x } _ { t + k } ^ { i }$ at time $\mathbf { t } { + } \mathbf { k }$ . We calculate i-th loss using Eq. 7 and decide the loss for backpropagation using Eq. 9. Finally, we update the parameters depending on this loss for backpropagation.
+
+$$
+\begin{array} { c c l } { { l ^ { i } } } & { { = } } & { { L ( x _ { t + k } , \hat { x } _ { t + k } ^ { i } ) } } \\ { { L } } & { { = } } & { { [ l ^ { 1 } , . . . l ^ { i } , . . l ^ { N _ { o } } ] } } \\ { { } } & { { } } & { { } } \\ { { l _ { b p } ^ { i } } } & { { = } } & { { \left\{ \begin{array} { c } { { 0 i \ne \arg \operatorname* { m i n } ( L ) } } \\ { { l ^ { i } i = \arg \operatorname* { m i n } ( L ) } } \end{array} \right. } } \end{array}
+$$
+
+Backpropagation in the competitive learning architecture is shown in Fig. 4. In the competitive learning architecture, we train only the computation path that output minimum loss. In Fig. 4, the computation path to be trained is indicated by solid lines and the layer whose parameters are not updated is indicated by dashed lines. In this case, the i-th output layer has minimum loss and is trained. The other output layers (i.e., whose losses are bigger than i-th) are not trained and the losses are compensated as zero. Since each output layer is trained by different data, each prediction reflects different intentions. Therefore, competitive learning can extract several potential intentions.
+
+![](images/7152df6e47af2ba2cacae6cb75817761bdc3d79822bc5355aa6047243ff233eb.jpg)  
+Figure 5: Pre-training for competitive learning architecture.
+
+# 3.2 PRE-TRAINING FOR COMPETITIVE LEARNING
+
+Here, we discuss the pre-training for competitive learning. In our experiments, competitive layers with simple initialization are difficult to train, and many experiments result in only one output layer being trained. Since only one computation path is trained at a time in competitive learning, how the trained path is decided depends on the initialization. Therefore, we need to ensure appropriate initialization for competitive layers. To this end , we adopt a pre-training technique for competitive learning (Erhan et al. (2010), Erhan et al.). Pre-training is an initialization technique for neural networks and is typically used for stacking neural networks. In this work, we apply pre-training to initialize the parallel competitive layer, as shown in Fig. 5. First, we train only one output layer by means of the ordinal loss function in Eq. 6. Then, we initialize competitive layers by copying pre-trained parameters. Finally, we train each output layer as fine-tuning.
+
+# 4 EXPERIMENTAL RESULTS
+
+In order to evaluate the proposed method, we record the front camera view using a smartphone and collect actual vehicle data using OBD2 (Birnbaum & Truglia (2000), International (2003)). The data on vehicle states are whitened by removing means and scaled variances. Front camera images and vehicle data are resampled to $2 \ \mathrm { H z }$ . Six steps (equivalent to three seconds in the future) are predicted. We collect 80 minutes of data and use 40 minutes to train the neural networks. We set three competitive layers and train 300 iterations for pre-training and 2000 iterations for fine-tuning. We train neural networks with TITAN Z and use the Chainer framework (Tokui et al. (2015)).
+
+# 4.1 COMPARISON OF COMPETITIVE LEARNING ARCHITECTURE WITH BASELINE ARCHITECTURE
+
+Before we show the competitive learning results, we present the results of the baseline architecture shown in Fig. 6 . These data are predictions of vehicle speed over ten minutes. The left figure is the prediction on training data and the right one is on test data. Red line indicates the measured speed and blue line indicates the prediction by baseline architecture. In the training data, the baseline architecture could predict accurately in the low speed band under $3 0 \mathrm { k m / h }$ . However, the prediction error became bigger in the middle-high speed band over $3 0 ~ \mathrm { k m / h }$ . In the higher speed band, the driverfs action had several variations even when the vehicle was operating in the same environment. This variation made prediction difficult. In the test data prediction, prediction error became bigger in not only the high speed band but also the very low speed band around $0  { \mathrm { k m } } /  { \mathrm { h } }$ . Additionally, the timing of the acceleration or deceleration shifted later, too. This is because the baseline architecture cannot extract potential driving intentions.
+
+The competitive learning results are shown in Fig. 7. This figure is written up the same way as Fig. 6, except the blue line refers to integrated predictions by the competitive learning architecture. These predictions are a combination of three outputs derived by selecting minimum loss. In the training data prediction, the competitive learning architecture predicted a value quite close to the measured vehicle speed before three seconds . In the test data prediction, the competitive learning architecture could also predict the speed accurately. Additionally, the timing shift of acceleration or deceleration became smaller. The loss summation in both the training and test data is listed in Table 1. Competitive learning architecture loss was about 1/25 smaller in the training data and about 1/3 smaller in the test data compared with the baseline architecture.
+
+![](images/956dd7597b79cdf9242bd503d59d43902c0cec65e032c487bfce52f829b507d8.jpg)  
+Figure 6: Prediction of baseline architecture on training data (left) and test data (right).
+
+![](images/91463632bcdca87f522eea7b00d381aadfc893ffdeaa183e2b81e5b93f92ae1a.jpg)  
+Figure 7: Integrated prediction of competitive architecture on training data (left) and test data (right).
+
+# 4.2 COMPETITIVE LEARNING PREDICTION ASSOCIATED WITH POTENTIAL INTENTIONS
+
+Here, we show the driving intentions extracted using the competitive learning architecture. The intentions extracted from the training data are shown in Fig. 8. Four time series data are included: upper left is the integrated prediction, upper right is the first output layer’s prediction (indicated by green line), lower left is the second output prediction (blue line), and lower right is the third output prediction (purple line). The red lines are the measured vehicle speed. The upper left figure depicts the winning output prediction, where the minimum error prediction is output for each time and the line color refers to the winning output layer . For example, the purple line in the upper left figure is the prediction by the third output layer . We can see that each output layer is affected by other driving intentions. The first output layer accurately predicted the stop timing associated with the stop intention, the second output layer accurately predicted the acceleration or high speed band associated with a rapid intention, and the third output layer accurately predicted the deceleration timing associated with a careful intention. We also show the results of the test data in Fig. 9, which are written the same as the training data in Fig. 8. Trained intentions are also valid in test data because the first output was accurate at stop time, the second output was accurate at acceleration or the high speed band, and the third output was accurate at the time of deceleration. Therefore, extracting these potential intentions enables accurate prediction.
+
+Table 1: Summation loss of each architecture   
+
+<table><tr><td>Architecture</td><td>Loss (training)</td><td>Loss (test)</td></tr><tr><td>Baseline</td><td>335.8</td><td>2603</td></tr><tr><td>Competitive learning</td><td>13.14</td><td>816.4</td></tr></table>
+
+![](images/282ee5f1189a6acd2ee759c476c2558045baf577e08e7d34c8e0b6fbdaea83f6.jpg)  
+Figure 8: Driving intentions extracted by competitive learning architecture; training data.
+
+![](images/ee7dd3c19338cb3661006b67ba074036ff9f8127baae1b9f939bd321badf5267.jpg)  
+Figure 9: Driving intentions extracted by competitive learning architecture; test data.
+
+![](images/90578603e5d8aacceb08f50886c637d5a23fec293071ea21e18e3ec7a1e6e0d9.jpg)  
+Figure 10: Competitive layer outputs without pre-training in training data.
+
+Table 2: Summation loss without pre-training   
+
+<table><tr><td>Architecture</td><td>Loss (training)</td><td>Loss (test)</td></tr><tr><td>Baseline</td><td>335.8</td><td>2603</td></tr><tr><td>Competitive learning</td><td>13.14</td><td>816.4</td></tr><tr><td>Competitive learning without pre-training</td><td>164.0</td><td>870.9</td></tr></table>
+
+# 4.3 EFFECT OF PRE-TRAINING
+
+The competitive learning result without pre-training is shown in Fig. 10. We can train ”only one” output layer to predict driver intention even if we have three output layers. Potential intentions of the driver have similar trends. Therefore, we require the initialization of several of the same output layers . We can extract potential intentions by training each output layer using other data.
+
+We show the summation loss in Table 2. Surprisingly, competitive learning without pre-training significantly improved its losses by about $1 / 2$ for training data and about 1/3 for test data. We consider the second and third output layers to play an important role, even though they cannot learn potential intentions. There is usually a lot of inadequate data to train, and these data disrupt the training of the model. However, in most cases we cannot distinguish useful data from disturbance data. In the competitive learning architecture, each output layer automatically selects data to train its computation path. This selection might distinguish useful data from disturbance data, and the first output layer can be trained using just the useful data, even though other output layers are trained using inadequate data. In this way, competitive learning can train the model such that it is robust against noisy data.
+
+# 5 CONCLUSION
+
+We proposed supervised competitive learning to imitate a driver’s potential intentions. Competitive learning was applied to supervised learning and the squared error was reduced to 1/25 that of a conventional method. We also demonstrated that competitive learning can distinguish valid data from disturbance data to train a model.
+
+# REFERENCES
+
+Stanley C Ahalt, Ashok K Krishnamurthy, Prakoon Chen, and Douglas E Melton. Competitive learning algorithms for vector quantization. Neural networks, 3(3):277–290, 1990.
+
+Ralph Birnbaum and Jerry Truglia. Getting to Know OBD II. New York, 2000.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+A. Kornhauser C. Chen, A. Seff and J. Xiao. Deepdriving: Learning affordance for direct perception in autonomous driving. In Proceedings of 15th IEEE International Conference on Computer Vision, 2015.
+
+Dumitru Erhan, Pierre-Antoine Manzagol, Yoshua Bengio, Samy Bengio, and Pascal Vincent. The difficulty of training deep architectures and the effect of unsupervised pre-training.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11(Feb):625–660, 2010.
+
+Tobias Gindele, Sebastian Brechtel, and Rudiger Dillmann. A probabilistic model for estimating ¨ driver behaviors and vehicle trajectories in traffic environments. In Intelligent Transportation Systems (ITSC), 2010 13th International IEEE Conference on, pp. 1625–1631. IEEE, 2010.
+
+Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.
+
+Robert Hecht-Nielsen. Theory of the backpropagation neural network. In Neural Networks, 1989. IJCNN., International Joint Conference on, pp. 593–605. IEEE.
+
+SAE International. On-Board Diagnostics for Light and Medium Duty Vehicles Standards Manual. Pennsylvania, 2003.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of The 32nd International Conference on Machine Learning, pp. 448–456, 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Xiaoliang Ma and Ingmar Andreasson. Driver reaction time estimation from real car following data ´ and application in gm-type model evaluation. In Proceedings of the 85th TRB annual meeting, pp. 1–19, 2006.
+
+Chulwoo Moon and Seibum B Choi. A driver model for vehicle lateral dynamics. International journal of vehicle design, 56(1-4):49–80, 2011.
+
+Osonde Osoba and Bart Kosko. Noise-enhanced clustering and competitive learning algorithms. Neural Networks, 37:132–140, 2013.
+
+Takashi Shinozaki and Yasushi Naruse. Competitive learning with feedforward supervisory signal for pre-trained multilayered networks. arXiv preprint arXiv:1312.5845, 2013.
+
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a nextgeneration open source framework for deep learning. In Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), 2015. URL http://learningsys.org/papers/LearningSys_2015_paper_33.pdf.
+
+Takahiro Wada, Shun’ichi Doi, Keisuke Imai, Naohiko Tsuru, Kazuyoshi Isaji, and Hiroshi Kaneko. On driver’s braking behavior in car following. In SICE, 2007 Annual Conference, pp. 2396–2401. IEEE, 2007.
+
+Paul J Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.

parse/train/SkqMSCHxe/SkqMSCHxe_content_list.json

@@ -0,0 +1,953 @@
+[
+    {
+        "type": "text",
+        "text": "PREDICTION OF POTENTIAL HUMAN INTENTION USING SUPERVISED COMPETITIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Masayoshi Ishikawa, Mariko Okude, Takehisa Nishida & Kazuo Muto   \nHitachi, Ltd   \nOmika 7-1-1, Hitachi, Ibaraki, JAPAN   \n{masayoshi.ishikawa.gv, mariko.okude.uh}@hitachi.com   \n{takehisa.nishida.cu, kazuo.muto.ny}@hitachi.com ",
+        "bbox": [
+            184,
+            169,
+            691,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a learning method to quantify human intention. Generally, a human being will imagine several potential actions for a given scene, but only one of these actions will subsequently be taken. This makes it difficult to quantify human intentions. ",
+        "bbox": [
+            232,
+            310,
+            764,
+            366
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To solve this problem, we apply competitive learning to human behavior prediction as supervised learning. In our approach, competitive learning generates several outputs that are then associated with several potential situations imagined by a human. We applied the proposed method to human driving behavior and extracted three potential driving patterns. Results showed a squared error is reduced to 1/25 that of a conventional method . We also found that competitive learning can distinguish valid data from disturbance data in order to train a model. ",
+        "bbox": [
+            233,
+            369,
+            764,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            334,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Progress in advanced driving assistance systems (ADASs) has led to an autonomous driving function applicable for highway driving . The vehicle control logic of ADAS is typically developed by hand. There are a few related works on controlling vehicles comfortably , but the complex nature of vehicle environments prevents development by hand. Therefore, recent research has focused on the application of machine learning to autonomous driving systems. The convolutional neural network (CNN) shows particular promise as a core algorithm (Krizhevsky et al. (2012)). C. Chen & Xiao (2015) estimates affordance for driving directly from a front camera image. They train a CNN to generate key perception indicators from images to easily control a vehicle. Similarly, Bojarski et al. (2016) predict the desired steering command directly from front camera images. They train a CNN with a human command as training data and drive in traffic on local roads with or without lane marking and on highways. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            688
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our objective is to provide drivers with a comfortable trip featuring automatic vehicle control . The above methods provide a uniform control for various scenarios, but drivers have an assortment of preference behaviors, and individuals may drive in different ways even if the scenario or situation is the same. For example, on the highway, one person might drive hard to arrive at a destination quickly while another might drive relatively slowly to arrive at a destination safely. Therefore, we want to provide autonomous driving adapted to each individual to improve ease of driving and to generate control targets that imitate individual behavior. To imitate individual behavior, we predict future vehicle states resulting from an individualfs decision. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are many studies on the imitation of human behavior within the context of driving. Ma & Andreasson ´ (2006) proposed a vehicle interaction model that predicts future acceleration on the basis of current acceleration, velocity, relative velocity, and relative distance of the preceding vehicle. Moon & Choi (2011) proposed a method to predict human steering behavior. Their model considers path planning, feed-forward steering, and feedback steering. While these methods consider only acceleration or steering, Gindele et al. (2010) proposed a more complex model, the dynamic Bayesian network model, to estimate driver behavior and vehicle trajectory. This model considers vehicle model, trajectory, driver decision, and situation context. Wada et al. (2007) proposed a method to predict braking behavior. This method monitors the size of a preceding vehicle by means of front camera images to detect collision risk. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ff027ddbe2c5f82db15c38f1ad9cd6be92e8aa16a7160d49c54aed49b1a4140.jpg",
+        "image_caption": [
+            "Figure 1: Graphical model of driving behavior. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            380,
+            98,
+            612,
+            275
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            328,
+            823,
+            356
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These methods provide one output for one scene. However, we assume that one output might represent just one part of a driverfs behavior. We assume a driver will imagine several potential situations for one scene and have several potential actions to take associated with each situation. This means the driver is making decisions all the time. Therefore, we want to extract several of the driver’s candidate actions or intentions for the autonomous control of a vehicle while considering various potential situations. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a method to extract a driver’s potential intention by utilizing competitive learning (Ahalt et al. (1990), Shinozaki & Naruse (2013), Osoba & Kosko (2013)). Originally, competitive learning was used for unsupervised neural network algorithms and functioned as clustering. In such competitive learning, neural networks have several output layers and only one path that outputs the smallest loss to be trained . Consequently, neural networks predict the cluster with the most activated units . ",
+        "bbox": [
+            174,
+            453,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Ahalt et al. (1990) compare several competitive learning algorithms. In this paper, competitive learning algorithms is dealt as a kind of vector quantization algorithms. Shinozaki & Naruse (2013) utilize competitive learning for pre-training of deep neural networks and they also use competitive learning as unsupervised learning. Osoba & Kosko (2013) consider supervised competitive learning. However, they use also competitive learning as a kind of clustering methods. Therefore, in our best knowledge, competitive learning is dealt as a kind of unsupervised learning algorithms or clustering algorithms. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We apply competitive learning to time series supervised learning, especially, regression task. And we train neural networks to output several patterns associated with a driver’s potential intentions. In this paper, we describe how to model the driving behavior with competitive learning architecture . Additionally, we show the experimental results of tests performed with an actual vehicle. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 DRIVER BEHAVIOR MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            434,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we describe how to model driving behavior and how to implement the neural network architecture. ",
+        "bbox": [
+            173,
+            756,
+            823,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our driving behavior model is a dynamic system that includes both a driver and a vehicle system. In this model, the driver observes the environment and then decides on a driving action, e.g., steering or pedal operation. The vehicle system then changes its state depending on the driving action and the state of the vehicle at a previous time. Finally, we observe the various vehicle states. For example, the environment observed by the driver is the same as that shown by the front camera and the vehicle states include travel speed, accelerations, gas pedal position, brake pedal position, engine speed, engine load, engine temperature, fuel level, fuel temperature, cooling water temperature, etc. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A graphical model of driving behavior is shown in Fig. 1. Here, $e$ stands for the environment observed by the driver, $d$ stands for the driving action decided by the driver, $s$ stands for vehicle states, and $x$ stands for observed vehicle states. Subscripts $t - 1$ and $t$ refer to time steps. Environment $e$ and parts of vehicle states $x$ are observed. Driving action $d$ and whole vehicle states $s$ are latent variables. We assume a front camera view for environment $e$ . Observed variables $x$ include travel speed, gas pedal position, engine speed, and engine load. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/368046ac29b30176160365c67ef0756dd0cb48eae41b1e61bfce56c1ee2c4391.jpg",
+        "image_caption": [
+            "Figure 2: Neural network architecture designed to imitate driving model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            820,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            354,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To ensure comfortable driving, we estimate the driver’s intention by predicting vehicle states in $\\mathbf { k }$ step future . The relations between each variable are shown in the following equations. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db07fdfec5fa18cce4c9ed1ed492ee88b567a4804bf241606927ab4875a45d39.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { d _ { t } } } & { { = } } & { { f _ { e } ( e _ { t } ; \\theta _ { e } ) } } \\\\ { { s _ { t } } } & { { = } } & { { f _ { s } ( s _ { t - 1 } ; \\theta _ { s } ) + f _ { d } ( , d _ { t } ; \\theta _ { d } ) } } \\\\ { { x _ { t } } } & { { = } } & { { f _ { x } ( s _ { t } ; \\theta _ { x } ) } } \\\\ { { x _ { t + k } } } & { { = } } & { { f _ { x + k } ( s _ { t } ; \\theta _ { x + k } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            469,
+            625,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we compensate for latent variable $s _ { t }$ by observable variable $x _ { t }$ . The compensated $s _ { t }$ are shown in Eq. 5: ",
+        "bbox": [
+            176,
+            549,
+            825,
+            578
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cb8a3f5b0acd41d7174b111aad57c3a7fd3fde6c8d1218c43feb3d0e4ef3fd9.jpg",
+        "text": "$$\ns _ { t } = f _ { s } ( s _ { t - 1 } ; \\theta _ { s } ) + f _ { d } ( , d _ { t } ; \\theta _ { d } ) + f _ { x } ^ { - 1 } ( x _ { t } ; \\theta _ { x } ^ { - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            595,
+            655,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We design the neural network architecture in accordance with the driving behavior model shown in Fig. 1. The designed architecture is shown in Fig. 2. First, we select convolutional neural network (CNN) layers to approximate driving action $f _ { e }$ , as the driver decides which action to take depending on the front view and CNN is the best layer to process images. The front camera images are resized to $2 5 6 \\times 2 5 6$ with RGB channels. Second, we select a recurrent neural network (RNN) layer to approximate vehicle states $f _ { s }$ , as our driver model is a dynamic system (Graves (2013)). Finally, we select a fully connected layer for other layers $f _ { d } , f _ { x } ^ { - 1 } , f _ { x + k }$ because of its usability. This model predicts observed variables and we train the driver behavior model by loss function. We select squared error as loss function $L ( x _ { t + k } , \\hat { x } _ { t + k } )$ and update parameters by backpropagation (Hecht-NielsenWerbos (1990)). ",
+        "bbox": [
+            173,
+            621,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79a2ca80b7955f8fe407d7265adb3fea9288e9cc03b4b4fc0b45bf4f3544d3da.jpg",
+        "text": "$$\nL ( x _ { t + k } , \\hat { x } _ { t + k } ) = | x _ { t + k } - \\hat { x } _ { t + k } | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            779,
+            611,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The CNN consists of three layers. In the first layer, kernel size is $1 1 \\times 1 1$ with 64 channels and stride 4 . In the second layer, kernel size is $5 \\times 5$ with 128 channels. In the third layer, kernel size is $3 \\times 3$ with 128 channels. After all CNN layers, we apply batch normalization, ReLU, and max pooling (Ioffe & Szegedy (2015)). The RNN layer has 1024 units. We use the ADAM algorithm for optimization (Kingma & Ba (2014)). ",
+        "bbox": [
+            174,
+            804,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The architecture shown in Fig. 2 is a baseline architecture and cannot extract potential driver intentions. In the next section, we introduce a competitive learning architecture that can extract potential intentions and discuss how to train it. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ad87973d930c6a8677ff61777eea246abe1608f5d12c7c301c15c5999ea7223.jpg",
+        "image_caption": [
+            "Figure 3: Competitive learning architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            109,
+            825,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b40f23d73f0dd6f17a0ed1519a1f5ec696dafb129d381c990fec9432ec22b79.jpg",
+        "image_caption": [
+            "Figure 4: Backpropagation in competitive learning architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            319,
+            825,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 COMPETITIVE LEARNING FOR DRIVER BEHAVIOR MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            537,
+            689,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMPETITIVE LEARNING ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            574,
+            503,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The competitive learning architecture is shown in Fig. 3. It has $N _ { o }$ output layers. Additionally, we set up $N _ { o }$ RNN layers, as the driver’s potential intentions are separated depending on the driving actions . Therefore, a separated RNN will be affected by separated intentions. The i-th RNN i and the output layer generate i-th prediction $\\hat { x } _ { t + k } ^ { i }$ at time $\\mathbf { t } { + } \\mathbf { k }$ . We calculate i-th loss using Eq. 7 and decide the loss for backpropagation using Eq. 9. Finally, we update the parameters depending on this loss for backpropagation. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30fb43d7f13087e6b1925faffab79bac336fa2237ca738da844271829f839591.jpg",
+        "text": "$$\n\\begin{array} { c c l } { { l ^ { i } } } & { { = } } & { { L ( x _ { t + k } , \\hat { x } _ { t + k } ^ { i } ) } } \\\\ { { L } } & { { = } } & { { [ l ^ { 1 } , . . . l ^ { i } , . . l ^ { N _ { o } } ] } } \\\\ { { } } & { { } } & { { } } \\\\ { { l _ { b p } ^ { i } } } & { { = } } & { { \\left\\{ \\begin{array} { c } { { 0 i \\ne \\arg \\operatorname* { m i n } ( L ) } } \\\\ { { l ^ { i } i = \\arg \\operatorname* { m i n } ( L ) } } \\end{array} \\right. } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            717,
+            598,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Backpropagation in the competitive learning architecture is shown in Fig. 4. In the competitive learning architecture, we train only the computation path that output minimum loss. In Fig. 4, the computation path to be trained is indicated by solid lines and the layer whose parameters are not updated is indicated by dashed lines. In this case, the i-th output layer has minimum loss and is trained. The other output layers (i.e., whose losses are bigger than i-th) are not trained and the losses are compensated as zero. Since each output layer is trained by different data, each prediction reflects different intentions. Therefore, competitive learning can extract several potential intentions. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7152df6e47af2ba2cacae6cb75817761bdc3d79822bc5355aa6047243ff233eb.jpg",
+        "image_caption": [
+            "Figure 5: Pre-training for competitive learning architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            823,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 PRE-TRAINING FOR COMPETITIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            333,
+            532,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, we discuss the pre-training for competitive learning. In our experiments, competitive layers with simple initialization are difficult to train, and many experiments result in only one output layer being trained. Since only one computation path is trained at a time in competitive learning, how the trained path is decided depends on the initialization. Therefore, we need to ensure appropriate initialization for competitive layers. To this end , we adopt a pre-training technique for competitive learning (Erhan et al. (2010), Erhan et al.). Pre-training is an initialization technique for neural networks and is typically used for stacking neural networks. In this work, we apply pre-training to initialize the parallel competitive layer, as shown in Fig. 5. First, we train only one output layer by means of the ordinal loss function in Eq. 6. Then, we initialize competitive layers by copying pre-trained parameters. Finally, we train each output layer as fine-tuning. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            418,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the proposed method, we record the front camera view using a smartphone and collect actual vehicle data using OBD2 (Birnbaum & Truglia (2000), International (2003)). The data on vehicle states are whitened by removing means and scaled variances. Front camera images and vehicle data are resampled to $2 \\ \\mathrm { H z }$ . Six steps (equivalent to three seconds in the future) are predicted. We collect 80 minutes of data and use 40 minutes to train the neural networks. We set three competitive layers and train 300 iterations for pre-training and 2000 iterations for fine-tuning. We train neural networks with TITAN Z and use the Chainer framework (Tokui et al. (2015)). ",
+        "bbox": [
+            174,
+            551,
+            825,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPARISON OF COMPETITIVE LEARNING ARCHITECTURE WITH BASELINE ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            741,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Before we show the competitive learning results, we present the results of the baseline architecture shown in Fig. 6 . These data are predictions of vehicle speed over ten minutes. The left figure is the prediction on training data and the right one is on test data. Red line indicates the measured speed and blue line indicates the prediction by baseline architecture. In the training data, the baseline architecture could predict accurately in the low speed band under $3 0 \\mathrm { k m / h }$ . However, the prediction error became bigger in the middle-high speed band over $3 0 ~ \\mathrm { k m / h }$ . In the higher speed band, the driverfs action had several variations even when the vehicle was operating in the same environment. This variation made prediction difficult. In the test data prediction, prediction error became bigger in not only the high speed band but also the very low speed band around $0  { \\mathrm { k m } } /  { \\mathrm { h } }$ . Additionally, the timing of the acceleration or deceleration shifted later, too. This is because the baseline architecture cannot extract potential driving intentions. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The competitive learning results are shown in Fig. 7. This figure is written up the same way as Fig. 6, except the blue line refers to integrated predictions by the competitive learning architecture. These predictions are a combination of three outputs derived by selecting minimum loss. In the training data prediction, the competitive learning architecture predicted a value quite close to the measured vehicle speed before three seconds . In the test data prediction, the competitive learning architecture could also predict the speed accurately. Additionally, the timing shift of acceleration or deceleration became smaller. The loss summation in both the training and test data is listed in Table 1. Competitive learning architecture loss was about 1/25 smaller in the training data and about 1/3 smaller in the test data compared with the baseline architecture. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/956dd7597b79cdf9242bd503d59d43902c0cec65e032c487bfce52f829b507d8.jpg",
+        "image_caption": [
+            "Figure 6: Prediction of baseline architecture on training data (left) and test data (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            112,
+            797,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/91463632bcdca87f522eea7b00d381aadfc893ffdeaa183e2b81e5b93f92ae1a.jpg",
+        "image_caption": [
+            "Figure 7: Integrated prediction of competitive architecture on training data (left) and test data (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            285,
+            797,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            474,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPETITIVE LEARNING PREDICTION ASSOCIATED WITH POTENTIAL INTENTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            569,
+            792,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we show the driving intentions extracted using the competitive learning architecture. The intentions extracted from the training data are shown in Fig. 8. Four time series data are included: upper left is the integrated prediction, upper right is the first output layer’s prediction (indicated by green line), lower left is the second output prediction (blue line), and lower right is the third output prediction (purple line). The red lines are the measured vehicle speed. The upper left figure depicts the winning output prediction, where the minimum error prediction is output for each time and the line color refers to the winning output layer . For example, the purple line in the upper left figure is the prediction by the third output layer . We can see that each output layer is affected by other driving intentions. The first output layer accurately predicted the stop timing associated with the stop intention, the second output layer accurately predicted the acceleration or high speed band associated with a rapid intention, and the third output layer accurately predicted the deceleration timing associated with a careful intention. We also show the results of the test data in Fig. 9, which are written the same as the training data in Fig. 8. Trained intentions are also valid in test data because the first output was accurate at stop time, the second output was accurate at acceleration or the high speed band, and the third output was accurate at the time of deceleration. Therefore, extracting these potential intentions enables accurate prediction. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3ce0e60fccee554f6e4395008567be420a7996840f3838df595f57c4960a4912.jpg",
+        "table_caption": [
+            "Table 1: Summation loss of each architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Loss (training)</td><td>Loss (test)</td></tr><tr><td>Baseline</td><td>335.8</td><td>2603</td></tr><tr><td>Competitive learning</td><td>13.14</td><td>816.4</td></tr></table>",
+        "bbox": [
+            315,
+            876,
+            679,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/282ee5f1189a6acd2ee759c476c2558045baf577e08e7d34c8e0b6fbdaea83f6.jpg",
+        "image_caption": [
+            "Figure 8: Driving intentions extracted by competitive learning architecture; training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            181,
+            764,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ee7dd3c19338cb3661006b67ba074036ff9f8127baae1b9f939bd321badf5267.jpg",
+        "image_caption": [
+            "Figure 9: Driving intentions extracted by competitive learning architecture; test data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            594,
+            764,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/90578603e5d8aacceb08f50886c637d5a23fec293071ea21e18e3ec7a1e6e0d9.jpg",
+        "image_caption": [
+            "Figure 10: Competitive layer outputs without pre-training in training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            119,
+            764,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e559237d41e22b6a79ff26772e0fe461ebad1bc0826ff74722b1a1489c159131.jpg",
+        "table_caption": [
+            "Table 2: Summation loss without pre-training "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Loss (training)</td><td>Loss (test)</td></tr><tr><td>Baseline</td><td>335.8</td><td>2603</td></tr><tr><td>Competitive learning</td><td>13.14</td><td>816.4</td></tr><tr><td>Competitive learning without pre-training</td><td>164.0</td><td>870.9</td></tr></table>",
+        "bbox": [
+            248,
+            422,
+            746,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF PRE-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            398,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The competitive learning result without pre-training is shown in Fig. 10. We can train ”only one” output layer to predict driver intention even if we have three output layers. Potential intentions of the driver have similar trends. Therefore, we require the initialization of several of the same output layers . We can extract potential intentions by training each output layer using other data. ",
+        "bbox": [
+            176,
+            536,
+            825,
+            592
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show the summation loss in Table 2. Surprisingly, competitive learning without pre-training significantly improved its losses by about $1 / 2$ for training data and about 1/3 for test data. We consider the second and third output layers to play an important role, even though they cannot learn potential intentions. There is usually a lot of inadequate data to train, and these data disrupt the training of the model. However, in most cases we cannot distinguish useful data from disturbance data. In the competitive learning architecture, each output layer automatically selects data to train its computation path. This selection might distinguish useful data from disturbance data, and the first output layer can be trained using just the useful data, even though other output layers are trained using inadequate data. In this way, competitive learning can train the model such that it is robust against noisy data. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            760,
+            318,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We proposed supervised competitive learning to imitate a driver’s potential intentions. Competitive learning was applied to supervised learning and the squared error was reduced to 1/25 that of a conventional method. We also demonstrated that competitive learning can distinguish valid data from disturbance data to train a model. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            285,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Stanley C Ahalt, Ashok K Krishnamurthy, Prakoon Chen, and Douglas E Melton. Competitive learning algorithms for vector quantization. Neural networks, 3(3):277–290, 1990. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ralph Birnbaum and Jerry Truglia. Getting to Know OBD II. New York, 2000. ",
+        "bbox": [
+            173,
+            103,
+            691,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016. ",
+        "bbox": [
+            176,
+            125,
+            818,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Kornhauser C. Chen, A. Seff and J. Xiao. Deepdriving: Learning affordance for direct perception in autonomous driving. In Proceedings of 15th IEEE International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            173,
+            175,
+            821,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Pierre-Antoine Manzagol, Yoshua Bengio, Samy Bengio, and Pascal Vincent. The difficulty of training deep architectures and the effect of unsupervised pre-training. ",
+        "bbox": [
+            173,
+            226,
+            823,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11(Feb):625–660, 2010. ",
+        "bbox": [
+            176,
+            262,
+            823,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tobias Gindele, Sebastian Brechtel, and Rudiger Dillmann. A probabilistic model for estimating ¨ driver behaviors and vehicle trajectories in traffic environments. In Intelligent Transportation Systems (ITSC), 2010 13th International IEEE Conference on, pp. 1625–1631. IEEE, 2010. ",
+        "bbox": [
+            173,
+            311,
+            823,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Hecht-Nielsen. Theory of the backpropagation neural network. In Neural Networks, 1989. IJCNN., International Joint Conference on, pp. 593–605. IEEE. ",
+        "bbox": [
+            173,
+            398,
+            821,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SAE International. On-Board Diagnostics for Light and Medium Duty Vehicles Standards Manual. Pennsylvania, 2003. ",
+        "bbox": [
+            173,
+            434,
+            821,
+            463
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of The 32nd International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            173,
+            470,
+            825,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            520,
+            821,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaoliang Ma and Ingmar Andreasson. Driver reaction time estimation from real car following data ´ and application in gm-type model evaluation. In Proceedings of the 85th TRB annual meeting, pp. 1–19, 2006. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chulwoo Moon and Seibum B Choi. A driver model for vehicle lateral dynamics. International journal of vehicle design, 56(1-4):49–80, 2011. ",
+        "bbox": [
+            173,
+            656,
+            821,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Osonde Osoba and Bart Kosko. Noise-enhanced clustering and competitive learning algorithms. Neural Networks, 37:132–140, 2013. ",
+        "bbox": [
+            174,
+            693,
+            821,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takashi Shinozaki and Yasushi Naruse. Competitive learning with feedforward supervisory signal for pre-trained multilayered networks. arXiv preprint arXiv:1312.5845, 2013. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a nextgeneration open source framework for deep learning. In Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), 2015. URL http://learningsys.org/papers/LearningSys_2015_paper_33.pdf. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takahiro Wada, Shun’ichi Doi, Keisuke Imai, Naohiko Tsuru, Kazuyoshi Isaji, and Hiroshi Kaneko. On driver’s braking behavior in car following. In SICE, 2007 Annual Conference, pp. 2396–2401. IEEE, 2007. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Paul J Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990. ",
+        "bbox": [
+            173,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 8
+    }
+]

parse/train/jfDaBf8PAE/jfDaBf8PAE.md

@@ -0,0 +1,208 @@
+# Fast Minimum-norm Adversarial Attacks through Adaptive Norm Constraints
+
+# Maura Pintor
+
+University of Cagliari, Italy Pluribus One, Italy maura.pintor@unica.it
+
+Fabio Roli   
+University of Cagliari, Italy   
+Pluribus One, Italy   
+roli@unica.it
+
+# Wieland Brendel
+
+Tübingen AI Center, University of Tübingen, Germany wieland.brendel@uni-tuebingen.de
+
+Battista Biggio   
+University of Cagliari, Italy   
+Pluribus One, Italy   
+battista.biggio@unica.it
+
+# Abstract
+
+Evaluating adversarial robustness amounts to finding the minimum perturbation needed to have an input sample misclassified. The inherent complexity of the underlying optimization requires current gradient-based attacks to be carefully tuned, initialized, and possibly executed for many computationally-demanding iterations, even if specialized to a given perturbation model. In this work, we overcome these limitations by proposing a fast minimum-norm (FMN) attack that works with different $\ell _ { p }$ -norm perturbation models $( p = 0 , 1 , 2 , \infty )$ , is robust to hyperparameter choices, does not require adversarial starting points, and converges within few lightweight steps. It works by iteratively finding the sample misclassified with maximum confidence within an $\ell _ { p }$ -norm constraint of size $\epsilon$ , while adapting $\epsilon$ to minimize the distance of the current sample to the decision boundary. Extensive experiments show that FMN significantly outperforms existing $\ell _ { 0 } , \ \ell _ { 1 }$ , and $\ell _ { \infty }$ -norm attacks in terms of perturbation size, convergence speed and computation time, while reporting comparable performances with state-of-the-art $\ell _ { 2 }$ -norm attacks. Our open-source code is available at: https://github.com/pralab/Fast-Minimum-Norm-FMN-Attack.
+
+# 1 Introduction
+
+Learning algorithms are vulnerable to adversarial examples, i.e., intentionally-perturbed inputs aimed to mislead classification at test time [24, 3]. While adversarial examples have received much attention, evaluating the robustness of deep networks against them remains a challenge. Adversarial attacks solve a non-convex optimization problem and are thus prone to finding suboptimal solutions; in particular, all attacks make certain assumptions about the underlying geometry and properties of the optimization problem which, if violated, can derail the attack and may lead to premature conclusions regarding model robustness. That is why the vast majority of defenses published in recent years have later shown to be ineffective against more powerful white-box attacks [5, 1]. Having an arsenal of diverse attacks that can be adapted to specific defenses is one of the most promising avenues for increasing confidence in white-box robustness evaluations [6, 25]. While it may seem that the number of attacks is already large, most of them are just small variations of the same technique, make similar underlying assumptions and thus tend to fail jointly (see, e.g., [25], in which projected-gradient attacks all fail similarly against the “Ensemble Diversity” defense).
+
+![](images/6e92813f0feb373a75fa090e445a8a98192750c2b614c1184bc1017b5bdc978c.jpg)  
+Figure 1: (a) Conceptual representation of the FMN attack algorithm (leftmost plot). The $\epsilon$ -step updates the constraint size $\epsilon$ to minimize its distance to the boundary. The $\delta$ -step updates the perturbation $\pmb { \delta }$ with a projected-gradient step to maximize misclassification confidence within the current $\epsilon { \cdot }$ -sized constraint. (b) Example of execution of our attack on a bi-dimensional problem (middle plot), along with the corresponding values of the loss function $L$ and the constraint size $\epsilon$ across iterations (rightmost plot). Our algorithm works by first pushing the initial point (red dot) towards the adversarial region (in red), and then perturbing it around the decision boundary to improve the current solution towards a local optimum. The vertical lines in the rightmost plot highlight the steps in which a better solution (smaller $\lVert \pmb { \delta } ^ { \star } \rVert$ and $L < 0$ ) is found.
+
+In this work, we focus on minimum-norm attacks for evaluating adversarial robustness, i.e., attacks that aim to mislead classification by finding the smallest input perturbation according to a given norm. In contrast to maximum-confidence attacks, which maximize confidence in a wrong class within a given perturbation budget, the former are better suited to evaluate adversarial robustness as one can compute the accuracy of a classifier under attack for any perturbation budget without re-running the attack. Within the class of gradient-based minimum-norm attacks, there are three main sub-categories: (i) soft-constraint attacks, (ii) boundary attacks and (iii) projected-gradient attacks. Soft-constraint attacks like CW [5] optimize a trade-off between confidence of the misclassified samples and perturbation size. This class of attacks needs a sample-wise tuning of the trade-off hyperparameter to find the smallest possible perturbation, thus requiring many steps to converge. Boundary attacks like BB [4] and FAB [10] move along the decision boundary towards the closest point to the input sample. These attacks converge within relatively few steps, but BB requires an adversarial starting point, and both attacks need to solve a relatively expensive optimization problem in each step. Finally, recent minimum-norm projected-gradient attacks like DDN [23] perform a maximum-confidence attack in each step under a given perturbation budget $\epsilon$ , while iteratively adjusting $\epsilon$ to reduce the perturbation size. DDN combines the effectiveness of boundary attacks with the simplicity and per-step speed of soft-constraint attacks; however, it is specific to the $\ell _ { 2 }$ norm and cannot be readily extended to other norms.
+
+To overcome the aforementioned limitations, in this work we propose a novel, fast minimum-norm (FMN) attack (Sect. 2), which retains the main advantages of DDN while generalizing it to different $\ell _ { p }$ norms $( p = 0 , 1 , 2 , \infty )$ . We perform large-scale experiments on different datasets and models (Sect. 3), showing that FMN is able to significantly outperform current minimum-norm attacks in terms of convergence speed and computation time (except for $\ell _ { 2 }$ -norm attacks, for which FMN achieves comparable results), while finding equal or better optima, on average, across almost all tested scenarios and $\ell _ { p }$ norms. FMN thus combines all desirable traits a good adversarial attack should have, providing an important step towards improving adversarial robustness evaluations. We conclude the paper by discussing related work (Sect. 4) and future research directions (Sect. 5).
+
+# 2 Minimum-Norm Adversarial Examples with Adaptive Projections
+
+Problem formulation. Given an input sample $\pmb { x } \in [ 0 , 1 ] ^ { d }$ , belonging to class $y \in \{ 1 , \ldots , c \}$ , the goal of an untargeted attack is to find the minimum-norm perturbation $\delta ^ { \star }$ such that the corresponding adversarial example $\pmb { x } ^ { \star } = \pmb { x } + \pmb { \delta } ^ { \star }$ is misclassified. This problem can be formulated as:
+
+$$
+\begin{array} { r l } { \delta ^ { \star } \in \arg \operatorname* { m i n } \quad } & { \| \delta \| _ { p } , } \\ { \mathrm { s . t . } \quad } & { L ( x + \delta , y , \theta ) < 0 , } \\ & { x + \delta \in [ 0 , 1 ] ^ { d } , } \end{array}
+$$
+
+# Algorithm 1 Fast Minimum-norm (FMN) Attack
+
+Input: $_ { \textbf { \em x } }$ , the input sample; $t$ , a variable denoting whether the attack is targeted $( t = + 1$ ) or untargeted $\mathit { t } = - 1 ,$ ); $y$ , the target (true) class label if the attack is targeted (untargeted); $\gamma _ { 0 }$ and $\gamma _ { K }$ , the initial and final $\epsilon$ -step sizes; $\alpha _ { 0 }$ and $\alpha _ { K }$ , the initial and final $\delta$ -step sizes; $K$ , the total number of iterations.
+
+Output: The minimum-norm adversarial example $\scriptstyle { \pmb x } ^ { \star }$ .   
+1: $\mathbf { \boldsymbol { x } } _ { 0 } \gets \mathbf { \boldsymbol { x } }$ , $\epsilon _ { 0 } = 0$ , $\delta _ { 0 }  \mathbf { 0 }$ , $\delta ^ { \star }  \infty$   
+2: for $k = 1 , \ldots , K$ do   
+3: $\pmb { \mathscr { g } } \gets \tau \cdot \nabla _ { \delta } L ( \pmb { x } _ { k - 1 } + \delta , y , \pmb { \theta } )$ // loss gradient   
+4: $\gamma _ { k }  h ( \gamma _ { 0 } , \gamma _ { K } , k , K )$ // -step size decay (Eq. 6)   
+5: if $L ( x _ { k - 1 } , y , \pmb \theta ) \ge 0$ then   
+6: $\epsilon _ { k } = \| \pmb { \delta } _ { k - 1 } \| _ { p } + L ( \pmb { x } _ { k - 1 } , \pmb { y } , \pmb { \theta } ) / \| \pmb { g } \| _ { q }$ if adversarial not found yet else $\epsilon _ { k } = \epsilon _ { k - 1 } ( 1 + \gamma _ { k } )$   
+7: else   
+8: if $\| \delta _ { k - 1 } \| _ { p } \leq \| \delta ^ { \star } \| _ { p }$ then   
+9: $\delta ^ { \star } \gets \delta _ { k - 1 }$ // update best min-norm solution   
+10: end if   
+11: $\epsilon _ { k } = \operatorname* { m i n } ( \epsilon _ { k - 1 } ( 1 - \gamma _ { k } ) , \| \pmb { \delta } ^ { \star } \| _ { p } )$   
+12: end if   
+13: $\alpha _ { k }  h ( \alpha _ { 0 } , \alpha _ { K } , k , K )$ // $\delta$ -step size decay (Eq. 6)   
+14: $\delta _ { k }  \delta _ { k - 1 } + \alpha _ { k } \cdot g / \| g \| _ { 2 }$ // gradient-scaling step   
+15: $\delta _ { k } \gets \Pi _ { \epsilon } ( \pmb { x } _ { 0 } + \pmb { \delta } _ { k } ) - \pmb { x } _ { 0 }$   
+16: $\delta _ { k } \gets \mathrm { c l i p } ( { \pmb x } _ { 0 } + \delta _ { k } ) - { \pmb x } _ { 0 }$   
+17: ${ \pmb x } _ { k }  { \pmb x } _ { 0 } + \delta _ { k }$   
+18: end for   
+19: return ${ \pmb x } ^ { \star }  { \pmb x } _ { 0 } + \delta ^ { \star }$
+
+where $| | \cdot | | _ { p }$ indicates the $\ell _ { p }$ -norm operator. The loss $L$ in the constraint in Eq. (2) is defined as:
+
+$$
+L (  { \boldsymbol { { x } } } , y , \mathbf { \theta } ) = f _ { y } (  { \boldsymbol { { x } } } , \theta ) - \operatorname* { m a x } _ { j \neq y } f _ { j } (  { \boldsymbol { { x } } } , \theta ) ,
+$$
+
+where $f _ { j } ( { \pmb x } , { \pmb \theta } )$ is the confidence given by the model $f$ for classifying $_ { \textbf { \em x } }$ as class $j$ , and $\pmb \theta$ is the set of its learned parameters. Assuming that the classifier assigns $_ { \textbf { \em x } }$ to the class exhibiting the highest confidence, i.e., $y _ { . } ^ { \star } = \arg \operatorname* { m a x } _ { j \in 1 , \ldots , c } f _ { j } ( x , \pmb { \theta } )$ , the loss function $L ( x , y , \theta )$ takes on negative values only when $_ { \textbf { \em x } }$ is misclassified. Finally, the box constraint in Eq. (3) ensures that the perturbed sample $\pm \delta$ lies in the feasible input space. The aforementioned problem typically involves a non-convex loss function $L$ (w.r.t. its first argument), due to the non-convexity of the underlying decision function $f$ . For this reason, it may admit different locally-optimal solutions. Note also that the solution is trivial (i.e., $\delta ^ { \star } = \mathbf { 0 }$ ) when the input sample $_ { \textbf { \em x } }$ is already adversarial (i.e., $L ( x , y , \pmb \theta ) < 0 ,$ ).
+
+Extension to the targeted case. The goal of a targeted attack is to have the input sample misclassified in a given target class $y ^ { \prime }$ . This can be accounted for by modifying the loss function in Eq. (4) as $L ^ { t } ( \bar { { \mathbf x } } , y ^ { \prime } , \pmb \theta ) = \operatorname* { m a x } _ { j \neq y ^ { \prime } } f _ { j } ( { \pmb x } , \pmb \theta ) - f _ { y ^ { \prime } } ( { \pmb x } , \pmb \theta ) = - L ( { \pmb x } , y ^ { \prime } , \pmb \theta )$ , i.e., changing its sign and using the target class label $y ^ { \prime }$ instead of the true class label $y$ .
+
+Solution algorithm. To solve Problem (1)-(3), we reformulate it using an upper bound $\epsilon$ on $\| \delta \| _ { p }$
+
+$$
+\operatorname* { m i n } _ { \epsilon , \delta } \epsilon , \quad \mathrm { s . t . } \| \delta \| _ { p } \leq \epsilon ,
+$$
+
+and to the constraints in Eqs. (2)-(3). This allows us to derive an algorithm that works in two main steps, similarly to DDN [23], by updating the maximum perturbation size $\epsilon$ separately from the actual perturbation $\pmb { \delta }$ , as represented in Fig. 1(a). In particular, the constraint size $\epsilon$ is adapted to reduce the distance of the constraint to the boundary ( $\cdot$ -step), while the perturbation $\delta$ is updated using a projected-gradient step to minimize the loss function $L$ within the given $\epsilon$ -sized constraint $\delta$ -step). This essentially amounts to a projected gradient descent algorithm that iteratively adapts the constraint size $\epsilon$ to find the minimum-norm adversarial example. The complete algorithm is given as Algorithm 1, while a more detailed explanation of the two aforementioned steps is given below.
+
+$\epsilon$ -step. This step updates the upper bound $\epsilon$ on the perturbation norm (lines 4-12 in Algorithm 1). The underlying idea is to increase $\epsilon$ if the current sample is not adversarial (i.e., $L ( x _ { k - 1 } , y , \pmb \theta ) \ge 0 )$ , and to decrease it otherwise, while reducing the step size to dampen oscillations around the boundary and reach convergence. In the former case (-increase), the increment of $\epsilon$ depends on whether an adversarial example has been previously found or not. If not, we estimate the distance to the boundary with a first-order linear approximation, and set $\epsilon _ { k } = | | \delta _ { k - 1 } | | _ { p } + L ( \pmb { x } _ { k - 1 } , y , \pmb { \theta } ) / | | \nabla L ( \pmb { x } _ { k - 1 } , y , \pmb { \theta } ) | | _ { q }$ , where $q$ is the dual norm of $p$ . This approximation allows the attack point to make faster progress towards the decision boundary. Conversely, if an adversarial sample has been previously found, but the current sample is not adversarial, it is likely that the current estimate of $\epsilon$ is only slightly smaller than the minimum-norm solution. We thus increase $\epsilon$ by a small fraction as $\epsilon _ { k } = \epsilon _ { k - 1 } \left( 1 + \gamma _ { k } \right)$ , being $\gamma _ { k }$ a decaying step size. In the latter case $\epsilon$ -decrease), if the current sample is adversarial, i.e., $L ( x _ { k - 1 } , y , \pmb \theta ) < 0$ , we decrease $\epsilon$ as $\epsilon _ { k } = \epsilon _ { k - 1 } \left( 1 - \gamma _ { k } \right)$ , to check whether the current solution can be improved. If the corresponding $\epsilon _ { k }$ value is larger than the optimal $\| \delta ^ { \star } \| _ { p }$ found so far, we retain the best value and set $\epsilon _ { k } = \| \boldsymbol { \delta } ^ { \star } \| _ { p }$ . These multiplicative updates of $\epsilon$ exhibit an oscillating behavior around the decision boundary, due to the conflicting requirements of minimizing the perturbation size and finding an adversarial point. To ensure convergence, as anticipated before, the step size $\gamma _ { k }$ is decayed with cosine annealing:
+
+$$
+\begin{array} { r } { \gamma _ { k } = h ( \gamma _ { 0 } , \gamma _ { K } , k , K ) = \gamma _ { K } + \frac { 1 } { 2 } ( \gamma _ { 0 } - \gamma _ { K } ) \left( 1 + \cos \left( \frac { k \pi } { K } \right) \right) , } \end{array}
+$$
+
+being $k$ the current step, $K$ the total number of steps, and $\gamma _ { 0 }$ and $\gamma _ { K }$ the initial and final step sizes.
+
+$\delta$ -step. This step updates $\delta$ (lines 13-17 in Algorithm 1). The goal is to find the adversarial example that is misclassified with maximum confidence (i.e., for which $L$ is minimized) within the current $\epsilon$ -sized constraint (Eq. 5) and bounds (Eq. 3). This amounts to performing a projected-gradient step along the negative gradient of $L$ . We consider a normalized steepest descent with decaying step size $\alpha$ to overcome potential issues related to noisy gradients while ensuring convergence (line 14). Note that this step only rescales the gradient by its $\ell _ { 2 }$ norm, while preserving its direction. The step size $\alpha$ is decayed using cosine annealing (Eq. 6). Once $\delta$ is updated, we project it onto the given $\epsilon$ -sized $\ell _ { p }$ -norm constraint via a projection operator $\Pi _ { \epsilon }$ (line 15), to fulfill the constraint in Eq. (5). The projection is trivial for $p = \infty$ and $p = 2$ . For $p = 1$ , we use the efficient algorithm by Duchi et al. [14]. For $p = 0$ , we retain only the first $\epsilon$ components of $\delta$ exhibiting the largest absolute value. We finally clip the components of $\pmb { \delta }$ that violate the bounds in Eq. (3) (line 16).
+
+Execution example. In Fig. 1(b), we report an example of execution of our algorithm on a bidimensional problem. The initial sample is updated to follow the negative gradient of $L$ towards the decision boundary. When an adversarial point is found, the algorithm reduces $\epsilon$ to find a better solution. The point is thus projected back onto the non-adversarial region, and $\epsilon$ increased (by a smaller, decaying amount). These oscillations allow the point to walk on the boundary towards a local optimum, i.e., an adversarial point lying on the boundary, where the gradient of the loss function and that of the norm constraint have opposite direction. FMN tends to quickly converge to a good local optimum, provided that the step size is reduced to a sufficiently-small value and that a sufficiently-large number of iterations are performed. This is also confirmed empirically in Sect. 3.
+
+Adversarial initialization. Our attack can be initialized from the input sample $_ { \textbf { \em x } }$ , or from a point $\pmb { x } _ { \mathrm { i n i t } }$ belonging either to a different class (if the attack is untargeted) or to the target class (if the attack is targeted). When initializing the attack from ${ \bf { x } } _ { \mathrm { { i n i t } } }$ , we perform a 10-step binary search between $_ { \textbf { \em x } }$ and ${ \bf { x } } _ { \mathrm { { i n i t } } }$ , to find an adversarial point which is closer to the decision boundary. In particular, we aim to find the minimum $\epsilon$ such that $L ( \pmb { x } + \Pi _ { \epsilon } ( \pmb { x } _ { \mathrm { i n i t } } - \pmb { x } ) , y , \pmb { \theta } ) < 0$ (or $L ^ { t } < 0$ for targeted attacks). Then we run our attack starting from the corresponding values of $\boldsymbol { x } _ { k } , \epsilon _ { k } , \delta _ { k }$ and $\delta ^ { \star }$ .
+
+Differences with DDN. FMN applies substantial changes to both the algorithm and the formulation of DDN. The main difference is that (i) DDN always rescales the perturbation to have size $\epsilon$ . This operation is problematic when using other norms, especially sparse ones, as it hinders the ability of the attack to explore the neighboring space and find a suitable descent direction. Another difference is that (ii) FMN does not use the cross-entropy loss, but it uses the logit difference as the loss function $L$ , since the latter is less affected by saturation effects. Moreover, (iii) FMN does not need an initial value for $\epsilon$ , as $\epsilon$ is dynamically estimated; and (iv) $\gamma$ is decayed to improve convergence around better minimum-norm solutions, by more effectively dampening oscillations around the boundary. Finally, we include the possibility of (v) initializing the attack from an adversarial point, which can greatly increase the convergence speed of the algorithm, as it uses a fast line-search algorithm to find the boundary and the remaining queries to refine the result.
+
+# 3 Experiments
+
+We report here an extensive experimental analysis involving several state-of-the-art defenses and minimum-norm attacks, covering $\ell _ { 0 } , \ell _ { 1 } , \ell _ { 2 }$ and $\ell _ { \infty }$ norms. The goal is to empirically benchmark our attack and assess its effectiveness and efficiency as a tool for adversarial robustness evaluation.
+
+# 3.1 Experimental Setup
+
+Datasets. We consider two commonly-used datasets for benchmarking adversarial robustness of deep neural networks, i.e., the MNIST handwritten digits and CIFAR10. Following the experimental setup in [4], we use a subset of 1000 test samples to evaluate the considered attacks and defenses.
+
+Models. We use a diverse selection of models to thoroughly evaluate attacks under different conditions. For MNIST, we consider the following four models: $M l$ , the 9-layer network used as the undefended baseline model by Papernot et al. [20], Carlini and Wagner [5]; $M 2$ , the robust model by Madry et al. [17], trained on $\ell _ { \infty }$ attacks (robustness claim: $8 9 . 6 \%$ accuracy with $\| \delta \| _ { \infty } \leq 0 . 3$ current best evaluation: $8 8 . 0 \%$ ); M3, the robust model by Rony et al. [23], trained on $\ell _ { 2 }$ attacks (robustness claim: $8 7 . 6 \%$ accuracy with $\lVert \delta \rVert _ { 2 } \leq 1 . 5 )$ ; and $M 4$ , the IBP Large Model by Zhang et al. [27] (robustness claim: $9 4 . 3 \%$ accuracy with $\| \delta \| _ { \infty } \leq 0 . 3 )$ . For CIFAR10, we consider three state-ofthe-art robust models from RobustBench [11]: $C I$ , the robust model by Madry et al. [17], trained on $\ell _ { \infty }$ attacks (robustness claim: $4 4 . 7 \%$ accuracy with $\| \delta \| _ { \infty } \leq 8 / 2 5 5$ , current best evaluation: $4 4 . 0 \%$ ); $C 2$ , the defended model by Carmon et al. [7] (top-5 in RobustBench), trained on $\ell _ { \infty }$ attacks and additional unsupervised data (robustness claim: $6 2 . 5 \%$ accuracy with $\| \delta \| _ { \infty } \leq 8 / 2 5 5$ , current best evaluation: $5 9 . 5 \%$ ); and $C 3$ , the robust model by Rony et al. [23], trained on $\ell _ { 2 }$ attacks (robustness claim: $6 7 . 9 \%$ accuracy with $\| \pmb { \delta } \| _ { 2 } \le 0 . 5$ , current best evaluation: $6 6 . 4 \%$ ).
+
+Attacks. We compare our algorithm against different state-of-the-art attacks for finding minimumnorm adversarial perturbations across different norms: the Carlini & Wagner (CW) attack [5], the Decoupling Direction and Norm (DDN) attack [23], the Brendel & Bethge (BB) attack [4], and the Fast Adaptive Boundary (FAB) attack [10]. We use the implementation of FAB from Ding et al. [12], while for all the remaining attacks we use the implementation available in Foolbox [21, 22]. All these attacks are defined on the $\ell _ { 2 }$ norm. BB and FAB are also defined on the $\ell _ { 1 }$ and $\ell _ { \infty }$ norms, and only BB is defined on the $\ell _ { 0 }$ norm. We consider both untargeted and targeted attack scenarios, as defined in Sect. 2, except for FAB, which is only evaluated in the untargeted case.1
+
+Hyperparameters. To ensure a fair comparison, we perform an extensive hyperparameter search for each of the considered attacks. We consider two main scenarios: tuning the hyperparameters at the sample-level and at the dataset-level. In the sample-level scenario, we select the optimal hyperparameters separately for each input sample by running each attack 10 to 16 times per sample, with a different hyperparameter configuration or random initialization point each time. In the datasetlevel scenario, we choose the same hyperparameters for all samples, selecting the configuration that yields the best attack performance. While sample-level tuning provides a fairer comparison across attacks, it is more computationally demanding and less practical than dataset-level tuning. In addition, the latter allows us to understand how robust attacks are to suboptimal hyperparameter choices. We select the hyperparameters to be optimized for each attack as recommended by the corresponding authors [4, 5, 10, 23]. The hyperparameter configurations considered for each attack are detailed below. For attacks that are claimed to be robust to hyperparameter changes, like BB and FAB, we follow the recommendation of using a larger number of random restarts rather than increasing the number of hyperparameter configurations to be tested. In addition, as BB requires being initialized from an adversarial starting point, we initialize it by randomly selecting a sample either from a different class (in the untargeted case) or from the target class (in the targeted case). Finally, as each attack performs operations with different levels of complexity within each iteration, possibly querying the model multiple times, we set the number of steps for each attack such that at least 1, 000 forward passes (i.e., queries) are performed. This ensures a fairer comparison also in terms of the computational time and resources required to execute each attack.
+
+![](images/badc4682ac0af93640da0b7b3facca7d77ff8749ecc5ffd5b17d961a19bba7fa.jpg)  
+Figure 2: Query-distortion curves for MNIST (M2, top) and CIFAR10 (C1, bottom) models (untargeted scenario).
+
+CW. This attack minimizes the soft-constraint version of our problem, i.e., $\begin{array} { r l } { \operatorname* { m i n } _ { \pmb { \delta } } \| \pmb { \delta } \| _ { p } + c \cdot \operatorname* { m i n } ( L ( \pmb { x } + } & { { } } \end{array}$ ${ \delta , y , \theta } ) , - \kappa )$ . The hyperparameters $\kappa$ and $c$ are used to tune the trade-off between perturbation size and misclassification confidence. To find minimum-norm perturbations, CW requires setting $\kappa = 0$ , while the constant $c$ is tuned via binary search (re-running the attack at each iteration). We set the number of binary-search steps to 9, and the maximum number of iterations to 250, to ensure that at least $1 , 0 0 0$ queries are performed. We also set different values for $c , \eta \in \{ 1 0 ^ { - 3 } , 1 0 ^ { - 2 } , 1 0 ^ { - 1 } , 1 \}$ .
+
+DDN. This attack, similarly to ours, maximizes the misclassification confidence within an $\epsilon$ -sized constraint, while adjusting $\epsilon$ to minimize the perturbation size. We consider initial values of $\epsilon _ { 0 } \in$ $\{ 0 . 0 3 , 0 . 1 , 0 . 3 , 1 , 3 \}$ , and run the attack with a different number of iterations $K \in \{ 2 0 0 , 1 0 0 0 \}$ , as this affects the size of each update on $\pmb { \delta }$ .
+
+$B B ,$ . This attack starts from a randomly-drawn adversarial point, performs a 10-step binary search to find a point which is closer to the decision boundary, and then updates the point to minimize its perturbation size by following the decision boundary. In each iteration, BB computes the optimal update within a given trust region of radius $\rho$ . We consider different values for $\rho \in \{ 1 0 ^ { - 3 } , 1 \dot { 0 } ^ { - 2 } , 1 0 ^ { - \dot { 1 } } , 1 \}$ while we fix the number of steps to 1000. We run the attack 3 times by considering different initialization points, and eventually retain the best solution.
+
+$F A B$ . This attack iteratively optimizes the attack point by linearly approximating its distance to the decision boundary. It uses an adaptive step size bounded by $\alpha _ { \mathrm { m a x } }$ and an extrapolation step $\eta$ to facilitate finding adversarial points. As suggested by Croce and Hein [10], we tune $\alpha _ { \mathrm { m a x } } \in$ $\{ 0 . 1 , 0 . 0 5 \}$ and $\eta \in \{ 1 . 0 5 , 1 , 3 \}$ . We consider 3 different random initialization points, and run the attack for 500 steps each time, eventually selecting the best solution.
+
+FMN. We run FMN for $K = 1 0 0 0$ steps, using $\gamma _ { 0 } \in \{ 0 . 0 5 , 0 . 3 \}$ , $\gamma _ { K } = 1 0 ^ { - 4 }$ , and $\alpha _ { K } = 1 0 ^ { - 5 }$ . For $\ell _ { 0 } , \ell _ { 1 }$ , and $\ell _ { 2 }$ , we set $\alpha _ { 0 } \in \{ 1 , 5 , 1 0 \}$ . For $\ell _ { \infty }$ , we set $\alpha _ { 0 } \in \{ 1 0 ^ { 1 } , 1 0 ^ { 2 } , 1 0 ^ { 3 } \}$ , as the normalized $\ell _ { 2 }$ step yields much smaller updates in the $\ell _ { \infty }$ norm. For each hyperparameter setting we run the attack twice, starting from (i) the input sample and (ii) an adversarial point.
+
+Evaluation criteria. We evaluate the attacks along four different criteria: (i) perturbation size and (ii) robustness to hyperparameter selection, measured as the median $\| \delta ^ { \star } \| _ { p }$ on the test set (for a fixed budget of $Q$ queries and for sample- and dataset-level hyperparameter tuning, where by “robustness” we mean that a fixed hyperparameter configuration works well across different samples); (iii) execution time, measured as the average time spent per query (in milliseconds); and (iv) convergence speed, measured as the average number of queries required to converge to a good-enough solution (within $10 \%$ of the best value found at $Q = 1 0 0 0 ^ { \cdot }$ ). When computing the median, we follow the evaluation in [4]: the perturbation size is set to 0 if a clean sample is misclassified, while it is set to $\infty$ when the attack fails (no adversarial is found). The median perturbation size thus represents the value for which $50 \%$ of the samples evade a particular model.
+
+# 3.2 Experimental Results
+
+Query-distortion $( Q D )$ curves. To evaluate each attack in terms of perturbation size under the same query budget $Q$ , we use the so-called QD curves introduced by Brendel et al. [4]. These curves report, for each attack, the median value of $\delta ^ { \star }$ as a function of the number of queries $Q$ . For each given $Q$ value, the optimal $\delta ^ { \star }$ for each point is selected among the different attack executions (i.e., using different hyperparameters and/or initialization points, as described in Sect. 3.1). In Fig. 2, we report the QD curves for the MNIST and CIFAR10 challenge models (i.e., M2 and C1) in the untargeted scenario. The remaining QD curves exhibit a similar behavior and can be found in the supplementary material. It is worth noting that our attack attains comparable results in terms of perturbation size across all norms, while significantly outperforming FAB and BB in the $\ell _ { 1 }$ case. It typically requires also less iterations than the other attacks to converge. While the QD curves show the complete behavior of each attack as $Q$ increases, a more compact and thorough summary of our evaluation is reported below, according to the four evaluation criteria described in Sect. 3.1.
+
+Perturbation size. Table 1 reports the median value of $\lVert \delta ^ { \star } \rVert$ at $Q = 1 0 0 0$ queries (i.e., the last value from the query-distortion curve), for all models, attacks and norms. The values obtained with sample-level hyperparamter tuning confirm that our attack can find smaller or comparable perturbations with those found by the competing attacks, in most of the untargeted and targeted cases, and that the biggest margin is achieved in the $\ell _ { 1 }$ case. FMN is only slightly worse than DDN and BB in a few cases, including $\ell _ { 2 }$ -DDN on M4 and $\ell _ { \infty }$ -BB on M2 and M4. The reason may be that these robust models exhibit noisy gradients and flat regions around the clean input samples, hindering the initial optimization steps of the FMN attack.
+
+Robustness to hyperparameter selection. The values reported in the lower part of Table 1 show that, when using dataset-level hyperparameter tuning, FMN outperforms the other attacks in a much larger number of cases. This shows that FMN is more robust to hyperparameter changes, while other attacks like $\ell _ { 0 } \cdot$ and $\ell _ { 1 }$ -BB suffer when using the same hyperparameters for all samples.
+
+Execution time. The average runtime per query for each attack-model pair, measured on a workstation with an NVIDIA GeForce RTX 2080 Ti GPU with 11GB of RAM, can be found in Table 2. The results show that our attack is up to 2-3 times faster, with the exception of DDN in the $\ell _ { 2 }$ case. This is however compensated by the fact that FMN finds better solutions. The advantage is that our attack avoids costly inner projections as in BB and FAB. FMN is slightly less time-efficient than DDN and CW, as it simultaneously updates the adversarial point and the norm constraint. In particular, the update on the constraint may initially require computing the norm of the gradient $\textbf {  { g } }$ (line 6 in Algorithm 1), which increases the runtime of our attack. FAB computes a similar step, but for all the output classes, which hinders its scalability to problems with many classes.
+
+Convergence speed. To get an estimate of the convergence speed, we measure the number of queries required by each attack to reach a perturbation size that is within $10 \%$ of the value found at $Q = 1 0 0 0$ queries (the lower the better). Results are shown in Table 3. Our attack converges on par with or faster than all other attacks for almost all models, often requiring only half or a fifth as many queries as the state of the art. Exceptions are MNIST and CIFAR10 challenge models (M2 and C1) for $\ell _ { 2 }$ and $\ell _ { \infty }$ , where BB and DDN occasionally converge faster. FMN rarely needs more than 100 steps, reaching the minimal perturbation after only 10-30 queries on many datasets, models and norms.
+
+Robust accuracy. Despite our attack being not tailored to target specific defenses, and our evaluation restricted to a subset of the testing samples, it is worth remarking that the robust accuracies of the models against our attack are aligned with that reported in current evaluations, with the notable exception of C3, where our attack can decrease robust accuracy from $6 7 . 9 \%$ to $6 5 . 5 \%$ .
+
+Experiments on ImageNet. We conclude our experiments by running an additional comparison between FMN and a widely-used maximum-confidence attack, i.e., the Projected Gradient Descent (PGD) attack [17], on two pretrained ImageNet models (i.e., ResNet18 and VGG16), considering $\ell _ { 1 }$ , $\ell _ { 2 }$ and $\ell _ { \infty }$ norms. The hyperparameters are tuned at the dataset-level using 20 validation samples. For FMN, we fix the hyperparameters as discussed before, and only tune $\alpha _ { 0 } \in \{ 0 . 1 , 1 , 2 , 8 \}$ , without using adversarial initialization. For PGD, we tune the step size $\alpha \in \{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 , 1 , 2 , 8 \}$ . We run both attacks for $Q = 1 , 0 0 0$ queries on a separate set of $1 , 0 0 0$ samples. The success rates of both attacks at fixed $\epsilon$ values are reported in Table 4. The results show that FMN outperforms or equals PGD in all norms.
+
+Table 1: Median $\| \delta ^ { \star } \| _ { p }$ value at $Q = 1 0 0 0$ queries for targeted and untargeted attacks, with samplelevel and dataset-level hyperparameter tuning.   
+
+<table><tr><td></td><td></td><td colspan="6">MNIST</td><td colspan="6"></td><td colspan="5"></td></tr><tr><td></td><td></td><td colspan="3">Untargeted M2</td><td colspan="2"></td><td colspan="3">Targeted</td><td colspan="2">M4</td><td colspan="2">Untargeted C2</td><td colspan="2"></td><td colspan="2">Targeted C2</td></tr><tr><td>Model</td><td>M1</td><td></td><td>M3</td><td></td><td>M4</td><td>M1</td><td>M2 Sample-level Hyperparameter Tuning</td><td>M3</td><td></td><td>C1</td><td></td><td></td><td>C3</td><td>C1</td><td></td><td>C3</td></tr><tr><td>l</td><td>BB</td><td>8</td><td></td><td>15</td><td>94</td><td>14</td><td>27</td><td>24</td><td>93</td><td>8</td><td>12</td><td>13</td><td>19</td><td></td><td>32 32</td><td>25</td></tr><tr><td>l1</td><td>Ours FAB BB</td><td>7 6.60 6.26</td><td>9 3.08 5.81</td><td>15 14.23 13.16</td><td>5 109.4 5.44</td><td>14 1 12.42</td><td>20 1 10.38</td><td>24 1 20.41</td><td>23 1 6.25</td><td>8 4.79 3.75</td><td>11 5.17 4.29</td><td>14 8.79 8.62</td><td>19 1 8.04</td><td></td><td>- 10.93</td><td>27 - 15.71</td></tr><tr><td>l</td><td>Ours FAB Cw BB</td><td>5.57 1.45 1.49 1.43</td><td>2.95 1.36 4.22 1.34</td><td>12.04 2.62 2.78 2.61</td><td>1.96 2.97 1 1.61</td><td>12.20 - 2.33 2.27</td><td>6.75 1 6.97 2.04</td><td>18.79 1 3.54 3.23</td><td>7.31 - - 1.79</td><td>3.04 0.66 0.67 0.63</td><td>3.43 0.72 0.74 0.70</td><td>8.26 0.94 0.91 0.91</td><td>7.07 - 1.08 1.07</td><td></td><td>9.40 1 1.27 1.26</td><td>15.24 - 1.38 1.38</td></tr><tr><td>lo</td><td>DDN Ours FAB</td><td>1.46 1.41 .138</td><td>1.71 1.23 .337</td><td>2.56 2.50 .233</td><td>0.79 0.94 .421</td><td>2.29 2.28 -</td><td>2.20 1.89 1</td><td>3.27 3.19</td><td>1.33 1.85</td><td>0.64 0.61</td><td>0.73 0.69</td><td>0.91 0.91</td><td></td><td>1.09 1.03</td><td>1.29 1.21</td><td>1.39 1.38</td></tr><tr><td></td><td>BB Ours</td><td>.138 .134</td><td>.330 .339</td><td>.227 .226</td><td>.402 .404</td><td>.202 .201</td><td>.355 .389</td><td>1 .271 .272</td><td>.403 .406</td><td>.033 .032 .032</td><td>.043 .041 .040</td><td>.025 .024 .024</td><td>1 .055 .055</td><td></td><td>- .064 .063</td><td>- .037 .037</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>Dataset-level Hyperparameter Tuning</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l</td><td>BB Ours</td><td>12 9</td><td>152 33</td><td>52 18</td><td>145 15</td><td>20 16</td><td>179 48</td><td>39 28</td><td>183 55</td><td>28 11</td><td>44 17</td><td>32 16</td><td>29 25</td><td>65 38</td><td></td><td>33 32</td></tr><tr><td>l1</td><td>FAB BB Ours</td><td>8.66 10.60 7.13</td><td>225.7 49.83 4.18</td><td>163.9 17.57 13.66</td><td>312.3 46.99 4.99</td><td>1 16.60 13.18</td><td>1 53.11 8.33</td><td>1 29.89</td><td>1 54.31</td><td>1 7.02 4.28</td><td>1 10.20 4.82</td><td>20.48 17.13 9.52</td><td>1 11.41</td><td></td><td>1 15.26 10.40</td><td>1 23.37 17.32</td></tr><tr><td>l</td><td>FAB Cw</td><td>1.54 1.63</td><td>1.59 5.15</td><td>2.81 3.71</td><td>16.30</td><td>1 2.50</td><td>1 1</td><td>21.37 1</td><td>12.16 1</td><td>0.77 0.86</td><td>1.11 1.00</td><td>1.06 0.99</td><td></td><td>8.51 1</td><td>- 2.90</td><td>- 1.55</td></tr><tr><td></td><td>BB</td><td></td><td></td><td></td><td>4.57</td><td>2.64</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.73</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2.30</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.31</td><td>1.40</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2.31</td><td></td><td></td><td>1.96</td><td>0.66</td><td>0.77</td><td>0.91</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.15</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>1.75</td><td>1.82</td><td>3.02</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.36 1.25</td><td>1.45</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>-</td><td></td><td>2.59</td><td>4.72 3.52</td><td>- 5.31</td><td>0.86</td><td>0.95</td><td>1.10</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>DDN</td><td>1.47</td><td>2.01</td><td>2.62</td><td></td><td></td><td>2.72</td><td>3.36</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.56</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.11</td><td></td><td></td></tr><tr><td></td><td></td><td>1.61</td><td>1.42</td><td>2.61</td><td></td><td></td><td>2.13</td><td>3.24</td><td>2.41</td><td>0.67</td><td>0.74</td><td>0.91</td><td></td><td></td><td></td><td>1.38</td></tr><tr><td></td><td>Ours</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.09</td><td>1.28</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>：</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l</td><td>FAB</td><td>.148</td><td>.365</td><td>.248</td><td>.900</td><td></td><td>-</td><td>-</td><td>1</td><td>.038</td><td>.052</td><td>.029 .029</td><td></td><td>- .059</td><td>- .074</td><td>， .042</td></tr><tr><td></td><td>BB</td><td>.159 .140</td><td>.336 .357</td><td>.243 .233</td><td>.409 .408</td><td>.223 .206</td><td>.361 .426</td><td>.280 .277</td><td>.477 .434</td><td></td><td>.044 .054 .034 .042</td></table>
+
+Table 2: Average execution time (milliseconds / query) for each attack-model pair.   
+
+<table><tr><td></td><td></td><td colspan="7">MNIST</td><td colspan="7"></td></tr><tr><td rowspan="2"></td><td rowspan="2">Model</td><td colspan="3">Untargeted</td><td rowspan="2">M1</td><td colspan="3">Targeted</td><td rowspan="2"></td><td colspan="3">Untargeted</td><td colspan="3">Targeted</td></tr><tr><td>M1 M2</td><td>M3</td><td>M4</td><td>M2</td><td>M3</td><td>M4</td><td>C1</td><td>C2</td><td>C3</td><td>C1</td><td>C2</td><td>C3</td></tr><tr><td>l</td><td>BB</td><td>10.76</td><td>11.85</td><td>10.19</td><td>12.02</td><td>60.88</td><td>62.17</td><td>62.31</td><td>57.74</td><td>46.51</td><td>50.31</td><td>50.43</td><td>99.71</td><td>105.28</td><td>103.53</td></tr><tr><td></td><td>Ours</td><td>5.15</td><td>4.87</td><td>5.87</td><td>9.70</td><td>5.14</td><td>4.75</td><td>5.85</td><td>9.71</td><td>26.26</td><td>30.54</td><td>30.89</td><td>26.13</td><td>30.26</td><td>30.81</td></tr><tr><td>l1</td><td>FAB BB</td><td>9.38 6.73</td><td>8.88 7.03</td><td>12.61</td><td>36.00</td><td>- 43.25</td><td>- 43.54</td><td></td><td></td><td>84.04 32.56</td><td>108.91</td><td>108.64 37.59</td><td>- 68.99</td><td>73.33 =</td><td>- 74.03</td></tr><tr><td></td><td>Ours</td><td>5.43</td><td>5.14</td><td>7.31 6.10</td><td>12.50 9.35</td><td>5.44</td><td>5.10</td><td>43.69 6.09</td><td>43.86 9.35</td><td>27.34</td><td>37.40 31.17</td><td>31.18</td><td>26.00</td><td>30.98</td><td>31.03</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l2</td><td>FAB</td><td>10.22</td><td>10.13</td><td>13.45</td><td>36.72</td><td>-</td><td>-</td><td>-</td><td>-</td><td>84.27</td><td>109.43</td><td>108.87</td><td>-</td><td>1</td><td>、 31.30</td></tr><tr><td></td><td>Cw</td><td>4.22</td><td>4.09</td><td>5.17</td><td>10.07</td><td>4.23</td><td>4.14</td><td>5.15</td><td>10.06</td><td>25.90</td><td>31.32</td><td>31.31</td><td>25.78</td><td>31.32</td><td>54.07</td></tr><tr><td></td><td>BB</td><td>4.44</td><td>4.15</td><td>5.03</td><td>12.38</td><td>26.20</td><td>26.76</td><td>27.24</td><td>31.00</td><td>26.64</td><td>31.82</td><td>31.90</td><td>48.74</td><td>54.35</td><td>29.52</td></tr><tr><td></td><td>DDN Ours</td><td>3.42 4.46</td><td>3.33 4.42</td><td>4.30</td><td>8.59</td><td>3.42</td><td>3.35</td><td>4.32</td><td>8.60</td><td>24.14</td><td>29.62</td><td>29.48</td><td>23.61</td><td>29.61</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>5.48</td><td>9.15</td><td>4.50</td><td>4.44</td><td>5.47</td><td>9.09</td><td>24.88</td><td>30.22</td><td>30.08</td><td>25.39</td><td>30.21</td><td>30.04</td></tr><tr><td>l8</td><td>FAB</td><td>10.85</td><td>10.61</td><td>14.05</td><td>36.23</td><td>-</td><td>-</td><td>-</td><td>-</td><td>84.62</td><td>109.83</td><td>109.57</td><td>-</td><td>-</td><td>-</td></tr><tr><td></td><td>BB</td><td>14.26</td><td>16.36</td><td>13.51</td><td>15.44</td><td>38.61</td><td>38.87</td><td>36.39</td><td>34.85</td><td>61.34</td><td>62.36</td><td>62.63</td><td>83.70</td><td>87.64</td><td>88.90</td></tr><tr><td></td><td>Ours</td><td>4.25</td><td>4.33</td><td>5.30</td><td>9.17</td><td>4.33</td><td>4.23</td><td>5.31</td><td>9.10</td><td>24.84</td><td>30.15</td><td>30.01</td><td>24.78</td><td>30.19</td><td>30.03</td></tr></table>
+
+# 4 Related Work
+
+Gradient-based attacks on machine learning have a long history [3, 2]. Maximum-confidence attacks optimize the adversarial loss (e.g., the difference between the logits of the true class and the best non-true class) to find an adversarial point misclassifed with maximum confidence within a given, bounded perturbation size. While attacks in this category like FGSM [15], PGD [16, 17] and momentum-based extensions of PGD [26, 13] are popular, they only partially evaluate the adversarial robustness of a model. Minimum-norm attacks aim to minimize the norm of the perturbation subject to being adversarial. Attacks from this class give a more complete picture of the model robustness and allow us to compute the accuracy of the model under attacks with any post-hoc defined maximum perturbation size. L-BFGS [24] solves this problem with a quasi-Newton optimizer while CW [5] and EAD [8] use first-order gradient-based optimizers to minimize a weighted loss between perturbation size and misclassification confidence. To find the smallest adversarial perturbation, both CW and EAD need to tune the relative weighting which makes them query-inefficient. DeepFool [19] and SparseFool [18] compute gradients with respect to all classes in each step to estimate a linear approximation of the model from which the optimal adversarial perturbation can be computed. These two attacks are fast but do not converge to competitive solutions. BB [4] and FAB [10] use complex projections and approximations to stay close to the decision boundary (using the gradient to estimate the local geometry of the boundary) while minimizing the norm. This way of formulating minimum-norm optimization bypasses the tuning of a weighting term, but in the case of BB it also requires an adversarial starting point to begin with. The DDN attack [23] maximizes the adversarial criterion within a given norm constraint, and iteratively reduces the norm to find the smallest possible adversarial perturbation; however, it is constrained to $\ell _ { 2 }$ and does not perform well on other $\ell _ { p }$ norms.
+
+Table 3: Number of queries required by each attack to reach a perturbation size that is within $10 \%$ o f the value obtained at $Q = 1 0 0 0$ .   
+
+<table><tr><td></td><td></td><td colspan="7">MNIST</td><td colspan="7">CIFAR10</td></tr><tr><td colspan="2"></td><td colspan="3">Untargeted</td><td></td><td colspan="3">Targeted</td><td colspan="3">Untargeted</td><td colspan="3">Targeted C1</td></tr><tr><td colspan="2">Model</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>C1</td><td>C2</td><td>C3</td><td>C2</td><td>C3</td></tr><tr><td>l</td><td>BB Ours</td><td>22 22</td><td>43 82</td><td>68 38</td><td>114 182</td><td>30 27</td><td>443 165</td><td>71 46</td><td>376 145</td><td>497 48</td><td>372 71</td><td>58 37</td><td>384 500 271</td><td>85</td></tr><tr><td>l1</td><td>FAB</td><td>44</td><td></td><td></td><td>569</td><td>1</td><td>1</td><td>-</td><td></td><td></td><td></td><td></td><td>146</td><td>70</td></tr><tr><td></td><td>BB</td><td>24</td><td>242 314</td><td>152 83</td><td>391</td><td>45</td><td>614 233</td><td>- 722</td><td>124 674</td><td>220 570</td><td>72 34</td><td>- 526</td><td>1 464</td><td>1 206</td></tr><tr><td></td><td>Ours</td><td>21</td><td>363</td><td>34</td><td>631</td><td>25</td><td>37</td><td>336</td><td>48</td><td>85</td><td>31</td><td>89</td><td>130</td><td>38</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>243</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l2</td><td>FAB CW</td><td>14 110</td><td>60 799</td><td>40 335</td><td>532 -</td><td>- 100</td><td></td><td>-</td><td>18</td><td>28</td><td>14</td><td>-</td><td>-</td><td>- 42</td></tr><tr><td></td><td>BB</td><td>20</td><td>24</td><td>337</td><td>21</td><td>913 61</td><td>469 20</td><td>- 692</td><td>67 22</td><td>39 23</td><td>33 22</td><td>56 26</td><td>144 27</td><td>29</td></tr><tr><td></td><td></td><td></td><td></td><td>20</td><td></td><td></td><td>26</td><td>670</td><td>13</td><td>20</td><td>4</td><td>18</td><td>19</td><td>18</td></tr><tr><td></td><td>DDN Ours</td><td>12 16</td><td>136 94</td><td>15</td><td>474 190</td><td>12</td><td>149</td><td>188</td><td>28</td><td>23</td><td>7</td><td>25</td><td>29</td><td>13</td></tr><tr><td></td><td></td><td></td><td></td><td>16</td><td></td><td>11</td><td>136</td><td>16</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>lo</td><td>FAB BB</td><td>36</td><td>50</td><td>44</td><td>11 5</td><td>- 24</td><td>- 17</td><td></td><td>50</td><td>50</td><td>54</td><td></td><td>-</td><td>1</td></tr><tr><td></td><td></td><td>19</td><td>17</td><td>20</td><td></td><td></td><td>22 26</td><td>5 5</td><td>20 22</td><td>24 15</td><td>21 14</td><td>27 20</td><td>33 29</td><td>29</td></tr><tr><td></td><td>Ours</td><td>9</td><td>10</td><td>22</td><td>5</td><td>27</td><td>8</td><td></td><td></td><td></td><td></td><td></td><td></td><td>34</td></tr></table>
+
+The proposed FMN attack belongs to the category of minimum-norm attacks, and builds on BB, FAB and DDN to retain their main advantages. First, FMN is not specific to a given norm, and converges in many fewer steps than soft-constraint attacks like CW, as it does not need to optimize the trade-off between perturbation size and misclassification confidence. FMN needs significantly less computational time per step than the other attacks, it is very accurate and easy to use, and it does not necessarily require being initialized from an adversarial starting point.
+
+Table 4: Success rate $( \% )$ of FMN against PGD on ImageNet models.   
+
+<table><tr><td></td><td>ResNet18</td><td></td><td>VGG</td></tr><tr><td rowspan="2">l1 (∈ = 1.0)</td><td>PGD</td><td>31.4</td><td>30.4</td></tr><tr><td>FMN</td><td>38.4</td><td>39.8</td></tr><tr><td rowspan="2">l2 (∈= 0.15)</td><td>PGD</td><td>61.7</td><td>61.4</td></tr><tr><td>FMN</td><td>65.8</td><td>66.2</td></tr><tr><td rowspan="2">l (∈=4·10-4)</td><td>PGD</td><td>51.0</td><td>49.0</td></tr><tr><td>FMN</td><td>55.2</td><td>49.0</td></tr></table>
+
+# 5 Contributions, Limitations, and Future Work
+
+This work introduces a novel minimum-norm attack that combines all desirable traits to help improve current adversarial evaluations: (i) finding smaller or comparable minimum-norm perturbations across a range of models and datasets; (ii) being less sensitive to hyperparameter choices; and being extremely fast, by (iii) reducing runtime up to 3 times per query with respect to competing attacks and (iv) converging within less iterations. FMN also works with different $\ell _ { p }$ norms $( p = 0 , 1 , 2 , \infty )$ and it does not necessarily require being initialized from an adversarial starting point. Our experiments have shown that FMN rivals or surpasses other attacks in speed, reliability, efficacy and versatility. While FMN is able to find smaller perturbations consistently when compared against $\ell _ { 0 }$ and $\ell _ { 1 }$ attacks, it only rivals the performance of other attacks for $\ell _ { 2 }$ and $\ell _ { \infty }$ norms, especially when tested against robust models which may present obfuscated gradients. To overcome this limitation, FMN may be extended using smoothing strategies that help find better descent directions, e.g., by averaging gradients on randomly-perturbed inputs. This can be regarded as an interesting extension of FMN towards attacking robust models. In this respect, we also believe that FMN may facilitate minimumnorm adaptive evaluations in a more general sense. Adaptive evaluations, where the attack is modified to be maximally effective against a new defense, are the key element towards properly evaluating adversarial robustness [6, 25]. PGD attacks are popular in part for the ease by which they can be adapted to new defenses. Since FMN combines PGD with a dynamic minimization of the perturbation size, we argue that our attack can also be easily adapted to new defenses, thereby facilitating adaptive evaluations. FMN may also benefit from other improvements that have been suggested for PGD, including momentum, cyclical step sizes or restarts. We leave such improvements to future work.
+
+To conclude, we firmly believe that FMN will establish itself as a useful tool in the arsenal of robustness evaluation. By facilitating more reliable robustness evaluations, we expect that FMN will foster advancements in the development of machine-learning models with improved robustness guarantees. We thus argue that there are neither ethical aspects nor evident future societal consequences with potential negative impacts that should be specifically addressed in the context of this work.
+
+# Acknowledgements
+
+This work has been partly supported by the PRIN 2017 project RexLearn (grant no. 2017TWNMH2), funded by the Italian Ministry of Education, University and Research; by the EU H2020 project ALOHA, under the European Union’s Horizon 2020 research and innovation programme (grant no. 780788); and by BMK, BMDW, and the Province of Upper Austria in the frame of the COMET Programme managed by FFG in the COMET Module S3AI. Wieland Brendel acknowledges support from the German Federal Ministry of Education and Research (BMBF) through the Competence Center for Machine Learning (TUE.AI, FKZ 01IS18039A), from the German Science Foundation (DFG) under grant no. BR 6382/1-1 (Emmy Noether Program) as well as support by Open Philantropy and the Good Ventures Foundation.
+
+# References
+
+[1] A. Athalye, N. Carlini, and D. A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, volume 80 of JMLR Workshop and Conf. Proceedings, pages 274–283. JMLR.org, 2018.   
+[2] B. Biggio and F. Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018.   
+[3] B. Biggio, I. Corona, D. Maiorca, B. Nelson, N. Šrndic, P. Laskov, G. Giacinto, and F. Roli. ´ Evasion attacks against machine learning at test time. In H. Blockeel, K. Kersting, S. Nijssen, and F. Železný, editors, Machine Learning and Knowledge Discovery in Databases (ECML PKDD), Part III, volume 8190 of LNCS, pages 387–402. Springer Berlin Heidelberg, 2013.   
+[4] W. Brendel, J. Rauber, M. Kümmerer, I. Ustyuzhaninov, and M. Bethge. Accurate, reliable and fast robustness evaluation. In Advances in Neural Inf. Proc. Systems, pages 12861–12871, 2019.   
+[5] N. Carlini and D. Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pages 39–57. IEEE, 2017.   
+[6] N. Carlini, A. Athalye, N. Papernot, W. Brendel, J. Rauber, D. Tsipras, I. Goodfellow, A. Madry, and A. Kurakin. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019.   
+[7] Y. Carmon, A. Raghunathan, L. Schmidt, J. C. Duchi, and P. S. Liang. Unlabeled data improves adversarial robustness. In Advances in Neural Inf. Proc. Systems, pages 11192–11203, 2019.   
+[8] P.-Y. Chen, Y. Sharma, H. Zhang, J. Yi, and C.-J. Hsieh. EAD: Elastic-net attacks to deep neural networks via adversarial examples. arXiv preprint arXiv:1709.04114, 2017.   
+[9] F. Croce and M. Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.   
+[10] F. Croce and M. Hein. Minimally distorted adversarial examples with a fast adaptive boundary attack. In Int’l Conf. on Machine Learning, pages 2196–2205. PMLR, 2020.   
+[11] F. Croce, M. Andriushchenko, V. Sehwag, N. Flammarion, M. Chiang, P. Mittal, and M. Hein. Robustbench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670, 2020.   
+[12] G. W. Ding, L. Wang, and X. Jin. AdverTorch v0.1: An adversarial robustness toolbox based on pytorch. arXiv preprint arXiv:1902.07623, 2019.   
+[13] Y. Dong, F. Liao, T. Pang, H. Su, J. Zhu, X. Hu, and J. Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition, 2018.   
+[14] J. Duchi, S. Shalev-Shwartz, Y. Singer, and T. Chandra. Efficient projections onto the l 1-ball for learning in high dimensions. In Proceedings of the 25th Int’l Conf. on Machine learning, pages 272–279, 2008.   
+[15] I. Goodfellow, J. Shlens, and C. Szegedy. Explaining and harnessing adversarial examples. In Int’l Conf. on Learning Representations, 2015. URL http://arxiv.org/abs/1412.6572.   
+[16] A. Kurakin, I. Goodfellow, and S. Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.   
+[17] A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.   
+[18] A. Modas, S.-M. Moosavi-Dezfooli, and P. Frossard. Sparsefool: a few pixels make a big difference. In The IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[19] S.-M. Moosavi-Dezfooli, A. Fawzi, and P. Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In The IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2016.   
+[20] N. Papernot, P. McDaniel, X. Wu, S. Jha, and A. Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE symposium on security and privacy (SP), pages 582–597. IEEE, 2016.   
+[21] J. Rauber, W. Brendel, and M. Bethge. Foolbox: A python toolbox to benchmark the robustness of machine learning models. In Reliable Machine Learning in the Wild Workshop, 34th Int’l Conf. on Machine Learning, 2017. URL http://arxiv.org/abs/1707.04131.   
+[22] J. Rauber, R. Zimmermann, M. Bethge, and W. Brendel. Foolbox native: Fast adversarial attacks to benchmark the robustness of machine learning models in pytorch, tensorflow, and jax. Journal of Open Source Software, 5(53):2607, 2020. doi: 10.21105/joss.02607. URL https://doi.org/10.21105/joss.02607.   
+[23] J. Rony, L. G. Hafemann, L. S. Oliveira, I. B. Ayed, R. Sabourin, and E. Granger. Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition, pages 4322–4330, 2019.   
+[24] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks. In Int’l Conf. on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.   
+[25] F. Tramer, N. Carlini, W. Brendel, and A. Madry. On adaptive attacks to adversarial example defenses. In Advances in Neural Inf. Proc. Systems, 2020.   
+[26] J. Uesato, B. O’Donoghue, A. v. d. Oord, and P. Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018.   
+[27] H. Zhang, H. Chen, C. Xiao, S. Gowal, R. Stanforth, B. Li, D. Boning, and C.-J. Hsieh. Towards stable and efficient training of verifiably robust neural networks. In Int’l Conf. on Learning Representations, 2020. URL https://openreview.net/forum?id $\equiv$ Skxuk1rFwB.

parse/train/jfDaBf8PAE/jfDaBf8PAE_content_list.json

@@ -0,0 +1,888 @@
+[
+    {
+        "type": "text",
+        "text": "Fast Minimum-norm Adversarial Attacks through Adaptive Norm Constraints ",
+        "text_level": 1,
+        "bbox": [
+            194,
+            122,
+            803,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maura Pintor ",
+        "text_level": 1,
+        "bbox": [
+            310,
+            227,
+            408,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of Cagliari, Italy Pluribus One, Italy maura.pintor@unica.it ",
+        "bbox": [
+            277,
+            242,
+            442,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fabio Roli   \nUniversity of Cagliari, Italy   \nPluribus One, Italy   \nroli@unica.it ",
+        "bbox": [
+            553,
+            226,
+            718,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wieland Brendel ",
+        "text_level": 1,
+        "bbox": [
+            302,
+            303,
+            421,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tübingen AI Center, University of Tübingen, Germany wieland.brendel@uni-tuebingen.de ",
+        "bbox": [
+            238,
+            319,
+            486,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio   \nUniversity of Cagliari, Italy   \nPluribus One, Italy   \nbattista.biggio@unica.it ",
+        "bbox": [
+            547,
+            303,
+            735,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            395,
+            535,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Evaluating adversarial robustness amounts to finding the minimum perturbation needed to have an input sample misclassified. The inherent complexity of the underlying optimization requires current gradient-based attacks to be carefully tuned, initialized, and possibly executed for many computationally-demanding iterations, even if specialized to a given perturbation model. In this work, we overcome these limitations by proposing a fast minimum-norm (FMN) attack that works with different $\\ell _ { p }$ -norm perturbation models $( p = 0 , 1 , 2 , \\infty )$ , is robust to hyperparameter choices, does not require adversarial starting points, and converges within few lightweight steps. It works by iteratively finding the sample misclassified with maximum confidence within an $\\ell _ { p }$ -norm constraint of size $\\epsilon$ , while adapting $\\epsilon$ to minimize the distance of the current sample to the decision boundary. Extensive experiments show that FMN significantly outperforms existing $\\ell _ { 0 } , \\ \\ell _ { 1 }$ , and $\\ell _ { \\infty }$ -norm attacks in terms of perturbation size, convergence speed and computation time, while reporting comparable performances with state-of-the-art $\\ell _ { 2 }$ -norm attacks. Our open-source code is available at: https://github.com/pralab/Fast-Minimum-Norm-FMN-Attack. ",
+        "bbox": [
+            233,
+            430,
+            766,
+            648
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            310,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning algorithms are vulnerable to adversarial examples, i.e., intentionally-perturbed inputs aimed to mislead classification at test time [24, 3]. While adversarial examples have received much attention, evaluating the robustness of deep networks against them remains a challenge. Adversarial attacks solve a non-convex optimization problem and are thus prone to finding suboptimal solutions; in particular, all attacks make certain assumptions about the underlying geometry and properties of the optimization problem which, if violated, can derail the attack and may lead to premature conclusions regarding model robustness. That is why the vast majority of defenses published in recent years have later shown to be ineffective against more powerful white-box attacks [5, 1]. Having an arsenal of diverse attacks that can be adapted to specific defenses is one of the most promising avenues for increasing confidence in white-box robustness evaluations [6, 25]. While it may seem that the number of attacks is already large, most of them are just small variations of the same technique, make similar underlying assumptions and thus tend to fail jointly (see, e.g., [25], in which projected-gradient attacks all fail similarly against the “Ensemble Diversity” defense). ",
+        "bbox": [
+            174,
+            717,
+            825,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/6e92813f0feb373a75fa090e445a8a98192750c2b614c1184bc1017b5bdc978c.jpg",
+        "image_caption": [
+            "Figure 1: (a) Conceptual representation of the FMN attack algorithm (leftmost plot). The $\\epsilon$ -step updates the constraint size $\\epsilon$ to minimize its distance to the boundary. The $\\delta$ -step updates the perturbation $\\pmb { \\delta }$ with a projected-gradient step to maximize misclassification confidence within the current $\\epsilon { \\cdot }$ -sized constraint. (b) Example of execution of our attack on a bi-dimensional problem (middle plot), along with the corresponding values of the loss function $L$ and the constraint size $\\epsilon$ across iterations (rightmost plot). Our algorithm works by first pushing the initial point (red dot) towards the adversarial region (in red), and then perturbing it around the decision boundary to improve the current solution towards a local optimum. The vertical lines in the rightmost plot highlight the steps in which a better solution (smaller $\\lVert \\pmb { \\delta } ^ { \\star } \\rVert$ and $L < 0$ ) is found. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            90,
+            816,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on minimum-norm attacks for evaluating adversarial robustness, i.e., attacks that aim to mislead classification by finding the smallest input perturbation according to a given norm. In contrast to maximum-confidence attacks, which maximize confidence in a wrong class within a given perturbation budget, the former are better suited to evaluate adversarial robustness as one can compute the accuracy of a classifier under attack for any perturbation budget without re-running the attack. Within the class of gradient-based minimum-norm attacks, there are three main sub-categories: (i) soft-constraint attacks, (ii) boundary attacks and (iii) projected-gradient attacks. Soft-constraint attacks like CW [5] optimize a trade-off between confidence of the misclassified samples and perturbation size. This class of attacks needs a sample-wise tuning of the trade-off hyperparameter to find the smallest possible perturbation, thus requiring many steps to converge. Boundary attacks like BB [4] and FAB [10] move along the decision boundary towards the closest point to the input sample. These attacks converge within relatively few steps, but BB requires an adversarial starting point, and both attacks need to solve a relatively expensive optimization problem in each step. Finally, recent minimum-norm projected-gradient attacks like DDN [23] perform a maximum-confidence attack in each step under a given perturbation budget $\\epsilon$ , while iteratively adjusting $\\epsilon$ to reduce the perturbation size. DDN combines the effectiveness of boundary attacks with the simplicity and per-step speed of soft-constraint attacks; however, it is specific to the $\\ell _ { 2 }$ norm and cannot be readily extended to other norms. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            621
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome the aforementioned limitations, in this work we propose a novel, fast minimum-norm (FMN) attack (Sect. 2), which retains the main advantages of DDN while generalizing it to different $\\ell _ { p }$ norms $( p = 0 , 1 , 2 , \\infty )$ . We perform large-scale experiments on different datasets and models (Sect. 3), showing that FMN is able to significantly outperform current minimum-norm attacks in terms of convergence speed and computation time (except for $\\ell _ { 2 }$ -norm attacks, for which FMN achieves comparable results), while finding equal or better optima, on average, across almost all tested scenarios and $\\ell _ { p }$ norms. FMN thus combines all desirable traits a good adversarial attack should have, providing an important step towards improving adversarial robustness evaluations. We conclude the paper by discussing related work (Sect. 4) and future research directions (Sect. 5). ",
+        "bbox": [
+            174,
+            627,
+            825,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Minimum-Norm Adversarial Examples with Adaptive Projections ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            771,
+            754,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Problem formulation. Given an input sample $\\pmb { x } \\in [ 0 , 1 ] ^ { d }$ , belonging to class $y \\in \\{ 1 , \\ldots , c \\}$ , the goal of an untargeted attack is to find the minimum-norm perturbation $\\delta ^ { \\star }$ such that the corresponding adversarial example $\\pmb { x } ^ { \\star } = \\pmb { x } + \\pmb { \\delta } ^ { \\star }$ is misclassified. This problem can be formulated as: ",
+        "bbox": [
+            174,
+            801,
+            825,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9cbdf60ce8b48c7f36f4d31a67efd8f71a7de625bf3f5e51f14f71259cc0ea2b.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\delta ^ { \\star } \\in \\arg \\operatorname* { m i n } \\quad } & { \\| \\delta \\| _ { p } , } \\\\ { \\mathrm { s . t . } \\quad } & { L ( x + \\delta , y , \\theta ) < 0 , } \\\\ & { x + \\delta \\in [ 0 , 1 ] ^ { d } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            848,
+            627,
+            915
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Fast Minimum-norm (FMN) Attack ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            496,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: $_ { \\textbf { \\em x } }$ , the input sample; $t$ , a variable denoting whether the attack is targeted $( t = + 1$ ) or untargeted $\\mathit { t } = - 1 ,$ ); $y$ , the target (true) class label if the attack is targeted (untargeted); $\\gamma _ { 0 }$ and $\\gamma _ { K }$ , the initial and final $\\epsilon$ -step sizes; $\\alpha _ { 0 }$ and $\\alpha _ { K }$ , the initial and final $\\delta$ -step sizes; $K$ , the total number of iterations. ",
+        "bbox": [
+            174,
+            109,
+            825,
+            165
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Output: The minimum-norm adversarial example $\\scriptstyle { \\pmb x } ^ { \\star }$ .   \n1: $\\mathbf { \\boldsymbol { x } } _ { 0 } \\gets \\mathbf { \\boldsymbol { x } }$ , $\\epsilon _ { 0 } = 0$ , $\\delta _ { 0 }  \\mathbf { 0 }$ , $\\delta ^ { \\star }  \\infty$   \n2: for $k = 1 , \\ldots , K$ do   \n3: $\\pmb { \\mathscr { g } } \\gets \\tau \\cdot \\nabla _ { \\delta } L ( \\pmb { x } _ { k - 1 } + \\delta , y , \\pmb { \\theta } )$ // loss gradient   \n4: $\\gamma _ { k }  h ( \\gamma _ { 0 } , \\gamma _ { K } , k , K )$ // \u000f-step size decay (Eq. 6)   \n5: if $L ( x _ { k - 1 } , y , \\pmb \\theta ) \\ge 0$ then   \n6: $\\epsilon _ { k } = \\| \\pmb { \\delta } _ { k - 1 } \\| _ { p } + L ( \\pmb { x } _ { k - 1 } , \\pmb { y } , \\pmb { \\theta } ) / \\| \\pmb { g } \\| _ { q }$ if adversarial not found yet else $\\epsilon _ { k } = \\epsilon _ { k - 1 } ( 1 + \\gamma _ { k } )$   \n7: else   \n8: if $\\| \\delta _ { k - 1 } \\| _ { p } \\leq \\| \\delta ^ { \\star } \\| _ { p }$ then   \n9: $\\delta ^ { \\star } \\gets \\delta _ { k - 1 }$ // update best min-norm solution   \n10: end if   \n11: $\\epsilon _ { k } = \\operatorname* { m i n } ( \\epsilon _ { k - 1 } ( 1 - \\gamma _ { k } ) , \\| \\pmb { \\delta } ^ { \\star } \\| _ { p } )$   \n12: end if   \n13: $\\alpha _ { k }  h ( \\alpha _ { 0 } , \\alpha _ { K } , k , K )$ // $\\delta$ -step size decay (Eq. 6)   \n14: $\\delta _ { k }  \\delta _ { k - 1 } + \\alpha _ { k } \\cdot g / \\| g \\| _ { 2 }$ // gradient-scaling step   \n15: $\\delta _ { k } \\gets \\Pi _ { \\epsilon } ( \\pmb { x } _ { 0 } + \\pmb { \\delta } _ { k } ) - \\pmb { x } _ { 0 }$   \n16: $\\delta _ { k } \\gets \\mathrm { c l i p } ( { \\pmb x } _ { 0 } + \\delta _ { k } ) - { \\pmb x } _ { 0 }$   \n17: ${ \\pmb x } _ { k }  { \\pmb x } _ { 0 } + \\delta _ { k }$   \n18: end for   \n19: return ${ \\pmb x } ^ { \\star }  { \\pmb x } _ { 0 } + \\delta ^ { \\star }$ ",
+        "bbox": [
+            176,
+            166,
+            823,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $| | \\cdot | | _ { p }$ indicates the $\\ell _ { p }$ -norm operator. The loss $L$ in the constraint in Eq. (2) is defined as: ",
+        "bbox": [
+            171,
+            470,
+            800,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beb90b1f57a6e2041870c20e62ca68d52681f19c9269cd73fc3c8af3d9f936e0.jpg",
+        "text": "$$\nL (  { \\boldsymbol { { x } } } , y , \\mathbf { \\theta } ) = f _ { y } (  { \\boldsymbol { { x } } } , \\theta ) - \\operatorname* { m a x } _ { j \\neq y } f _ { j } (  { \\boldsymbol { { x } } } , \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            491,
+            630,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { j } ( { \\pmb x } , { \\pmb \\theta } )$ is the confidence given by the model $f$ for classifying $_ { \\textbf { \\em x } }$ as class $j$ , and $\\pmb \\theta$ is the set of its learned parameters. Assuming that the classifier assigns $_ { \\textbf { \\em x } }$ to the class exhibiting the highest confidence, i.e., $y _ { . } ^ { \\star } = \\arg \\operatorname* { m a x } _ { j \\in 1 , \\ldots , c } f _ { j } ( x , \\pmb { \\theta } )$ , the loss function $L ( x , y , \\theta )$ takes on negative values only when $_ { \\textbf { \\em x } }$ is misclassified. Finally, the box constraint in Eq. (3) ensures that the perturbed sample $\\pm \\delta$ lies in the feasible input space. The aforementioned problem typically involves a non-convex loss function $L$ (w.r.t. its first argument), due to the non-convexity of the underlying decision function $f$ . For this reason, it may admit different locally-optimal solutions. Note also that the solution is trivial (i.e., $\\delta ^ { \\star } = \\mathbf { 0 }$ ) when the input sample $_ { \\textbf { \\em x } }$ is already adversarial (i.e., $L ( x , y , \\pmb \\theta ) < 0 ,$ ). ",
+        "bbox": [
+            173,
+            522,
+            825,
+            635
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Extension to the targeted case. The goal of a targeted attack is to have the input sample misclassified in a given target class $y ^ { \\prime }$ . This can be accounted for by modifying the loss function in Eq. (4) as $L ^ { t } ( \\bar { { \\mathbf x } } , y ^ { \\prime } , \\pmb \\theta ) = \\operatorname* { m a x } _ { j \\neq y ^ { \\prime } } f _ { j } ( { \\pmb x } , \\pmb \\theta ) - f _ { y ^ { \\prime } } ( { \\pmb x } , \\pmb \\theta ) = - L ( { \\pmb x } , y ^ { \\prime } , \\pmb \\theta )$ , i.e., changing its sign and using the target class label $y ^ { \\prime }$ instead of the true class label $y$ . ",
+        "bbox": [
+            174,
+            638,
+            825,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Solution algorithm. To solve Problem (1)-(3), we reformulate it using an upper bound $\\epsilon$ on $\\| \\delta \\| _ { p }$ ",
+        "bbox": [
+            173,
+            702,
+            815,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1f56eef096545ba0ba8e200b6beca11e38279df93d8c4c04924be6db34a65bd.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\epsilon , \\delta } \\epsilon , \\quad \\mathrm { s . t . } \\| \\delta \\| _ { p } \\leq \\epsilon ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            722,
+            558,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and to the constraints in Eqs. (2)-(3). This allows us to derive an algorithm that works in two main steps, similarly to DDN [23], by updating the maximum perturbation size $\\epsilon$ separately from the actual perturbation $\\pmb { \\delta }$ , as represented in Fig. 1(a). In particular, the constraint size $\\epsilon$ is adapted to reduce the distance of the constraint to the boundary ( $\\cdot$ -step), while the perturbation $\\delta$ is updated using a projected-gradient step to minimize the loss function $L$ within the given $\\epsilon$ -sized constraint $\\delta$ -step). This essentially amounts to a projected gradient descent algorithm that iteratively adapts the constraint size $\\epsilon$ to find the minimum-norm adversarial example. The complete algorithm is given as Algorithm 1, while a more detailed explanation of the two aforementioned steps is given below. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\epsilon$ -step. This step updates the upper bound $\\epsilon$ on the perturbation norm (lines 4-12 in Algorithm 1). The underlying idea is to increase $\\epsilon$ if the current sample is not adversarial (i.e., $L ( x _ { k - 1 } , y , \\pmb \\theta ) \\ge 0 )$ , and to decrease it otherwise, while reducing the step size to dampen oscillations around the boundary and reach convergence. In the former case (\u000f-increase), the increment of $\\epsilon$ depends on whether an adversarial example has been previously found or not. If not, we estimate the distance to the boundary with a first-order linear approximation, and set $\\epsilon _ { k } = | | \\delta _ { k - 1 } | | _ { p } + L ( \\pmb { x } _ { k - 1 } , y , \\pmb { \\theta } ) / | | \\nabla L ( \\pmb { x } _ { k - 1 } , y , \\pmb { \\theta } ) | | _ { q }$ , where $q$ is the dual norm of $p$ . This approximation allows the attack point to make faster progress towards the decision boundary. Conversely, if an adversarial sample has been previously found, but the current sample is not adversarial, it is likely that the current estimate of $\\epsilon$ is only slightly smaller than the minimum-norm solution. We thus increase $\\epsilon$ by a small fraction as $\\epsilon _ { k } = \\epsilon _ { k - 1 } \\left( 1 + \\gamma _ { k } \\right)$ , being $\\gamma _ { k }$ a decaying step size. In the latter case $\\epsilon$ -decrease), if the current sample is adversarial, i.e., $L ( x _ { k - 1 } , y , \\pmb \\theta ) < 0$ , we decrease $\\epsilon$ as $\\epsilon _ { k } = \\epsilon _ { k - 1 } \\left( 1 - \\gamma _ { k } \\right)$ , to check whether the current solution can be improved. If the corresponding $\\epsilon _ { k }$ value is larger than the optimal $\\| \\delta ^ { \\star } \\| _ { p }$ found so far, we retain the best value and set $\\epsilon _ { k } = \\| \\boldsymbol { \\delta } ^ { \\star } \\| _ { p }$ . These multiplicative updates of $\\epsilon$ exhibit an oscillating behavior around the decision boundary, due to the conflicting requirements of minimizing the perturbation size and finding an adversarial point. To ensure convergence, as anticipated before, the step size $\\gamma _ { k }$ is decayed with cosine annealing: ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67ecb84eba7ca0da6ab6b9431524a243b21c73316a0da466a55958add04ccdd0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\gamma _ { k } = h ( \\gamma _ { 0 } , \\gamma _ { K } , k , K ) = \\gamma _ { K } + \\frac { 1 } { 2 } ( \\gamma _ { 0 } - \\gamma _ { K } ) \\left( 1 + \\cos \\left( \\frac { k \\pi } { K } \\right) \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            313,
+            699,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "being $k$ the current step, $K$ the total number of steps, and $\\gamma _ { 0 }$ and $\\gamma _ { K }$ the initial and final step sizes. ",
+        "bbox": [
+            173,
+            359,
+            818,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\delta$ -step. This step updates $\\delta$ (lines 13-17 in Algorithm 1). The goal is to find the adversarial example that is misclassified with maximum confidence (i.e., for which $L$ is minimized) within the current $\\epsilon$ -sized constraint (Eq. 5) and bounds (Eq. 3). This amounts to performing a projected-gradient step along the negative gradient of $L$ . We consider a normalized steepest descent with decaying step size $\\alpha$ to overcome potential issues related to noisy gradients while ensuring convergence (line 14). Note that this step only rescales the gradient by its $\\ell _ { 2 }$ norm, while preserving its direction. The step size $\\alpha$ is decayed using cosine annealing (Eq. 6). Once $\\delta$ is updated, we project it onto the given $\\epsilon$ -sized $\\ell _ { p }$ -norm constraint via a projection operator $\\Pi _ { \\epsilon }$ (line 15), to fulfill the constraint in Eq. (5). The projection is trivial for $p = \\infty$ and $p = 2$ . For $p = 1$ , we use the efficient algorithm by Duchi et al. [14]. For $p = 0$ , we retain only the first $\\epsilon$ components of $\\delta$ exhibiting the largest absolute value. We finally clip the components of $\\pmb { \\delta }$ that violate the bounds in Eq. (3) (line 16). ",
+        "bbox": [
+            174,
+            378,
+            825,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Execution example. In Fig. 1(b), we report an example of execution of our algorithm on a bidimensional problem. The initial sample is updated to follow the negative gradient of $L$ towards the decision boundary. When an adversarial point is found, the algorithm reduces $\\epsilon$ to find a better solution. The point is thus projected back onto the non-adversarial region, and $\\epsilon$ increased (by a smaller, decaying amount). These oscillations allow the point to walk on the boundary towards a local optimum, i.e., an adversarial point lying on the boundary, where the gradient of the loss function and that of the norm constraint have opposite direction. FMN tends to quickly converge to a good local optimum, provided that the step size is reduced to a sufficiently-small value and that a sufficiently-large number of iterations are performed. This is also confirmed empirically in Sect. 3. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial initialization. Our attack can be initialized from the input sample $_ { \\textbf { \\em x } }$ , or from a point $\\pmb { x } _ { \\mathrm { i n i t } }$ belonging either to a different class (if the attack is untargeted) or to the target class (if the attack is targeted). When initializing the attack from ${ \\bf { x } } _ { \\mathrm { { i n i t } } }$ , we perform a 10-step binary search between $_ { \\textbf { \\em x } }$ and ${ \\bf { x } } _ { \\mathrm { { i n i t } } }$ , to find an adversarial point which is closer to the decision boundary. In particular, we aim to find the minimum $\\epsilon$ such that $L ( \\pmb { x } + \\Pi _ { \\epsilon } ( \\pmb { x } _ { \\mathrm { i n i t } } - \\pmb { x } ) , y , \\pmb { \\theta } ) < 0$ (or $L ^ { t } < 0$ for targeted attacks). Then we run our attack starting from the corresponding values of $\\boldsymbol { x } _ { k } , \\epsilon _ { k } , \\delta _ { k }$ and $\\delta ^ { \\star }$ . ",
+        "bbox": [
+            174,
+            669,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Differences with DDN. FMN applies substantial changes to both the algorithm and the formulation of DDN. The main difference is that (i) DDN always rescales the perturbation to have size $\\epsilon$ . This operation is problematic when using other norms, especially sparse ones, as it hinders the ability of the attack to explore the neighboring space and find a suitable descent direction. Another difference is that (ii) FMN does not use the cross-entropy loss, but it uses the logit difference as the loss function $L$ , since the latter is less affected by saturation effects. Moreover, (iii) FMN does not need an initial value for $\\epsilon$ , as $\\epsilon$ is dynamically estimated; and (iv) $\\gamma$ is decayed to improve convergence around better minimum-norm solutions, by more effectively dampening oscillations around the boundary. Finally, we include the possibility of (v) initializing the attack from an adversarial point, which can greatly increase the convergence speed of the algorithm, as it uses a fast line-search algorithm to find the boundary and the remaining queries to refine the result. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We report here an extensive experimental analysis involving several state-of-the-art defenses and minimum-norm attacks, covering $\\ell _ { 0 } , \\ell _ { 1 } , \\ell _ { 2 }$ and $\\ell _ { \\infty }$ norms. The goal is to empirically benchmark our attack and assess its effectiveness and efficiency as a tool for adversarial robustness evaluation. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            191,
+            351,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We consider two commonly-used datasets for benchmarking adversarial robustness of deep neural networks, i.e., the MNIST handwritten digits and CIFAR10. Following the experimental setup in [4], we use a subset of 1000 test samples to evaluate the considered attacks and defenses. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Models. We use a diverse selection of models to thoroughly evaluate attacks under different conditions. For MNIST, we consider the following four models: $M l$ , the 9-layer network used as the undefended baseline model by Papernot et al. [20], Carlini and Wagner [5]; $M 2$ , the robust model by Madry et al. [17], trained on $\\ell _ { \\infty }$ attacks (robustness claim: $8 9 . 6 \\%$ accuracy with $\\| \\delta \\| _ { \\infty } \\leq 0 . 3$ current best evaluation: $8 8 . 0 \\%$ ); M3, the robust model by Rony et al. [23], trained on $\\ell _ { 2 }$ attacks (robustness claim: $8 7 . 6 \\%$ accuracy with $\\lVert \\delta \\rVert _ { 2 } \\leq 1 . 5 )$ ; and $M 4$ , the IBP Large Model by Zhang et al. [27] (robustness claim: $9 4 . 3 \\%$ accuracy with $\\| \\delta \\| _ { \\infty } \\leq 0 . 3 )$ . For CIFAR10, we consider three state-ofthe-art robust models from RobustBench [11]: $C I$ , the robust model by Madry et al. [17], trained on $\\ell _ { \\infty }$ attacks (robustness claim: $4 4 . 7 \\%$ accuracy with $\\| \\delta \\| _ { \\infty } \\leq 8 / 2 5 5$ , current best evaluation: $4 4 . 0 \\%$ ); $C 2$ , the defended model by Carmon et al. [7] (top-5 in RobustBench), trained on $\\ell _ { \\infty }$ attacks and additional unsupervised data (robustness claim: $6 2 . 5 \\%$ accuracy with $\\| \\delta \\| _ { \\infty } \\leq 8 / 2 5 5$ , current best evaluation: $5 9 . 5 \\%$ ); and $C 3$ , the robust model by Rony et al. [23], trained on $\\ell _ { 2 }$ attacks (robustness claim: $6 7 . 9 \\%$ accuracy with $\\| \\pmb { \\delta } \\| _ { 2 } \\le 0 . 5$ , current best evaluation: $6 6 . 4 \\%$ ). ",
+        "bbox": [
+            174,
+            268,
+            825,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attacks. We compare our algorithm against different state-of-the-art attacks for finding minimumnorm adversarial perturbations across different norms: the Carlini & Wagner (CW) attack [5], the Decoupling Direction and Norm (DDN) attack [23], the Brendel & Bethge (BB) attack [4], and the Fast Adaptive Boundary (FAB) attack [10]. We use the implementation of FAB from Ding et al. [12], while for all the remaining attacks we use the implementation available in Foolbox [21, 22]. All these attacks are defined on the $\\ell _ { 2 }$ norm. BB and FAB are also defined on the $\\ell _ { 1 }$ and $\\ell _ { \\infty }$ norms, and only BB is defined on the $\\ell _ { 0 }$ norm. We consider both untargeted and targeted attack scenarios, as defined in Sect. 2, except for FAB, which is only evaluated in the untargeted case.1 ",
+        "bbox": [
+            173,
+            454,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. To ensure a fair comparison, we perform an extensive hyperparameter search for each of the considered attacks. We consider two main scenarios: tuning the hyperparameters at the sample-level and at the dataset-level. In the sample-level scenario, we select the optimal hyperparameters separately for each input sample by running each attack 10 to 16 times per sample, with a different hyperparameter configuration or random initialization point each time. In the datasetlevel scenario, we choose the same hyperparameters for all samples, selecting the configuration that yields the best attack performance. While sample-level tuning provides a fairer comparison across attacks, it is more computationally demanding and less practical than dataset-level tuning. In addition, the latter allows us to understand how robust attacks are to suboptimal hyperparameter choices. We select the hyperparameters to be optimized for each attack as recommended by the corresponding authors [4, 5, 10, 23]. The hyperparameter configurations considered for each attack are detailed below. For attacks that are claimed to be robust to hyperparameter changes, like BB and FAB, we follow the recommendation of using a larger number of random restarts rather than increasing the number of hyperparameter configurations to be tested. In addition, as BB requires being initialized from an adversarial starting point, we initialize it by randomly selecting a sample either from a different class (in the untargeted case) or from the target class (in the targeted case). Finally, as each attack performs operations with different levels of complexity within each iteration, possibly querying the model multiple times, we set the number of steps for each attack such that at least 1, 000 forward passes (i.e., queries) are performed. This ensures a fairer comparison also in terms of the computational time and resources required to execute each attack. ",
+        "bbox": [
+            174,
+            570,
+            826,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/badc4682ac0af93640da0b7b3facca7d77ff8749ecc5ffd5b17d961a19bba7fa.jpg",
+        "image_caption": [
+            "Figure 2: Query-distortion curves for MNIST (M2, top) and CIFAR10 (C1, bottom) models (untargeted scenario). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            813,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CW. This attack minimizes the soft-constraint version of our problem, i.e., $\\begin{array} { r l } { \\operatorname* { m i n } _ { \\pmb { \\delta } } \\| \\pmb { \\delta } \\| _ { p } + c \\cdot \\operatorname* { m i n } ( L ( \\pmb { x } + } & { { } } \\end{array}$ ${ \\delta , y , \\theta } ) , - \\kappa )$ . The hyperparameters $\\kappa$ and $c$ are used to tune the trade-off between perturbation size and misclassification confidence. To find minimum-norm perturbations, CW requires setting $\\kappa = 0$ , while the constant $c$ is tuned via binary search (re-running the attack at each iteration). We set the number of binary-search steps to 9, and the maximum number of iterations to 250, to ensure that at least $1 , 0 0 0$ queries are performed. We also set different values for $c , \\eta \\in \\{ 1 0 ^ { - 3 } , 1 0 ^ { - 2 } , 1 0 ^ { - 1 } , 1 \\}$ . ",
+        "bbox": [
+            174,
+            421,
+            826,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DDN. This attack, similarly to ours, maximizes the misclassification confidence within an $\\epsilon$ -sized constraint, while adjusting $\\epsilon$ to minimize the perturbation size. We consider initial values of $\\epsilon _ { 0 } \\in$ $\\{ 0 . 0 3 , 0 . 1 , 0 . 3 , 1 , 3 \\}$ , and run the attack with a different number of iterations $K \\in \\{ 2 0 0 , 1 0 0 0 \\}$ , as this affects the size of each update on $\\pmb { \\delta }$ . ",
+        "bbox": [
+            174,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$B B ,$ . This attack starts from a randomly-drawn adversarial point, performs a 10-step binary search to find a point which is closer to the decision boundary, and then updates the point to minimize its perturbation size by following the decision boundary. In each iteration, BB computes the optimal update within a given trust region of radius $\\rho$ . We consider different values for $\\rho \\in \\{ 1 0 ^ { - 3 } , 1 \\dot { 0 } ^ { - 2 } , 1 0 ^ { - \\dot { 1 } } , 1 \\}$ while we fix the number of steps to 1000. We run the attack 3 times by considering different initialization points, and eventually retain the best solution. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$F A B$ . This attack iteratively optimizes the attack point by linearly approximating its distance to the decision boundary. It uses an adaptive step size bounded by $\\alpha _ { \\mathrm { m a x } }$ and an extrapolation step $\\eta$ to facilitate finding adversarial points. As suggested by Croce and Hein [10], we tune $\\alpha _ { \\mathrm { m a x } } \\in$ $\\{ 0 . 1 , 0 . 0 5 \\}$ and $\\eta \\in \\{ 1 . 0 5 , 1 , 3 \\}$ . We consider 3 different random initialization points, and run the attack for 500 steps each time, eventually selecting the best solution. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "FMN. We run FMN for $K = 1 0 0 0$ steps, using $\\gamma _ { 0 } \\in \\{ 0 . 0 5 , 0 . 3 \\}$ , $\\gamma _ { K } = 1 0 ^ { - 4 }$ , and $\\alpha _ { K } = 1 0 ^ { - 5 }$ . For $\\ell _ { 0 } , \\ell _ { 1 }$ , and $\\ell _ { 2 }$ , we set $\\alpha _ { 0 } \\in \\{ 1 , 5 , 1 0 \\}$ . For $\\ell _ { \\infty }$ , we set $\\alpha _ { 0 } \\in \\{ 1 0 ^ { 1 } , 1 0 ^ { 2 } , 1 0 ^ { 3 } \\}$ , as the normalized $\\ell _ { 2 }$ step yields much smaller updates in the $\\ell _ { \\infty }$ norm. For each hyperparameter setting we run the attack twice, starting from (i) the input sample and (ii) an adversarial point. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation criteria. We evaluate the attacks along four different criteria: (i) perturbation size and (ii) robustness to hyperparameter selection, measured as the median $\\| \\delta ^ { \\star } \\| _ { p }$ on the test set (for a fixed budget of $Q$ queries and for sample- and dataset-level hyperparameter tuning, where by “robustness” we mean that a fixed hyperparameter configuration works well across different samples); (iii) execution time, measured as the average time spent per query (in milliseconds); and (iv) convergence speed, measured as the average number of queries required to converge to a good-enough solution (within $10 \\%$ of the best value found at $Q = 1 0 0 0 ^ { \\cdot }$ ). When computing the median, we follow the evaluation in [4]: the perturbation size is set to 0 if a clean sample is misclassified, while it is set to $\\infty$ when the attack fails (no adversarial is found). The median perturbation size thus represents the value for which $50 \\%$ of the samples evade a particular model. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            362,
+            155
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Query-distortion $( Q D )$ curves. To evaluate each attack in terms of perturbation size under the same query budget $Q$ , we use the so-called QD curves introduced by Brendel et al. [4]. These curves report, for each attack, the median value of $\\delta ^ { \\star }$ as a function of the number of queries $Q$ . For each given $Q$ value, the optimal $\\delta ^ { \\star }$ for each point is selected among the different attack executions (i.e., using different hyperparameters and/or initialization points, as described in Sect. 3.1). In Fig. 2, we report the QD curves for the MNIST and CIFAR10 challenge models (i.e., M2 and C1) in the untargeted scenario. The remaining QD curves exhibit a similar behavior and can be found in the supplementary material. It is worth noting that our attack attains comparable results in terms of perturbation size across all norms, while significantly outperforming FAB and BB in the $\\ell _ { 1 }$ case. It typically requires also less iterations than the other attacks to converge. While the QD curves show the complete behavior of each attack as $Q$ increases, a more compact and thorough summary of our evaluation is reported below, according to the four evaluation criteria described in Sect. 3.1. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Perturbation size. Table 1 reports the median value of $\\lVert \\delta ^ { \\star } \\rVert$ at $Q = 1 0 0 0$ queries (i.e., the last value from the query-distortion curve), for all models, attacks and norms. The values obtained with sample-level hyperparamter tuning confirm that our attack can find smaller or comparable perturbations with those found by the competing attacks, in most of the untargeted and targeted cases, and that the biggest margin is achieved in the $\\ell _ { 1 }$ case. FMN is only slightly worse than DDN and BB in a few cases, including $\\ell _ { 2 }$ -DDN on M4 and $\\ell _ { \\infty }$ -BB on M2 and M4. The reason may be that these robust models exhibit noisy gradients and flat regions around the clean input samples, hindering the initial optimization steps of the FMN attack. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Robustness to hyperparameter selection. The values reported in the lower part of Table 1 show that, when using dataset-level hyperparameter tuning, FMN outperforms the other attacks in a much larger number of cases. This shows that FMN is more robust to hyperparameter changes, while other attacks like $\\ell _ { 0 } \\cdot$ and $\\ell _ { 1 }$ -BB suffer when using the same hyperparameters for all samples. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Execution time. The average runtime per query for each attack-model pair, measured on a workstation with an NVIDIA GeForce RTX 2080 Ti GPU with 11GB of RAM, can be found in Table 2. The results show that our attack is up to 2-3 times faster, with the exception of DDN in the $\\ell _ { 2 }$ case. This is however compensated by the fact that FMN finds better solutions. The advantage is that our attack avoids costly inner projections as in BB and FAB. FMN is slightly less time-efficient than DDN and CW, as it simultaneously updates the adversarial point and the norm constraint. In particular, the update on the constraint may initially require computing the norm of the gradient $\\textbf {  { g } }$ (line 6 in Algorithm 1), which increases the runtime of our attack. FAB computes a similar step, but for all the output classes, which hinders its scalability to problems with many classes. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Convergence speed. To get an estimate of the convergence speed, we measure the number of queries required by each attack to reach a perturbation size that is within $10 \\%$ of the value found at $Q = 1 0 0 0$ queries (the lower the better). Results are shown in Table 3. Our attack converges on par with or faster than all other attacks for almost all models, often requiring only half or a fifth as many queries as the state of the art. Exceptions are MNIST and CIFAR10 challenge models (M2 and C1) for $\\ell _ { 2 }$ and $\\ell _ { \\infty }$ , where BB and DDN occasionally converge faster. FMN rarely needs more than 100 steps, reaching the minimal perturbation after only 10-30 queries on many datasets, models and norms. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Robust accuracy. Despite our attack being not tailored to target specific defenses, and our evaluation restricted to a subset of the testing samples, it is worth remarking that the robust accuracies of the models against our attack are aligned with that reported in current evaluations, with the notable exception of C3, where our attack can decrease robust accuracy from $6 7 . 9 \\%$ to $6 5 . 5 \\%$ . ",
+        "bbox": [
+            174,
+            752,
+            823,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experiments on ImageNet. We conclude our experiments by running an additional comparison between FMN and a widely-used maximum-confidence attack, i.e., the Projected Gradient Descent (PGD) attack [17], on two pretrained ImageNet models (i.e., ResNet18 and VGG16), considering $\\ell _ { 1 }$ , $\\ell _ { 2 }$ and $\\ell _ { \\infty }$ norms. The hyperparameters are tuned at the dataset-level using 20 validation samples. For FMN, we fix the hyperparameters as discussed before, and only tune $\\alpha _ { 0 } \\in \\{ 0 . 1 , 1 , 2 , 8 \\}$ , without using adversarial initialization. For PGD, we tune the step size $\\alpha \\in \\{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 , 1 , 2 , 8 \\}$ . We run both attacks for $Q = 1 , 0 0 0$ queries on a separate set of $1 , 0 0 0$ samples. The success rates of both attacks at fixed $\\epsilon$ values are reported in Table 4. The results show that FMN outperforms or equals PGD in all norms. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3e4d752cb5d3fa117b0af543dce0e530667601fc00482cfe238ad4f04ed2d45.jpg",
+        "table_caption": [
+            "Table 1: Median $\\| \\delta ^ { \\star } \\| _ { p }$ value at $Q = 1 0 0 0$ queries for targeted and untargeted attacks, with samplelevel and dataset-level hyperparameter tuning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"6\">MNIST</td><td colspan=\"6\"></td><td colspan=\"5\"></td></tr><tr><td></td><td></td><td colspan=\"3\">Untargeted M2</td><td colspan=\"2\"></td><td colspan=\"3\">Targeted</td><td colspan=\"2\">M4</td><td colspan=\"2\">Untargeted C2</td><td colspan=\"2\"></td><td colspan=\"2\">Targeted C2</td></tr><tr><td>Model</td><td>M1</td><td></td><td>M3</td><td></td><td>M4</td><td>M1</td><td>M2 Sample-level Hyperparameter Tuning</td><td>M3</td><td></td><td>C1</td><td></td><td></td><td>C3</td><td>C1</td><td></td><td>C3</td></tr><tr><td>l</td><td>BB</td><td>8</td><td></td><td>15</td><td>94</td><td>14</td><td>27</td><td>24</td><td>93</td><td>8</td><td>12</td><td>13</td><td>19</td><td></td><td>32 32</td><td>25</td></tr><tr><td>l1</td><td>Ours FAB BB</td><td>7 6.60 6.26</td><td>9 3.08 5.81</td><td>15 14.23 13.16</td><td>5 109.4 5.44</td><td>14 1 12.42</td><td>20 1 10.38</td><td>24 1 20.41</td><td>23 1 6.25</td><td>8 4.79 3.75</td><td>11 5.17 4.29</td><td>14 8.79 8.62</td><td>19 1 8.04</td><td></td><td>- 10.93</td><td>27 - 15.71</td></tr><tr><td>l</td><td>Ours FAB Cw BB</td><td>5.57 1.45 1.49 1.43</td><td>2.95 1.36 4.22 1.34</td><td>12.04 2.62 2.78 2.61</td><td>1.96 2.97 1 1.61</td><td>12.20 - 2.33 2.27</td><td>6.75 1 6.97 2.04</td><td>18.79 1 3.54 3.23</td><td>7.31 - - 1.79</td><td>3.04 0.66 0.67 0.63</td><td>3.43 0.72 0.74 0.70</td><td>8.26 0.94 0.91 0.91</td><td>7.07 - 1.08 1.07</td><td></td><td>9.40 1 1.27 1.26</td><td>15.24 - 1.38 1.38</td></tr><tr><td>lo</td><td>DDN Ours FAB</td><td>1.46 1.41 .138</td><td>1.71 1.23 .337</td><td>2.56 2.50 .233</td><td>0.79 0.94 .421</td><td>2.29 2.28 -</td><td>2.20 1.89 1</td><td>3.27 3.19</td><td>1.33 1.85</td><td>0.64 0.61</td><td>0.73 0.69</td><td>0.91 0.91</td><td></td><td>1.09 1.03</td><td>1.29 1.21</td><td>1.39 1.38</td></tr><tr><td></td><td>BB Ours</td><td>.138 .134</td><td>.330 .339</td><td>.227 .226</td><td>.402 .404</td><td>.202 .201</td><td>.355 .389</td><td>1 .271 .272</td><td>.403 .406</td><td>.033 .032 .032</td><td>.043 .041 .040</td><td>.025 .024 .024</td><td>1 .055 .055</td><td></td><td>- .064 .063</td><td>- .037 .037</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>Dataset-level Hyperparameter Tuning</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l</td><td>BB Ours</td><td>12 9</td><td>152 33</td><td>52 18</td><td>145 15</td><td>20 16</td><td>179 48</td><td>39 28</td><td>183 55</td><td>28 11</td><td>44 17</td><td>32 16</td><td>29 25</td><td>65 38</td><td></td><td>33 32</td></tr><tr><td>l1</td><td>FAB BB Ours</td><td>8.66 10.60 7.13</td><td>225.7 49.83 4.18</td><td>163.9 17.57 13.66</td><td>312.3 46.99 4.99</td><td>1 16.60 13.18</td><td>1 53.11 8.33</td><td>1 29.89</td><td>1 54.31</td><td>1 7.02 4.28</td><td>1 10.20 4.82</td><td>20.48 17.13 9.52</td><td>1 11.41</td><td></td><td>1 15.26 10.40</td><td>1 23.37 17.32</td></tr><tr><td>l</td><td>FAB Cw</td><td>1.54 1.63</td><td>1.59 5.15</td><td>2.81 3.71</td><td>16.30</td><td>1 2.50</td><td>1 1</td><td>21.37 1</td><td>12.16 1</td><td>0.77 0.86</td><td>1.11 1.00</td><td>1.06 0.99</td><td></td><td>8.51 1</td><td>- 2.90</td><td>- 1.55</td></tr><tr><td></td><td>BB</td><td></td><td></td><td></td><td>4.57</td><td>2.64</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.73</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2.30</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.31</td><td>1.40</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2.31</td><td></td><td></td><td>1.96</td><td>0.66</td><td>0.77</td><td>0.91</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.15</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>1.75</td><td>1.82</td><td>3.02</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.36 1.25</td><td>1.45</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>-</td><td></td><td>2.59</td><td>4.72 3.52</td><td>- 5.31</td><td>0.86</td><td>0.95</td><td>1.10</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>DDN</td><td>1.47</td><td>2.01</td><td>2.62</td><td></td><td></td><td>2.72</td><td>3.36</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.56</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.11</td><td></td><td></td></tr><tr><td></td><td></td><td>1.61</td><td>1.42</td><td>2.61</td><td></td><td></td><td>2.13</td><td>3.24</td><td>2.41</td><td>0.67</td><td>0.74</td><td>0.91</td><td></td><td></td><td></td><td>1.38</td></tr><tr><td></td><td>Ours</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>1.09</td><td>1.28</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>：</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l</td><td>FAB</td><td>.148</td><td>.365</td><td>.248</td><td>.900</td><td></td><td>-</td><td>-</td><td>1</td><td>.038</td><td>.052</td><td>.029 .029</td><td></td><td>- .059</td><td>- .074</td><td>， .042</td></tr><tr><td></td><td>BB</td><td>.159 .140</td><td>.336 .357</td><td>.243 .233</td><td>.409 .408</td><td>.223 .206</td><td>.361 .426</td><td>.280 .277</td><td>.477 .434</td><td></td><td>.044 .054 .034 .042</td></table>",
+        "bbox": [
+            176,
+            126,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b6696dfd1cfda3366dcbeb52fc82197e063d8a933c11a4a2635aa5bf99e8f87b.jpg",
+        "table_caption": [
+            "Table 2: Average execution time (milliseconds / query) for each attack-model pair. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"7\">MNIST</td><td colspan=\"7\"></td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Model</td><td colspan=\"3\">Untargeted</td><td rowspan=\"2\">M1</td><td colspan=\"3\">Targeted</td><td rowspan=\"2\"></td><td colspan=\"3\">Untargeted</td><td colspan=\"3\">Targeted</td></tr><tr><td>M1 M2</td><td>M3</td><td>M4</td><td>M2</td><td>M3</td><td>M4</td><td>C1</td><td>C2</td><td>C3</td><td>C1</td><td>C2</td><td>C3</td></tr><tr><td>l</td><td>BB</td><td>10.76</td><td>11.85</td><td>10.19</td><td>12.02</td><td>60.88</td><td>62.17</td><td>62.31</td><td>57.74</td><td>46.51</td><td>50.31</td><td>50.43</td><td>99.71</td><td>105.28</td><td>103.53</td></tr><tr><td></td><td>Ours</td><td>5.15</td><td>4.87</td><td>5.87</td><td>9.70</td><td>5.14</td><td>4.75</td><td>5.85</td><td>9.71</td><td>26.26</td><td>30.54</td><td>30.89</td><td>26.13</td><td>30.26</td><td>30.81</td></tr><tr><td>l1</td><td>FAB BB</td><td>9.38 6.73</td><td>8.88 7.03</td><td>12.61</td><td>36.00</td><td>- 43.25</td><td>- 43.54</td><td></td><td></td><td>84.04 32.56</td><td>108.91</td><td>108.64 37.59</td><td>- 68.99</td><td>73.33 =</td><td>- 74.03</td></tr><tr><td></td><td>Ours</td><td>5.43</td><td>5.14</td><td>7.31 6.10</td><td>12.50 9.35</td><td>5.44</td><td>5.10</td><td>43.69 6.09</td><td>43.86 9.35</td><td>27.34</td><td>37.40 31.17</td><td>31.18</td><td>26.00</td><td>30.98</td><td>31.03</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l2</td><td>FAB</td><td>10.22</td><td>10.13</td><td>13.45</td><td>36.72</td><td>-</td><td>-</td><td>-</td><td>-</td><td>84.27</td><td>109.43</td><td>108.87</td><td>-</td><td>1</td><td>、 31.30</td></tr><tr><td></td><td>Cw</td><td>4.22</td><td>4.09</td><td>5.17</td><td>10.07</td><td>4.23</td><td>4.14</td><td>5.15</td><td>10.06</td><td>25.90</td><td>31.32</td><td>31.31</td><td>25.78</td><td>31.32</td><td>54.07</td></tr><tr><td></td><td>BB</td><td>4.44</td><td>4.15</td><td>5.03</td><td>12.38</td><td>26.20</td><td>26.76</td><td>27.24</td><td>31.00</td><td>26.64</td><td>31.82</td><td>31.90</td><td>48.74</td><td>54.35</td><td>29.52</td></tr><tr><td></td><td>DDN Ours</td><td>3.42 4.46</td><td>3.33 4.42</td><td>4.30</td><td>8.59</td><td>3.42</td><td>3.35</td><td>4.32</td><td>8.60</td><td>24.14</td><td>29.62</td><td>29.48</td><td>23.61</td><td>29.61</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>5.48</td><td>9.15</td><td>4.50</td><td>4.44</td><td>5.47</td><td>9.09</td><td>24.88</td><td>30.22</td><td>30.08</td><td>25.39</td><td>30.21</td><td>30.04</td></tr><tr><td>l8</td><td>FAB</td><td>10.85</td><td>10.61</td><td>14.05</td><td>36.23</td><td>-</td><td>-</td><td>-</td><td>-</td><td>84.62</td><td>109.83</td><td>109.57</td><td>-</td><td>-</td><td>-</td></tr><tr><td></td><td>BB</td><td>14.26</td><td>16.36</td><td>13.51</td><td>15.44</td><td>38.61</td><td>38.87</td><td>36.39</td><td>34.85</td><td>61.34</td><td>62.36</td><td>62.63</td><td>83.70</td><td>87.64</td><td>88.90</td></tr><tr><td></td><td>Ours</td><td>4.25</td><td>4.33</td><td>5.30</td><td>9.17</td><td>4.33</td><td>4.23</td><td>5.31</td><td>9.10</td><td>24.84</td><td>30.15</td><td>30.01</td><td>24.78</td><td>30.19</td><td>30.03</td></tr></table>",
+        "bbox": [
+            176,
+            542,
+            823,
+            729
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            758,
+            821,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            321,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Gradient-based attacks on machine learning have a long history [3, 2]. Maximum-confidence attacks optimize the adversarial loss (e.g., the difference between the logits of the true class and the best non-true class) to find an adversarial point misclassifed with maximum confidence within a given, bounded perturbation size. While attacks in this category like FGSM [15], PGD [16, 17] and momentum-based extensions of PGD [26, 13] are popular, they only partially evaluate the adversarial robustness of a model. Minimum-norm attacks aim to minimize the norm of the perturbation subject to being adversarial. Attacks from this class give a more complete picture of the model robustness and allow us to compute the accuracy of the model under attacks with any post-hoc defined maximum perturbation size. L-BFGS [24] solves this problem with a quasi-Newton optimizer while CW [5] and EAD [8] use first-order gradient-based optimizers to minimize a weighted loss between perturbation size and misclassification confidence. To find the smallest adversarial perturbation, both CW and EAD need to tune the relative weighting which makes them query-inefficient. DeepFool [19] and SparseFool [18] compute gradients with respect to all classes in each step to estimate a linear approximation of the model from which the optimal adversarial perturbation can be computed. These two attacks are fast but do not converge to competitive solutions. BB [4] and FAB [10] use complex projections and approximations to stay close to the decision boundary (using the gradient to estimate the local geometry of the boundary) while minimizing the norm. This way of formulating minimum-norm optimization bypasses the tuning of a weighting term, but in the case of BB it also requires an adversarial starting point to begin with. The DDN attack [23] maximizes the adversarial criterion within a given norm constraint, and iteratively reduces the norm to find the smallest possible adversarial perturbation; however, it is constrained to $\\ell _ { 2 }$ and does not perform well on other $\\ell _ { p }$ norms. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4a579ec45da2f7080dfa2552da43ad62cb307b59e43215c09ac87b7dc8d7599b.jpg",
+        "table_caption": [
+            "Table 3: Number of queries required by each attack to reach a perturbation size that is within $10 \\%$ o f the value obtained at $Q = 1 0 0 0$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"7\">MNIST</td><td colspan=\"7\">CIFAR10</td></tr><tr><td colspan=\"2\"></td><td colspan=\"3\">Untargeted</td><td></td><td colspan=\"3\">Targeted</td><td colspan=\"3\">Untargeted</td><td colspan=\"3\">Targeted C1</td></tr><tr><td colspan=\"2\">Model</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>C1</td><td>C2</td><td>C3</td><td>C2</td><td>C3</td></tr><tr><td>l</td><td>BB Ours</td><td>22 22</td><td>43 82</td><td>68 38</td><td>114 182</td><td>30 27</td><td>443 165</td><td>71 46</td><td>376 145</td><td>497 48</td><td>372 71</td><td>58 37</td><td>384 500 271</td><td>85</td></tr><tr><td>l1</td><td>FAB</td><td>44</td><td></td><td></td><td>569</td><td>1</td><td>1</td><td>-</td><td></td><td></td><td></td><td></td><td>146</td><td>70</td></tr><tr><td></td><td>BB</td><td>24</td><td>242 314</td><td>152 83</td><td>391</td><td>45</td><td>614 233</td><td>- 722</td><td>124 674</td><td>220 570</td><td>72 34</td><td>- 526</td><td>1 464</td><td>1 206</td></tr><tr><td></td><td>Ours</td><td>21</td><td>363</td><td>34</td><td>631</td><td>25</td><td>37</td><td>336</td><td>48</td><td>85</td><td>31</td><td>89</td><td>130</td><td>38</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>243</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>l2</td><td>FAB CW</td><td>14 110</td><td>60 799</td><td>40 335</td><td>532 -</td><td>- 100</td><td></td><td>-</td><td>18</td><td>28</td><td>14</td><td>-</td><td>-</td><td>- 42</td></tr><tr><td></td><td>BB</td><td>20</td><td>24</td><td>337</td><td>21</td><td>913 61</td><td>469 20</td><td>- 692</td><td>67 22</td><td>39 23</td><td>33 22</td><td>56 26</td><td>144 27</td><td>29</td></tr><tr><td></td><td></td><td></td><td></td><td>20</td><td></td><td></td><td>26</td><td>670</td><td>13</td><td>20</td><td>4</td><td>18</td><td>19</td><td>18</td></tr><tr><td></td><td>DDN Ours</td><td>12 16</td><td>136 94</td><td>15</td><td>474 190</td><td>12</td><td>149</td><td>188</td><td>28</td><td>23</td><td>7</td><td>25</td><td>29</td><td>13</td></tr><tr><td></td><td></td><td></td><td></td><td>16</td><td></td><td>11</td><td>136</td><td>16</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>lo</td><td>FAB BB</td><td>36</td><td>50</td><td>44</td><td>11 5</td><td>- 24</td><td>- 17</td><td></td><td>50</td><td>50</td><td>54</td><td></td><td>-</td><td>1</td></tr><tr><td></td><td></td><td>19</td><td>17</td><td>20</td><td></td><td></td><td>22 26</td><td>5 5</td><td>20 22</td><td>24 15</td><td>21 14</td><td>27 20</td><td>33 29</td><td>29</td></tr><tr><td></td><td>Ours</td><td>9</td><td>10</td><td>22</td><td>5</td><td>27</td><td>8</td><td></td><td></td><td></td><td></td><td></td><td></td><td>34</td></tr></table>",
+        "bbox": [
+            238,
+            125,
+            756,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            343,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The proposed FMN attack belongs to the category of minimum-norm attacks, and builds on BB, FAB and DDN to retain their main advantages. First, FMN is not specific to a given norm, and converges in many fewer steps than soft-constraint attacks like CW, as it does not need to optimize the trade-off between perturbation size and misclassification confidence. FMN needs significantly less computational time per step than the other attacks, it is very accurate and easy to use, and it does not necessarily require being initialized from an adversarial starting point. ",
+        "bbox": [
+            174,
+            570,
+            549,
+            709
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d966628910d335ad67e820d98b7574b49b11d793fcd74be6201bf50e1b1edfa5.jpg",
+        "table_caption": [
+            "Table 4: Success rate $( \\% )$ of FMN against PGD on ImageNet models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ResNet18</td><td></td><td>VGG</td></tr><tr><td rowspan=\"2\">l1 (∈ = 1.0)</td><td>PGD</td><td>31.4</td><td>30.4</td></tr><tr><td>FMN</td><td>38.4</td><td>39.8</td></tr><tr><td rowspan=\"2\">l2 (∈= 0.15)</td><td>PGD</td><td>61.7</td><td>61.4</td></tr><tr><td>FMN</td><td>65.8</td><td>66.2</td></tr><tr><td rowspan=\"2\">l (∈=4·10-4)</td><td>PGD</td><td>51.0</td><td>49.0</td></tr><tr><td>FMN</td><td>55.2</td><td>49.0</td></tr></table>",
+        "bbox": [
+            562,
+            598,
+            823,
+            691
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Contributions, Limitations, and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            727,
+            584,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work introduces a novel minimum-norm attack that combines all desirable traits to help improve current adversarial evaluations: (i) finding smaller or comparable minimum-norm perturbations across a range of models and datasets; (ii) being less sensitive to hyperparameter choices; and being extremely fast, by (iii) reducing runtime up to 3 times per query with respect to competing attacks and (iv) converging within less iterations. FMN also works with different $\\ell _ { p }$ norms $( p = 0 , 1 , 2 , \\infty )$ and it does not necessarily require being initialized from an adversarial starting point. Our experiments have shown that FMN rivals or surpasses other attacks in speed, reliability, efficacy and versatility. While FMN is able to find smaller perturbations consistently when compared against $\\ell _ { 0 }$ and $\\ell _ { 1 }$ attacks, it only rivals the performance of other attacks for $\\ell _ { 2 }$ and $\\ell _ { \\infty }$ norms, especially when tested against robust models which may present obfuscated gradients. To overcome this limitation, FMN may be extended using smoothing strategies that help find better descent directions, e.g., by averaging gradients on randomly-perturbed inputs. This can be regarded as an interesting extension of FMN towards attacking robust models. In this respect, we also believe that FMN may facilitate minimumnorm adaptive evaluations in a more general sense. Adaptive evaluations, where the attack is modified to be maximally effective against a new defense, are the key element towards properly evaluating adversarial robustness [6, 25]. PGD attacks are popular in part for the ease by which they can be adapted to new defenses. Since FMN combines PGD with a dynamic minimization of the perturbation size, we argue that our attack can also be easily adapted to new defenses, thereby facilitating adaptive evaluations. FMN may also benefit from other improvements that have been suggested for PGD, including momentum, cyclical step sizes or restarts. We leave such improvements to future work. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To conclude, we firmly believe that FMN will establish itself as a useful tool in the arsenal of robustness evaluation. By facilitating more reliable robustness evaluations, we expect that FMN will foster advancements in the development of machine-learning models with improved robustness guarantees. We thus argue that there are neither ethical aspects nor evident future societal consequences with potential negative impacts that should be specifically addressed in the context of this work. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            310,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work has been partly supported by the PRIN 2017 project RexLearn (grant no. 2017TWNMH2), funded by the Italian Ministry of Education, University and Research; by the EU H2020 project ALOHA, under the European Union’s Horizon 2020 research and innovation programme (grant no. 780788); and by BMK, BMDW, and the Province of Upper Austria in the frame of the COMET Programme managed by FFG in the COMET Module S3AI. Wieland Brendel acknowledges support from the German Federal Ministry of Education and Research (BMBF) through the Competence Center for Machine Learning (TUE.AI, FKZ 01IS18039A), from the German Science Foundation (DFG) under grant no. BR 6382/1-1 (Emmy Noether Program) as well as support by Open Philantropy and the Good Ventures Foundation. ",
+        "bbox": [
+            174,
+            333,
+            826,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            266,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] A. Athalye, N. Carlini, and D. A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, volume 80 of JMLR Workshop and Conf. Proceedings, pages 274–283. JMLR.org, 2018.   \n[2] B. Biggio and F. Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018.   \n[3] B. Biggio, I. Corona, D. Maiorca, B. Nelson, N. Šrndic, P. Laskov, G. Giacinto, and F. Roli. ´ Evasion attacks against machine learning at test time. In H. Blockeel, K. Kersting, S. Nijssen, and F. Železný, editors, Machine Learning and Knowledge Discovery in Databases (ECML PKDD), Part III, volume 8190 of LNCS, pages 387–402. Springer Berlin Heidelberg, 2013.   \n[4] W. Brendel, J. Rauber, M. Kümmerer, I. Ustyuzhaninov, and M. Bethge. Accurate, reliable and fast robustness evaluation. In Advances in Neural Inf. Proc. Systems, pages 12861–12871, 2019.   \n[5] N. Carlini and D. Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pages 39–57. IEEE, 2017.   \n[6] N. Carlini, A. Athalye, N. Papernot, W. Brendel, J. Rauber, D. Tsipras, I. Goodfellow, A. Madry, and A. Kurakin. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019.   \n[7] Y. Carmon, A. Raghunathan, L. Schmidt, J. C. Duchi, and P. S. Liang. Unlabeled data improves adversarial robustness. In Advances in Neural Inf. Proc. Systems, pages 11192–11203, 2019.   \n[8] P.-Y. Chen, Y. Sharma, H. Zhang, J. Yi, and C.-J. Hsieh. EAD: Elastic-net attacks to deep neural networks via adversarial examples. arXiv preprint arXiv:1709.04114, 2017.   \n[9] F. Croce and M. Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.   \n[10] F. Croce and M. Hein. Minimally distorted adversarial examples with a fast adaptive boundary attack. In Int’l Conf. on Machine Learning, pages 2196–2205. PMLR, 2020.   \n[11] F. Croce, M. Andriushchenko, V. Sehwag, N. Flammarion, M. Chiang, P. Mittal, and M. Hein. Robustbench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670, 2020.   \n[12] G. W. Ding, L. Wang, and X. Jin. AdverTorch v0.1: An adversarial robustness toolbox based on pytorch. arXiv preprint arXiv:1902.07623, 2019.   \n[13] Y. Dong, F. Liao, T. Pang, H. Su, J. Zhu, X. Hu, and J. Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition, 2018.   \n[14] J. Duchi, S. Shalev-Shwartz, Y. Singer, and T. Chandra. Efficient projections onto the l 1-ball for learning in high dimensions. In Proceedings of the 25th Int’l Conf. on Machine learning, pages 272–279, 2008.   \n[15] I. Goodfellow, J. Shlens, and C. Szegedy. Explaining and harnessing adversarial examples. In Int’l Conf. on Learning Representations, 2015. URL http://arxiv.org/abs/1412.6572.   \n[16] A. Kurakin, I. Goodfellow, and S. Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.   \n[17] A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.   \n[18] A. Modas, S.-M. Moosavi-Dezfooli, and P. Frossard. Sparsefool: a few pixels make a big difference. In The IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[19] S.-M. Moosavi-Dezfooli, A. Fawzi, and P. Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In The IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2016.   \n[20] N. Papernot, P. McDaniel, X. Wu, S. Jha, and A. Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE symposium on security and privacy (SP), pages 582–597. IEEE, 2016.   \n[21] J. Rauber, W. Brendel, and M. Bethge. Foolbox: A python toolbox to benchmark the robustness of machine learning models. In Reliable Machine Learning in the Wild Workshop, 34th Int’l Conf. on Machine Learning, 2017. URL http://arxiv.org/abs/1707.04131.   \n[22] J. Rauber, R. Zimmermann, M. Bethge, and W. Brendel. Foolbox native: Fast adversarial attacks to benchmark the robustness of machine learning models in pytorch, tensorflow, and jax. Journal of Open Source Software, 5(53):2607, 2020. doi: 10.21105/joss.02607. URL https://doi.org/10.21105/joss.02607.   \n[23] J. Rony, L. G. Hafemann, L. S. Oliveira, I. B. Ayed, R. Sabourin, and E. Granger. Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition, pages 4322–4330, 2019.   \n[24] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks. In Int’l Conf. on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.   \n[25] F. Tramer, N. Carlini, W. Brendel, and A. Madry. On adaptive attacks to adversarial example defenses. In Advances in Neural Inf. Proc. Systems, 2020.   \n[26] J. Uesato, B. O’Donoghue, A. v. d. Oord, and P. Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018.   \n[27] H. Zhang, H. Chen, C. Xiao, S. Gowal, R. Stanforth, B. Li, D. Boning, and C.-J. Hsieh. Towards stable and efficient training of verifiably robust neural networks. In Int’l Conf. on Learning Representations, 2020. URL https://openreview.net/forum?id $\\equiv$ Skxuk1rFwB. ",
+        "bbox": [
+            179,
+            501,
+            828,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            21,
+            828,
+            887
+        ],
+        "page_idx": 10
+    }
+]