Add files using upload-large-folder tool

parse/train/1AoMhc_9jER/1AoMhc_9jER.md

@@ -0,0 +1,352 @@
+# GANS CAN PLAY LOTTERY TICKETS TOO
+
+Xuxi Chen1\*, Zhenyu Zhang1\*, Yongduo $\mathbf { S u i ^ { 1 } }$ , Tianlong Chen2 1University of Science and Technology of China, 2University of Texas at Austin {chanyh,zzy19969,syd2019}@mail.ustc.edu.cn, tianlong.chen@utexas.edu
+
+# ABSTRACT
+
+Deep generative adversarial networks (GANs) have gained growing popularity in numerous scenarios, while usually suffer from high parameter complexities for resource-constrained real-world applications. However, the compression of GANs has less been explored. A few works show that heuristically applying compression techniques normally leads to unsatisfactory results, due to the notorious training instability of GANs. In parallel, the lottery ticket hypothesis shows prevailing success on discriminative models, in locating sparse matching subnetworks capable of training in isolation to full model performance. In this work, we for the first time study the existence of such trainable matching subnetworks in deep GANs. For a range of GANs, we certainly find matching subnetworks at $6 7 \% - 7 4 \%$ sparsity. We observe that with or without pruning discriminator has a minor effect on the existence and quality of matching subnetworks, while the initialization weights used in the discriminator plays a significant role. We then show the powerful transferability of these subnetworks to unseen tasks. Furthermore, extensive experimental results demonstrate that our found subnetworks substantially outperform previous state-of-the-art GAN compression approaches in both image generation (e.g. SNGAN) and image-to-image translation GANs (e.g. CycleGAN). Codes available at https://github.com/VITA-Group/GAN-LTH.
+
+# 1 INTRODUCTION
+
+Generative adversarial networks (GANs) have been successfully applied to many fields like image translation (Jing et al., 2019; Isola et al., 2017; Liu & Tuzel, 2016; Shrivastava et al., 2017; Zhu et al., 2017) and image generation (Miyato et al., 2018; Radford et al., 2016; Gulrajani et al., 2017; Arjovsky et al., 2017). However, they are often heavily parameterized and often require intensive calculation at the training and inference phase. Network compressing techniques (LeCun et al., 1990; Wang et al., 2019; 2020b; Li et al., 2020) can be of help at inference by reducing the number of parameters or usage of memory; nonetheless, they can not save computational burden at no cost. Although they strive to maintain the performance after compressing the model, a non-negligible drop in generative capacity is usually observed. A question is raised:
+
+Is there any way to compress a GAN model while preserving or even improving its performance?
+
+The lottery ticket hypothesis (LTH) (Frankle & Carbin, 2019) provides positive answers with matching subnetworks (Chen et al., 2020b). It states that there exist matching subnetworks in dense models that can be trained to reach a comparable test accuracy to the full model within similar training iterations. The hypothesis has successfully shown its success in various fields (Yu et al., 2020; Renda et al., 2020; Chen et al., 2020b), and its property has been studied widely (Malach et al., 2020; Pensia et al., 2020; Elesedy et al., 2020). However, it is never introduced to GANs, and therefore the presence of matching subnetworks in generative adversarial networks still remains mysterious.
+
+To address this gap in the literature, we investigate the lottery ticket hypothesis in GANs. One most critical challenge of extending LTH in GANs emerges: how to deal with the discriminator while compressing the generator, including (i) whether prunes the discriminator simultaneously and (ii) what initialization should be adopted by discriminators during the re-training? Previous GAN compression methods (Shu et al., 2019; Wang et al., 2019; Li et al., 2020; Wang et al., 2020b) prune the generator model only since they aim at reducing parameters in the inference stage. The effect of pruning the discriminator has never been studied by these works, which is unnecessary for them but possibly essential in finding matching subnetworks. It is because that finding matching subnetworks involves re-training the whole GAN network, in which an imbalance in generative and discriminative power could result in degraded training results. For the same reason, the disequilibrium between initialization used in generators and discriminators incurs severe training instability and unsatisfactory results.
+
+Another attractive property of LTH is the powerful transferability of located matching subnetworks. Although it has been well studied in discriminative models (Mehta, 2019; Morcos et al., 2019; Chen et al., 2020b), an in-depth understanding of transfer learning in GAN tickets is still missing. In this work, we not only show whether the sparse matching subnetworks in GANs can transfer across multiple datasets but also study what initialization benefits more to the transferability.
+
+To convert parameter efficiency of LTH into the advantage of computational saving, we also utilize channel pruning (He et al., 2017) to find the structural matching subnetworks of GANs, which enjoys the bonus of accelerated training and inference. Our contributions can be summarized in the following four aspects:
+
+• Using unstructured magnitude pruning, we identify matching subnetworks at $74 \%$ sparsity in SNGAN (Miyato et al., 2018) and $67 \%$ in CycleGAN (Zhu et al., 2017). The matching subnetworks in GANs exist no matter whether pruning discriminators, while the initialization weights used in the discriminator are crucial.   
+• We show that the matching subnetworks found by iterative magnitude pruning outperform subnetworks extracted by randomly pruning and random initialization in terms of extreme sparsity and performance. To fully exploit the trained discriminator, we using the dense discriminator as a distillation source and further improve the quality of winning tickets.   
+• We demonstrate that the found subnetworks in GANs transfer well across diverse generative tasks.   
+• The matching subnetworks found by channel pruning surpass previous state-of-the-art GAN compression methods (i.e., GAN Slimming (Wang et al., 2020b)) in both efficiency and performance.
+
+# 2 RELATED WORK
+
+GAN Compression Generative adversarial networks (GANs) have succeeded in computer vision fields, for example, image generation and translation. One significant drawback of the generative models is the high computational cost of the models’ complex structure. A wide range of neural network compression techniques has been applied to generative models to address this problem. There are several categories of compression techniques, including pruning (removing some parameters), quantization (reducing the bit width), and distillation. Shu et al. (2019) proposed a channel pruning method for CycleGAN by using a co-evolution algorithm. Wang et al. (2019) proposed a quantization method for GANs based on the EM algorithm. Li et al. (2020) used a distillation method to transfer knowledge of the dense to the compressed model. Recently Wang et al. (2020b) proposed a GAN compression framework, GAN slimming, that integrated the above three mainstream compression techniques into a unified form. Previous works on GAN pruning usually aim at finding a sparse structure of the trained generator model for faster inference speed, while we are focusing on finding trainable structures of GANs following the lottery ticket hypothesis. Moreover, in existing GAN compression methods, only the generator is pruned, which could undermine the performance of re-training since the left-out discriminator may have a stronger computational ability than the pruned generator and therefore cause a degraded result due to the imparity of these two models.
+
+The Lottery Ticket Hypothesis The lottery ticket hypothesis (LTH) (Frankle & Carbin, 2019) claims the existence of sparse, separate trainable sub-networks in a dense network. These subnetworks are capable of reaching comparable or even better performance than full dense model, which has been evidenced in various fields, such as image classification (Frankle & Carbin, 2019; Liu et al., 2019; Wang et al., 2020a; Evci et al., 2019; Frankle et al., 2020; Savarese et al., 2020; Yin et al., 2020; You et al., 2020; Ma et al., 2021; Chen et al., 2020a), natural language processing (Gale et al., 2019; Chen et al., 2020b), reinforcement learning (Yu et al., 2020), lifelong learning (Chen et al., 2021b), graph neural networks (Chen et al., 2021a), and adversarial robustness (Cosentino et al., 2019). Most works of LTH use unstructured weight magnitude pruning (Han et al., 2016; Frankle &
+
+Carbin, 2019) to find the matching subnetworks, and the channel pruning is also adopted in a recent work (You et al., 2020). In order to scale up LTH to larger networks and datasets, the “late rewinding” technique is proposed by Frankle et al. (2019); Renda et al. (2020). Mehta (2019); Morcos et al. (2019); Desai et al. (2019) are the pioneers to study the transferability of found subnetworks. However, all previous works focus on discriminative models. In this paper, we extend LTH to GANs and reveal unique findings of GAN tickets.
+
+# 3 PRELIMINARIES
+
+In this section, we describe our pruning algorithms and list related experimental settings.
+
+Backbone Networks We use two GANs in our experiments in Section 4: SNGAN (Miyato et al., 2018) and CycleGAN (Zhu et al., 2017)). SNGAN with ResNet (He et al., 2016) is one of the most popular noise-to-image GAN network and has strong performance on several datasets like CIFAR10. CycleGAN is a popular and well-studied image-to-image GAN network that also performs well on several benchmarks. For SNGAN, let $g ( \mathbf { z } ; \pmb { \theta } _ { g } )$ be the output of the generator network $\mathcal { G }$ with parameters $\theta _ { g }$ and a latent variable $\textbf { z } \in \mathbb { R } ^ { | | z | | _ { 0 } }$ and $d ( \mathbf { x } ; \pmb { \theta } _ { d } )$ be the output of the discriminator network $\mathcal { D }$ with parameters $\theta _ { d }$ and input example $\mathbf { x }$ . For CycleGAN which is composed of two generator-discriminator pairs, we use $g ( \mathbf { x } ; \pmb { \theta } _ { g } )$ and $\theta _ { g }$ again to represent the output and the weights of the two generators where $\mathbf { x } = ( \mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } )$ indicates a pair of input examples. The same modification can be done for the two discriminators in CycleGAN.
+
+Datasets For image-to-image experiments, we use a widely-used benchmark horse2zebra (Zhu et al., 2017) for model training. As for noise-to-image experiments, we use CIFAR-10 (Krizhevsky et al., 2009) as the benchmark. For the transfer study, the experiments are conducted on CIFAR-10 and STL-10 (Coates et al., 2011). For better transferring, we resize the image in STL-10 to $3 2 \times 3 2$ .
+
+Subnetworks For a network $f ( \cdot ; \pmb \theta )$ parameterized by $\pmb \theta$ , a subnetwork is defined as $f ( \cdot ; m \odot \pmb { \theta } )$ , where $m \in \{ 0 , 1 \} ^ { \| \theta \| _ { 0 } }$ is a pruning mask for $\pmb { \theta } \in \mathbb { R } ^ { | | \theta | | _ { 0 } }$ and $\odot$ is the element-wise product. For GANs, two separate masks, $\mathbf { \nabla } m _ { d }$ and $m _ { g }$ , are needed for both the generator and the discriminator. Consequently, a subnetwork of GANs is consistent of: a sparse generator $g ( \cdot ; m _ { g } \odot \theta _ { g } )$ and a sparse discriminator $d ( \cdot ; m _ { d } \odot \theta _ { d } )$ .
+
+Let $\pmb { \theta _ { 0 } }$ be the initialization weights of model $f$ and $\theta _ { t }$ be the weights at training step $t$ . Following Frankle et al. (2019), we define a matching network as a subnetwork $f ( \cdot ; m \odot \pmb \theta )$ , where $\pmb { \theta }$ is initialized with $\theta _ { t }$ , that can reach the comparable performance to the full network within a similar training iterations when trained in isolation; a winning ticket is defined as a matching subnetwork where $t = 0$ , i.e. $\pmb \theta$ initialized with $\pmb { \theta } _ { 0 }$ .
+
+Finding subnetworks Finding GAN subnetworks is to find two masks $m _ { g }$ and $\mathbf { \nabla } m _ { d }$ for the generator and the discriminator. We use both an unstructured magnitude method, i.e. the iterative magnitude pruning (IMP), and a structured pruning method, i.e. the channel pruning (He et al., 2017), to generate the masks.
+
+For unstructured pruning, we follow the following steps. After we finish training the full GAN model for $N$ iterations, we prune the weights with the lowest magnitude globally (Han et al., 2016) to obtain masks $\pmb { m } = ( m _ { g } , m _ { d } )$ , where the position of a remaining weight in $_ { \mathbf { \nabla } } \mathbf { m }$ is marked as one, and the position of a pruned weight is marked as zero. The weights of the sparse generator and the sparse discriminator are then reset to the initial weights of the full network. Previous works have shown that the iterative magnitude pruning (IMP) method is better than the one-shot pruning method. So rather than pruning the network only once to reach the desired sparsity, we prune a certain amount of non-zero parameters and re-train the network several times to meet the requirement. Details of this algorithm are in Appendix A1.1, Algorithm 1.
+
+As for channel pruning, the first step is to train the full model as well. Besides using a normal loss function $\mathcal { L } _ { \mathrm { G A N } }$ , we follow Liu et al. (2017) to apply a $\ell _ { 1 }$ -norm on the trainable scale parameters $\gamma$ in the normalization layers to encourage channel-level sparsity: $\mathcal { L } _ { \mathrm { c p } } = | | \gamma | | _ { 1 }$ . To prevent the compressed network behave severely differently with the original large network, we introduce a distillation loss as Wang et al. (2020b) did: $\mathcal { L } _ { \mathrm { d i s t } } = \mathbb { E } _ { \mathbf { z } } [ \mathrm { d i s t } ( g ( \bar { \mathbf { z } } ; \theta _ { g } ) , g ( \mathbf { z } ; m _ { g } \odot \pmb { \theta } _ { g } ) ) ]$ . We train the
+
+GAN network with these two additional losses for $N _ { 1 }$ epochs and get the sparse networks $g ( \cdot ; m _ { g } \odot$ $\theta _ { g , \mathrm { ~ \tiny ~  ~ } }$ ) and $d ( \cdot ; m _ { d } \odot \theta _ { g } )$ . Details of this algorithm are in Appendix A1.1, Algorithm 2.
+
+Evaluation of subnetworks After obtaining the subnetworks $g ( \cdot ; \theta _ { g } \odot m _ { g } )$ and $d ( \cdot ; \pmb { \theta } _ { d } \odot \pmb { m } _ { d } )$ , we test whether the subnetworks are matching or not. We reset the weights to a specific step $i$ , and train the subnetworks for $N$ iterations and evaluate them using two specific metrics, Inception Score (Salimans et al., 2016) and Frechet Inception Distance (Heusel et al., 2017). ´
+
+Other Pruning Methods We compare the size and the performance of subnetworks found by IMP with subnetworks found by other techniques that aim at compressing the network after training to reduce computational costs at inference. We use a benchmark pruning approach named Standard Pruning (Chen et al., 2020b; Han et al., 2016), which iteratively prune the $20 \%$ of lowest magnitude weights, and train the network for another $N$ iterations without any rewinding, and repeat until we have reached the target sparsity.
+
+In order to verify that the statement of iterative magnitude pruning is better than one-shot pruning, we compare $\mathrm { I M P _ { G } }$ and $\mathrm { I M P _ { G D } }$ with their one-shot counterparts. Additionally, we compare IMP with some randomly pruning techniques to prove the effectiveness of IMP. They are: 1) Randomly Pruning: Randomly generate a sparsity mask $m ^ { \prime }$ . 2) Random Tickets: Rewinding the weights to another initialization $\theta _ { \mathbf { 0 } } ^ { \prime }$ .
+
+# 4 THE EXISTENCE OF WINNING TICKETS IN GAN
+
+In this section, we will validate the existence of winning tickets in GANs with initialization $\theta _ { 0 } : =$ $( \theta _ { g _ { 0 } } , \theta _ { d _ { 0 } } )$ . Specifically, we will empirically prove several important properties of the tickets by authenticating the following four claims:
+
+Claim $I$ : Iterative Magnitude Pruning (IMP) finds winning tickets in GANs, $g ( \cdot ; m _ { g } \odot \theta _ { g _ { 0 } } )$ and $d ( \cdot ; m _ { d } \odot \theta _ { d _ { 0 } } )$ . Channel pruning is also able to find winning tickets as well.
+
+Claim 2: Whether pruning the discriminator $\mathcal { D }$ does not change the existence of winning tickets. It is the initialization used in $\mathcal { D }$ that matters. Moreover, pruning the discriminator has a slight boost of matching networks in terms of extreme sparsity and performance.
+
+Claim 3: IMP finds winning tickets at sparsity where some other pruning methods (randomly pruning, one-shot magnitude pruning, and random tickets) are not matching.
+
+Claim 4: The late rewinding technique (Frankle et al., 2019) helps. Matching subnetworks that are initialized to $\theta _ { i }$ , i.e., $i$ steps from $\pmb { \theta _ { 0 } }$ , can outperform those initialized to $\pmb { \theta _ { 0 } }$ . Moreover, matching subnetworks that are late rewound can be trained to match the performance of standard pruning.
+
+Claim 1: Are there winning tickets in GANs? To answer this question, we first conduct experiments on SNGAN by pruning the generator only in the following steps: 1) Run IMP to get sequential sparsity masks $( m _ { d _ { i } } , m _ { g _ { i } } )$ of sparsity $s _ { i } \bar { \% }$ remaining weights; 2) Apply the masks to the GAN and reset the weights of the subnetworks to the same random initialization $\theta _ { \mathbf { 0 } } ; 3 )$ Train models to evaluate whether they are winning tickets. 1 We set $s _ { i } \% = ( 1 - 0 . 8 ^ { i } ) \times 1 0 0 \%$ , which we use for all the experiments that involve iteratively pruning hereinafter. The number of training epochs for subnetworks is identical to that of training the full models.
+
+Figure 1 verifies the existence of winning tickets in SNGAN and CycleGAN. We are able to find winning tickets by iterative pruning the generators at the highest sparsity, around $74 \%$ in SNGAN, and around $67 \%$ in CycleGAN, where the FID scores of these subnetworks successfully match the FID scores of the full network respectively. The confidence interval also suggests that the winning tickets at some sparsities are statistically significantly better than the full model.
+
+To show that channel pruning can find winning tickets as well, we extract several subnetworks from the trained full SNGAN and CycleGAN by varying $\rho$ in Algorithm 2. We define the channel-pruned model’s sparsity as the ratio of MFLOPs between the sparse model and the full model.
+
+![](images/7513d5cd63eac48aa4d57f06bcfa222e824d83221d800f1918c160f8bd993b4a.jpg)  
+Figure 1: The Frechet Inception Distance (FID) curve of subnetworks of SNGAN (left) and CycleGAN (right) ´ generated by iterative magnitude pruning (IMP) on CIFAR-10 and horse2zebra. The dashed line indicates the FID score of the full model on CIFAR-10 and horse2zebra. The $9 5 \%$ confidence interval of 5 runs is reported.
+
+We can confirm that winning tickets can also be found by channel pruning (CP). CP is able to find winning tickets in SNGAN at sparsity around $34 \%$ . We will analyze it more carefully in Section 7.
+
+![](images/8911baf780540c2c3bb95561086c246e134ffe27ca1dfbd17bf48521ae5c5f05.jpg)  
+Figure 2: Visualization by sampling and interpolation of SNGAN Winning Tickets found by IMP. Sparsity of best winning tickets : $4 8 . 8 0 \%$ . Extreme sparsity of matching subnetworks: $7 3 . 7 9 \%$ .
+
+![](images/58e0acd15a2f5c11aa5a7559feab903e95dea4d4079e86d4039c325cf35e41dd.jpg)  
+Figure 3: Visualization of CycleGAN Winning Tickets found by IMP. Sparsity of best winning tickets : $5 9 . 0 4 \%$ . Extreme sparsity of matching subnetworks: $6 7 . 2 4 \%$ . Left: visualization results on horse2zebra. Right: visualization results on zebra2horse.
+
+Claim 2: Does the treatment of the discriminator affect the existence of winning tickets? Previous works of GAN pruning did not analyze the effect of pruning the discriminator. To study the effect, we compare two different iterative pruning settings: 1) Prune the generator only $\left( \mathrm { I M P _ { G } } \right)$ and 2) Prune both the generator and the discriminator iteratively $( \mathrm { I M P _ { G D } } )$ . Both the generator and the discriminator are reset to the same random initialization $\pmb { \theta _ { 0 } }$ after the masks are obtained.
+
+The FID scores of the two experiments are shown in Figure 4. The graph suggests that the two settings share similar patterns: the minimal FID of $\mathrm { I M P _ { G } }$ is 14.19, and the minimal FID of $\mathrm { I M P _ { G D } }$ is 14.59. The difference between these two best FID is only 0.4, showing a slight difference in generative power. The FID curve of $\mathrm { I M P _ { G } }$ lies below that of $\mathrm { I M P _ { G D } }$ at low sparsity but lies above at high sparsity, indicating that pruning the discriminator produces slightly better performance when the percent of remaining weights is small. The extreme sparsity where $\mathrm { I M P _ { G D } }$ can match the performance of the full model is $7 3 . 8 \%$ . In contrast, $\mathrm { I M P _ { G } }$ can only match no sparser than $6 7 . 2 \%$ , demonstrating that pruning the discriminator can also push the frontier of extreme sparsity where the pruned models are still able to match.
+
+In addition, we study the effects of different initialization for the sparse discriminator. We compare different weights loading methods when applying the iterative magnitude pruning process: 1) Reset the weights of generator to $\theta _ { g _ { 0 } }$ and reset the weights of discriminator to $\theta _ { d _ { 0 } }$ , which is identical to $\mathrm { I M P _ { G } }$ ; 2) Reset the weights of generator to $\theta _ { g _ { 0 } }$ and fine-tune the discriminator, which we will call $\mathrm { I M P _ { G } ^ { F } }$ . Figure 4 shows that resetting both the weights to $\pmb { \theta _ { 0 } }$ produces a much better result than only resetting the generator. The discriminator $\mathcal { D }$ without resetting its weights is too strong for the generator $\mathcal { G }$ with initial weights $\theta _ { g _ { 0 } }$ that will lead to degraded performance. In summary, different initialization of the discriminator will significantly influence the existence and quality of winning tickets in GAN models.
+
+![](images/66ed5eab2be7c87a44dd7ec54916199d028c93910d2e62b9e9fe26aa369272b9.jpg)  
+Figure 4: The FID score of Left: The FID score of best subnetworks generated by two different pruning settings: $\mathrm { I M P _ { G } }$ and $\mathrm { I M P } _ { \mathrm { G D } }$ . Right: The FID score of best subnetworks generated by two different pruning settings: $\mathrm { I M P _ { G } }$ and $\mathrm { I M P _ { G } ^ { F } }$ . $\mathrm { I M P _ { G } }$ : iteratively prune and reset the generator. $\mathrm { I M P } _ { \mathrm { G D } }$ : iteratively prune and reset the generator and the discriminator. $\mathrm { I M P _ { G } ^ { \tilde { \mathrm { F } } } }$ : iteratively prune and reset the generator, and iteratively prune but not reset the discriminator.
+
+A follow-up question arises from the previous observations: is there any way to use the weights of the dense discriminator, as the direct usage of the dense weights yields inferior results? One possible way is to use it as a “teacher” and transfer the knowledge to pruned discriminator using a consistency loss. Formally speaking, an additional regularization term is used when training the whole network:
+
+$$
+\mathcal { L } _ { \mathrm { K D } } ( \mathbf { x } ; \pmb { \theta } _ { d } , m _ { d } ) = \mathbb { E } _ { \mathbf { x } } [ \mathrm { K L } _ { \mathrm { D i v } } ( d ( \mathbf { x } ; m _ { d } \odot \pmb { \theta } _ { d } ) , d ( \mathbf { x } ; \pmb { \theta } _ { d _ { 1 } } ) ) ]
+$$
+
+where $\mathrm { K L } _ { \mathrm { D i v } }$ denotes the KL-Divergence. We name the iterative pruning method with this additional regularization $\mathrm { I M P _ { G D } ^ { K D } }$ .
+
+Figure 5 shows the result of pruning method IMPKD compared to the previous two pruning methods we proposed, $\mathrm { I M P _ { G } }$ and $\mathrm { I M P _ { G D } }$ . $\mathrm { I M P _ { G D } ^ { K D } }$ is capable of finding winning tickets at sparsity around $70 \%$ , outperforming $\mathrm { I M P _ { G } }$ , and showing comparable results to $\mathrm { I M P _ { G D } }$ regarding the extreme sparsity. The FID curve of setting $\mathrm { \tilde { I M P } _ { G D } ^ { K D } }$ is further mostly located below the curve of $\mathrm { \Delta I M P _ { G D } }$ , demonstrating a stronger generative ability than $\mathrm { I M P _ { G D } }$ . It suggests transferring knowledge from the full discriminator benefits to find the winning tickets.
+
+![](images/a8b60e4bcd678fb4f89a4ccc93e2d320ddc699b7352edcc9c2574225e0eddc94.jpg)  
+Figure 5: The FID curve of best subnetworks generated by three different pruning methods: $\mathrm { I M P G }$ , $\mathrm { I M P } _ { \mathrm { G D } }$ and $\mathrm { I M P _ { G D } ^ { K D } }$ . $\mathrm { I M P _ { G D } ^ { K D } }$ : iteratively prune and reset both the generator and the discriminator, and train them with the KD regularization.
+
+Claim 3: Can IMP find matching subnetworks sparser than other pruning methods? Previous works claim that both a specific sparsity mask and a specific initialization are necessary for finding winning tickets (Frankle & Carbin, 2019), and iterative magnitude pruning is better than one-shot pruning. To extend such a statement in the context of GANs, we compare IMP with several other benchmarks, randomly pruning (RP), one-shot magnitude pruning (OMP), and random tickets (RT), to see if IMP can find matching networks at higher sparsity.
+
+![](images/8d085d6300af245b69cf6781c1d9e225b046161a0b431dbf111e4009fc915ef9.jpg)  
+Figure 6: FID curves: $\mathrm { O M P G }$ , $\mathrm { I M P G }$ , ${ \mathrm { O M P } } _ { \mathrm { G D } }$ and $\mathrm { I M P } _ { \mathrm { G D } }$ . $\mathrm { O M P _ { G } }$ : one-shot prune the generator. ${ \mathrm { O M P } } _ { \mathrm { G P } }$ : one-shot prune generator/discriminator.
+
+<table><tr><td>Method</td><td>FIDBest (Sparsity)</td><td>FIDExtreme (Sparsity)</td></tr><tr><td>No Pruning</td><td>15.69 (0.0%)</td><td>1</td></tr><tr><td>IMPG</td><td>14.19 (20.0%)</td><td>15.58 (67.2%)</td></tr><tr><td>IMPGD</td><td>14.59 (59.0%)</td><td>15.53 (73.8%)</td></tr><tr><td>OMPG</td><td>14.36 (36.0%)</td><td>15.33 (59.0%)</td></tr><tr><td>OMPGD</td><td>14.52 (20.0%)</td><td>15.69 (48.8%)</td></tr></table>
+
+Table 1: The extreme sparsity of the matching networks and the FID score of best subnetworks, found by iterative pruning and one-shot pruning. $\mathrm { O M P G }$ : one-shot prune the generator. ${ \mathrm { O M P } } _ { \mathrm { G P } }$ : one-shot prune generator/discriminator.
+
+Figure 6 and Table 1 show that iterative magnitude pruning outperforms one-shot magnitude pruning no matter pruning the discriminator or not. IMP finds winning tickets at higher sparsity $( 6 7 . 2 3 \%$ and $7 3 . 7 9 \%$ , respectively) than one-shot pruning $( 5 9 . 0 0 \%$ and $4 8 . 8 0 \%$ , respectively). The minimal FID score of subnetworks found by IMP is smaller than that of subnetworks found by OMP as well. This observation defends the statement that pruning iteratively is superior compared to one-shot pruning.
+
+We also list the minimal FID scores and extreme sparsity of matching networks for other pruning methods in Figure 7 and Table 2. It can be seen that IMP finds winning tickets at sparsity where some other pruning methods, randomly pruning and random initialization, cannot match. Since $\mathrm { I M P _ { G } }$ shows the best overall result, we authenticate the previous statement that both the specific sparsity mask and the specific initialization are essential for finding winning tickets.
+
+![](images/459ef32da8d72453aabd929c181e761be23bb6bb14cfc391573cf4c04ab0f836.jpg)  
+Figure 7: The FID curve of best subnetworks generated by three different pruning settings: $\mathrm { I M P G }$ , RP, and RT. RP: iteratively randomly prune the generator. RT: iteratively prune the generator but reset the weights randomly.
+
+Table 2: The FID score of best subnetworks and the extreme sparsity of matching networks found by Random Pruning, Random Rickets, and iterative magnitude pruning.   
+
+<table><tr><td>Method</td><td>FIDBest (Sparsity)</td><td>FIDExtreme (Sparsity)</td></tr><tr><td>No Pruning</td><td>15.69 (0.0%)</td><td></td></tr><tr><td>IMPG</td><td>14.19 (20.0%)</td><td>15.58 (67.2%)</td></tr><tr><td>Random Pruning</td><td>14.57 (20.0%)</td><td>15.60 (36.0%)</td></tr><tr><td>Random Tickets</td><td>14.28 (36.0%)</td><td>15.33 (59.0%)</td></tr></table>
+
+Claim 4: Does rewinding improve performance? In previous paragraphs, we show that we are able to find winning tickets in both SNGAN and CycleGAN. However, these subnetworks cannot match the performance of the original network at extremely high sparsity, while the subnetworks found by standard pruning can (Table 3). To find matching subnetworks at such high sparsity, we adopt the rewinding paradigm: after the masks are obtained, the weights of the model are rewound to $\theta _ { i }$ , the weights after $i$ steps of training, rather than reset to the same random initialization $\pmb { \theta _ { 0 } }$ . It was pointed out by Renda et al. (2020) that subnetworks found by IMP and rewound early in training can be trained to achieve the same accuracy at the same sparsity as subnetworks found by the standard pruning, providing a possibility that rewinding can also help GAN subnetworks.
+
+We choose different rewinding settings: $5 \%$ , $10 \%$ , and $20 \%$ of the whole training epochs. The results are shown in Table 3. We observe that rewinding can significantly increase the extreme sparsity of matching networks. Rewinding to even only $5 \%$ of the training process can raise the extreme sparsity from $6 7 . 2 3 \%$ to $8 6 . 2 6 \%$ , and rewinding to $20 \%$ can match the performance of standard pruning. We also compare the FID score of subnetworks found at $89 \%$ sparsity. Rewind to $2 0 \%$ of the training
+
+Table 3: Rewinding results. $\mathrm { S _ { E x t r e m e } }$ : Extreme sparsity where matching subnetworks exist. $\mathrm { F I D } _ { \mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\mathrm { F I D } _ { 8 9 \% }$ : The FID score of subnetworks at $8 9 \%$ sparsity.   
+
+<table><tr><td>Setting of rewinding</td><td>SExtreme</td><td>FIDBest</td><td>FID89%</td></tr><tr><td>Rewind 0%</td><td>67.23%</td><td>14.20</td><td>19.60</td></tr><tr><td>Rewind 5%</td><td>86.26%</td><td>13.96</td><td>15.82</td></tr><tr><td>Rewind 10%</td><td>86.26%</td><td>14.43</td><td>15.63</td></tr><tr><td>Rewind 20%</td><td>89.26%</td><td>14.82</td><td>15.29</td></tr><tr><td>Standard Pruning</td><td>89.26%</td><td>14.18</td><td>15.22</td></tr></table>
+
+process can match the performance of standard pruning at $89 \%$ sparsity, and other late rewinding settings can match the performance of the full model. This suggests that late rewinding techniques can greatly contribute to matching subnetworks with higher sparsity.
+
+Summary Extensive experiments are conducted to examine the existence of matching subnetworks in generative adversarial models. We confirmed that there were matching subnetworks at high sparsities, and both the sparsity mask and the initialization matter for finding winning tickets. We also studied the effect of pruning the discriminator and demonstrate that pruning the discriminator can slightly boost the performance regarding the extreme sparsity and the minimal FID. We proposed a method to utilize the weights of the dense discriminator model to boost the performance further. We also compare IMP with different pruning methods, showing that IMP is superior to random tickets and random pruning. In addition, late rewinding can match the performance of standard pruning, which again shows consistency with previous works.
+
+# 5 THE TRANSFER LEARNING OF GAN MATCHING NETWORKS
+
+In the previous section, we confirm the presence of winning tickets in GANs. In this section, we will study the transferability of winning tickets. Existing works (Mehta, 2019) show that the matching networks in discriminative models can transfer across tasks. Here we evaluate this claim in GANs.
+
+To investigate the transferability, we propose three transfer experiments from CIFAR-10 to STL-10 on SNGAN. We first identify matching subnetworks $g ( \cdot , m _ { g } \odot \theta )$ and $d ( \cdot , m _ { d } \odot \pmb \theta )$ on CIFAR10, and then train and evaluate the subnetworks on STL-10. To assess whether the same random initialization $\pmb { \theta _ { 0 } }$ is needed for transferring, we test three different weights loading method: 1) reset the weights to $\theta _ { 0 } ; 2 )$ reset the weights to another initialization $\theta _ { \mathbf { 0 } } ^ { \prime }$ ; 3) rewind the weights to $\theta _ { N }$ . We train the network on STL-10 using the same hyper-parameters as on CIFAR-10. It is noteworthy that the hyper-parameters setting might not be optimal for the target task, yet it is fair to compare different transferring settings.
+
+Table 4: Results of late rewinding experiments. $\pmb { \theta _ { 0 } }$ : train the target model from the same random initialization as the source model; $\theta _ { r }$ : train from random initialization; $\pmb { \theta } _ { \mathbf { B } \mathbf { e s t } }$ : train from the weights of trained source model. Baseline: full model trained on STL-10.   
+
+<table><tr><td>Model</td><td>Baseline</td><td>IMPg (S = 67.23%)</td><td></td><td>IMPGD (S = 73.79%)</td><td>IMPKB</td><td>(S= 73.79%)</td></tr><tr><td>Metrics</td><td>FIDBest</td><td>FIDBest</td><td>Matching?</td><td>FIDBest</td><td>Matching？</td><td>FIDBest Matching?</td></tr><tr><td>0</td><td></td><td>116.7</td><td>√</td><td>121.8</td><td>× 120.1</td><td>×</td></tr><tr><td>0r</td><td>115.3</td><td>119.2</td><td>×</td><td>113.1 √</td><td>115.5</td><td>√</td></tr><tr><td>0Best</td><td></td><td>204.7</td><td>×</td><td>163.0 ×</td><td>179.1</td><td>×</td></tr></table>
+
+The FID score of different settings is shown in Table 4. Subnetworks initialized by $\theta _ { 0 }$ and using masks generated by $\mathrm { I M P _ { G } }$ can be trained to achieve comparable results to the baseline model. Surprisingly, random re-initialization ${ \pmb \theta } _ { \mathbf { 0 } } ^ { \prime }$ shows better transferability than using the same initialization $\pmb { \theta _ { 0 } }$ in our transfer settings and outperforms the full model trained on STL-10, indicating that the combination of $\pmb { \theta _ { 0 } }$ and the mask generated by $\mathrm { I M P } _ { \mathrm { G D } }$ is more focused on the source dataset and consequently has lower transferability.
+
+Summary In this section, we tested the transferability of IMP subnetworks. Transferring from $\pmb { \theta _ { 0 } }$ and $\theta _ { r }$ both produce matching results on the target dataset, STL-10. $\pmb { \theta _ { 0 } }$ works better with masks generated by $\mathrm { I M P _ { G } }$ while the masks generated by $\mathrm { I M P _ { G D } }$ prefer a different initialization $\theta _ { r }$ . Given that $\mathrm { I M P _ { G D } }$ performs better on CIFAR-10, it is reasonable that the same initialization $\pmb { \theta _ { 0 } }$ has lower transferability when using masks from $\mathrm { I M P _ { G D } }$ .
+
+# 6 EXPERIMENTS ON OTHER GAN MODELS AND OTHER DATASETS
+
+We conducted experiments on DCGAN (Radford et al., 2016), WGAN-GP (Gulrajani et al., 2017), ACGAN (Odena et al., 2017), GGAN (Lim & Ye, 2017), DiffAugGAN (Zhao et al., 2020a), ProjGAN (Miyato & Koyama, 2018), SAGAN (Zhang et al., 2019), as well as a NAS-based GAN, AutoGAN (Gong et al., 2019). We use CIFAR-10 and Tiny ImageNet (Wu et al., 2017) as our benchmark datasets.
+
+Table 5 and 6 consistently verify that the existence of winning tickets in diverse GAN architectures in spite of the different extreme sparsities, showing that the lottery ticket hypothesis can be generalized to various GAN models.
+
+# 7 EFFICIENCY OF GAN WINNING TICKETS
+
+Unlike the unstructured magnitude pruning method, channel pruning can reduce the number of parameters in GANs. Therefore, winning tickets found by channel pruning are more efficient than the original model regarding computational cost. To fully exploit the advantage of subnetworks founded by structural pruning, we further compare our prune-and-train pipeline with a state-of-the-art GAN compression framework (Wang et al., 2020b). The pipeline is described as follows: after extracting the sparse structure generated by channel pruning, we reset the model weights to the same random initialization $\pmb { \theta _ { 0 } }$ and then train for the same number of epochs as the dense model used.
+
+Table 5: Results on other GAN models on CIFAR-10. $\mathrm { F I D } _ { \mathrm { F u l l } }$ : FID score of the full model. $\mathrm { F I D } _ { \mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\mathrm { F I D } _ { \mathrm { E x t r e m e } }$ : The FID score of matching networks at extreme sparsity level. AutoGAN-A/B/C are three representative GAN architectures represented in the official repository (https://github.com/VITA-Group/AutoGAN)   
+
+<table><tr><td>Model</td><td>Benchmark</td><td>FIDFull (Sparsity)</td><td>FIDBest (Sparsity)</td><td>SExtreme (Sparsity)</td></tr><tr><td>DCGAN (Radford et al., 2016)</td><td>CIFAR-10</td><td>57.39 (0%)</td><td>49.31 (20.0%)</td><td>54.48 (67.2%)</td></tr><tr><td>WGAN-GP(Gulrajani et al., 2017)</td><td>CIFAR-10</td><td>19.23 (0%)</td><td>16.77 (36.0%)</td><td>17.28 (73.8%)</td></tr><tr><td>ACGAN (Odena et al.,2017)</td><td>CIFAR-10</td><td>39.26 (0%)</td><td>31.45 (36.0%)</td><td>38.95 (79.0%)</td></tr><tr><td>GGAN(Lim &amp; Ye,2017)</td><td>CIFAR-10</td><td>38.50 (0%)</td><td>33.42 (20.0%)</td><td>36.67 (48.8%)</td></tr><tr><td>ProjGAN (Miyato &amp; Koyama,2018)</td><td>CIFAR-10</td><td>31.47 (0%)</td><td>28.19 (20.0%)</td><td>31.31 (67.2%)</td></tr><tr><td>SAGAN (Zhang et al.,2019)</td><td>CIFAR-10</td><td>14.73 (0%)</td><td>13.57 (20.0%)</td><td>14.68 (48.8%)</td></tr><tr><td>AutoGAN(A) (Gong et al.,2019)</td><td>CIFAR-10</td><td>14.38 (0%)</td><td>14.04 (36.0%)</td><td>14.04 (36.0%)</td></tr><tr><td>AutoGAN(B) (Gong et al., 2019)</td><td>CIFAR-10</td><td>14.62 (0%)</td><td>13.16 (20.0%)</td><td>14.20 (36.0%)</td></tr><tr><td>AutoGAN(C) (Gong et al.,2019)</td><td>CIFAR-10</td><td>13.61 (0%)</td><td>13.41 (48.8%)</td><td>13.41 (48.8%)</td></tr><tr><td>DiffAugGAN (Zhao et al., 2020b)</td><td>CIFAR-10</td><td>8.23 (0%)</td><td>8.05 (48.8%)</td><td>8.05 (48.8%)</td></tr></table>
+
+Table 6: Results on other GAN models on Tiny ImageNet. $\mathrm { F I D } _ { \mathrm { F u l l } }$ : FID score of the full model. $\mathrm { F I D } _ { \mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\mathrm { F I D } _ { \mathrm { E x t r e m e } }$ : The FID score of matching networks at extreme sparsity level.   
+
+<table><tr><td>Model</td><td>Benchmark</td><td>FIDFull (Sparsity)</td><td>FIDBest (Sparsity)|SExtreme (Sparsity)</td><td></td></tr><tr><td>DCGAN (Radford et al., 2016)</td><td>Tiny ImageNet</td><td>121.35 (0%)</td><td>78.51 (36.0%)</td><td>114.00 (67.2%)</td></tr><tr><td>WGAN-GP(Gulrajani et al.,2017)</td><td>Tiny ImageNet</td><td>211.77 (0%)</td><td>194.72 (48.8%)</td><td>200.22 (67.2%)</td></tr></table>
+
+We can see from Figure 8 that subnetworks are founded by the channel pruning method at about $67 \%$ sparsity, which provides a new path for winning tickets other than magnitude pruning. The matching networks at $6 7 . 7 \%$ outperform GS-32 regarding Inception Score by 0.25; the subnetworks at about $2 9 \%$ sparsity can outperform GS-32 by 0.20, setting up a new benchmark for GAN compressions.
+
+# 8 CONCLUSION
+
+In this paper, the lottery ticket hypothesis has been extended to GANs. We successfully identify winning tickets in GANs, which are separately trainable to match the full dense GAN performance. Pruning the discriminator, which is rarely studied before, had only slight effects on the ticket finding process, while the initialization used in the discriminator is essential. We also demonstrate that the winning tickets found can transfer across diverse tasks. Moreover, we provide a new way of finding winning tickets that alter the structure of models. Channel pruning is able to extract matching subnetworks from a dense model that can outperform the current state-of-the-art GAN compression after resetting the weights and re-training.
+
+![](images/46aff1e9d2922bac930f9ce3e210cba2f3eb0ea47700daac3ace1446a848b52f.jpg)  
+Figure 8: Relationship between the best IS score of SNGAN subnetworks generated by channel pruning and the percent of remaining weights. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full model trained on CIFAR-10.
+
+# ACKNOWLEDGEMENT
+
+Zhenyu Zhang is supported by the National Natural Science Foundation of China under grand No.U19B2044.
+
+# REFERENCES
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Proceedings of the 34th International Conference on Machine Learning, 2017.
+
+Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Michael Carbin, and Zhangyang Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. arXiv, abs/2012.06908, 2020a.
+
+Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks. arXiv, abs/2007.12223, 2020b.
+
+Tianlong Chen, Yongduo Sui, Xuxi Chen, Aston Zhang, and Zhangyang Wang. A unified lottery ticket hypothesis for graph neural networks, 2021a.
+
+Tianlong Chen, Zhenyu Zhang, Sijia Liu, Shiyu Chang, and Zhangyang Wang. Long live the lottery: The existence of winning tickets in lifelong learning. In International Conference on Learning Representations, 2021b.
+
+Adam Coates, Andrew Y. Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the 14th International Conference on Artificial Intelligence and Statistics, 2011.
+
+Justin Cosentino, Federico Zaiter, Dan Pei, and Jun Zhu. The search for sparse, robust neural networks. arXiv, abs/1912.02386, 2019.
+
+Shrey Desai, Hongyuan Zhan, and Ahmed Aly. Evaluating lottery tickets under distributional shifts. In Proceedings of the 2nd Workshop on Deep Learning Approaches for Low-Resource NLP, 2019.
+
+Bryn Elesedy, Varun Kanade, and Y. Teh. Lottery tickets in linear models: An analysis of iterative magnitude pruning. arXiv, abs/2007.08243, 2020.
+
+Utku Evci, Fabian Pedregosa, Aidan Gomez, and Erich Elsen. The difficulty of training sparse neural networks. arXiv, abs/1906.10732, 2019.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In 7th International Conference on Learning Representations, 2019.
+
+Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. arXiv, abs/1912.05671, 2019.
+
+Jonathan Frankle, David J. Schwab, and Ari S. Morcos. The early phase of neural network training. In 8th International Conference on Learning Representations, 2020.
+
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv, abs/1902.09574, 2019.
+
+Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, 2019.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems 30, 2017.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium, 2017.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Yongcheng Jing, Yezhou Yang, Zunlei Feng, Jingwen Ye, Yizhou Yu, and Mingli Song. Neural style transfer: A review. IEEE Transactions on Visualization and Computer Graphics, 2019.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems 2, 1990.
+
+Muyang Li, Ji Lin, Yaoyao Ding, Zhijian Liu, Jun-Yan Zhu, and Song Han. Gan compression: Efficient architectures for interactive conditional gans. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020.
+
+Jae Hyun Lim and Jong Chul Ye. Geometric gan. abs/1705.02894, 2017.
+
+Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. In Advances in Neural Information Processing Systems 29, 2016.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, 2017.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In 7th International Conference on Learning Representations, 2019.
+
+Haoyu Ma, Tianlong Chen, Ting-Kuei Hu, Chenyu You, Xiaohui Xie, and Zhangyang Wang. Good students play big lottery better. arXiv, abs/2101.03255, 2021.
+
+Eran Malach, Gilad Yehudai, Shai Shalev-Shwartz, and Ohad Shamir. Proving the lottery ticket hypothesis: Pruning is all you need. arXiv, abs/2002.00585, 2020.
+
+Rahul Mehta. Sparse transfer learning via winning lottery tickets. arXiv, abs/1905.07785, 2019.
+
+Takeru Miyato and Masanori Koyama. cgans with projection discriminator. In 6th International Conference on Learning Representations, 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral Normalization for Generative Adversarial Networks. In 6th International Conference on Learning Representations, 2018.
+
+Ari Morcos, Haonan Yu, Michela Paganini, and Yuandong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. In Advances in Neural Information Processing Systems 32, 2019.
+
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier gans. In Proceedings of the 34th International Conference on Machine Learning, 2017.
+
+Ankit Pensia, Shashank Rajput, Alliot Nagle, Harit Vishwakarma, and Dimitris Papailiopoulos. Optimal lottery tickets via subsetsum: Logarithmic over-parameterization is sufficient. In Advances in Neural Information Processing Systems 33 pre-proceedings, 2020.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In 4th International Conference on Learning Representations, 2016.
+
+Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. In 8th International Conference on Learning Representations, 2020.
+
+Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In Advances in Neural Information Processing Systems 31, 2018.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems 29, 2016.
+
+Pedro Savarese, Hugo Silva, and Michael Maire. Winning the lottery with continuous sparsification. In Advances in Neural Information Processing Systems 33 pre-proceedings, 2020.
+
+Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Han Shu, Yunhe Wang, Xu Jia, Kai Han, Hanting Chen, Chunjing Xu, Qi Tian, and Chang Xu. Coevolutionary compression for unpaired image translation. In Proceedings of IEEE International Conference on Computer Vision, 2019.
+
+Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In 8th International Conference on Learning Representations, 2020a.
+
+Haotao Wang, Shupeng Gui, Haichuan Yang, Ji Liu, and Zhangyang Wang. Gan slimming: All-inone gan compression by a unified optimization framework. In Proceedings of the 16th European Conference on Computer Vision, 2020b.
+
+Peiqi Wang, Dongsheng Wang, Yu Ji, Xinfeng Xie, Haoxuan Song, XuXin Liu, Yongqiang Lyu, and Yuan Xie. Qgan: Quantized generative adversarial networks. abs/1901.08263, 2019.
+
+Jiayu Wu, Qixiang Zhang, and Guoxi Xu. Tiny imagenet challenge. Technical report, 2017.
+
+Shihui Yin, Kyu-Hyoun Kim, Jinwook Oh, Naigang Wang, Mauricio Serrano, Jae-Sun Seo, and Jungwook Choi. The sooner the better: Investigating structure of early winning lottery tickets, 2020.
+
+Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In 8th International Conference on Learning Representations, 2020.
+
+Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S. Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in rl and nlp. In 8th International Conference on Learning Representations, 2020.
+
+Han Zhang, Ian J. Goodfellow, Dimitris N. Metaxas, and Augustus Odena. Self-attention generative adversarial networks. In Proceedings of the 36th International Conference on Machine Learning, 2019.
+
+Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In 34th Conference on Neural Information Processing Systems, 2020a.
+
+Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In Advances in Neural Information Processing Systems 33 preproceedings, 2020b.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017.
+
+# A1 MORE TECHNICAL DETAILS
+
+# A1.1 ALGORITHMS
+
+In this section, we describe the details of the algorithm we used in finding lottery tickets. Two distinct pruning methods are used in Algorithm 1 and Algorithm 2.
+
+<table><tr><td>Model</td><td>F8</td><td>F1/8</td></tr><tr><td>Full Model</td><td>0.971</td><td>0.974</td></tr><tr><td>Best Winning Tickets</td><td>0.977</td><td>0.977</td></tr><tr><td>Extreme Winning Tickets</td><td>0.974</td><td>0.971</td></tr></table>
+
+![](images/d3f50733c9ff213e215e08b8f571fd038bc11685be71b72a50c143e2f15bc01f.jpg)  
+Figure A9: The curve of precision and recall of SNGANs under different sparsities. baseline: Full model. best: Best winning tickets (Sparsity: $4 8 . 8 0 \%$ ). extreme: Extreme winning tickets (Sparsity: $7 3 . 7 9 \%$ ).
+
+Table A7: The $\mathrm { F } _ { 8 }$ and $\mathrm { F _ { 1 / 8 } }$ score of the full network, best subnetworks and the matching networks at extreme sparsity. We used the official codes to calculate recall, precision, $\mathrm { F } _ { 8 }$ and $\mathrm { F _ { 1 / 8 } }$ .
+
+# A2 MORE EXPERIMENTS RESULTS AND ANALYSIS
+
+We will provide extra experiments results and analysis in this section.
+
+# A2.1 MORE VISUALIZATION OF IMP WINNING TICKETS
+
+We also conducted experiments to find winning tickets in CycleGAN on dataset winter2summer (Zhu et al., 2017). We observed similar patterns and found matching networks at $7 9 . 0 2 \%$ sparsity. We randomly sample four images from the dataset and show the translated images in Figure A10, Figure A11, and Figure A12. The winning tickets of CycleGAN can generate comparable visual quality to the full model under all cases.
+
+![](images/a4a7cd1df085f55ab9c026cb42d9ca927154695ca8510814ca18dd8991c93ff1.jpg)  
+Figure A10: Visualization of CycleGAN Winning Tickets found by IMP on summer2winter. Sparsity of best winning tickets: $5 9 . 0 4 \%$ . Extreme sparsity of matching subnetworks: $7 9 . 0 2 \%$ . Left: visualization results of task summer2winter. Right: visualization results of task winter2summer.
+
+# A2.2 EXTRA METRICS FOR EVALUATING SNGAN
+
+We also evaluate the quality of images generated by SNGAN using precision and recall Sajjadi et al. (2018). The results are shown in Table A7 and Figure A9. The results show that the best winning tickets have higher $\mathrm { F _ { 8 } }$ and $\mathrm { F _ { 1 / 8 } }$ compared to the full model, and the extreme winning tickets have on-par performance.
+
+![](images/9c051b9b4a45c22ea552b6f3e653ce2126427bed0b801be34f7105798ecd2d7d.jpg)  
+Figure A11: Extra visualization of CycleGAN Winning Tickets found by IMP on horse2zebra. Sparsity of best winning tickets : $5 9 . 0 4 \%$ . Extreme sparsity of matching subnetworks: $6 7 . 2 4 \%$ .
+
+![](images/2a47c17dde15327013127d3e523874a5ff24da9dfa9dc6259a8443ef29c8c9a3.jpg)  
+Figure A12: Extra visualization of CycleGAN Winning Tickets found by IMP on summer2winter. Sparsity of best winning tickets : $5 9 . 0 4 \%$ . Extreme sparsity of matching subnetworks: $7 9 . 0 2 \%$ .
+
+![](images/28a3242fa0eb244811de40579e0a15a3304f07ebcd1c07f6f4b5f06da441b30e.jpg)  
+Figure A13: Relationship between the best IS score of SNGAN subnetworks generated by channel pruning and the percent of remaining model size. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full model trained on CIFAR-10.
+
+![](images/862d8474dad0d7cec22aa65a73af92677ffbb75e0aaba0af4e37d7d5b0d8ddfa.jpg)  
+Figure A14: Relationship between the best FID score of CycleGAN subnetworks generated by channel pruning and the percent of remaining weights. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full un-pruned CycleGAN trained on horse2zebra.
+
+# A2.3 CHANNEL PRUNING FOR SNGAN
+
+We study the relationship between the Inception Score and the remaining model size, i.e. the ratio between the size of a channel-pruned model and its original model. The results are plotted in Figure A13. A similar conclusion can be drawn from the graph that matching networks exist, and at the same sparsity, the matching networks can be trained to outperform the current state-of-the-art GAN compression framework.
+
+# A2.4 CHANNEL PRUNING FOR CYCLEGAN
+
+We also conducted experiments on CycleGAN using channel pruning. The task we choose is horseto-zebra, i.e., we prune each of the two generators separately, which is aligned with SNGAN, which has only one generator. We prove that channel pruning is also capable of finding winning tickets in CycleGAN in Figure A14. Moreover, at extreme sparsity, the sparse subnetwork that we obtain can be trained to reach slightly better results than the current state-of-the-art GAN compression framework without quantization.
+
+<table><tr><td>Algorithm 1: Finding winning tickets by Iterative Magnitude Pruning</td></tr><tr><td>Input: The desired sparsity s Output: A sparse GAN g(- mg  0g)</td></tr><tr><td>and d(·; md  0d) 1 Set mg = 1 ∈ Rg llo and</td></tr><tr><td>md =1∈ Rl0dollo. 2 Set 0go := initial weights of the generator model, 0do := initial weights</td></tr><tr><td>of the discriminator model. 3 Iteration i= 0</td></tr><tr><td>4 while the sparsity of mg &lt; s do Train the generator g(*; mg ? 0go) 5</td></tr><tr><td>and the discriminator d( ; md ? 0dg) for N epochs to get parameters 0gN and 0dN</td></tr><tr><td>6 if pruning the discriminator then Prune 2O% of the parameters in 7</td></tr><tr><td>Na and Odn, creating two mask m&#x27;g and m&#x27;:</td></tr><tr><td>8 else Prune 2O% of the parameters in 9</td></tr><tr><td>0 gN, creating a mask m&#x27;. m&#x27; remains1 ∈ Rdo llo. 10 end</td></tr></table>
+
+<table><tr><td>Algorithm 2: Finding winning tickets by Channel Pruning Input:A threshold ρ of importance score,</td></tr><tr><td>number of steps for training N Output: A sparse GAN g(:; mg  0go) and d(-; md ③ 0do)</td></tr><tr><td>1 Randomly initialize Yg for every normalization layers in generator G and Yd for discriminator D. γ = (Yg, Yd) 2 Set 0go := initial weights of the generator</td></tr><tr><td>model, 0do := initial weights of the discriminator model. 3i=0</td></tr><tr><td>4 whilei&lt;N do Compute masks md from Yd and mg 5 from Yg: Compute Lcp, LGAN and Ldist: 6</td></tr><tr><td>Update 0g and 0d by training the 7 generator g(-; mg ?0g) and the</td></tr><tr><td></td></tr><tr><td>discriminator d(·; md  0d) for one step. Update γ: γ ← proxρn(γ -n∀γLcp), 8 where proxx(𝑥)= sgn(x)①max(|𝑥|-λ·1,0) 9 i←i+1 10 end</td></tr></table>

parse/train/1AoMhc_9jER/1AoMhc_9jER_content_list.json

@@ -0,0 +1,1931 @@
+[
+    {
+        "type": "text",
+        "text": "GANS CAN PLAY LOTTERY TICKETS TOO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            683,
+            122
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xuxi Chen1\\*, Zhenyu Zhang1\\*, Yongduo $\\mathbf { S u i ^ { 1 } }$ , Tianlong Chen2 1University of Science and Technology of China, 2University of Texas at Austin {chanyh,zzy19969,syd2019}@mail.ustc.edu.cn, tianlong.chen@utexas.edu ",
+        "bbox": [
+            184,
+            143,
+            781,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep generative adversarial networks (GANs) have gained growing popularity in numerous scenarios, while usually suffer from high parameter complexities for resource-constrained real-world applications. However, the compression of GANs has less been explored. A few works show that heuristically applying compression techniques normally leads to unsatisfactory results, due to the notorious training instability of GANs. In parallel, the lottery ticket hypothesis shows prevailing success on discriminative models, in locating sparse matching subnetworks capable of training in isolation to full model performance. In this work, we for the first time study the existence of such trainable matching subnetworks in deep GANs. For a range of GANs, we certainly find matching subnetworks at $6 7 \\% - 7 4 \\%$ sparsity. We observe that with or without pruning discriminator has a minor effect on the existence and quality of matching subnetworks, while the initialization weights used in the discriminator plays a significant role. We then show the powerful transferability of these subnetworks to unseen tasks. Furthermore, extensive experimental results demonstrate that our found subnetworks substantially outperform previous state-of-the-art GAN compression approaches in both image generation (e.g. SNGAN) and image-to-image translation GANs (e.g. CycleGAN). Codes available at https://github.com/VITA-Group/GAN-LTH. ",
+        "bbox": [
+            233,
+            256,
+            764,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            336,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks (GANs) have been successfully applied to many fields like image translation (Jing et al., 2019; Isola et al., 2017; Liu & Tuzel, 2016; Shrivastava et al., 2017; Zhu et al., 2017) and image generation (Miyato et al., 2018; Radford et al., 2016; Gulrajani et al., 2017; Arjovsky et al., 2017). However, they are often heavily parameterized and often require intensive calculation at the training and inference phase. Network compressing techniques (LeCun et al., 1990; Wang et al., 2019; 2020b; Li et al., 2020) can be of help at inference by reducing the number of parameters or usage of memory; nonetheless, they can not save computational burden at no cost. Although they strive to maintain the performance after compressing the model, a non-negligible drop in generative capacity is usually observed. A question is raised: ",
+        "bbox": [
+            174,
+            560,
+            825,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Is there any way to compress a GAN model while preserving or even improving its performance? ",
+        "bbox": [
+            176,
+            693,
+            807,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The lottery ticket hypothesis (LTH) (Frankle & Carbin, 2019) provides positive answers with matching subnetworks (Chen et al., 2020b). It states that there exist matching subnetworks in dense models that can be trained to reach a comparable test accuracy to the full model within similar training iterations. The hypothesis has successfully shown its success in various fields (Yu et al., 2020; Renda et al., 2020; Chen et al., 2020b), and its property has been studied widely (Malach et al., 2020; Pensia et al., 2020; Elesedy et al., 2020). However, it is never introduced to GANs, and therefore the presence of matching subnetworks in generative adversarial networks still remains mysterious. ",
+        "bbox": [
+            174,
+            713,
+            823,
+            811
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this gap in the literature, we investigate the lottery ticket hypothesis in GANs. One most critical challenge of extending LTH in GANs emerges: how to deal with the discriminator while compressing the generator, including (i) whether prunes the discriminator simultaneously and (ii) what initialization should be adopted by discriminators during the re-training? Previous GAN compression methods (Shu et al., 2019; Wang et al., 2019; Li et al., 2020; Wang et al., 2020b) prune the generator model only since they aim at reducing parameters in the inference stage. The effect of pruning the discriminator has never been studied by these works, which is unnecessary for them but possibly essential in finding matching subnetworks. It is because that finding matching subnetworks involves re-training the whole GAN network, in which an imbalance in generative and discriminative power could result in degraded training results. For the same reason, the disequilibrium between initialization used in generators and discriminators incurs severe training instability and unsatisfactory results. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another attractive property of LTH is the powerful transferability of located matching subnetworks. Although it has been well studied in discriminative models (Mehta, 2019; Morcos et al., 2019; Chen et al., 2020b), an in-depth understanding of transfer learning in GAN tickets is still missing. In this work, we not only show whether the sparse matching subnetworks in GANs can transfer across multiple datasets but also study what initialization benefits more to the transferability. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To convert parameter efficiency of LTH into the advantage of computational saving, we also utilize channel pruning (He et al., 2017) to find the structural matching subnetworks of GANs, which enjoys the bonus of accelerated training and inference. Our contributions can be summarized in the following four aspects: ",
+        "bbox": [
+            174,
+            271,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Using unstructured magnitude pruning, we identify matching subnetworks at $74 \\%$ sparsity in SNGAN (Miyato et al., 2018) and $67 \\%$ in CycleGAN (Zhu et al., 2017). The matching subnetworks in GANs exist no matter whether pruning discriminators, while the initialization weights used in the discriminator are crucial.   \n• We show that the matching subnetworks found by iterative magnitude pruning outperform subnetworks extracted by randomly pruning and random initialization in terms of extreme sparsity and performance. To fully exploit the trained discriminator, we using the dense discriminator as a distillation source and further improve the quality of winning tickets.   \n• We demonstrate that the found subnetworks in GANs transfer well across diverse generative tasks.   \n• The matching subnetworks found by channel pruning surpass previous state-of-the-art GAN compression methods (i.e., GAN Slimming (Wang et al., 2020b)) in both efficiency and performance. ",
+        "bbox": [
+            173,
+            340,
+            826,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            344,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GAN Compression Generative adversarial networks (GANs) have succeeded in computer vision fields, for example, image generation and translation. One significant drawback of the generative models is the high computational cost of the models’ complex structure. A wide range of neural network compression techniques has been applied to generative models to address this problem. There are several categories of compression techniques, including pruning (removing some parameters), quantization (reducing the bit width), and distillation. Shu et al. (2019) proposed a channel pruning method for CycleGAN by using a co-evolution algorithm. Wang et al. (2019) proposed a quantization method for GANs based on the EM algorithm. Li et al. (2020) used a distillation method to transfer knowledge of the dense to the compressed model. Recently Wang et al. (2020b) proposed a GAN compression framework, GAN slimming, that integrated the above three mainstream compression techniques into a unified form. Previous works on GAN pruning usually aim at finding a sparse structure of the trained generator model for faster inference speed, while we are focusing on finding trainable structures of GANs following the lottery ticket hypothesis. Moreover, in existing GAN compression methods, only the generator is pruned, which could undermine the performance of re-training since the left-out discriminator may have a stronger computational ability than the pruned generator and therefore cause a degraded result due to the imparity of these two models. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Lottery Ticket Hypothesis The lottery ticket hypothesis (LTH) (Frankle & Carbin, 2019) claims the existence of sparse, separate trainable sub-networks in a dense network. These subnetworks are capable of reaching comparable or even better performance than full dense model, which has been evidenced in various fields, such as image classification (Frankle & Carbin, 2019; Liu et al., 2019; Wang et al., 2020a; Evci et al., 2019; Frankle et al., 2020; Savarese et al., 2020; Yin et al., 2020; You et al., 2020; Ma et al., 2021; Chen et al., 2020a), natural language processing (Gale et al., 2019; Chen et al., 2020b), reinforcement learning (Yu et al., 2020), lifelong learning (Chen et al., 2021b), graph neural networks (Chen et al., 2021a), and adversarial robustness (Cosentino et al., 2019). Most works of LTH use unstructured weight magnitude pruning (Han et al., 2016; Frankle & ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Carbin, 2019) to find the matching subnetworks, and the channel pruning is also adopted in a recent work (You et al., 2020). In order to scale up LTH to larger networks and datasets, the “late rewinding” technique is proposed by Frankle et al. (2019); Renda et al. (2020). Mehta (2019); Morcos et al. (2019); Desai et al. (2019) are the pioneers to study the transferability of found subnetworks. However, all previous works focus on discriminative models. In this paper, we extend LTH to GANs and reveal unique findings of GAN tickets. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            207,
+            339,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe our pruning algorithms and list related experimental settings. ",
+        "bbox": [
+            173,
+            238,
+            753,
+            253
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Backbone Networks We use two GANs in our experiments in Section 4: SNGAN (Miyato et al., 2018) and CycleGAN (Zhu et al., 2017)). SNGAN with ResNet (He et al., 2016) is one of the most popular noise-to-image GAN network and has strong performance on several datasets like CIFAR10. CycleGAN is a popular and well-studied image-to-image GAN network that also performs well on several benchmarks. For SNGAN, let $g ( \\mathbf { z } ; \\pmb { \\theta } _ { g } )$ be the output of the generator network $\\mathcal { G }$ with parameters $\\theta _ { g }$ and a latent variable $\\textbf { z } \\in \\mathbb { R } ^ { | | z | | _ { 0 } }$ and $d ( \\mathbf { x } ; \\pmb { \\theta } _ { d } )$ be the output of the discriminator network $\\mathcal { D }$ with parameters $\\theta _ { d }$ and input example $\\mathbf { x }$ . For CycleGAN which is composed of two generator-discriminator pairs, we use $g ( \\mathbf { x } ; \\pmb { \\theta } _ { g } )$ and $\\theta _ { g }$ again to represent the output and the weights of the two generators where $\\mathbf { x } = ( \\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } )$ indicates a pair of input examples. The same modification can be done for the two discriminators in CycleGAN. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Datasets For image-to-image experiments, we use a widely-used benchmark horse2zebra (Zhu et al., 2017) for model training. As for noise-to-image experiments, we use CIFAR-10 (Krizhevsky et al., 2009) as the benchmark. For the transfer study, the experiments are conducted on CIFAR-10 and STL-10 (Coates et al., 2011). For better transferring, we resize the image in STL-10 to $3 2 \\times 3 2$ . ",
+        "bbox": [
+            174,
+            424,
+            825,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Subnetworks For a network $f ( \\cdot ; \\pmb \\theta )$ parameterized by $\\pmb \\theta$ , a subnetwork is defined as $f ( \\cdot ; m \\odot \\pmb { \\theta } )$ , where $m \\in \\{ 0 , 1 \\} ^ { \\| \\theta \\| _ { 0 } }$ is a pruning mask for $\\pmb { \\theta } \\in \\mathbb { R } ^ { | | \\theta | | _ { 0 } }$ and $\\odot$ is the element-wise product. For GANs, two separate masks, $\\mathbf { \\nabla } m _ { d }$ and $m _ { g }$ , are needed for both the generator and the discriminator. Consequently, a subnetwork of GANs is consistent of: a sparse generator $g ( \\cdot ; m _ { g } \\odot \\theta _ { g } )$ and a sparse discriminator $d ( \\cdot ; m _ { d } \\odot \\theta _ { d } )$ . ",
+        "bbox": [
+            174,
+            494,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\pmb { \\theta _ { 0 } }$ be the initialization weights of model $f$ and $\\theta _ { t }$ be the weights at training step $t$ . Following Frankle et al. (2019), we define a matching network as a subnetwork $f ( \\cdot ; m \\odot \\pmb \\theta )$ , where $\\pmb { \\theta }$ is initialized with $\\theta _ { t }$ , that can reach the comparable performance to the full network within a similar training iterations when trained in isolation; a winning ticket is defined as a matching subnetwork where $t = 0$ , i.e. $\\pmb \\theta$ initialized with $\\pmb { \\theta } _ { 0 }$ . ",
+        "bbox": [
+            174,
+            574,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finding subnetworks Finding GAN subnetworks is to find two masks $m _ { g }$ and $\\mathbf { \\nabla } m _ { d }$ for the generator and the discriminator. We use both an unstructured magnitude method, i.e. the iterative magnitude pruning (IMP), and a structured pruning method, i.e. the channel pruning (He et al., 2017), to generate the masks. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For unstructured pruning, we follow the following steps. After we finish training the full GAN model for $N$ iterations, we prune the weights with the lowest magnitude globally (Han et al., 2016) to obtain masks $\\pmb { m } = ( m _ { g } , m _ { d } )$ , where the position of a remaining weight in $_ { \\mathbf { \\nabla } } \\mathbf { m }$ is marked as one, and the position of a pruned weight is marked as zero. The weights of the sparse generator and the sparse discriminator are then reset to the initial weights of the full network. Previous works have shown that the iterative magnitude pruning (IMP) method is better than the one-shot pruning method. So rather than pruning the network only once to reach the desired sparsity, we prune a certain amount of non-zero parameters and re-train the network several times to meet the requirement. Details of this algorithm are in Appendix A1.1, Algorithm 1. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As for channel pruning, the first step is to train the full model as well. Besides using a normal loss function $\\mathcal { L } _ { \\mathrm { G A N } }$ , we follow Liu et al. (2017) to apply a $\\ell _ { 1 }$ -norm on the trainable scale parameters $\\gamma$ in the normalization layers to encourage channel-level sparsity: $\\mathcal { L } _ { \\mathrm { c p } } = | | \\gamma | | _ { 1 }$ . To prevent the compressed network behave severely differently with the original large network, we introduce a distillation loss as Wang et al. (2020b) did: $\\mathcal { L } _ { \\mathrm { d i s t } } = \\mathbb { E } _ { \\mathbf { z } } [ \\mathrm { d i s t } ( g ( \\bar { \\mathbf { z } } ; \\theta _ { g } ) , g ( \\mathbf { z } ; m _ { g } \\odot \\pmb { \\theta } _ { g } ) ) ]$ . We train the ",
+        "bbox": [
+            174,
+            854,
+            823,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GAN network with these two additional losses for $N _ { 1 }$ epochs and get the sparse networks $g ( \\cdot ; m _ { g } \\odot$ $\\theta _ { g , \\mathrm { ~ \\tiny ~  ~ } }$ ) and $d ( \\cdot ; m _ { d } \\odot \\theta _ { g } )$ . Details of this algorithm are in Appendix A1.1, Algorithm 2. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of subnetworks After obtaining the subnetworks $g ( \\cdot ; \\theta _ { g } \\odot m _ { g } )$ and $d ( \\cdot ; \\pmb { \\theta } _ { d } \\odot \\pmb { m } _ { d } )$ , we test whether the subnetworks are matching or not. We reset the weights to a specific step $i$ , and train the subnetworks for $N$ iterations and evaluate them using two specific metrics, Inception Score (Salimans et al., 2016) and Frechet Inception Distance (Heusel et al., 2017). ´ ",
+        "bbox": [
+            174,
+            150,
+            825,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Other Pruning Methods We compare the size and the performance of subnetworks found by IMP with subnetworks found by other techniques that aim at compressing the network after training to reduce computational costs at inference. We use a benchmark pruning approach named Standard Pruning (Chen et al., 2020b; Han et al., 2016), which iteratively prune the $20 \\%$ of lowest magnitude weights, and train the network for another $N$ iterations without any rewinding, and repeat until we have reached the target sparsity. ",
+        "bbox": [
+            173,
+            224,
+            825,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to verify that the statement of iterative magnitude pruning is better than one-shot pruning, we compare $\\mathrm { I M P _ { G } }$ and $\\mathrm { I M P _ { G D } }$ with their one-shot counterparts. Additionally, we compare IMP with some randomly pruning techniques to prove the effectiveness of IMP. They are: 1) Randomly Pruning: Randomly generate a sparsity mask $m ^ { \\prime }$ . 2) Random Tickets: Rewinding the weights to another initialization $\\theta _ { \\mathbf { 0 } } ^ { \\prime }$ . ",
+        "bbox": [
+            174,
+            315,
+            825,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 THE EXISTENCE OF WINNING TICKETS IN GAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            607,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will validate the existence of winning tickets in GANs with initialization $\\theta _ { 0 } : =$ $( \\theta _ { g _ { 0 } } , \\theta _ { d _ { 0 } } )$ . Specifically, we will empirically prove several important properties of the tickets by authenticating the following four claims: ",
+        "bbox": [
+            176,
+            441,
+            823,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim $I$ : Iterative Magnitude Pruning (IMP) finds winning tickets in GANs, $g ( \\cdot ; m _ { g } \\odot \\theta _ { g _ { 0 } } )$ and $d ( \\cdot ; m _ { d } \\odot \\theta _ { d _ { 0 } } )$ . Channel pruning is also able to find winning tickets as well. ",
+        "bbox": [
+            171,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim 2: Whether pruning the discriminator $\\mathcal { D }$ does not change the existence of winning tickets. It is the initialization used in $\\mathcal { D }$ that matters. Moreover, pruning the discriminator has a slight boost of matching networks in terms of extreme sparsity and performance. ",
+        "bbox": [
+            176,
+            526,
+            821,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim 3: IMP finds winning tickets at sparsity where some other pruning methods (randomly pruning, one-shot magnitude pruning, and random tickets) are not matching. ",
+        "bbox": [
+            173,
+            575,
+            820,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim 4: The late rewinding technique (Frankle et al., 2019) helps. Matching subnetworks that are initialized to $\\theta _ { i }$ , i.e., $i$ steps from $\\pmb { \\theta _ { 0 } }$ , can outperform those initialized to $\\pmb { \\theta _ { 0 } }$ . Moreover, matching subnetworks that are late rewound can be trained to match the performance of standard pruning. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim 1: Are there winning tickets in GANs? To answer this question, we first conduct experiments on SNGAN by pruning the generator only in the following steps: 1) Run IMP to get sequential sparsity masks $( m _ { d _ { i } } , m _ { g _ { i } } )$ of sparsity $s _ { i } \\bar { \\% }$ remaining weights; 2) Apply the masks to the GAN and reset the weights of the subnetworks to the same random initialization $\\theta _ { \\mathbf { 0 } } ; 3 )$ Train models to evaluate whether they are winning tickets. 1 We set $s _ { i } \\% = ( 1 - 0 . 8 ^ { i } ) \\times 1 0 0 \\%$ , which we use for all the experiments that involve iteratively pruning hereinafter. The number of training epochs for subnetworks is identical to that of training the full models. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 verifies the existence of winning tickets in SNGAN and CycleGAN. We are able to find winning tickets by iterative pruning the generators at the highest sparsity, around $74 \\%$ in SNGAN, and around $67 \\%$ in CycleGAN, where the FID scores of these subnetworks successfully match the FID scores of the full network respectively. The confidence interval also suggests that the winning tickets at some sparsities are statistically significantly better than the full model. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To show that channel pruning can find winning tickets as well, we extract several subnetworks from the trained full SNGAN and CycleGAN by varying $\\rho$ in Algorithm 2. We define the channel-pruned model’s sparsity as the ratio of MFLOPs between the sparse model and the full model. ",
+        "bbox": [
+            178,
+            852,
+            821,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7513d5cd63eac48aa4d57f06bcfa222e824d83221d800f1918c160f8bd993b4a.jpg",
+        "image_caption": [
+            "Figure 1: The Frechet Inception Distance (FID) curve of subnetworks of SNGAN (left) and CycleGAN (right) ´ generated by iterative magnitude pruning (IMP) on CIFAR-10 and horse2zebra. The dashed line indicates the FID score of the full model on CIFAR-10 and horse2zebra. The $9 5 \\%$ confidence interval of 5 runs is reported. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            821,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can confirm that winning tickets can also be found by channel pruning (CP). CP is able to find winning tickets in SNGAN at sparsity around $34 \\%$ . We will analyze it more carefully in Section 7. ",
+        "bbox": [
+            174,
+            285,
+            823,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8911baf780540c2c3bb95561086c246e134ffe27ca1dfbd17bf48521ae5c5f05.jpg",
+        "image_caption": [
+            "Figure 2: Visualization by sampling and interpolation of SNGAN Winning Tickets found by IMP. Sparsity of best winning tickets : $4 8 . 8 0 \\%$ . Extreme sparsity of matching subnetworks: $7 3 . 7 9 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            325,
+            823,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/58e0acd15a2f5c11aa5a7559feab903e95dea4d4079e86d4039c325cf35e41dd.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of CycleGAN Winning Tickets found by IMP. Sparsity of best winning tickets : $5 9 . 0 4 \\%$ . Extreme sparsity of matching subnetworks: $6 7 . 2 4 \\%$ . Left: visualization results on horse2zebra. Right: visualization results on zebra2horse. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            455,
+            821,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Claim 2: Does the treatment of the discriminator affect the existence of winning tickets? Previous works of GAN pruning did not analyze the effect of pruning the discriminator. To study the effect, we compare two different iterative pruning settings: 1) Prune the generator only $\\left( \\mathrm { I M P _ { G } } \\right)$ and 2) Prune both the generator and the discriminator iteratively $( \\mathrm { I M P _ { G D } } )$ . Both the generator and the discriminator are reset to the same random initialization $\\pmb { \\theta _ { 0 } }$ after the masks are obtained. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The FID scores of the two experiments are shown in Figure 4. The graph suggests that the two settings share similar patterns: the minimal FID of $\\mathrm { I M P _ { G } }$ is 14.19, and the minimal FID of $\\mathrm { I M P _ { G D } }$ is 14.59. The difference between these two best FID is only 0.4, showing a slight difference in generative power. The FID curve of $\\mathrm { I M P _ { G } }$ lies below that of $\\mathrm { I M P _ { G D } }$ at low sparsity but lies above at high sparsity, indicating that pruning the discriminator produces slightly better performance when the percent of remaining weights is small. The extreme sparsity where $\\mathrm { I M P _ { G D } }$ can match the performance of the full model is $7 3 . 8 \\%$ . In contrast, $\\mathrm { I M P _ { G } }$ can only match no sparser than $6 7 . 2 \\%$ , demonstrating that pruning the discriminator can also push the frontier of extreme sparsity where the pruned models are still able to match. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition, we study the effects of different initialization for the sparse discriminator. We compare different weights loading methods when applying the iterative magnitude pruning process: 1) Reset the weights of generator to $\\theta _ { g _ { 0 } }$ and reset the weights of discriminator to $\\theta _ { d _ { 0 } }$ , which is identical to $\\mathrm { I M P _ { G } }$ ; 2) Reset the weights of generator to $\\theta _ { g _ { 0 } }$ and fine-tune the discriminator, which we will call $\\mathrm { I M P _ { G } ^ { F } }$ . Figure 4 shows that resetting both the weights to $\\pmb { \\theta _ { 0 } }$ produces a much better result than only resetting the generator. The discriminator $\\mathcal { D }$ without resetting its weights is too strong for the generator $\\mathcal { G }$ with initial weights $\\theta _ { g _ { 0 } }$ that will lead to degraded performance. In summary, different initialization of the discriminator will significantly influence the existence and quality of winning tickets in GAN models. ",
+        "bbox": [
+            174,
+            852,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/66ed5eab2be7c87a44dd7ec54916199d028c93910d2e62b9e9fe26aa369272b9.jpg",
+        "image_caption": [
+            "Figure 4: The FID score of Left: The FID score of best subnetworks generated by two different pruning settings: $\\mathrm { I M P _ { G } }$ and $\\mathrm { I M P } _ { \\mathrm { G D } }$ . Right: The FID score of best subnetworks generated by two different pruning settings: $\\mathrm { I M P _ { G } }$ and $\\mathrm { I M P _ { G } ^ { F } }$ . $\\mathrm { I M P _ { G } }$ : iteratively prune and reset the generator. $\\mathrm { I M P } _ { \\mathrm { G D } }$ : iteratively prune and reset the generator and the discriminator. $\\mathrm { I M P _ { G } ^ { \\tilde { \\mathrm { F } } } }$ : iteratively prune and reset the generator, and iteratively prune but not reset the discriminator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            170,
+            823,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A follow-up question arises from the previous observations: is there any way to use the weights of the dense discriminator, as the direct usage of the dense weights yields inferior results? One possible way is to use it as a “teacher” and transfer the knowledge to pruned discriminator using a consistency loss. Formally speaking, an additional regularization term is used when training the whole network: ",
+        "bbox": [
+            173,
+            367,
+            825,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02c677da7ca9d5b3f17e58706bc6bf16bfa4e74b1d2d36b3809a680a405a082f.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { K D } } ( \\mathbf { x } ; \\pmb { \\theta } _ { d } , m _ { d } ) = \\mathbb { E } _ { \\mathbf { x } } [ \\mathrm { K L } _ { \\mathrm { D i v } } ( d ( \\mathbf { x } ; m _ { d } \\odot \\pmb { \\theta } _ { d } ) , d ( \\mathbf { x } ; \\pmb { \\theta } _ { d _ { 1 } } ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            430,
+            696,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { K L } _ { \\mathrm { D i v } }$ denotes the KL-Divergence. We name the iterative pruning method with this additional regularization $\\mathrm { I M P _ { G D } ^ { K D } }$ . ",
+        "bbox": [
+            174,
+            454,
+            820,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows the result of pruning method IMPKD compared to the previous two pruning methods we proposed, $\\mathrm { I M P _ { G } }$ and $\\mathrm { I M P _ { G D } }$ . $\\mathrm { I M P _ { G D } ^ { K D } }$ is capable of finding winning tickets at sparsity around $70 \\%$ , outperforming $\\mathrm { I M P _ { G } }$ , and showing comparable results to $\\mathrm { I M P _ { G D } }$ regarding the extreme sparsity. The FID curve of setting $\\mathrm { \\tilde { I M P } _ { G D } ^ { K D } }$ is further mostly located below the curve of $\\mathrm { \\Delta I M P _ { G D } }$ , demonstrating a stronger generative ability than $\\mathrm { I M P _ { G D } }$ . It suggests transferring knowledge from the full discriminator benefits to find the winning tickets. ",
+        "bbox": [
+            174,
+            489,
+            483,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8b60e4bcd678fb4f89a4ccc93e2d320ddc699b7352edcc9c2574225e0eddc94.jpg",
+        "image_caption": [
+            "Figure 5: The FID curve of best subnetworks generated by three different pruning methods: $\\mathrm { I M P G }$ , $\\mathrm { I M P } _ { \\mathrm { G D } }$ and $\\mathrm { I M P _ { G D } ^ { K D } }$ . $\\mathrm { I M P _ { G D } ^ { K D } }$ : iteratively prune and reset both the generator and the discriminator, and train them with the KD regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            481,
+            820,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Claim 3: Can IMP find matching subnetworks sparser than other pruning methods? Previous works claim that both a specific sparsity mask and a specific initialization are necessary for finding winning tickets (Frankle & Carbin, 2019), and iterative magnitude pruning is better than one-shot pruning. To extend such a statement in the context of GANs, we compare IMP with several other benchmarks, randomly pruning (RP), one-shot magnitude pruning (OMP), and random tickets (RT), to see if IMP can find matching networks at higher sparsity. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d085d6300af245b69cf6781c1d9e225b046161a0b431dbf111e4009fc915ef9.jpg",
+        "image_caption": [
+            "Figure 6: FID curves: $\\mathrm { O M P G }$ , $\\mathrm { I M P G }$ , ${ \\mathrm { O M P } } _ { \\mathrm { G D } }$ and $\\mathrm { I M P } _ { \\mathrm { G D } }$ . $\\mathrm { O M P _ { G } }$ : one-shot prune the generator. ${ \\mathrm { O M P } } _ { \\mathrm { G P } }$ : one-shot prune generator/discriminator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            768,
+            472,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/011bb3b912541cfa66d114361ae5efe1fabddf9251fb6590ca16d30a2b6ee5ca.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>FIDBest (Sparsity)</td><td>FIDExtreme (Sparsity)</td></tr><tr><td>No Pruning</td><td>15.69 (0.0%)</td><td>1</td></tr><tr><td>IMPG</td><td>14.19 (20.0%)</td><td>15.58 (67.2%)</td></tr><tr><td>IMPGD</td><td>14.59 (59.0%)</td><td>15.53 (73.8%)</td></tr><tr><td>OMPG</td><td>14.36 (36.0%)</td><td>15.33 (59.0%)</td></tr><tr><td>OMPGD</td><td>14.52 (20.0%)</td><td>15.69 (48.8%)</td></tr></table>",
+        "bbox": [
+            517,
+            767,
+            810,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: The extreme sparsity of the matching networks and the FID score of best subnetworks, found by iterative pruning and one-shot pruning. $\\mathrm { O M P G }$ : one-shot prune the generator. ${ \\mathrm { O M P } } _ { \\mathrm { G P } }$ : one-shot prune generator/discriminator. ",
+        "bbox": [
+            504,
+            847,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 and Table 1 show that iterative magnitude pruning outperforms one-shot magnitude pruning no matter pruning the discriminator or not. IMP finds winning tickets at higher sparsity $( 6 7 . 2 3 \\%$ and $7 3 . 7 9 \\%$ , respectively) than one-shot pruning $( 5 9 . 0 0 \\%$ and $4 8 . 8 0 \\%$ , respectively). The minimal FID score of subnetworks found by IMP is smaller than that of subnetworks found by OMP as well. This observation defends the statement that pruning iteratively is superior compared to one-shot pruning. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also list the minimal FID scores and extreme sparsity of matching networks for other pruning methods in Figure 7 and Table 2. It can be seen that IMP finds winning tickets at sparsity where some other pruning methods, randomly pruning and random initialization, cannot match. Since $\\mathrm { I M P _ { G } }$ shows the best overall result, we authenticate the previous statement that both the specific sparsity mask and the specific initialization are essential for finding winning tickets. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/459ef32da8d72453aabd929c181e761be23bb6bb14cfc391573cf4c04ab0f836.jpg",
+        "image_caption": [
+            "Figure 7: The FID curve of best subnetworks generated by three different pruning settings: $\\mathrm { I M P G }$ , RP, and RT. RP: iteratively randomly prune the generator. RT: iteratively prune the generator but reset the weights randomly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            266,
+            490,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/50f76ecae07df30927fb8e48164cd099a2c41f6d7fef9e4bcd12eefbc2694e11.jpg",
+        "table_caption": [
+            "Table 2: The FID score of best subnetworks and the extreme sparsity of matching networks found by Random Pruning, Random Rickets, and iterative magnitude pruning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>FIDBest (Sparsity)</td><td>FIDExtreme (Sparsity)</td></tr><tr><td>No Pruning</td><td>15.69 (0.0%)</td><td></td></tr><tr><td>IMPG</td><td>14.19 (20.0%)</td><td>15.58 (67.2%)</td></tr><tr><td>Random Pruning</td><td>14.57 (20.0%)</td><td>15.60 (36.0%)</td></tr><tr><td>Random Tickets</td><td>14.28 (36.0%)</td><td>15.33 (59.0%)</td></tr></table>",
+        "bbox": [
+            508,
+            265,
+            818,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Claim 4: Does rewinding improve performance? In previous paragraphs, we show that we are able to find winning tickets in both SNGAN and CycleGAN. However, these subnetworks cannot match the performance of the original network at extremely high sparsity, while the subnetworks found by standard pruning can (Table 3). To find matching subnetworks at such high sparsity, we adopt the rewinding paradigm: after the masks are obtained, the weights of the model are rewound to $\\theta _ { i }$ , the weights after $i$ steps of training, rather than reset to the same random initialization $\\pmb { \\theta _ { 0 } }$ . It was pointed out by Renda et al. (2020) that subnetworks found by IMP and rewound early in training can be trained to achieve the same accuracy at the same sparsity as subnetworks found by the standard pruning, providing a possibility that rewinding can also help GAN subnetworks. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            592
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We choose different rewinding settings: $5 \\%$ , $10 \\%$ , and $20 \\%$ of the whole training epochs. The results are shown in Table 3. We observe that rewinding can significantly increase the extreme sparsity of matching networks. Rewinding to even only $5 \\%$ of the training process can raise the extreme sparsity from $6 7 . 2 3 \\%$ to $8 6 . 2 6 \\%$ , and rewinding to $20 \\%$ can match the performance of standard pruning. We also compare the FID score of subnetworks found at $89 \\%$ sparsity. Rewind to $2 0 \\%$ of the training ",
+        "bbox": [
+            174,
+            599,
+            483,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1b8650df3dd36bdc689e9f7afdc27d1cf97725a759b3fdde7ee8b76d1da53ed.jpg",
+        "table_caption": [
+            "Table 3: Rewinding results. $\\mathrm { S _ { E x t r e m e } }$ : Extreme sparsity where matching subnetworks exist. $\\mathrm { F I D } _ { \\mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\\mathrm { F I D } _ { 8 9 \\% }$ : The FID score of subnetworks at $8 9 \\%$ sparsity. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Setting of rewinding</td><td>SExtreme</td><td>FIDBest</td><td>FID89%</td></tr><tr><td>Rewind 0%</td><td>67.23%</td><td>14.20</td><td>19.60</td></tr><tr><td>Rewind 5%</td><td>86.26%</td><td>13.96</td><td>15.82</td></tr><tr><td>Rewind 10%</td><td>86.26%</td><td>14.43</td><td>15.63</td></tr><tr><td>Rewind 20%</td><td>89.26%</td><td>14.82</td><td>15.29</td></tr><tr><td>Standard Pruning</td><td>89.26%</td><td>14.18</td><td>15.22</td></tr></table>",
+        "bbox": [
+            498,
+            655,
+            823,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "process can match the performance of standard pruning at $89 \\%$ sparsity, and other late rewinding settings can match the performance of the full model. This suggests that late rewinding techniques can greatly contribute to matching subnetworks with higher sparsity. ",
+        "bbox": [
+            176,
+            752,
+            821,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Summary Extensive experiments are conducted to examine the existence of matching subnetworks in generative adversarial models. We confirmed that there were matching subnetworks at high sparsities, and both the sparsity mask and the initialization matter for finding winning tickets. We also studied the effect of pruning the discriminator and demonstrate that pruning the discriminator can slightly boost the performance regarding the extreme sparsity and the minimal FID. We proposed a method to utilize the weights of the dense discriminator model to boost the performance further. We also compare IMP with different pruning methods, showing that IMP is superior to random tickets and random pruning. In addition, late rewinding can match the performance of standard pruning, which again shows consistency with previous works. ",
+        "bbox": [
+            173,
+            803,
+            825,
+            929
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 THE TRANSFER LEARNING OF GAN MATCHING NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            697,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we confirm the presence of winning tickets in GANs. In this section, we will study the transferability of winning tickets. Existing works (Mehta, 2019) show that the matching networks in discriminative models can transfer across tasks. Here we evaluate this claim in GANs. ",
+        "bbox": [
+            176,
+            127,
+            820,
+            169
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To investigate the transferability, we propose three transfer experiments from CIFAR-10 to STL-10 on SNGAN. We first identify matching subnetworks $g ( \\cdot , m _ { g } \\odot \\theta )$ and $d ( \\cdot , m _ { d } \\odot \\pmb \\theta )$ on CIFAR10, and then train and evaluate the subnetworks on STL-10. To assess whether the same random initialization $\\pmb { \\theta _ { 0 } }$ is needed for transferring, we test three different weights loading method: 1) reset the weights to $\\theta _ { 0 } ; 2 )$ reset the weights to another initialization $\\theta _ { \\mathbf { 0 } } ^ { \\prime }$ ; 3) rewind the weights to $\\theta _ { N }$ . We train the network on STL-10 using the same hyper-parameters as on CIFAR-10. It is noteworthy that the hyper-parameters setting might not be optimal for the target task, yet it is fair to compare different transferring settings. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d273131fff1630d39da7f3289b49472b24839e964b94c3ceeba8221f6621ac6b.jpg",
+        "table_caption": [
+            "Table 4: Results of late rewinding experiments. $\\pmb { \\theta _ { 0 } }$ : train the target model from the same random initialization as the source model; $\\theta _ { r }$ : train from random initialization; $\\pmb { \\theta } _ { \\mathbf { B } \\mathbf { e s t } }$ : train from the weights of trained source model. Baseline: full model trained on STL-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Baseline</td><td>IMPg (S = 67.23%)</td><td></td><td>IMPGD (S = 73.79%)</td><td>IMPKB</td><td>(S= 73.79%)</td></tr><tr><td>Metrics</td><td>FIDBest</td><td>FIDBest</td><td>Matching?</td><td>FIDBest</td><td>Matching？</td><td>FIDBest Matching?</td></tr><tr><td>0</td><td></td><td>116.7</td><td>√</td><td>121.8</td><td>× 120.1</td><td>×</td></tr><tr><td>0r</td><td>115.3</td><td>119.2</td><td>×</td><td>113.1 √</td><td>115.5</td><td>√</td></tr><tr><td>0Best</td><td></td><td>204.7</td><td>×</td><td>163.0 ×</td><td>179.1</td><td>×</td></tr></table>",
+        "bbox": [
+            176,
+            330,
+            825,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The FID score of different settings is shown in Table 4. Subnetworks initialized by $\\theta _ { 0 }$ and using masks generated by $\\mathrm { I M P _ { G } }$ can be trained to achieve comparable results to the baseline model. Surprisingly, random re-initialization ${ \\pmb \\theta } _ { \\mathbf { 0 } } ^ { \\prime }$ shows better transferability than using the same initialization $\\pmb { \\theta _ { 0 } }$ in our transfer settings and outperforms the full model trained on STL-10, indicating that the combination of $\\pmb { \\theta _ { 0 } }$ and the mask generated by $\\mathrm { I M P } _ { \\mathrm { G D } }$ is more focused on the source dataset and consequently has lower transferability. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Summary In this section, we tested the transferability of IMP subnetworks. Transferring from $\\pmb { \\theta _ { 0 } }$ and $\\theta _ { r }$ both produce matching results on the target dataset, STL-10. $\\pmb { \\theta _ { 0 } }$ works better with masks generated by $\\mathrm { I M P _ { G } }$ while the masks generated by $\\mathrm { I M P _ { G D } }$ prefer a different initialization $\\theta _ { r }$ . Given that $\\mathrm { I M P _ { G D } }$ performs better on CIFAR-10, it is reasonable that the same initialization $\\pmb { \\theta _ { 0 } }$ has lower transferability when using masks from $\\mathrm { I M P _ { G D } }$ . ",
+        "bbox": [
+            174,
+            529,
+            825,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ON OTHER GAN MODELS AND OTHER DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            732,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conducted experiments on DCGAN (Radford et al., 2016), WGAN-GP (Gulrajani et al., 2017), ACGAN (Odena et al., 2017), GGAN (Lim & Ye, 2017), DiffAugGAN (Zhao et al., 2020a), ProjGAN (Miyato & Koyama, 2018), SAGAN (Zhang et al., 2019), as well as a NAS-based GAN, AutoGAN (Gong et al., 2019). We use CIFAR-10 and Tiny ImageNet (Wu et al., 2017) as our benchmark datasets. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5 and 6 consistently verify that the existence of winning tickets in diverse GAN architectures in spite of the different extreme sparsities, showing that the lottery ticket hypothesis can be generalized to various GAN models. ",
+        "bbox": [
+            176,
+            729,
+            823,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 EFFICIENCY OF GAN WINNING TICKETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            547,
+            810
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unlike the unstructured magnitude pruning method, channel pruning can reduce the number of parameters in GANs. Therefore, winning tickets found by channel pruning are more efficient than the original model regarding computational cost. To fully exploit the advantage of subnetworks founded by structural pruning, we further compare our prune-and-train pipeline with a state-of-the-art GAN compression framework (Wang et al., 2020b). The pipeline is described as follows: after extracting the sparse structure generated by channel pruning, we reset the model weights to the same random initialization $\\pmb { \\theta _ { 0 } }$ and then train for the same number of epochs as the dense model used. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2c784b08bd4738f2ea9340ef3ba60cc282ce2184148e87721093125a9f245637.jpg",
+        "table_caption": [
+            "Table 5: Results on other GAN models on CIFAR-10. $\\mathrm { F I D } _ { \\mathrm { F u l l } }$ : FID score of the full model. $\\mathrm { F I D } _ { \\mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\\mathrm { F I D } _ { \\mathrm { E x t r e m e } }$ : The FID score of matching networks at extreme sparsity level. AutoGAN-A/B/C are three representative GAN architectures represented in the official repository (https://github.com/VITA-Group/AutoGAN) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Benchmark</td><td>FIDFull (Sparsity)</td><td>FIDBest (Sparsity)</td><td>SExtreme (Sparsity)</td></tr><tr><td>DCGAN (Radford et al., 2016)</td><td>CIFAR-10</td><td>57.39 (0%)</td><td>49.31 (20.0%)</td><td>54.48 (67.2%)</td></tr><tr><td>WGAN-GP(Gulrajani et al., 2017)</td><td>CIFAR-10</td><td>19.23 (0%)</td><td>16.77 (36.0%)</td><td>17.28 (73.8%)</td></tr><tr><td>ACGAN (Odena et al.,2017)</td><td>CIFAR-10</td><td>39.26 (0%)</td><td>31.45 (36.0%)</td><td>38.95 (79.0%)</td></tr><tr><td>GGAN(Lim &amp; Ye,2017)</td><td>CIFAR-10</td><td>38.50 (0%)</td><td>33.42 (20.0%)</td><td>36.67 (48.8%)</td></tr><tr><td>ProjGAN (Miyato &amp; Koyama,2018)</td><td>CIFAR-10</td><td>31.47 (0%)</td><td>28.19 (20.0%)</td><td>31.31 (67.2%)</td></tr><tr><td>SAGAN (Zhang et al.,2019)</td><td>CIFAR-10</td><td>14.73 (0%)</td><td>13.57 (20.0%)</td><td>14.68 (48.8%)</td></tr><tr><td>AutoGAN(A) (Gong et al.,2019)</td><td>CIFAR-10</td><td>14.38 (0%)</td><td>14.04 (36.0%)</td><td>14.04 (36.0%)</td></tr><tr><td>AutoGAN(B) (Gong et al., 2019)</td><td>CIFAR-10</td><td>14.62 (0%)</td><td>13.16 (20.0%)</td><td>14.20 (36.0%)</td></tr><tr><td>AutoGAN(C) (Gong et al.,2019)</td><td>CIFAR-10</td><td>13.61 (0%)</td><td>13.41 (48.8%)</td><td>13.41 (48.8%)</td></tr><tr><td>DiffAugGAN (Zhao et al., 2020b)</td><td>CIFAR-10</td><td>8.23 (0%)</td><td>8.05 (48.8%)</td><td>8.05 (48.8%)</td></tr></table>",
+        "bbox": [
+            176,
+            169,
+            825,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d10f2ea84e490dbee3e49e7444c7cb9421d550f260fd0030d6ac1d80fd68cab.jpg",
+        "table_caption": [
+            "Table 6: Results on other GAN models on Tiny ImageNet. $\\mathrm { F I D } _ { \\mathrm { F u l l } }$ : FID score of the full model. $\\mathrm { F I D } _ { \\mathrm { B e s t } }$ : The minimal FID score of all subnetworks. $\\mathrm { F I D } _ { \\mathrm { E x t r e m e } }$ : The FID score of matching networks at extreme sparsity level. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Benchmark</td><td>FIDFull (Sparsity)</td><td>FIDBest (Sparsity)|SExtreme (Sparsity)</td><td></td></tr><tr><td>DCGAN (Radford et al., 2016)</td><td>Tiny ImageNet</td><td>121.35 (0%)</td><td>78.51 (36.0%)</td><td>114.00 (67.2%)</td></tr><tr><td>WGAN-GP(Gulrajani et al.,2017)</td><td>Tiny ImageNet</td><td>211.77 (0%)</td><td>194.72 (48.8%)</td><td>200.22 (67.2%)</td></tr></table>",
+        "bbox": [
+            176,
+            396,
+            825,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We can see from Figure 8 that subnetworks are founded by the channel pruning method at about $67 \\%$ sparsity, which provides a new path for winning tickets other than magnitude pruning. The matching networks at $6 7 . 7 \\%$ outperform GS-32 regarding Inception Score by 0.25; the subnetworks at about $2 9 \\%$ sparsity can outperform GS-32 by 0.20, setting up a new benchmark for GAN compressions. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            535
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            318,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, the lottery ticket hypothesis has been extended to GANs. We successfully identify winning tickets in GANs, which are separately trainable to match the full dense GAN performance. Pruning the discriminator, which is rarely studied before, had only slight effects on the ticket finding process, while the initialization used in the discriminator is essential. We also demonstrate that the winning tickets found can transfer across diverse tasks. Moreover, we provide a new way of finding winning tickets that alter the structure of models. Channel pruning is able to extract matching subnetworks from a dense model that can outperform the current state-of-the-art GAN compression after resetting the weights and re-training. ",
+        "bbox": [
+            174,
+            602,
+            483,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/46aff1e9d2922bac930f9ce3e210cba2f3eb0ea47700daac3ace1446a848b52f.jpg",
+        "image_caption": [
+            "Figure 8: Relationship between the best IS score of SNGAN subnetworks generated by channel pruning and the percent of remaining weights. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full model trained on CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            618,
+            820,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            858,
+            356,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhenyu Zhang is supported by the National Natural Science Foundation of China under grand No.U19B2044. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Proceedings of the 34th International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            171,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Michael Carbin, and Zhangyang Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. arXiv, abs/2012.06908, 2020a. ",
+        "bbox": [
+            176,
+            164,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks. arXiv, abs/2007.12223, 2020b. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen, Yongduo Sui, Xuxi Chen, Aston Zhang, and Zhangyang Wang. A unified lottery ticket hypothesis for graph neural networks, 2021a. ",
+        "bbox": [
+            173,
+            268,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen, Zhenyu Zhang, Sijia Liu, Shiyu Chang, and Zhangyang Wang. Long live the lottery: The existence of winning tickets in lifelong learning. In International Conference on Learning Representations, 2021b. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Andrew Y. Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the 14th International Conference on Artificial Intelligence and Statistics, 2011. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Cosentino, Federico Zaiter, Dan Pei, and Jun Zhu. The search for sparse, robust neural networks. arXiv, abs/1912.02386, 2019. ",
+        "bbox": [
+            168,
+            412,
+            825,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shrey Desai, Hongyuan Zhan, and Ahmed Aly. Evaluating lottery tickets under distributional shifts. In Proceedings of the 2nd Workshop on Deep Learning Approaches for Low-Resource NLP, 2019. ",
+        "bbox": [
+            169,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryn Elesedy, Varun Kanade, and Y. Teh. Lottery tickets in linear models: An analysis of iterative magnitude pruning. arXiv, abs/2007.08243, 2020. ",
+        "bbox": [
+            171,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Utku Evci, Fabian Pedregosa, Aidan Gomez, and Erich Elsen. The difficulty of training sparse neural networks. arXiv, abs/1906.10732, 2019. ",
+        "bbox": [
+            171,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In 7th International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            171,
+            568,
+            823,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. arXiv, abs/1912.05671, 2019. ",
+        "bbox": [
+            173,
+            607,
+            823,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle, David J. Schwab, and Ari S. Morcos. The early phase of neural network training. In 8th International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            173,
+            645,
+            821,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv, abs/1902.09574, 2019. ",
+        "bbox": [
+            173,
+            684,
+            823,
+            714
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, 2019. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems 30, 2017. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium, 2017. ",
+        "bbox": [
+            174,
+            141,
+            821,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            178,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yongcheng Jing, Yezhou Yang, Zunlei Feng, Jingwen Ye, Yizhou Yu, and Mingli Song. Neural style transfer: A review. IEEE Transactions on Visualization and Computer Graphics, 2019. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            268,
+            723,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems 2, 1990. ",
+        "bbox": [
+            173,
+            292,
+            823,
+            323
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muyang Li, Ji Lin, Yaoyao Ding, Zhijian Liu, Jun-Yan Zhu, and Song Han. Gan compression: Efficient architectures for interactive conditional gans. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jae Hyun Lim and Jong Chul Ye. Geometric gan. abs/1705.02894, 2017. ",
+        "bbox": [
+            173,
+            382,
+            653,
+            398
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. In Advances in Neural Information Processing Systems 29, 2016. ",
+        "bbox": [
+            174,
+            407,
+            820,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            445,
+            826,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In 7th International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haoyu Ma, Tianlong Chen, Ting-Kuei Hu, Chenyu You, Xiaohui Xie, and Zhangyang Wang. Good students play big lottery better. arXiv, abs/2101.03255, 2021. ",
+        "bbox": [
+            174,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eran Malach, Gilad Yehudai, Shai Shalev-Shwartz, and Ohad Shamir. Proving the lottery ticket hypothesis: Pruning is all you need. arXiv, abs/2002.00585, 2020. ",
+        "bbox": [
+            173,
+            573,
+            820,
+            603
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rahul Mehta. Sparse transfer learning via winning lottery tickets. arXiv, abs/1905.07785, 2019. ",
+        "bbox": [
+            173,
+            611,
+            803,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato and Masanori Koyama. cgans with projection discriminator. In 6th International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            636,
+            821,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral Normalization for Generative Adversarial Networks. In 6th International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ari Morcos, Haonan Yu, Michela Paganini, and Yuandong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. In Advances in Neural Information Processing Systems 32, 2019. ",
+        "bbox": [
+            173,
+            724,
+            821,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier gans. In Proceedings of the 34th International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            174,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Pensia, Shashank Rajput, Alliot Nagle, Harit Vishwakarma, and Dimitris Papailiopoulos. Optimal lottery tickets via subsetsum: Logarithmic over-parameterization is sufficient. In Advances in Neural Information Processing Systems 33 pre-proceedings, 2020. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In 4th International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. In 8th International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In Advances in Neural Information Processing Systems 31, 2018. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems 29, 2016. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pedro Savarese, Hugo Silva, and Michael Maire. Winning the lottery with continuous sparsification. In Advances in Neural Information Processing Systems 33 pre-proceedings, 2020. ",
+        "bbox": [
+            171,
+            243,
+            820,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Han Shu, Yunhe Wang, Xu Jia, Kai Han, Hanting Chen, Chunjing Xu, Qi Tian, and Chang Xu. Coevolutionary compression for unpaired image translation. In Proceedings of IEEE International Conference on Computer Vision, 2019. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In 8th International Conference on Learning Representations, 2020a. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haotao Wang, Shupeng Gui, Haichuan Yang, Ji Liu, and Zhangyang Wang. Gan slimming: All-inone gan compression by a unified optimization framework. In Proceedings of the 16th European Conference on Computer Vision, 2020b. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peiqi Wang, Dongsheng Wang, Yu Ji, Xinfeng Xie, Haoxuan Song, XuXin Liu, Yongqiang Lyu, and Yuan Xie. Qgan: Quantized generative adversarial networks. abs/1901.08263, 2019. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiayu Wu, Qixiang Zhang, and Guoxi Xu. Tiny imagenet challenge. Technical report, 2017. ",
+        "bbox": [
+            169,
+            511,
+            774,
+            527
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shihui Yin, Kyu-Hyoun Kim, Jinwook Oh, Naigang Wang, Mauricio Serrano, Jae-Sun Seo, and Jungwook Choi. The sooner the better: Investigating structure of early winning lottery tickets, 2020. ",
+        "bbox": [
+            174,
+            535,
+            826,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In 8th International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            631
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S. Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in rl and nlp. In 8th International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Ian J. Goodfellow, Dimitris N. Metaxas, and Augustus Odena. Self-attention generative adversarial networks. In Proceedings of the 36th International Conference on Machine Learning, 2019. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            733
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In 34th Conference on Neural Information Processing Systems, 2020a. ",
+        "bbox": [
+            171,
+            742,
+            823,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In Advances in Neural Information Processing Systems 33 preproceedings, 2020b. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A1 MORE TECHNICAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            457,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A1.1 ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            323,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the details of the algorithm we used in finding lottery tickets. Two distinct pruning methods are used in Algorithm 1 and Algorithm 2. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ef6d45655a54445869cf77881accc2e4db9e575575ddb321ae49c4e0496c1cb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>F8</td><td>F1/8</td></tr><tr><td>Full Model</td><td>0.971</td><td>0.974</td></tr><tr><td>Best Winning Tickets</td><td>0.977</td><td>0.977</td></tr><tr><td>Extreme Winning Tickets</td><td>0.974</td><td>0.971</td></tr></table>",
+        "bbox": [
+            509,
+            210,
+            813,
+            281
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3f50733c9ff213e215e08b8f571fd038bc11685be71b72a50c143e2f15bc01f.jpg",
+        "image_caption": [
+            "Figure A9: The curve of precision and recall of SNGANs under different sparsities. baseline: Full model. best: Best winning tickets (Sparsity: $4 8 . 8 0 \\%$ ). extreme: Extreme winning tickets (Sparsity: $7 3 . 7 9 \\%$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            204,
+            482,
+            340
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table A7: The $\\mathrm { F } _ { 8 }$ and $\\mathrm { F _ { 1 / 8 } }$ score of the full network, best subnetworks and the matching networks at extreme sparsity. We used the official codes to calculate recall, precision, $\\mathrm { F } _ { 8 }$ and $\\mathrm { F _ { 1 / 8 } }$ . ",
+        "bbox": [
+            504,
+            313,
+            823,
+            368
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A2 MORE EXPERIMENTS RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            612,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We will provide extra experiments results and analysis in this section. ",
+        "bbox": [
+            176,
+            457,
+            629,
+            470
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A2.1 MORE VISUALIZATION OF IMP WINNING TICKETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            488,
+            578,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We also conducted experiments to find winning tickets in CycleGAN on dataset winter2summer (Zhu et al., 2017). We observed similar patterns and found matching networks at $7 9 . 0 2 \\%$ sparsity. We randomly sample four images from the dataset and show the translated images in Figure A10, Figure A11, and Figure A12. The winning tickets of CycleGAN can generate comparable visual quality to the full model under all cases. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4a7cd1df085f55ab9c026cb42d9ca927154695ca8510814ca18dd8991c93ff1.jpg",
+        "image_caption": [
+            "Figure A10: Visualization of CycleGAN Winning Tickets found by IMP on summer2winter. Sparsity of best winning tickets: $5 9 . 0 4 \\%$ . Extreme sparsity of matching subnetworks: $7 9 . 0 2 \\%$ . Left: visualization results of task summer2winter. Right: visualization results of task winter2summer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            597,
+            821,
+            738
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A2.2 EXTRA METRICS FOR EVALUATING SNGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            537,
+            848
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the quality of images generated by SNGAN using precision and recall Sajjadi et al. (2018). The results are shown in Table A7 and Figure A9. The results show that the best winning tickets have higher $\\mathrm { F _ { 8 } }$ and $\\mathrm { F _ { 1 / 8 } }$ compared to the full model, and the extreme winning tickets have on-par performance. ",
+        "bbox": [
+            174,
+            859,
+            825,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c051b9b4a45c22ea552b6f3e653ce2126427bed0b801be34f7105798ecd2d7d.jpg",
+        "image_caption": [
+            "Figure A11: Extra visualization of CycleGAN Winning Tickets found by IMP on horse2zebra. Sparsity of best winning tickets : $5 9 . 0 4 \\%$ . Extreme sparsity of matching subnetworks: $6 7 . 2 4 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            820,
+            242
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a47c17dde15327013127d3e523874a5ff24da9dfa9dc6259a8443ef29c8c9a3.jpg",
+        "image_caption": [
+            "Figure A12: Extra visualization of CycleGAN Winning Tickets found by IMP on summer2winter. Sparsity of best winning tickets : $5 9 . 0 4 \\%$ . Extreme sparsity of matching subnetworks: $7 9 . 0 2 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            272,
+            821,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/28a3242fa0eb244811de40579e0a15a3304f07ebcd1c07f6f4b5f06da441b30e.jpg",
+        "image_caption": [
+            "Figure A13: Relationship between the best IS score of SNGAN subnetworks generated by channel pruning and the percent of remaining model size. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full model trained on CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            455,
+            490,
+            577
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/862d8474dad0d7cec22aa65a73af92677ffbb75e0aaba0af4e37d7d5b0d8ddfa.jpg",
+        "image_caption": [
+            "Figure A14: Relationship between the best FID score of CycleGAN subnetworks generated by channel pruning and the percent of remaining weights. GS-32: GAN Slimming without quantization (Wang et al., 2020b). Full Model: Full un-pruned CycleGAN trained on horse2zebra. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            506,
+            455,
+            820,
+            577
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A2.3 CHANNEL PRUNING FOR SNGAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            462,
+            736
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We study the relationship between the Inception Score and the remaining model size, i.e. the ratio between the size of a channel-pruned model and its original model. The results are plotted in Figure A13. A similar conclusion can be drawn from the graph that matching networks exist, and at the same sparsity, the matching networks can be trained to outperform the current state-of-the-art GAN compression framework. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A2.4 CHANNEL PRUNING FOR CYCLEGAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            488,
+            854
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We also conducted experiments on CycleGAN using channel pruning. The task we choose is horseto-zebra, i.e., we prune each of the two generators separately, which is aligned with SNGAN, which has only one generator. We prove that channel pruning is also capable of finding winning tickets in CycleGAN in Figure A14. Moreover, at extreme sparsity, the sparse subnetwork that we obtain can be trained to reach slightly better results than the current state-of-the-art GAN compression framework without quantization. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/4676628cb625cdf839d7a5917c971c066112bc510f8e99cc71a9ba03efcadca0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 1: Finding winning tickets by Iterative Magnitude Pruning</td></tr><tr><td>Input: The desired sparsity s Output: A sparse GAN g(- mg  0g)</td></tr><tr><td>and d(·; md  0d) 1 Set mg = 1 ∈ Rg llo and</td></tr><tr><td>md =1∈ Rl0dollo. 2 Set 0go := initial weights of the generator model, 0do := initial weights</td></tr><tr><td>of the discriminator model. 3 Iteration i= 0</td></tr><tr><td>4 while the sparsity of mg &lt; s do Train the generator g(*; mg ? 0go) 5</td></tr><tr><td>and the discriminator d( ; md ? 0dg) for N epochs to get parameters 0gN and 0dN</td></tr><tr><td>6 if pruning the discriminator then Prune 2O% of the parameters in 7</td></tr><tr><td>Na and Odn, creating two mask m&#x27;g and m&#x27;:</td></tr><tr><td>8 else Prune 2O% of the parameters in 9</td></tr><tr><td>0 gN, creating a mask m&#x27;. m&#x27; remains1 ∈ Rdo llo. 10 end</td></tr></table>",
+        "bbox": [
+            158,
+            146,
+            460,
+            564
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/1c985d1d0a879b886ecaa8275e1811a1f13f7739b6cc5b10005dce2ec9fc7ff7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2: Finding winning tickets by Channel Pruning Input:A threshold ρ of importance score,</td></tr><tr><td>number of steps for training N Output: A sparse GAN g(:; mg  0go) and d(-; md ③ 0do)</td></tr><tr><td>1 Randomly initialize Yg for every normalization layers in generator G and Yd for discriminator D. γ = (Yg, Yd) 2 Set 0go := initial weights of the generator</td></tr><tr><td>model, 0do := initial weights of the discriminator model. 3i=0</td></tr><tr><td>4 whilei&lt;N do Compute masks md from Yd and mg 5 from Yg: Compute Lcp, LGAN and Ldist: 6</td></tr><tr><td>Update 0g and 0d by training the 7 generator g(-; mg ?0g) and the</td></tr><tr><td></td></tr><tr><td>discriminator d(·; md  0d) for one step. Update γ: γ ← proxρn(γ -n∀γLcp), 8 where proxx(𝑥)= sgn(x)①max(|𝑥|-λ·1,0) 9 i←i+1 10 end</td></tr></table>",
+        "bbox": [
+            490,
+            148,
+            825,
+            545
+        ],
+        "page_idx": 14
+    }
+]

parse/train/H1ldNoC9tX/H1ldNoC9tX.md

@@ -0,0 +1,519 @@
+# CLASSIFICATION FROM POSITIVE, UNLABELED AND BIASED NEGATIVE DATA
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Positive-unlabeled (PU) learning addresses the problem of learning a binary classifier from positive (P) and unlabeled (U) data. It is often applied to situations where negative (N) data are difficult to be fully labeled. However, collecting a non-representative $\mathbf { N }$ set that contains only a small portion of all possible N data can be much easier in many practical situations. This paper studies a novel classification framework which incorporates such biased N (bN) data in PU learning. The fact that the training N data are biased also makes our work very different from those of standard semi-supervised learning. We provide an empirical risk minimization-based method to address this PUbN classification problem. Our approach can be regarded as a variant of traditional example-reweighting algorithms, with the weight of each example computed through a preliminary step that draws inspiration from PU learning. We also derive an estimation error bound for the proposed method. Experimental results demonstrate the effectiveness of our algorithm in not only PUbN learning scenarios but also ordinary PU leaning scenarios on several benchmark datasets.
+
+# 1 INTRODUCTION
+
+In conventional binary classification, examples are labeled as either positive (P) or negative (N), and we train a classifier on these labeled examples. On the contrary, positive-unlabeled (PU) learning addresses the problem of learning a classifier from P and unlabeled (U) data, without need of explicitly identifying N data (Elkan & Noto, 2008; Ward et al., 2009).
+
+PU learning finds its usefulness in many real-world problems. For example, in one-class remote sensing classification (Li et al., 2011), we seek to extract a specific land-cover class from an image. While it is easy to label examples of this specific land-cover class of interest, examples not belonging to this class are too diverse to be exhaustively annotated. The same problem arises in text classification, as it is difficult or even impossible to compile a set of N samples that provides a comprehensive characterization of everything that is not in the P class (Liu et al., 2003; Fung et al., 2006). Besides, PU learning has also been applied to other domains such as outlier detection (Hido et al., 2008; Scott & Blanchard, 2009), medical diagnosis (Zuluaga et al., 2011), or time series classification (Nguyen et al., 2011).
+
+By carefully examining the above examples, we find out that the most difficult step is often to collect a fully representative N set, whereas only labeling a small portion of all possible N data is relatively easy. Therefore, in this paper, we propose to study the problem of learning from P, U and biased N (bN) data, which we name PUbN learning hereinafter. We suppose that in addition to $\mathrm { \bf P }$ and U data, we also gather a set of bN samples, governed by a distribution distinct from the true $\mathbf { N }$ distribution. As described previously, this can be viewed as an extension of PU learning, but such bias may also occur naturally in some real-world scenarios. For instance, let us presume that we would like to judge whether a subject is affected by a particular disease based on the result of a physical examination. While the data collected from the patients represent rather well the $\mathrm { \bf P }$ distribution, healthy subjects that request the examination are in general highly biased with respect to the whole healthy subject population.
+
+We are not the first to be interested in learning with bN data. In fact, both Li et al. (2010) and Fei & Liu (2015) attempted to solve similar problems in the context of text classification. Li et al. (2010) simply discarded negative samples and performed ordinary PU classification. It was also mentioned in the paper that bN data could be harmful. Fei & Liu (2015) adapted another strategy. The authors considered even gathering unbiased U data is difficult and learned the classifier from only $\mathrm { \bf P }$ and bN data. However, their method is specific to text classification because it relies on the use of effective similarity measures to evaluate similarity between documents. Therefore, our work differs from these two in that the classifier is trained simultaneously on P, U and bN data, without resorting to domain-specific knowledge. The presence of U data allows us to address the problem from a statistical viewpoint, and thus the proposed method can be applied to any PUbN learning problem in principle.
+
+In this paper, we develop an empirical risk minimization-based algorithm that combines both PU learning and importance weighting to solve the PUbN classification problem, We first estimate the probability that an example is sampled into the P or the bN set. Based on this estimate, we regard bN and U data as N examples with instance-dependent weights. In particular, we assign larger weights to U examples that we believe to appear less often in the $\mathrm { \bf P }$ and bN sets. P data are treated as $\mathrm { \bf P }$ examples with unity weight but also as $_ \mathrm { N }$ examples with usually small or zero weight whose actual value depends on the same estimate.
+
+The contributions of the paper are three-fold:
+
+1. We formulate the PUbN learning problem as an extension of PU learning and propose an empirical risk minimization-based method to address the problem. We also theoretically establish an estimation error bound for the proposed method.   
+2. We experimentally demonstrate that the classification performance can be effectively improved thanks to the use of bN data during training. In other words, PUbN learning yields better performance than PU learning.   
+3. Our method can be easily adapted to ordinary PU learning. Experimentally we show that the resulting algorithm allows us to obtain new state-of-the-art results on several PU learning tasks.
+
+Relation with Semi-supervised Learning With P, N and U data available for training, our problem setup may seem similar to that of semi-supervised learning (Chapelle et al., 2010; Oliver et al., 2018). Nonetheless, in our case, N data are biased and often represent only a small portion of the whole N distribution. Therefore, most of the existing methods designed for the latter cannot be directly applied to the PUbN classification problem. Furthermore, our focus is on deducing a risk estimator using the three sets of data, whereas in semi-supervised learning the main concern is often how U data can be utilized for regularization (Grandvalet & Bengio, 2005; Belkin et al., 2006; Laine & Aila, 2017; Miyato et al., 2016). The two should be compatible and we believe adding such regularization to our algorithm can be beneficial in many cases.
+
+Relation with Dataset Shift PUbN learning can also be viewed as a special case of dataset shift1 (Quionero-Candela et al., 2009) if we consider that $\mathrm { \bf P }$ and bN data are drawn from the training distribution while U data are drawn from the test distribution. Covariate shift (Shimodaira, 2000; Sugiyama & Kawanabe, 2012) is another special case of dataset shift that has been studied intensively. In the covariate shift problem setting, training and test distributions have the same class conditional distribution and only differ in the marginal distribution of the independent variable. One popular approach to tackle this problem is to reweight each training example according to the ratio of the test density to the training density (Huang et al., 2007; Sugiyama et al., 2008). Nevertheless, simply training a classifier on a reweighted version of the labeled set is not sufficient in our case since there may be examples with zero probability to be labeled. It is also important to notice that the problem of PUbN learning is intrinsically different from that of covariate shift and neither of the two is a special case of the other.
+
+# 2 PROBLEM SETTING
+
+In this section, we briefly review the formulations of PN, PU and PNU classification and introduce the problem of learning from P, U and bN data.
+
+# 2.1 STANDARD BINARY CLASSIFICATION
+
+Let $\pmb { x } \in \mathbb { R } ^ { d }$ and $y \in \{ + 1 , - 1 \}$ be random variables following an unknown probability distribution with density $p ( { \pmb x } , { \pmb y } )$ . Let $g : \bar { \mathbb { R } ^ { d } }  \mathbb { R }$ be an arbitrary decision function for binary classification and $\ell : \mathbb { R } \to \mathbb { R } _ { + }$ be a loss function of margin $y g ( { \pmb x } )$ that usually takes a small value for a large margin. The goal of binary classification is to find $g$ that minimizes the classification risk:
+
+$$
+R ( g ) = \mathbb { E } _ { ( \pmb { x } , y ) \sim p ( \pmb { x } , y ) } [ \ell ( y g ( \pmb { x } ) ) ] ,
+$$
+
+where $\mathbb { E } _ { ( \pmb { x } , y ) \sim p ( \pmb { x } , y ) } [ \cdot ]$ denotes the expectation over the joint distribution $p ( { \pmb x } , { \pmb y } )$ . When we care about classification accuracy, $\ell$ is the zero-one loss $\ell _ { 0 1 } ( z ) = ( 1 - \mathrm { s i g n } ( z ) ) / 2$ . However, for ease of optimization, $\ell _ { 0 1 }$ is often substituted with a surrogate loss such as the sigmoid loss $\ell _ { \mathrm { s i g } } ( z ) =$ $1 / ( 1 + \exp ( z ) )$ or the logistic loss $\ell _ { \mathrm { l o g } } ( z ) = \ln ( 1 + \exp ( - z ) )$ during learning.
+
+In standard supervised learning scenarios (PN classification), we are given $\mathrm { \bf P }$ and N data that are sampled independently from $p ( \pmb { x } \mid \pmb { y } = + 1 )$ and $p ( \pmb { x } \mid \pmb { y } = - 1 )$ as $\mathbf { \mathcal { X } } _ { \mathrm { P } } = \{ \mathbf { x } _ { i } ^ { \mathrm { P } } \} _ { i = 1 } ^ { n _ { \mathrm { P } } }$ and $\mathcal { X } _ { \mathrm { N } } ~ =$ $\{ \pmb { x } _ { i } ^ { \mathrm { N } } \} _ { i = 1 } ^ { n _ { \mathrm { N } } }$ . Let us denote by $R _ { \mathrm { P } } ^ { + } ( g ) = \mathbb { E } _ { x \sim p ( x | y = + 1 ) } [ \ell ( g ( \pmb { x } ) ) ]$ , $R _ { \mathrm { N } } ^ { - } ( g ) = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } | y = - 1 ) } [ \ell ( - g ( { \pmb x } ) ) ]$ partial risks and $\pi = p ( y = 1 )$ the $\mathrm { \bf P }$ prior. We have the equality $R ( g ) = \pi R _ { \mathrm { P } } ^ { + } ( g ) + ( 1 - \pi ) R _ { \mathrm { N } } ^ { - } ( g )$ . The classification risk (1) can then be empirically approximated from data by
+
+$$
+\hat { R } _ { \mathrm { P N } } ( g ) = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) + ( 1 - \pi ) \hat { R } _ { \mathrm { N } } ^ { - } ( g ) ,
+$$
+
+where $\begin{array} { r } { \hat { R } _ { \mathrm { P } } ^ { + } ( g ) = \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \ell ( g ( \pmb { x } _ { i } ^ { \mathrm { P } } ) ) } \end{array}$ and $\begin{array} { r } { \hat { R } _ { \mathrm { N } } ^ { - } ( g ) = \frac { 1 } { n _ { \mathrm { N } } } \sum _ { i = 1 } ^ { n _ { \mathrm { N } } } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { N } } ) ) } \end{array}$ . By minimizing $\hat { R } _ { \mathrm { P N } } ( g )$ we obtain the ordinary empirical risk minimizer $\hat { g } _ { \mathrm { P N } }$ .
+
+# 2.2 PU CLASSIFICATION
+
+In PU classification, instead of $_ \mathrm { N }$ data $\mathcal { X } _ { \mathrm { N } }$ we have only access to $\mathcal { X } _ { \mathrm { U } } = \{ x _ { i } ^ { \mathrm { U } } \} _ { i = 1 } ^ { n _ { \mathrm { U } } } \sim p ( \pmb { x } )$ a set of U samples drawn from the marginal density . Several effective algorithms have been designed to address this problem. Liu et al. (2002) proposed the S-EM approach that first identifies reliable N data in the $\mathrm { U }$ set and then runs the Expectation-Maximization (EM) algorithm to build the final classifier. The biased support vector machine (Biased SVM) introduced in Liu et al. (2003) regards U samples as $\mathbf { N }$ samples with smaller weights. Mordelet & Vert (2014) solved the PU problem by aggregating classifiers trained to discriminate $\mathrm { \bf P }$ data from a small random subsample of $\mathrm { U }$ data.
+
+More recently, attention has been paid on the unbiased risk estimator proposed in du Plessis et al. (2014) and du Plessis et al. (2015). The key idea is to use the following equality:
+
+$$
+( 1 - \pi ) R _ { \mathrm { N } } ^ { - } ( g ) = R _ { \mathrm { U } } ^ { - } ( g ) - \pi R _ { \mathrm { P } } ^ { - } ( g ) ,
+$$
+
+where $R _ { \mathrm { U } } ^ { - } ( g ) = \mathbb { E } _ { x \sim p ( \mathbf { x } ) } [ \ell ( - g ( \pmb { x } ) ) ]$ and $R _ { \mathrm { P } } ^ { - } ( g ) = \mathbb { E } _ { x \sim p ( x | y = + 1 ) } [ \ell ( - g ( \pmb { x } ) ) ]$ . This equality is acquired by exploiting the fact $p ( \pmb { x } ) = \pi p ( \pmb { x } \mid y = + 1 ) + ( 1 - \pi ) p ( \pmb { x } \mid y = - 1 )$ . As a result, we can approximate the classification risk (1) by
+
+$$
+\hat { R } _ { \mathrm { P U } } ( g ) = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g ) + \hat { R } _ { \mathrm { U } } ^ { - } ( g ) ,
+$$
+
+where $\begin{array} { r } { \hat { R } _ { \mathrm { P } } ^ { - } ( g ) \ = \ \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { P } } ) ) } \end{array}$ and $\begin{array} { r } { \hat { R } _ { \mathrm { U } } ^ { - } ( g ) \ = \ \frac { 1 } { n _ { \mathrm { U } } } \sum _ { i = 1 } ^ { n _ { \mathrm { U } } } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) ) } \end{array}$ . We then minimize $\hat { R } _ { \mathrm { P U } } ( g )$ to obtain another empirical risk minimizer $\hat { g } _ { \mathrm { { P U } } }$ . Note that as the loss is always positive, the classification risk (1) that $\hat { R } _ { \mathrm { P U } } ( g )$ approximates is also positive. However, Kiryo et al. (2017) pointed out that when the model of $g$ is too flexible, that is, when the function class $\mathcal { G }$ is too large, $\hat { R } _ { \mathrm { P U } } ( \hat { g } _ { \mathrm { P U } } )$ indeed goes negative and the model seriously overfits the training data. To alleviate overfitting, the authors observed that $R _ { \mathrm { U } } ^ { - } ( g ) - \pi R _ { \mathrm { P } } ^ { - } ( g ) = ( 1 - \pi ) R _ { \mathrm { N } } ^ { - } ( g ) \geq 0$ and proposed the non-negative risk estimator for PU learning:
+
+$$
+\tilde { R } _ { \mathrm { P U } } ( g ) = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) + \operatorname* { m a x } \{ 0 , \hat { R } _ { \mathrm { U } } ^ { - } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g ) \} .
+$$
+
+In terms of implementation, stochastic optimization was used and when $r = \hat { R } _ { \mathrm { U } } ^ { - } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g )$ becomes negative for a mini-batch, they performed a step of gradient ascent along $\nabla r$ to make the mini-batch less overfitted.
+
+# 2.3 PNU CLASSIFICATION
+
+In semi-supervised learning (PNU classification), P, N and U data are all available. An abundance of works have been dedicated to solving this problem. Here we in particular introduce the PNU risk estimator proposed in Sakai et al. (2017). By directly leveraging U data for risk estimation, it is the most comparable to our method. The PNU risk is simply defined as a linear combination of PN and PU/NU risks. Let us just consider the case where PN and PU risks are combined, then for some $\gamma \in [ 0 , 1 ]$ , the PNU risk estimator is expressed as
+
+$$
+\begin{array} { r l } & { \hat { R } _ { \mathrm { P N U } } ^ { \gamma } ( g ) = \gamma \hat { R } _ { \mathrm { P N } } ( g ) + ( 1 - \gamma ) \hat { R } _ { \mathrm { P U } } ( g ) } \\ & { \qquad = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) + \gamma ( 1 - \pi ) \hat { R } _ { \mathrm { N } } ^ { - } ( g ) + ( 1 - \gamma ) ( \hat { R } _ { \mathrm { U } } ^ { - } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g ) ) . } \end{array}
+$$
+
+We can again consider the non-negative correction by forcing the term $\gamma ( 1 - \pi ) \hat { R } _ { \mathrm { N } } ^ { - } ( g ) + ( 1 -$ $\gamma ) ( \hat { R } _ { \mathrm { U } } ^ { - } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g ) )$ to be non-negative. In the rest of the paper, we refer to the resulting algorithm as non-negative PNU (nnPNU) learning (see Appendix D.4 for an alternative definition of nnPNU and the corresponding results).
+
+# 2.4 PUBN CLASSIFICATION
+
+In this paper, we study the problem of PUbN learning. It differs from usual semi-supervised learning in the fact that labeled $\mathbf { N }$ data are not fully representative of the underlying $_ \mathrm { N }$ distribution $p ( \pmb { x } \mid \pmb { y } =$ $^ { - 1 ) }$ . To take this point into account, we introduce a latent random variable $s$ and consider the joint distribution $p ( { \pmb x } , { \pmb y } , s )$ with constraint $p ( s = + 1 \mid x , y = + 1 ) = 1$ . Equivalently, $p ( y = { \bar { - 1 } } \ |$ $\pmb { x } , s = - 1 ) = 1$ . Let $\rho = p ( y = - 1 , s = + 1 )$ . Both $\pi$ and $\rho$ are assumed known throughout the paper. In practice they often need to be estimated from data (Jain et al., 2016; Ramaswamy et al., 2016; du Plessis et al., 2017). In place of ordinary $\mathbf { N }$ data we collect a set of bN samples
+
+$$
+\begin{array} { r } { \mathcal { X } _ { \mathrm { b N } } = \{ \pmb { x } _ { i } ^ { \mathrm { b N } } \} _ { i = 1 } ^ { n _ { \mathrm { b N } } } \sim p ( \pmb { x } | y = - 1 , s = + 1 ) . } \end{array}
+$$
+
+The goal remains the same: we would like to minimize the classification risk (1).
+
+# 3 METHOD
+
+In this section, we propose a risk estimator for PUbN classification and establish an estimation error bound for the proposed method. Finally we show how our method can be applied to PU learning as a special case when no bN data are available.
+
+# 3.1 RISK ESTIMATOR
+
+Let $R _ { \mathrm { b N } } ^ { - } ( g ) = \mathbb { E } _ { x \sim p ( x | y = - 1 , s = + 1 ) } [ \ell ( - g ( \pmb { x } ) ) ]$ and $R _ { s = - 1 } ^ { - } ( g ) = \mathbb { E } _ { x \sim p ( \pmb { x } | s = - 1 ) } [ \ell ( - g ( \pmb { x } ) ) ]$ . Since p( ${ \pmb x } ) = p ( { \pmb x } , y = + 1 ) + p ( { \pmb x } , y = - 1 , { \pmb s } = + 1 ) + p ( { \pmb x } , { \pmb s } = - 1 )$ , we have
+
+$$
+R ( g ) = \pi R _ { \mathrm { p } } ^ { + } ( g ) + \rho R _ { \mathrm { b N } } ^ { - } ( g ) + ( 1 - \pi - \rho ) R _ { s = - 1 } ^ { - } ( g ) .
+$$
+
+The firswriting $\begin{array} { r } { \hat { R } _ { \mathrm { P } } ^ { + } ( g ) = \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \ell ( g ( \pmb { x } _ { i } ^ { \mathrm { P } } ) ) } \end{array}$ side and $\begin{array} { r } { \hat { R } _ { \mathrm { b N } } ^ { - } ( g ) = \frac { 1 } { n _ { \mathrm { b N } } } \sum _ { i = 1 } ^ { n _ { \mathrm { b N } } } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { b N } } ) ) } \end{array}$ ed directly from data by. We therefore focus on the third term $\bar { R } _ { s = - 1 } ^ { - } ( g ) : = ( 1 - \pi - \rho ) R _ { s = - 1 } ^ { - } ( g )$ . Our approach is mainly based on the following theorem. We relegate all proofs to the appendix.
+
+Theorem 1. Let $\sigma ( { \pmb x } ) = p ( s = + 1 \mid { \pmb x } )$ . For all $\eta \in [ 0 , 1 ]$ and $h : \mathbb { R } ^ { d }  [ 0 , 1 ]$ satisfying the condition $h ( { \pmb x } ) > \eta \Rightarrow \sigma ( { \pmb x } ) > 0$ , the risk $\bar { R } _ { s = - 1 } ^ { - } ( g )$ can be expressed as
+
+$$
+\begin{array} { r l } & { \bar { R } _ { s = - 1 } ^ { - } ( g ) = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ \mathbb { 1 } _ { h ( { \pmb x } ) \leq \eta } \ell ( - g ( { \pmb x } ) ) ( 1 - \sigma ( { \pmb x } ) ) ] } \\ & { \qquad + \pi \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } \mid y = + 1 ) } \left[ \mathbb { 1 } _ { h ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { 1 - \sigma ( { \pmb x } ) } { \sigma ( { \pmb x } ) } \right] } \\ & { \qquad + \rho \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } \mid s = + 1 , y = - 1 ) } \left[ \mathbb { 1 } _ { h ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { 1 - \sigma ( { \pmb x } ) } { \sigma ( { \pmb x } ) } \right] . } \end{array}
+$$
+
+In the theorem, $\bar { R } _ { s = - 1 } ^ { - } ( g )$ is decomposed into three terms, and when the expectation is substituted with the average over training samples, these three terms are approximated respectively using data from $\mathcal { X } _ { \mathrm { U } } , \mathcal { X } _ { \mathrm { P } }$ and $\mathcal { X } _ { \mathrm { b N } }$ . The choice of $h$ and $\eta$ is thus very crucial because it determines what each of the three terms tries to capture in practice. Ideally, we would like $h$ to be an approximation of $\sigma$ . Then, for $_ { \textbf { \em x } }$ such that $h ( { \pmb x } )$ is close to 1, $\sigma ( { \pmb x } )$ is close to 1, so the last two terms on the righthand side of the equation can be reasonably evaluated using $\mathcal { X } _ { \mathrm { P } }$ and $\mathcal { X } _ { \mathrm { b N } }$ (i.e., samples drawn from $p ( { \pmb x } \mid s = + 1 )$ ). On the contrary, if $h ( { \pmb x } )$ is small, $\sigma ( { \pmb x } )$ is small and such samples can be hardly found in $\mathcal { X } _ { \mathrm { P } }$ or $\mathcal { X } _ { \mathrm { b N } }$ . Consequently the first term appeared in the decomposition is approximated with the help of $\mathcal { X } _ { \mathrm { U } }$ . Finally, in the empirical risk minimization paradigm, $\eta$ becomes a hyperparameter that controls how important U data is against $\mathrm { \bf P }$ and bN data when we evaluate $\bar { R } _ { s = - 1 } ^ { - } ( \bar { g } )$ . The larger $\eta$ is, the more attention we would pay to $\mathrm { U }$ data.
+
+One may be curious about why we do not simply approximate the whole risk using only $\mathrm { U }$ samples, that is, set $\eta$ to 1. There are two main reasons. On one hand, if we have a very small U set, which means $n _ { \mathrm { U } } ~ \ll ~ n _ { \mathrm { P } }$ and $n _ { \mathrm { U } } ~ \ll ~ n _ { \mathrm { b N } }$ , approximating a part of the risk with labeled samples should help us reduce the estimation error. This may seem unrealistic but sometimes unbiased $\mathrm { U }$ samples can also be difficult to collect (Ishida et al., 2018). On the other hand, more importantly, we have empirically observed that when the model of $g$ is highly flexible, even a sample regarded as $\mathbf { N }$ with small weight gets classified as $\mathbf { N }$ in the latter stage of training and performance of the resulting classifier can thus be severely degraded. Introducing $\eta$ alleviates this problem by avoiding treating all $\mathrm { U }$ data as $\mathbf { N }$ samples.
+
+As $\sigma$ is not available in reality, we propose to replace $\sigma$ by its estimate $\hat { \sigma }$ in (6). We further substitute $h$ with the same estimate and obtain the following expression:
+
+$$
+\begin{array} { r l } & { \bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) \leq \eta } \ell ( - g ( { \pmb x } ) ) ( 1 - \hat { \sigma } ( { \pmb x } ) ) ] } \\ & { \qquad + \pi \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } \mid { \pmb y } = + 1 ) } \left[ \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { 1 - \hat { \sigma } ( { \pmb x } ) } { \hat { \sigma } ( { \pmb x } ) } \right] } \\ & { \qquad + \rho \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } \mid { s = + 1 , \pmb y } = - 1 ) } \left[ \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { 1 - \hat { \sigma } ( { \pmb x } ) } { \hat { \sigma } ( { \pmb x } ) } \right] . } \end{array}
+$$
+
+We notice that $\bar { R } _ { s = - 1 , \eta , \hat { \sigma } }$ depends both on $\eta$ and $\hat { \sigma }$ . It can be directly approximated from data by
+
+$$
+\begin{array} { r l } & { \hat { R } _ { s = - 1 , \eta , \hat { \sigma } } ( g ) = \displaystyle \frac { 1 } { n _ { \mathrm { U } } } \sum _ { i = 1 } ^ { n _ { \mathrm { U } } } \Big [ \mathbb { 1 } _ { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) \leq \eta } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) ) ( 1 - \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) ) \Big ] } \\ & { \quad \quad \quad \quad \quad + \displaystyle \frac { \pi } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \bigg [ \mathbb { 1 } _ { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { P } } ) > \eta } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { P } } ) ) \frac { 1 - \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { P } } ) } { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { P } } ) } \bigg ] } \\ & { \quad \quad \quad \quad \quad + \displaystyle \frac { \rho } { n _ { \mathrm { b N } } } \sum _ { i = 1 } ^ { n _ { \mathrm { b N } } } \bigg [ \mathbb { 1 } _ { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { b N } } ) > \eta } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { b N } } ) ) \frac { 1 - \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { b N } } ) } { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { b N } } ) } ) \bigg ] . } \end{array}
+$$
+
+We are now able to derive the empirical version of Equation (5) as
+
+$$
+\begin{array} { r } { \hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g ) = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) + \rho \hat { R } _ { \mathrm { b N } } ^ { - } ( g ) + \hat { \bar { R } } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) . } \end{array}
+$$
+
+Estimating $\sigma$ If we regard $s$ as a class label, the problem of estimating $\sigma$ is then equivalent to training a probabilistic classifier separating the classes with $s = + 1$ and $s = - 1$ . Observing that ( $\begin{array} { r } { \pi + \bar { \rho } ) \mathbb { E } _ { \alpha \sim p ( x | s = + 1 ) } ^ { - } [ \ell ( \epsilon g ( x ) ) ] = \bar { \pi } \mathbb { E } _ { \alpha \sim p ( x | y = + 1 ) } [ \ell ( \epsilon g ( x ) ) ] + \rho \mathbb { E } _ { \alpha \sim p ( x | y = - 1 , s = + 1 ) } [ \ell ( \epsilon g ( x ) ) ] } \end{array}$ for $\epsilon \in \{ + 1 , - 1 \}$ , it is straightforward to apply nnPU learning with availability of $\mathcal { X } _ { \mathrm { P } }$ , $\mathcal { X } _ { \mathrm { b N } }$ and $\mathcal { X } _ { \mathrm { U } }$ to minimize $\mathbb { E } _ { ( \pmb { x } , s ) \sim p ( \pmb { x } , s ) } [ \ell ( s g ( \pmb { x } ) ) ]$ . In other words, here we regard $\mathcal { X } _ { \mathrm { P } }$ and $\mathcal { X } _ { \mathrm { b N } }$ as $\mathrm { \bf P }$ and $\mathcal { X } _ { \mathrm { U } }$ as U, and attempt to solve a PU learning problem by applying nnPU. Since we are interested in the classposterior probabilities, we minimize the risk with respect to the logistic loss and apply the sigmoid function to the output of the model to get $\hat { \sigma } ( { \pmb x } )$ . However, the above risk estimator accepts any reasonable $\hat { \sigma }$ and we are not limited to using nnPU for computing $\hat { \sigma }$ . For example, the least-squares fitting approach proposed in Kanamori et al. (2009) for direct density ratio estimation can also be adapted to solving the problem.
+
+# 3.2 ESTIMATION ERROR BOUND
+
+Here we establish an estimation error bound for the proposed method. Let $\mathcal { G }$ be the function class from which we find a function. The Rademacher complexity of $\mathcal { G }$ for the samples of size $n$ drawn from $q ( { \pmb x } )$ is defined as
+
+$$
+\mathfrak { R } _ { n , q } ( \mathcal { G } ) = \mathbb { E } _ { \mathcal { X } \sim q ^ { n } } \mathbb { E } _ { \theta } \left[ \operatorname* { s u p } _ { g \in \mathcal { G } } \frac { 1 } { n } \sum _ { x _ { i } \in \mathcal { X } } \theta _ { i } g ( \pmb { x } _ { i } ) \right] ,
+$$
+
+where $\mathcal { X } ~ = ~ \{ \pmb { x } _ { 1 } , \ldots , \pmb { x } _ { n } \}$ and $\theta ~ = ~ \{ \theta _ { 1 } , \ldots , \theta _ { n } \}$ with each $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ drawn from $q ( { \pmb x } )$ and $\theta _ { i }$ as a Rademacher variable (Mohri et al., 2012). In the following we will assume that $\mathfrak { R } _ { n , q } ( \mathcal { G } )$ vanishes asymptotically as $n \to \infty$ . This holds for most of the common choices of $\mathcal { G }$ if proper regularization is considered (Bartlett & Mendelson, 2002; Golowich et al., 2018). Assume additionally the existence of $C _ { g } > 0$ such that $\mathrm { s u p } _ { g \in { \mathcal { G } } } \| g \| _ { \infty } \leq C _ { g }$ as well as $C _ { \ell } > 0$ such that $\begin{array} { r } { \operatorname* { s u p } _ { | z | \leq C _ { g } } \hat { \ell } ( z ) \leq C _ { \ell } } \end{array}$ . We also assume that $\ell$ is Lipschitz continuous on the interval $[ - C _ { g } , C _ { g } ]$ with a Lipschitz constant $L _ { \ell }$ .
+
+Theorem 2. Let $\begin{array} { r l r } { g ^ { * } } & { { } = } & { \arg \operatorname* { m i n } _ { g \in { \mathcal G } } R ( g ) } \end{array}$ be the true risk minimizer and $\begin{array} { r l } { \hat { g } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } } & { { } = } \end{array}$ a $\begin{array} { r } { \operatorname { r g m i n } _ { g \in \mathcal { G } } \hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g ) } \end{array}$ be the PUbN empirical risk minimizer. We suppose that $\hat { \sigma }$ is a fixed function independent of data used to compute $\hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g )$ and $\eta \in ( 0 , 1 ]$ . Denote by $p _ { \mathrm { P } } ( { \pmb x } ) = p ( { \pmb x } \mid$ $y = + 1$ ) and $p _ { \mathrm { b N } } ( { \pmb x } ) = p ( { \pmb x } \mid y = - 1 , s = + 1 )$ the $P$ and bN marginals. Let $\zeta = p ( \boldsymbol { \hat { \sigma } } ( \pmb { x } ) \leq \eta )$ and $\epsilon = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | ^ { 2 } ]$ . Then for any $\delta > 0$ , with probability at least $1 - \delta$ ,
+
+$$
+\begin{array} { r l } & { R ( \hat { g } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ) - R ( g ^ { * } ) } \\ & { \quad \le 4 L _ { l } \mathfrak R _ { n _ { \mathrm { U } } , p } ( \mathcal { G } ) + \frac { 4 \pi L _ { l } } \eta \mathfrak R _ { n _ { \mathrm { P } } , p _ { \mathrm { P } } } ( \mathcal { G } ) + \frac { 4 \rho L _ { l } } \eta \mathfrak R _ { n _ { \mathrm { b N } } , p _ { \mathrm { b N } } } ( \mathcal { G } ) } \\ & { \qquad + 2 C _ { l } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { U } } } } + \frac { 2 \pi C _ { l } } \eta \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { P } } } } + \frac { 2 \rho C _ { l } } \eta \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { b N } } } } + 2 C _ { l } \sqrt { \zeta } \epsilon + \frac { 2 C _ { l } } \eta \sqrt { ( 1 - \zeta ) } \epsilon . } \end{array}
+$$
+
+Theorem 2 shows that as $n _ { \mathrm { P } }  \infty$ , $n _ { \mathrm { b N } }  \infty$ and $n _ { \mathrm { U } }  \infty$ , we have $R ( \hat { g } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ) - R ( g ^ { * } ) $ $2 C _ { l } \sqrt { \zeta \epsilon } + 2 ( C _ { l } / \eta ) \sqrt { ( 1 - \zeta ) \epsilon }$ . Furthermore, if there is $C _ { \mathcal { G } } ~ > ~ 0$ such that $\Re _ { n , q } ( { \mathcal { G } } ) \leq C \varsigma / \sqrt { n }$ 2, the convergence rate is $\mathcal { O } _ { p } ( 1 / \sqrt { n _ { \mathrm { P } } } + 1 / \sqrt { n _ { \mathrm { b N } } } + 1 / \sqrt { n _ { \mathrm { U } } } )$ , where $\mathcal { O } _ { p }$ denotes the order in probability. As for $\epsilon$ , knowing that $\hat { \sigma }$ is also estimated from data in practice 3, apparently its value depends on both the estimation algorithm and the number of samples that are involved in the estimation process. For example, in our approach we applied nnPU with the logistic loss to obtain $\hat { \sigma }$ , so the excess risk can be written as $\mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } \mathrm { K L } ( { \bf \bar { \sigma } } ( { \pmb x } ) | | { \hat { \sigma } } ( { \pmb x } ) )$ , where by abuse of notation $\operatorname { K L } ( p | | q ) = p \ln ( p / q ) + ( 1 - p ) \ln ( ( 1 - p ) / ( 1 - q ) )$ denotes the KL divergence between two Bernouilli distributions with parameters respectively $p$ and $q$ . It is known that $\epsilon = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | ^ { 2 } ] \leq$ $( 1 / 2 ) \mathbb { E } _ { \pmb { x } \sim p ( \pmb { x } ) } \mathrm { K L } ( \sigma ( \pmb { x } ) | | \hat { \sigma } ( \pmb { x } ) )$ (Zhang, 2004). The excess risk itself can be decomposed into the sum of the estimation error and the approximation error. Kiryo et al. (2017) showed that under mild assumptions the estimation error part converges to zero when the sample size increases to infinity in nnPU learning. It is however impossible to get rid of the approximation error part which is fixed once we fix the function class $\mathcal { G }$ . To circumvent this problem, we can either resort to kernel-based methods with universal kernels (Zhang, 2004) or simply enlarge the function class when we get more samples.
+
+# 3.3 PU LEARNING REVISITED
+
+In PU learning scenarios, we only have $\mathrm { \bf P }$ and $\mathrm { U }$ data and bN data are not available. Nevertheless, if we let $y$ play the role of $s$ and ignore all the terms related to bN data, our algorithm is naturally applicable to PU learning. Let us name the resulting algorithm PUbN\N, then
+
+$$
+\hat { R } _ { \mathrm { P U b N } \setminus \mathbb { N } , \eta , \hat { \sigma } } ( g ) = \pi \hat { R } _ { \mathrm { P } } ^ { + } ( g ) + \hat { \bar { R } } _ { y = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) ,
+$$
+
+where $\hat { \sigma }$ is an estimate of $p ( y = + 1 \mid x )$ and
+
+$$
+\begin{array} { r } { \bar { R } _ { y = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) = \mathbb { E } _ { x \sim p ( x ) } \bigl [ \mathbb { I } _ { \hat { \sigma } ( x ) \leq \eta } \ell ( - g ( \pmb { x } ) ) ( 1 - \hat { \sigma } ( \pmb { x } ) ) \bigr ] + \pi \mathbb { E } _ { x \sim p ( x \mid y = + 1 ) } \left[ \mathbb { I } _ { \hat { \sigma } ( \pmb { x } ) > \eta } \ell ( - g ( \pmb { x } ) ) \frac { 1 - \hat { \sigma } ( \pmb { x } ) } { \hat { \sigma } ( \pmb { x } ) } \right] . } \end{array}
+$$
+
+PUbN\N can be viewed as a variant of the traditional two-step approach in PU learning which first identifies possible $\mathbf { N }$ data in $\mathrm { U }$ data and then perform ordinary PN classification to distinguish P data from the identified $_ \mathrm { N }$ data. However, being based on state-of-the-art nnPU learning, our method is more promising than other similar algorithms. Moreover, by explicitly considering the posterior $p ( y = \bar { + } 1 \mid x )$ , we attempt to correct the bias induced by the fact of only taking into account confident negative samples. The benefit of using an unbiased risk estimator is that the resulting algorithm is always statistically consistent, i.e., the estimation error converges in probability to zero as the number of samples grows to infinity.
+
+# 4 EXPERIMENTS
+
+In this section, we experimentally investigate the proposed method and compare its performance against several baseline methods.
+
+# 4.1 BASIC SETUP
+
+We focus on training neural networks with stochastic optimization. For simplicity, in an experiment, $\hat { \sigma }$ and $g$ always use the same model and are trained for the same number of epochs. All models are learned using AMSGrad (Reddi et al., 2018) as the optimizer and the logistic loss as the surrogate loss unless otherwise specified. To determine the value of $\eta$ , we introduce another hyperparameter $\tau$ and choose $\eta$ such that $\# \{ x \in \mathcal { X } _ { \mathrm { U } } \mid \hat { \sigma } ( x ) \leq \eta \} = \tau ( 1 - \pi - \rho ) n _ { \mathrm { U } }$ . In all the experiments, an additional validation set, equally composed of P, U and bN data, is sampled for both hyperparameter tuning and choosing the model parameters with the lowest validation loss among those obtained after every epoch. Regarding the computation of the validation loss, we use the PU risk estimator (2) with the sigmoid loss for $g$ and an empirical approximation of $\mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | ^ { 2 } ] - \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ \sigma ( { \pmb x } ) ^ { 2 } ]$ for $\hat { \sigma }$ (see Appendix B).
+
+# 4.2 EFFECTIVENESS OF THE ALGORITHM
+
+We assess the performance of the proposed method on three benchmark datasets: MNIST, CIFAR-10 and 20 Newsgroups. Experimental details are given in Appendix C. In particular, since all the three datasets are originally designed for multiclass classification, we group different categories together to form a binary classification problem.
+
+Baselines. When $\mathcal { X } _ { \mathrm { b N } }$ is given, two baseline methods are considered. The first one is nnPNU adapted from (4). In the second method, named as $\mathrm { P U } \to \mathrm { P N }$ , we train two binary classifiers: one is learned with nnPU while we regard $s$ as the class label, and the other is learned from $\mathcal { X } _ { \mathrm { P } }$ and $\mathcal { X } _ { \mathrm { b N } }$ to separate $\mathrm { \bf P }$ samples from bN samples. A sample is classified in the $\mathrm { \bf P }$ class only if it is so classified by the two classifiers. When $\mathcal { X } _ { \mathrm { b N } }$ is not available, nnPU is compared with the proposed PUbN\N.
+
+Sampling bN Data To sample $\mathcal { X } _ { \mathrm { b N } }$ , we suppose that the bias of N data is caused by a latent prior probability change (Sugiyama & Storkey, 2007; Hu et al., 2018) in the $\mathbf { N }$ class. Let $z \in \mathcal { Z } : =$
+
+Table 1: Mean and standard deviation of misclassification rates over 10 trials for MNIST, CIFAR-10 and 20 Newsgroups under different choices of $\mathrm { \bf P }$ class and bN data sampling strategies. For a same learning task, different methods are compared using the same 10 random samplings. Underlines denote that with the use of bN data the method leads to an improvement of performance according to the $5 \%$ t-test. Boldface indicates the best method in each task.
+
+† Biased N data uniformly sampled from the indicated latent categories.
+
+⋆ Probabilities that a sample of $\mathcal { X } _ { \mathrm { b N } }$ belongs to the latent categories [1, 3, 5, 7, 9] / [bird, cat, deer, dog, frog, horse] / [sci., soc., talk.] are [0.03, 0.15, 0.3, 0.02, 0.5] / [0.1, 0.02, 0.2, 0.08, 0.2, 0.4] / [0.1, 0.5, 0.4].
+
+<table><tr><td>Dataset</td><td>P</td><td>biased N</td><td>p</td><td>nnPU/nnPNU</td><td>PUbN(\N)</td><td>PU→PN</td></tr><tr><td rowspan="3">MNIST</td><td rowspan="3">2,4,6,8,10</td><td>Not given</td><td>NA</td><td>5.76 ± 1.04</td><td>4.64±0.62</td><td>NA</td></tr><tr><td>1,3,5</td><td>0.3</td><td>5.33 ± 0.97</td><td>4.05 ± 0.27</td><td>4.00 ±0.30</td></tr><tr><td>9&gt;5&gt;others *</td><td>0.2</td><td>4.60 ± 0.65</td><td>3.91 ± 0.66</td><td>3.77 ± 0.31</td></tr><tr><td rowspan="3">CIFAR-10</td><td rowspan="3">Airplane, automobile, ship, truck</td><td>Not given</td><td>NA</td><td>12.02 ± 0.65</td><td>10.70 ± 0.57</td><td>NA</td></tr><tr><td>Cat, dog, horse † Horse &gt; deer</td><td>0.3</td><td>10.25 ± 0.38</td><td>9.71 ± 0.51</td><td>10.37 ± 0.65</td></tr><tr><td>= frog &gt; others *</td><td>0.25</td><td>9.98 ± 0.53</td><td>9.92 ±0.42</td><td>10.17 ± 0.35</td></tr><tr><td rowspan="3">CIFAR-10</td><td rowspan="3">Cat, deer, dog, horse</td><td>Not given</td><td>NA</td><td>23.78 ± 1.04</td><td>21.13 ±0.90</td><td>NA</td></tr><tr><td>Bird,frogt</td><td>0.2</td><td>22.00 ± 0.53</td><td>18.83± 0.71</td><td>19.88 ± 0.62</td></tr><tr><td>Car, truck t</td><td>0.2</td><td>22.00±0.74</td><td>20.19 ± 1.06</td><td>21.83 ± 1.36</td></tr><tr><td rowspan="4">20 Newsgroups</td><td rowspan="4">alt., comp., misc., rec.</td><td>Not given</td><td>NA</td><td>14.67 ± 0.87</td><td>13.30 ± 0.53</td><td>NA</td></tr><tr><td>sci.t</td><td>0.21</td><td>14.69 ± 0.46</td><td>13.10±0.90</td><td>13.58 ± 0.97</td></tr><tr><td>talk.t</td><td>0.17</td><td>14.38 ± 0.74</td><td>12.61 ± 0.75</td><td>13.76 ± 0.66</td></tr><tr><td>soc. &gt; talk. &gt; sci.*</td><td>0.1</td><td>14.41 ± 0.76</td><td>12.18± 0.59</td><td>12.92 ± 0.51</td></tr></table>
+
+$\{ 1 , \ldots , S \}$ be some latent variable which we call a latent category, where $S$ is a constant. It is assumed
+
+$$
+\begin{array} { c } { { p ( { \pmb x } \mid z , y = - 1 ) = p ( { \pmb x } \mid z , y = - 1 , s = + 1 ) , } } \\ { { p ( z \mid y = - 1 ) \not = p ( z \mid y = - 1 , s = + 1 ) . } } \end{array}
+$$
+
+In the experiments, the latent categories are the original class labels of the datasets. Concrete definitions of $\mathcal { X } _ { \mathrm { b N } }$ with experimental results are summarized in Table 1.
+
+Results. Overall, our proposed method consistently achieves the best or comparable performance in all the scenarios, including those of standard PU learning. Additionally, using bN data can effectively help improving classification performance. However, the choice of algorithm is essential. Both nnPNU and the naive $\mathrm { P U } \to \mathrm { P N }$ are able to leverage bN data to enhance classification accuracy in only relatively few tasks. In the contrast, the proposed PUbN successfully reduce the misclassification error most of the time.
+
+Clearly, the performance gain that we can benefit from the availability of bN data is case-dependent. On CIFAR-10, the greatest improvement is achieved when we regard mammals (i.e. cat, deer, dog and horse) as $\mathrm { \bf P }$ class and drawn samples from latent categories bird and frog as labeled negative data. This is not surprising because birds and frogs are more similar to mammals than vehicles, which makes the classification harder specifically for samples from these two latent categories. By explicitly labeling these samples as $_ \mathrm { N }$ data, we allow the classifier to make better predictions for these difficult samples.
+
+# 4.3 THE PRESENCE OF BN DATA HELPS: AN ILLUSTRATION
+
+Through experiments we have demonstrated that the presence of bN data effectively helps learning a better classifier. Here we would like to provide some intuition for the reason behind this. Let us consider the MNIST learning task where $\mathcal { X } _ { \mathrm { b N } }$ is uniformly sampled from the latent categories 1, 3 and 5. We project the representations learned by the classifier (i.e., the activation values of the last layer of the neural network) into a 2D plane using PCA for both nnPU and PUbN algorithms.
+
+![](images/040b3ac911910187bc1797c52cc052648df1ec84ffcf693f2a44712308124cfb.jpg)  
+Figure 1: PCA embeddings of the representations learned by the nnPU and PUbN classifiers for 500 samples from the test set in the MNIST learning task where $\mathcal { X } _ { \mathrm { b n } }$ is uniformly sampled from latent categories 1, 3 and 5.
+
+The results are shown in Figure 1. Since for both nnPU and PUbN classifiers, the first two principal components account around $90 \%$ of variance, we believe that this figure depicts fairly well the learned representations. Thanks to the use of bN data, in the high-level feature space 1, 3, 5 and P data are further pushed away when we employ the proposed PUbN learning algorithm, and we are always able to separate 7, 9 from P to some extent. This explains the better performance which is achieved by PUbN learning and the benefit of incorporating bN data into the learning process.
+
+# 5 CONCLUSION
+
+This paper studied the PUbN classification problem, where a binary classifier is trained on P, U and bN data. The proposed method is a two-step approach inspired from both PU learning and importance weighting. The key idea is to attribute appropriate weights to each example to evaluate the classification risk using the three sets of data. We theoretically established an estimation error bound for the proposed risk estimator and experimentally showed that our approach successfully leveraged bN data to improve the classification performance on several real-world datasets. A variant of our algorithm was able to achieve state-of-the-art results in PU learning.
+
+# REFERENCES
+
+P. L. Bartlett and S. Mendelson. Rademacher and gaussian complexities: Risk bounds and structural results. Journal of Machine Learning Research, 3(Nov):463–482, 2002.   
+M. Belkin, P. Niyogi, and V. Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. Journal of Machine Learning Research, 7(Nov): 2399–2434, 2006.   
+O. Chapelle, B. Schlkopf, and A. Zien. Semi-Supervised Learning. The MIT Press, 1st edition, 2010.   
+M. du Plessis, G. Niu, and M. Sugiyama. Convex formulation for learning from positive and unlabeled data. In International Conference on Machine Learning (ICML), pp. 1386–1394, 2015.   
+M. C. du Plessis, G. Niu, and M. Sugiyama. Analysis of learning from positive and unlabeled data. In Advances in Neural Information Processing Systems (NIPS), pp. 703–711, 2014.   
+M. C. du Plessis, G. Niu, and M. Sugiyama. Class-prior estimation for learning from positive and unlabeled data. Maching Learning, 106(4):463–492, April 2017. ISSN 0885-6125.   
+C. Elkan and K. Noto. Learning classifiers from only positive and unlabeled data. In KDD, 2008.   
+G. Fei and B. Liu. Social media text classification under negative covariate shift. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 2347–2356, 2015.
+
+G. P. C. Fung, J. X. Yu, H. Lu, and P. S. Yu. Text classification without negative examples revisit. IEEE transactions on Knowledge and Data Engineering, 18(1):6–20, 2006.
+
+N. Golowich, A. Rakhlin, and O. Shamir. Size-independent sample complexity of neural networks. In Conference On Learning Theory, pp. 297–299, 2018.
+
+Y. Grandvalet and Y. Bengio. Semi-supervised learning by entropy minimization. In Advances in Neural Information Processing Systems (NIPS), pp. 529–536, 2005.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision (ECCV), pp. 630–645. Springer, 2016.
+
+J. J. Heckman. Sample selection bias as a specification error. Econometrica, 47(1):153–161, 1979.
+
+S. Hido, Y. Tsuboi, H. Kashima, M. Sugiyama, and T. Kanamori. Inlier-based outlier detection via direct density ratio estimation. In Proceedings of IEEE International Conference on Data Mining (ICDM), pp. 223–232. IEEE, 2008.
+
+W. Hu, G. Niu, I. Sato, and M. Sugiyama. Does distributionally robust supervised learning give robust classifiers? In International Conference on Machine Learning (ICML), pp. 2034–2042, 2018.
+
+J. Huang, A. Gretton, K. M. Borgwardt, B. Scholkopf, and A. J. Smola. Correcting sample selection ¨ bias by unlabeled data. In Advances in Neural Information Processing Systems (NIPS), pp. 601– 608, 2007.
+
+T. Ishida, G. Niu, and M. Sugiyama. Binary classification from positive-confidence data. arXiv preprint arXiv:1710.07138, 2018.
+
+S. Jain, M. White, and P. Radivojac. Estimating the class prior and posterior from noisy positives and unlabeled data. In Advances in Neural Information Processing Systems (NIPS), pp. 2693–2701, 2016.
+
+T. Kanamori, S. Hido, and M. Sugiyama. A least-squares approach to direct importance estimation. Journal of Machine Learning Research, 10:1391–1445, 2009.
+
+R. Kiryo, G. Niu, M. C. du Plessis, and M. Sugiyama. Positive-unlabeled learning with non-negative risk estimator. In Advances in Neural Information Processing Systems (NIPS), pp. 1675–1685, 2017.
+
+S. Laine and T. Aila. Temporal ensembling for semi-supervised learning. In International Conference on Learning Representations (ICLR), 2017.
+
+W. Li, Q. Guo, and C. Elkan. A positive and unlabeled learning algorithm for one-class classification of remote-sensing data. IEEE Transactions on Geoscience and Remote Sensing, 49(2):717–725, 2011.
+
+X.-L. Li, B. Liu, and S.-K. Ng. Negative training data can be harmful to text classification. In Proceedings of the 2010 Conference on Empirical Methods in Natural Language Processing, pp. 218–228, 2010.
+
+B. Liu, W. S. Lee, P. S. Yu, and X. Li. Partially supervised classification of text documents. In International Conference on Machine Learning (ICML), volume 2, pp. 387–394, 2002.
+
+B. Liu, Y. Dai, X. Li, W. S. Lee, and P. S. Yu. Building text classifiers using positive and unlabeled examples. In Proceedings of IEEE International Conference on Data Mining (ICDM), pp. 179– 186. IEEE, 2003.
+
+T. Miyato, S.-i. Maeda, M. Koyama, K. Nakae, and S. Ishii. Distributional smoothing with virtual adversairal training. In International Conference on Learning Representations (ICLR), 2016.
+
+M. Mohri, A. Rostamizadeh, and A. Talwalkar. Foundations of machine learning. MIT press, 2012.
+
+F. Mordelet and J.-P. Vert. A bagging svm to learn from positive and unlabeled examples. Pattern Recognition Letters, 37:201–209, 2014.
+
+M. N. Nguyen, X.-L. Li, and S.-K. Ng. Positive unlabeled leaning for time series classification. In IJCAI, volume 11, pp. 1421–1426, 2011.   
+A. Oliver, A. Odena, C. Raffel, E. D. Cubuk, and I. J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. arXiv preprint arXiv:1804.09170, 2018.   
+M. E. Peters, M. Neumann, M. Iyyer, M. Gardner, C. Clark, K. Lee, and L. Zettlemoyer. Deep contextualized word representations. In Proc. of NAACL, 2018.   
+J. Quionero-Candela, M. Sugiyama, A. Schwaighofer, and N. D. Lawrence. Dataset shift in machine learning. 2009.   
+H. Ramaswamy, C. Scott, and A. Tewari. Mixture proportion estimation via kernel embeddings of distributions. In International Conference on Machine Learning (ICML), pp. 2052–2060, 2016.   
+S. J. Reddi, S. Kale, and S. Kumar. On the convergence of adam and beyond. In International Conference on Learning Representations (ICLR), 2018.   
+A. Ruckl ¨ e, S. Eger, M. Peyrard, and I. Gurevych. Concatenated -mean word embeddings as universal ´ cross-lingual sentence representations. arXiv preprint arXiv:1803.01400, 2018.   
+T. Sakai, M. C. d. du Plessis, G. Niu, and M. Sugiyama. Semi-supervised classification based on classification from positive and unlabeled data. In International Conference on Machine Learning (ICML), volume 70, pp. 2998–3006, 2017.   
+C. Scott and G. Blanchard. Novelty detection: Unlabeled data definitely help. In Artificial Intelligence and Statistics, pp. 464–471, 2009.   
+S. Shalev-Shwartz and S. Ben-David. Understanding Machine Learning: From Theory to Algorithms. Cambridge University Press, 2014.   
+H. Shimodaira. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.   
+M. Sugiyama and M. Kawanabe. Machine Learning in Non-Stationary Environments: Introduction to Covariate Shift Adaptation. MIT Press, Cambridge, Massachusetts, USA, 2012.   
+M. Sugiyama and A. J. Storkey. Mixture regression for covariate shift. In Advances in Neural Information Processing Systems (NIPS), pp. 1337–1344, 2007.   
+M. Sugiyama, S. Nakajima, H. Kashima, P. V. Buenau, and M. Kawanabe. Direct importance estimation with model selection and its application to covariate shift adaptation. In Advances in Neural Information Processing Systems (NIPS), pp. 1433–1440, 2008.   
+G. A. Ward, T. J. Hastie, S. T. Barry, J. Elith, and J. R. Leathwick. Presence-only data and the em algorithm. Biometrics, 65 2:554–63, 2009.   
+B. Zadrozny. Learning and evaluating classifiers under sample selection bias. In International Conference on Machine learning (ICML), pp. 903–910, 2004.   
+T. Zhang. Statistical behavior and consistency of classification methods based on convex risk minimization. Annals of Statistics, pp. 56–85, 2004.   
+M. Zuluaga, D. Hush, E. J F Delgado Leyton, M. Hernandez Hoyos, and M. Orkisz. Learning from only positive and unlabeled data to detect lesions in vascular ct images. In Medical image computing and computer-assisted intervention – MICCAI 2011, volume LNCS 6893, pp. 9–16, 2011.
+
+APPENDIX
+
+A PROOFS
+
+# A.1 PROOF OF THEOREM 1
+
+We notice that $( 1 - \pi - \rho ) p ( { \pmb x } \mid s = - 1 ) = p ( { \pmb x } , s = - 1 )$ and that when $h ( \pmb { x } ) > \eta$ , we have $p ( s = + 1 \mid \pmb { x } ) = \sigma ( \pmb { x } ) > 0$ , which allows us to write $p ( s = - 1 \mid x ) = ( p ( s = - 1 \mid x ) / p ( s =$ $+ 1 \mid { \pmb x } ) ) p ( s = + 1 \mid { \pmb x } )$ . We can thus decompose $\bar { R } _ { s = - 1 } ^ { - } ( \bar { g } )$ as following:
+
+$$
+\begin{array} { r l } {  { \bar { R } _ { s = - 1 } ^ { - } ( g ) = \int \ell ( - g ( x ) ) p ( x , s = - 1 ) d x } } \\ & { = \int 1 _ { h ( x ) \leq \eta } \ell ( - g ( x ) ) p ( x , s = - 1 ) d x } \\ & { \quad + \int 1 _ { h ( x ) > \eta } \ell ( - g ( x ) ) p ( x , s = - 1 ) d x } \\ & { = \int 1 _ { h ( x ) \leq \eta } \ell ( - g ( x ) ) \frac { p ( x , s = - 1 ) } { p ( x ) } p ( x ) d x } \\ & { \quad + \int 1 _ { h ( x ) > \eta } \ell ( - g ( x ) ) \frac { p ( x , s = - 1 ) } { p ( x , s = + 1 ) } p ( x , s = + 1 ) d x . } \end{array}
+$$
+
+By writing $p ( { \pmb x } , s = - 1 ) = p ( s = - 1 \mid { \pmb x } ) p ( { \pmb x } ) = ( 1 - \sigma ( { \pmb x } ) ) p ( { \pmb x } )$ and $p ( \pmb { x } , s = + 1 ) = p ( s =$ $+ 1 \mid x ) p ( x ) = \sigma ( { \pmb x } ) p ( { \pmb x } )$ , we have
+
+$$
+\begin{array} { l } { \displaystyle \bar { R } _ { s = - 1 } ^ { - } ( g ) = \int \mathbb { 1 } _ { h ( \pmb { x } ) \leq \eta } \ell ( - g ( \pmb { x } ) ) ( 1 - \sigma ( \pmb { x } ) ) p ( \pmb { x } ) d x } \\ { \displaystyle \qquad + \int \mathbb { 1 } _ { h ( \pmb { x } ) > \eta } \ell ( - g ( \pmb { x } ) ) \frac { 1 - \sigma ( \pmb { x } ) } { \sigma ( \pmb { x } ) } p ( \pmb { x } , s = + 1 ) d x . } \end{array}
+$$
+
+We obtain Equation (6) after replacing $p ( \pmb { x } , s = + 1 )$ by $\pi p ( x \mid y = + 1 ) + \rho p ( x \mid y = - 1 , s = + 1 )$ .
+
+# A.2 PROOF OF THEOREM 2
+
+For $\hat { \sigma }$ and $\eta$ given, let us define
+
+$$
+R _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g ) = \pi R _ { \mathrm { P } } ^ { + } ( g ) + \rho R _ { \mathrm { b N } } ^ { - } ( g ) + \bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) .
+$$
+
+The following lemma establishes the uniform deviation bound from $\hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$ to $R _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$
+
+Lemma 1. Let $\hat { \sigma } : \mathbb { R } ^ { d }  [ 0 , 1 ]$ be a fixed function independent of data used to compute $\hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$ and $\eta \in ( 0 , 1 ]$ . For any $\delta > 0$ , with probability at least $1 - \delta$ ,
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { s u p } _ { g \in \mathcal { G } } \vert \hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ^ { - } ( g ) - R _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g ) \vert } \\ { \displaystyle \quad \leq 2 L _ { l } \mathfrak { R } _ { n _ { \mathrm { U } } , p } ( \mathcal { G } ) + \frac { 2 \pi L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { P } } , p _ { \mathrm { P } } } ( \mathcal { G } ) + \frac { 2 \rho L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { b N } } , p _ { \mathrm { b N } } } ( \mathcal { G } ) } \\ { \displaystyle \quad + C _ { l } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { U } } } } + \frac { \pi C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { P } } } } + \frac { \rho C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { b N } } } } . } \end{array}
+$$
+
+Proof. For ease of notation, let
+
+$$
+R _ { \mathrm { P } } ( g ) = \mathbb { E } _ { { \pmb x } \sim p _ { \mathrm { P } } ( { \pmb x } ) } \left[ \ell ( g ( { \pmb x } ) ) + \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { 1 - \hat { \sigma } ( { \pmb x } ) } { \hat { \sigma } ( { \pmb x } ) } \right] ,
+$$
+
+$$
+R _ { \mathrm { b N } } ( g ) = \mathbb { E } _ { { \pmb x } \sim p _ { \mathrm { b N } } ( \pmb x ) } \left[ \ell ( - g ( { \pmb x } ) ) ( 1 + \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } \frac { 1 - \hat { \sigma } ( { \pmb x } ) } { \hat { \sigma } ( { \pmb x } ) } ) \right] ,
+$$
+
+$$
+R _ { \mathrm { U } } ( g ) = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } \left[ \mathbb { 1 } _ { \hat { \pmb \sigma } ( { \pmb x } ) \leq \eta } \ell ( - g ( { \pmb x } ) ) ( 1 - \hat { \pmb \sigma } ( { \pmb x } ) ) \right] ,
+$$
+
+$$
+\hat { R } _ { \mathrm { P } } ( g ) = \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \left[ \ell ( g ( \pmb { x } _ { i } ^ { \mathrm { P } } ) ) + \mathbb { 1 } _ { \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { P } } ) > \eta } \ell ( - g ( \pmb { x } _ { i } ^ { \mathrm { P } } ) ) \frac { 1 - \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { P } } ) } { \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { P } } ) } \right] ,
+$$
+
+$$
+\hat { R } _ { \mathrm { b N } } ( g ) = \frac { 1 } { n _ { \mathrm { b N } } } \sum _ { i = 1 } ^ { n _ { \mathrm { b N } } } \left[ \ell ( - g ( \boldsymbol x _ { i } ^ { \mathrm { b N } } ) ) ( 1 + \mathbb I _ { \hat { \sigma } ( \boldsymbol x _ { i } ^ { \mathrm { b N } } ) > \eta } \frac { 1 - \hat { \sigma } ( \boldsymbol x _ { i } ^ { \mathrm { b N } } ) } { \hat { \sigma } ( \boldsymbol x _ { i } ^ { \mathrm { b N } } ) } ) \right] ,
+$$
+
+$$
+\hat { R } _ { \mathrm { U } } ( g ) = \frac { 1 } { n _ { \mathrm { U } } } \sum _ { i = 1 } ^ { n _ { \mathrm { U } } } \left[ \mathbb { 1 } _ { \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) \leq \eta } \ell ( - g ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) ) ( 1 - \hat { \sigma } ( \mathbf { x } _ { i } ^ { \mathrm { U } } ) ) \right] .
+$$
+
+From the sub-additivity of the supremum operator, we have
+
+$$
+\begin{array} { r l } {  { \operatorname* { s u p } _ { g \in \mathcal { G } } | \hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ^ { - } ( g ) - R _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g ) | } \quad } & { } \\ & { \leq \pi \operatorname* { s u p } _ { g \in \mathcal { G } } | \hat { R } _ { \mathrm { P } } ( g ) - R _ { \mathrm { P } } ( g ) | + \rho \operatorname* { s u p } _ { g \in \mathcal { G } } | \hat { R } _ { \mathrm { b N } } ( g ) - R _ { \mathrm { b N } } ( g ) | + \operatorname* { s u p } _ { g \in \mathcal { G } } | \hat { R } _ { \mathrm { U } } ( g ) - R _ { \mathrm { U } } ( g ) | . } \end{array}
+$$
+
+As a consequence, to conclude the proof, it suffices to prove that with probability at least $1 - \delta / 3$ , the following bounds hold separately:
+
+$$
+\begin{array} { r l r } { \displaystyle \operatorname* { s u p } _ { g \in \mathcal { G } } \vert \hat { R } _ { \mathrm { P } } ( g ) - R _ { \mathrm { P } } ( g ) \vert \le \frac { 2 L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { P } } , p _ { \mathrm { P } } } ( \mathcal { G } ) + \frac { C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { P } } } } , } & \\ { \displaystyle \operatorname* { s u p } _ { g \in \mathcal { G } } \vert \hat { R } _ { \mathfrak { h } \mathrm { N } } ( g ) - R _ { \mathfrak { h } \mathrm { N } } ( g ) \vert \le \frac { 2 L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { b N } } , p _ { \mathrm { b N } } } ( \mathcal { G } ) + \frac { C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { b N } } } } , } & \\ { \displaystyle \operatorname* { s u p } _ { g \in \mathcal { G } } \vert \hat { R } _ { \mathrm { U } } ( g ) - R _ { \mathrm { U } } ( g ) \vert \le 2 L _ { l } \mathfrak { R } _ { n _ { \mathrm { U } } , p } ( \mathcal { G } ) + C _ { l } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { U } } } } . } & \end{array}
+$$
+
+Below we prove (8). (9) and (10) are proven similarly.
+
+Let $\phi _ { \pmb { x } } : \mathbb { R }  \mathbb { R } _ { + }$ be the function defined by $\phi _ { \pmb { x } } : z \mapsto \ell ( z ) + \mathbb { 1 } _ { \hat { \sigma } ( \pmb { x } ) > \eta } \ell ( - z ) ( ( 1 - \hat { \sigma } ( \pmb { x } ) ) / \hat { \sigma } ( \pmb { x } ) )$ . For $\pmb { x } \in \mathbb { R } ^ { d } , g \in \mathcal { G }$ , since $\ell ( g ( \pmb { x } ) ) \in [ 0 , C _ { l } ]$ , $\ell ( - g ( \pmb { x } ) ) \in [ 0 , C _ { l } ]$ and $\mathbb { 1 } _ { \hat { \sigma } ( \pmb { x } ) > \eta } ( ( 1 - \hat { \sigma } ( \pmb { x } ) ) / \hat { \sigma } ( \pmb { x } ) ) \in$ $[ 0 , ( 1 - \eta ) / \eta ]$ , we always have $\phi _ { \pmb { x } } ( g ( \pmb { x } ) ) \in [ 0 , C _ { l } / \eta ]$ . Following the proof of Theorem 3.1 in Mohri et al. (2012), it is then straightforward to show that with probability at least $1 - \delta / 3$ , it holds that
+
+$$
+\operatorname* { s u p } _ { g \in \mathcal { G } } | \hat { R } _ { \mathrm { P } } ( g ) - R _ { \mathrm { P } } ( g ) | \leq 2 \mathbb { E } _ { \mathcal { X } _ { \mathrm { P } } \sim p _ { \mathrm { P } } ^ { n _ { \mathrm { P } } } } \mathbb { E } _ { \theta } \left[ \operatorname* { s u p } _ { g \in \mathcal { G } } \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \theta _ { i } \phi _ { { \pmb x } _ { i } } ( g ( { \pmb x } _ { i } ) ) \right] + \frac { C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { P } } } } ,
+$$
+
+where $\boldsymbol { \theta } = \{ \theta _ { 1 } , \ldots , \theta _ { n _ { \mathrm { P } } } \}$ and each $\theta _ { i }$ is a Rademacher variable.
+
+Also notice that for all $_ { \textbf { \em x } }$ , $\phi _ { \pmb { x } }$ is a $( L _ { l } / \eta )$ -Lipschitz function on the interval $[ - C _ { g } , C _ { g } ]$ . By using a modified version of Talagrad’s concentration lemma (specifically, Lemma 26.9 in Shalev-Shwartz & Ben-David (2014)), we can show that, when the set $\mathcal { X } _ { \mathrm { P } }$ is fixed, we have
+
+$$
+\mathbb { E } _ { \theta } \left[ \operatorname* { s u p } _ { g \in \mathcal { G } } \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \theta _ { i } \phi _ { { \pmb x } _ { i } } ( g ( { \pmb x } _ { i } ) ) \right] \le \frac { L _ { l } } { \eta } \mathbb { E } _ { \theta } \left[ \operatorname* { s u p } _ { g \in \mathcal { G } } \frac { 1 } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \theta _ { i } g ( \pmb x _ { i } ) \right] .
+$$
+
+After taking expectation over $\mathcal { X } _ { \mathrm { P } } \sim p _ { \mathrm { P } } ^ { n _ { \mathrm { p } } }$ , we obtain the Equation (8).
+
+However, what we really want to minimize is the true risk $R ( g )$ . Therefore, we also need to bound the difference between $R _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ( g )$ and $R ( g )$ , or equivalently, the difference between $\bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g )$ and $\bar { R } _ { s = - 1 } ^ { - } ( g )$ .
+
+Lemma 2. Let $\hat { \sigma } : \mathbb { R } ^ { d }  [ 0 , 1 ]$ , $\eta \in ( 0 , 1 ]$ , $\zeta = p ( \hat { \sigma } \leq \eta )$ and $\epsilon = \mathbb { E } _ { { \pmb x } \sim p ( { \pmb x } ) } [ | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | ^ { 2 } ]$ . For all $g \in { \mathcal { G } }$ , it holds that
+
+$$
+| \bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) - \bar { R } _ { s = - 1 } ^ { - } ( g ) | \leq C _ { l } \sqrt { \zeta \epsilon } + \frac { C _ { l } } { \eta } \sqrt { ( 1 - \zeta ) \epsilon } .
+$$
+
+Proof. One one hand, we have
+
+$$
+\begin{array} { r } { \bar { R } _ { s = - 1 } ^ { - } ( g ) = \underbrace { \int \mathbb { 1 } _ { \hat { \sigma } ( \pmb { x } ) \leq \eta } \ell ( - g ( \pmb { x } ) ) ( 1 - \sigma ( \pmb { x } ) ) p ( \pmb { x } ) d \pmb { x } } _ { A _ { 1 } } } \\ { + \underbrace { \int \mathbb { 1 } _ { \hat { \sigma } ( \pmb { x } ) > \eta } \ell ( - g ( \pmb { x } ) ) ( 1 - \sigma ( \pmb { x } ) ) p ( \pmb { x } ) d \pmb { x } } _ { B _ { 1 } } . } \end{array}
+$$
+
+On the other hand, we can express $\bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g )$ as
+
+$$
+\begin{array} { r l } & { \bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) = \displaystyle \int \mathbb { 1 } _ { \hat { \sigma } ( \mathbf x ) \leq \eta } \ell ( - g ( \mathbf x ) ) ( 1 - \hat { \sigma } ( \mathbf x ) ) p ( \mathbf x ) d x } \\ & { \quad \quad \quad \quad + \displaystyle \int \mathbb { 1 } _ { \hat { \sigma } ( \mathbf x ) > \eta } \ell ( - g ( \mathbf x ) ) \frac { 1 - \hat { \sigma } ( \mathbf x ) } { \hat { \sigma } ( \mathbf x ) } p ( \mathbf x , s = + 1 ) d x . } \\ & { \quad \quad \quad \quad = \displaystyle \int \mathbb { 1 } _ { \hat { \sigma } ( \mathbf x ) \leq \eta } \ell ( - g ( \mathbf x ) ) ( 1 - \hat { \sigma } ( \mathbf x ) ) p ( \mathbf x ) d x } \\ & { \quad \quad \quad \quad + \displaystyle \int \mathbb { 1 } _ { \hat { \sigma } ( \mathbf x ) > \eta } \ell ( - g ( \mathbf x ) ) ( 1 - \hat { \sigma } ( \mathbf x ) ) \frac { \sigma ( \mathbf x ) } { \hat { \sigma } ( \mathbf x ) } p ( \mathbf x ) d x . } \end{array}
+$$
+
+The last equality follows from the fact $p ( { \pmb x } , s \ = \ + 1 ) \ = \ \sigma ( { \pmb x } ) p ( { \pmb x } )$ . As $\vert \bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g ) ~ -$ $\bar { R } _ { s = - 1 } ^ { - } ( g ) | \leq | A _ { 1 } - A _ { 2 } | + | B _ { 1 } - B _ { 2 } |$ , it is sufficient to derive bounds for $\left| A _ { 1 } - A _ { 2 } \right|$ and $\left| B _ { 1 } - B _ { 2 } \right|$ separately. For $\left| B _ { 1 } - B _ { 2 } \right|$ , we write
+
+$$
+\begin{array} { l } { \displaystyle | B _ { 1 } - B _ { 2 } | \le \int \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } \ell ( - g ( { \pmb x } ) ) \frac { \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | } { \hat { \sigma } ( { \pmb x } ) } p ( { \pmb x } ) d { \pmb x } } \\ { \displaystyle \qquad \le \frac { C _ { l } } { \eta } \int \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | p ( { \pmb x } ) d { \pmb x } } \\ { \displaystyle \qquad \le \frac { C _ { l } } { \eta } \left( \int \mathbb { 1 } _ { \hat { \sigma } ( { \pmb x } ) > \eta } ^ { 2 } p ( { \pmb x } ) d { \ b x } \right) ^ { \frac { 1 } { 2 } } \left( \int | \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) | ^ { 2 } p ( { \pmb x } ) d { \ b x } \right) ^ { \frac { 1 } { 2 } } } \\ { \displaystyle \qquad = \frac { C _ { l } } { \eta } \sqrt { ( 1 - \zeta ) \epsilon } } \end{array}
+$$
+
+From the second to the third line we use the Cauchy-Schwarz inequality. $| A _ { 1 } - A _ { 2 } | \le C _ { l } \sqrt { \zeta \epsilon }$ can be proven similarly, which concludes the proof. □
+
+Combining lemma 1 and lemma 2, we know that with probability at least $1 - \delta$ , the following holds:
+
+$$
+\begin{array} { r l } & { \underset { g \in \mathcal { G } } { \operatorname* { s u p } } | \hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } } ^ { - } ( g ) - R ( g ) | } \\ & { \leq 2 L _ { l } \mathfrak { R } _ { n _ { \mathrm { U } } , p } ( \mathcal { G } ) + \frac { 2 \pi L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { P } } , p _ { \mathrm { P } } } ( \mathcal { G } ) + \frac { 2 \rho L _ { l } } { \eta } \mathfrak { R } _ { n _ { \mathrm { b N } } , p _ { \mathrm { b N } } } ( \mathcal { G } ) } \\ & { \quad + C _ { l } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { U } } } } + \frac { \pi C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { P } } } } + \frac { \rho C _ { l } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 n _ { \mathrm { b N } } } } + C _ { l } \sqrt { \zeta \epsilon } + \frac { C _ { l } } { \eta } \sqrt { ( 1 - \zeta ) \epsilon } . } \end{array}
+$$
+
+Finally, with probability at least $1 - \delta$ ,
+
+$$
+\begin{array} { r l } & { R ( \hat { g } \mathrm { P r u N } _ { , \eta , \delta } ) - R ( g ^ { * } ) } \\ & { \quad = ( R ( \hat { g } _ { \mathrm { P U W N } , \eta , \delta } ) - \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( \hat { g } _ { \mathrm { P U W N } , \eta , \delta } ) ) } \\ & { \quad \quad + ( \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( \hat { g } _ { \mathrm { P U W N } , \eta , \delta } ) - \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( g ^ { * } ) ) + ( \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( g ^ { * } ) - R ( g ^ { * } ) ) } \\ & { \quad \le \operatorname* { s u p } _ { \delta \in \widetilde { G } } \left| \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( g ) - R ( g ) \right| + 0 + \operatorname* { s u p } _ { \delta \in \widetilde { G } } \left| \hat { R } _ { \mathrm { P U B N } , \eta , \delta } ^ { - 1 } ( g ) - R ( g ) \right| } \\ & { \quad \le 4 L _ { L } \mathfrak { P r } _ { \Omega , \eta , \delta } ( g ) + \frac { 4 \pi L } { \eta } _ { \mathfrak { R } _ { \eta } , \eta , \mathrm { P r } , \eta } ( g ) + \frac { 4 \mu L } { \eta } _ { \mathcal { I } } \mathfrak { P r } _ { \mathfrak { R U N } , \eta , \mathrm { P r } , \eta } ( g ) } \\ & { \quad \quad + 2 C _ { L } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 \eta _ { \mathfrak { I U } } } } + \frac { 2 \pi C _ { L } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 \eta _ { \mathfrak { p } } } } + \frac { 2 \mu C _ { L } } { \eta } \sqrt { \frac { \ln ( 6 / \delta ) } { 2 \eta _ { \mathfrak { p } } } } + 2 C _ { L } \sqrt { \zeta _ { \epsilon } } + \frac { 2 C _ { L } } { \eta } \sqrt { ( 1 - \zeta ) \epsilon } . } \end{array}
+$$
+
+The first inequality uses the definition of $\hat { g } _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$ .
+
+# B VALIDATION LOSS FOR ESTIMATION OF $\sigma$
+
+In terms of validation we want to choose the model for $\hat { \sigma }$ such that $J _ { 0 } ( \widehat { \sigma } ) = \mathbb { E } _ { \pmb { x } \sim p ( \pmb { x } ) } [ | \widehat { \sigma } ( \pmb { x } ) - \sigma ( \pmb { x } ) | ^ { 2 } ]$ is minimized. Since $\sigma ( { \pmb x } ) p ( { \pmb x } ) = p ( { \pmb x } , s = + 1 )$ , we have
+
+$$
+\begin{array} { l } { { \displaystyle { J _ { 0 } ( \hat { \sigma } ) = \int ( \hat { \sigma } ( { \pmb x } ) - \sigma ( { \pmb x } ) ) ^ { 2 } p ( { \pmb x } ) d x } } } \\ { { \displaystyle ~ = \int \hat { \sigma } ( { \pmb x } ) ^ { 2 } p ( { \pmb x } ) d x - 2 \int \hat { \sigma } ( { \pmb x } ) p ( { \pmb x } , s = + 1 ) d x + \int \sigma ( { \pmb x } ) ^ { 2 } p ( { \pmb x } ) d x . } } \end{array}
+$$
+
+The last term does not depend on $\hat { \sigma }$ and can be ignored if we want to identify $\hat { \sigma }$ achieving the smallest $J ( \hat { \sigma } )$ . We denote by $J ( \hat { \sigma } )$ the sum of the first two terms. The middle term can be further expanded using
+
+$$
+\int { \hat { \sigma } } ( x ) p ( \mathbf { x } , s = + 1 ) d x = \pi \int { \hat { \sigma } } ( x ) p ( \mathbf { x } \mid y = + 1 ) d x + \rho \int { \hat { \sigma } } ( \mathbf { x } ) p ( \mathbf { x } \mid y = - 1 , s = + 1 ) d x .
+$$
+
+The validation loss of an estimation $\hat { \sigma }$ is then defined as
+
+$$
+\hat { J } ( \hat { \sigma } ) = \frac { 1 } { n _ { \mathrm { U } } } \sum _ { i = 1 } ^ { n _ { \mathrm { U } } } \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { U } } ) ^ { 2 } - \frac { 2 \pi } { n _ { \mathrm { P } } } \sum _ { i = 1 } ^ { n _ { \mathrm { P } } } \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { P } } ) - \frac { 2 \rho } { n _ { \mathrm { b N } } } \sum _ { i = 1 } ^ { n _ { \mathrm { b N } } } \hat { \sigma } ( \pmb { x } _ { i } ^ { \mathrm { b N } } ) .
+$$
+
+It is also possible to minimize this value directly to acquire $\hat { \sigma }$ . In our experiments we decide to learn $\hat { \sigma }$ by nnPU for a better comparison between different methods.
+
+# C DETAILED EXPERIMENTAL SETTING
+
+# C.1 FROM MULTICLASS TO BINARY CLASS
+
+In the experiments we work on multiclass classification datasets. Therefore it is necessary to define the $\mathrm { \bf P }$ and $\mathbf { N }$ classes ourselves. MNIST is processed in such a way that pair numbers 0, 2, 4, 6, 8 form the P class and impair numbers 1, 3, 5, 7, 9 form the N class. Accordingly, $\pi = 0 . 4 9$ . For CIFAR-10, we consider two definitions of the P class. The first one corresponds to a quite natural task that aims to distinguish vehicles from animals. Airplane, automobile, ship and truck are therefore defined to be the $\mathrm { \bf P }$ class while the $\mathbf { N }$ class is formed by bird, cat, deer, dog, frog and horse. For the sake of diversity, we also study another task in which we attempt to distinguish the mammals from the non-mammals. The $\mathrm { \bf P }$ class is then formed by cat, deer, dog, and horse while the N class consists of the other six classes. We have $\pi = 0 . 4$ in the two cases. As for 20 Newsgroups, alt., comp., misc. and rec. make up the $\mathrm { \bf P }$ class whereas sci., soc. and talk. make up the N class. This gives $\pi = 0 . 5 6$ .
+
+# C.2 TRAINING, VALIDATION AND TEST SET
+
+For the three datasets, we use the standard test examples as a held-out test set. The test set size is thus of 10000 for MNIST and CIFAR-10, and 7528 for 20 Newsgroups. Regarding the training set, we sample 500, 500 and 6000 P, bN and U training examples for MNIST and 20 Newsgroups, and 1000, 1000 and $1 0 0 0 0 \mathrm { P } ,$ bN and U training examples for CIFAR-10. The validation set is always five times smaller than the training set.
+
+# C.3 20 NEWSGROUPS PREPROCESSING
+
+The original 20 Newsgroups dataset contains raw text data and needs to be preprocessed into text feature vectors for classification. In our experiments we borrow the pre-trained ELMo word embedding (Peters et al., 2018) from https://allennlp.org/elmo. The used 5.5B model was, according to the website, trained on a dataset of 5.5B tokens consisting of Wikipedia (1.9B) and all of the monolingual news crawl data from WMT 2008-2012 (3.6B). For each word, we concatenate the features from the three layers of the ELMo model, and for each document, as suggested in Ruckl ¨ e et al. ´ (2018), we concatenate the average, minimum, and maximum computed along the word dimension. This results in a 9216-dimensional feature vector for a single document.
+
+# C.4 MODELS AND HYPERPARAMETERS
+
+MNIST For MNIST, we use a standard ConvNet with ReLU. This model contains two 5x5 convolutional layers and one fully-connected layer, with each convolutional layer followed by a $2 \mathrm { x } 2 \mathrm { m a x }$ pooling. The channel sizes are 5-10-40. The model is trained for 100 epochs with a weight decay of $\mathrm { \dot { 1 } 0 ^ { - 4 } }$ . Each minibatch is made up of 10 P, 10 bN (if available) and $1 2 0 \mathrm { U }$ samples. The learning rate $\alpha \in \{ 1 0 ^ { - 2 } , 1 0 ^ { - 3 } \}$ and $\tau \in \{ 0 . 5 , 0 . 7 , 0 . 9 \}$ , $\gamma \in \{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \}$ are selected with validation data.
+
+CIFAR-10 For CIFAR-10, we train PreAct ResNet-18 (He et al., 2016) for 200 epochs and the learning rate is divided by 10 after 80 epochs and 120 epochs. This is a common practice and similar adjustment can be found in He et al. (2016). The weight decay is set to $1 0 ^ { - 4 }$ . The minibatch size is $1 / 1 0 0$ of the number of training samples, and the initial learning rate is chosen from $\lbrace 1 0 ^ { - 2 } , 1 0 ^ { - 3 } \rbrace$ . We also have $\tau \in \{ 0 . 5 , 0 . 7 , 0 . 9 \}$ and $\gamma \in \{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \}$ .
+
+20 Newsgroups For 20 Newsgroups, with the extracted features, we simply train a multilayer perceptron with two hidden layers of 300 neurons for 50 epochs. We use basically the same hyperparameters as for MNIST except that the learning rate $\alpha$ is selected from $\{ 5 \cdot 1 0 ^ { - 3 } , 1 0 ^ { - 3 } , 5 \cdot \mathrm { i } \mathrm { \dot { 0 } ^ { - 4 } } \}$ .
+
+# D ADDITIONAL EXPERIMENTS
+
+# D.1 WHY DOES PUBN\N OUTPERFORM NNPU ?
+
+Our method, specifically designed for PUbN learning, naturally outperforms other baseline methods in this problem. Nonetheless, Table 1 equally shows that the proposed method when applied to PU learning, achieves significantly better performance than the state-of-the-art nnPU algorithm. Here we numerically investigate the reason behind this phenomenon.
+
+Besides nnPU and PUbN\N, we compare with unbiased PU (uPU) learning (2). Both uPU and nnPU are learned with the sigmoid loss, learning rate $1 0 ^ { - 3 }$ for MNIST, initial learning rate $1 0 ^ { - 4 }$ for CIFAR-10, and learning rate $\mathrm { \bar { 1 0 } ^ { - 4 } }$ for 20 Newsgroups. This is because uPU learning is unstable with the logistic loss. The other parts of the experiments remain unchanged. On the test sets we compute the false positive rates, false negative rates and misclassification errors for the three methods and plot them in Figure 2. We first notice that PUbN\N still outperforms nnPU trained with the sigmoid loss. In fact, the final performance of the nnPU classifier does not change much when we replace the logistic loss with the sigmoid loss.
+
+![](images/d541efdb0152b9c786f9dedbc000a3b265230519f60ba8a3ce4233398a9818f3.jpg)  
+Figure 2: Comparison of uPU, nnPU and PUbN\N over the four PU learning tasks. For each task, means and standard deviations are computed based on the same 10 random samplings. Dashed lines indicate the corresponding values of the final classifiers (recall that at the end we select the model with the lowest validation loss out of all epochs).
+
+In Kiryo et al. (2017), the authors observed that uPU overfits training data with the risk going to negative. In other words, a large portion of U samples are classified to the N class. This is confirmed in our experiments by an increase of false negative rate and decrease of false positive rate. nnPU remedies the problem by introducing the non-negative risk estimator (3). While the non-negative correction successfully prevents false negative rate from going up, it also causes more $_ \mathrm { N }$ samples to be classified as P compared to uPU. However, since the gain in terms of false negative rate is enormous, at the end nnPU achieves a lower misclassification error. By further identifying possible N samples after nnPU learning, we expect that our algorithm can yield lower false positive rate than nnPU without misclassifying too many $\mathrm { \bf P }$ samples as $_ \mathrm { N }$ as in the case of uPU. Figure 2 suggests that this is effectively the case. In particular, we observe that on MNIST, our method achieves the same false positive rate than uPU whereas its false negative rate is comparable to nnPU.
+
+# D.2 INFLUENCE OF $\eta$ AND $\rho$
+
+In the proposed algorithm we introduce $\eta$ to control how $\bar { R } _ { s = - 1 } ( g )$ is approximated from data and assume that $\rho = p ( y = - 1 , s = + 1 )$ is given. Here we conduct experiments to see how our method is affected by these two factors. To assess the influence of $\eta$ , from Table 1 we pick four learning tasks and we choose $\tau$ from $\{ 0 . 5 , 0 . 7 , 0 . 9 , 2 \}$ while all the other hyperparameters are fixed. Similarly to simulate the case where $\rho$ is misspecified, we replace it by $\rho ^ { \dagger } \mathbf { \bar { \rho } } \in \mathbf { \bar { \{ 0 . 8 \rho , \rho , 1 . 2 \rho \} } }$ in our learning method and run experiments with all hyperparameters being fixed to a certain value. However, we still use the true $\rho$ to compute $\eta$ from $\tau$ to ensure that we always use the same number of $\mathrm { U }$ samples in the second step of the algorithm independent of the choice of $\rho ^ { \prime }$ .
+
+The results are reported in Table 2 and Table 3. We can see that the performance of the algorithm is sensitive to the choice of $\tau$ . With larger value of $\tau$ , more $\mathrm { U }$ data are treated as $\mathbf { N }$ data in PUbN learning, and consequently it often leads to higher false negative rate and lower false positive rate. The trade-off between these two measures is a classic problem in binary classification. In particular, when $\tau = 2$ , a lot more U samples are involved in the computation of the PUbN risk (7), but this does not allow the classifier to achieve a better performance. We also observe that there is a positive correlation between the misclassification rate and the validation loss, which confirms that the optimal value of $\eta$ can be chosen without need of unbiased $\mathbf { N }$ data.
+
+Table 3 shows that in general slight misspecification of $\rho$ does not cause obvious degradation of the classification performance. In fact, misspecification of $\rho$ mainly affect the weights of each sample when we compute $\hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$ (due to the direct presence of $\rho$ in (7) and influence on estimating $\sigma _ { \cdot }$ ). However, as long as the variation of these weights remain in a reasonable range, the learning algorithm should yield classifiers with similar performances.
+
+# D.3 ESTIMATING $\sigma$ FROM SEPARATE DATA
+
+Theorem 2 suggests that $\hat { \sigma }$ should be independent from the data used to compute $\hat { R } _ { \mathrm { P U b N } , \eta , \hat { \sigma } }$ . Therefore, here we investigate the performance of our algorithm when $\hat { \sigma }$ and $g$ are optimized using different sets of data. We sample two training sets and two validation sets in such a way that they are all disjoint. The size of a single training set and a single validation set is as indicated in Appendix C.2, except for 20 Newsgroups we reduce the number of examples in a single set by half. We then use different pairs of training and validation sets to learn $\hat { \sigma }$ and $g$ . For 20 Newsgroups we also conduct standard experiments where $\hat { \sigma }$ and $g$ are learned on the same data, whereas for MNIST and CIFAR-10 we resort to Table 1.
+
+The results are presented in Table 4. Estimating $\sigma$ from separate data does not seem to benefit much the final classification performance, despite the fact that it requires collecting twice more samples. In fact, $\hat { \bar { \cal R } } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g )$ is a good approximation of $\bar { R } _ { s = - 1 , \eta , \hat { \sigma } } ^ { - } ( g )$ as long as the function $\hat { \sigma }$ is smooth enough and does not possess abrupt changes between data points. With the use of non-negative correction, validation data and L2 regularization, the resulting $\hat { \sigma }$ does not overfit training data so this should always be the case. As a consequence, even if $\hat { \sigma }$ and $g$ are learned on the same data, we are still able to achieve small generalization error with sufficient number of samples.
+
+# D.4 ALTERNATIVE DEFINITION OF NNPNU
+
+In subsection 2.3, we define the nnPNU algorithm by forcing the estimator of the whole $_ \mathrm { N }$ partial risk to be positive. However, notice that the term $\gamma ( 1 - \pi ) \hat { R } _ { \mathrm { N } } ^ { - } ( g )$ is always positive and the chances are that including it simply makes non-negative correction weaker and is thus harmful to the final classification performance. Therefore, here we consider an alternative definition of nnPNU where we only force the term $( 1 - \gamma ) ( \hat { R } _ { \mathrm { U } } ^ { - } ( g ) - \pi \hat { R } _ { \mathrm { P } } ^ { - } ( g ) )$ to be positive. We plug the resulting algorithm in the experiments of subsection 4.2 and summarize the results in Table 5 in which we denote the alternative version of nnPNU by $\mathrm { n n P U + P N }$ since it uses the same non-negative correction as nnPU. The table indicates that neither of the two definitions of nnPNU consistently outperforms the other.
+
+Table 2: Results on four different PUbN learning tasks when we vary the value of $\tau$ (and accordingly, $\eta$ ). Reported are means of false positive rates (FPR), false negative rates (FNR), misclassification rates (Error), and validation losses (VLoss) over 10 trials.   
+
+<table><tr><td>Dataset</td><td>P</td><td>biased N</td><td>T</td><td>FPR</td><td>FNR</td><td>Error</td><td>VLosS</td></tr><tr><td rowspan="4">MNIST</td><td rowspan="4">2,4,6,8,10</td><td rowspan="4">1,3,5</td><td>0.5</td><td>4.79</td><td>4.32</td><td>4.56</td><td>10.11</td></tr><tr><td>0.7</td><td>3.32</td><td>4.81</td><td>4.05</td><td>9.15</td></tr><tr><td>0.9</td><td>3.29</td><td>4.40</td><td>3.83</td><td>9.30</td></tr><tr><td>2</td><td>3.38</td><td>5.32</td><td>4.33</td><td>10.68</td></tr><tr><td rowspan="4">CIFAR-10</td><td rowspan="4">Airplane, automobile, ship, truck</td><td rowspan="4">Horse &gt; deer = frog &gt; others</td><td>0.5</td><td>8.31</td><td>12.35</td><td>9.92</td><td>12.50</td></tr><tr><td>0.7</td><td>8.23</td><td>13.15</td><td>10.20</td><td>12.62</td></tr><tr><td>0.9</td><td>7.54</td><td>14.68</td><td>10.40</td><td>13.08</td></tr><tr><td>2</td><td>6.23</td><td>20.29</td><td>11.85</td><td>13.64</td></tr><tr><td rowspan="4">CIFAR-10</td><td rowspan="4">Cat, deer, dog, horse</td><td rowspan="4">Bird, frog</td><td>0.5</td><td>14.45</td><td>27.57</td><td>19.70</td><td>22.08</td></tr><tr><td>0.7</td><td>13.20</td><td>27.27</td><td>18.83</td><td>20.72</td></tr><tr><td>0.9</td><td>13.00</td><td>32.61</td><td>20.84</td><td>23.78</td></tr><tr><td>2</td><td>11.67</td><td>31.49</td><td>19.60</td><td>22.52</td></tr><tr><td rowspan="4">20 Newsgroups</td><td rowspan="4">alt., comp., misc., rec.</td><td rowspan="4">soc.&gt; talk.&gt; sci.</td><td>0.5</td><td>11.28</td><td>12.90</td><td>12.18</td><td>16.04</td></tr><tr><td>0.7</td><td>11.40</td><td>13.58</td><td>12.62</td><td>16.64</td></tr><tr><td>0.9</td><td>10.09</td><td>16.70</td><td>13.79</td><td>16.90</td></tr><tr><td>2</td><td>10.34</td><td>20.55</td><td>16.06</td><td>20.99</td></tr></table>
+
+Table 3: Mean and standard deviation of misclassification rates over 10 trials on different PUbN learning tasks when we replace $\rho$ by $\rho ^ { \prime } \in \{ 0 . 8 \rho , \rho , 1 . 2 \rho \}$ . Underlines indicate significant degradation of performance according to the $5 \%$ t-test.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">P</td><td rowspan="2">biased N</td><td colspan="3">p/p</td></tr><tr><td>0.8</td><td>1</td><td>1.2</td></tr><tr><td rowspan="2">MNIST</td><td rowspan="2">2,4,6,8,10</td><td>1,3,5</td><td>4.10 ± 0.39</td><td>4.05 ± 0.27</td><td>4.14 ± 0.45</td></tr><tr><td>9 &gt;5&gt;others</td><td>3.85 ± 0.55</td><td>3.91 ± 0.66</td><td>3.94± 0.54</td></tr><tr><td rowspan="2">CIFAR-10</td><td rowspan="2">Airplane, automobile, ship, truck</td><td>Cat, dog, horse</td><td>10.23 ± 0.59</td><td>9.71 ± 0.51</td><td>10.32 ± 0.57</td></tr><tr><td>Horse V deer = frog &gt; others</td><td>10.18 ± 0.40</td><td>9.92 ± 0.42</td><td>10.05 ± 0.59</td></tr><tr><td rowspan="2">CIFAR-10</td><td rowspan="2">Cat, deer, dog, horse</td><td>Bird, frog</td><td>18.94 ± 0.50</td><td>18.83 ± 0.71</td><td>19.06 ± 0.80</td></tr><tr><td>Car, truck</td><td>20.39 ± 1.24</td><td>20.19 ± 1.06</td><td>19.92 ± 0.89</td></tr><tr><td rowspan="3">20 Newsgroups</td><td rowspan="3">alt., comp., misc., rec.</td><td>sci.</td><td>13.49 ± 0.61</td><td>13.10 ±0.90</td><td>13.31 ± 1.05</td></tr><tr><td>talk.</td><td>12.64 ± 0.69</td><td>12.61 ± 0.75</td><td>13.77 ± 0.85</td></tr><tr><td>soc. &gt; talk.&gt; sci.</td><td>12.90 ± 0.79</td><td>12.18 ± 0.59</td><td>12.74 ± 0.35</td></tr></table>
+
+It also ensures that there is always a clear superiority of our proposed PUbN algorithm compared to nnPNU despite its possible variant that is considered here.
+
+Table 4: Mean and standard deviation of misclassification rates over 10 trials on different PUbN learning tasks with $\hat { \sigma }$ and $g$ trained using either the same or different sets of data.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">P</td><td rowspan="2">biased N</td><td colspan="2">Data for  and g</td></tr><tr><td>Same</td><td>Different</td></tr><tr><td>MNIST</td><td>2,4,6,8,10</td><td>1,3,5 9 &gt;5&gt;others</td><td>4.05 ± 0.27 3.91 ± 0.66</td><td>3.71 ± 0.45 4.06 ± 0.36</td></tr><tr><td>CIFAR-10</td><td>Airplane, automobile, ship, truck</td><td>Cat, dog, horse Horse V deer = frog &gt; others</td><td>9.71 ± 0.51 9.92 ± 0.42</td><td>10.00 ± 0.51 9.66 ± 0.46</td></tr><tr><td>CIFAR-10</td><td>Cat, deer, dog, horse</td><td>Bird, frog Car, truck</td><td>18.83 ± 0.71 20.19 ± 1.06</td><td>18.52 ± 0.70</td></tr><tr><td>20 Newsgroups</td><td>alt., comp., misc., rec.</td><td>sci. talk. soc. &gt; talk. &gt; sci.</td><td>15.61 ± 1.50 17.14 ± 1.87</td><td>19.98 ± 0.93 16.60 ± 2.38 15.80 ± 0.95</td></tr></table>
+
+Table 5: Mean and standard deviation of misclassification rates over 10 trials on different PUbN learning tasks for the two possible definitions of the nnPNU algorithm.   
+
+<table><tr><td>Dataset</td><td>P</td><td>biased N</td><td>nnPNU</td><td>nnPU + PN</td></tr><tr><td>MNIST</td><td>2,4,6, 8, 10</td><td>1,3,5 9 &gt;5&gt; others</td><td>5.33 ± 0.97 4.60 ± 0.65</td><td>5.68± 0.78 5.10 ± 1.54</td></tr><tr><td>CIFAR-10</td><td>Airplane, automobile, ship, truck</td><td>Cat, dog, horse Horse V deer = frog &gt; others</td><td>10.25 ± 0.38 9.98 ± 0.53</td><td>10.87 ± 0.62 10.77 ± 0.65</td></tr><tr><td>CIFAR-10</td><td>Cat, deer, dog, horse</td><td>Bird, frog Car, truck</td><td>22.00 ± 0.53 22.00 ± 0.74</td><td>21.41 ± 1.01 21.80 ± 0.74</td></tr><tr><td>20 Newsgroups</td><td>alt., comp., misc., rec.</td><td>sci. talk. soc. &gt; talk.&gt; sci.</td><td>14.69 ± 0.46 14.38 ± 0.74 14.41 ± 0.70</td><td>14.50 ± 1.32 14.71 ± 1.01 13.66 ± 0.72</td></tr></table>

parse/train/HJMN-xWC-/HJMN-xWC-.md

@@ -0,0 +1,237 @@
+# LEARNING PARSIMONIOUS DEEP FEED-FORWARD NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Convolutional neural networks and recurrent neural networks are designed with network structures well suited to the nature of spacial and sequential data respectively. However, the structure of standard feed-forward neural networks (FNNs) is simply a stack of fully connected layers, regardless of the feature correlations in data. In addition, the number of layers and the number of neurons are manually tuned on validation data, which is time-consuming and may lead to suboptimal networks. In this paper, we propose an unsupervised structure learning method for learning parsimonious deep FNNs. Our method determines the number of layers, the number of neurons at each layer, and the sparse connectivity between adjacent layers automatically from data. The resulting models are called Backbone-Skippath Neural Networks (BSNNs). Experiments on 17 tasks show that, in comparison with FNNs, BSNNs can achieve better or comparable classification performance with much fewer parameters. The interpretability of BSNNs is also shown to be better than that of FNNs.
+
+# 1 INTRODUCTION
+
+Deep neural networks have made breakthroughs in all kinds of machine learning tasks (LeCun et al., 2015; Hinton et al., 2012a; Mikolov et al., 2011), specifically with convolutional neural networks (CNNs) for tasks with spacial data (Krizhevsky et al., 2012) and recurrent neural networks (RNNs) for tasks with sequential data (Sutskever et al., 2014). One of the key reasons for the effectiveness of CNNs and RNNs is the well-designed network structures together with the parameter sharing schemes. For example, in the convolution layers of CNNs, each neuron is connected to a local region in the input volume instead of all the input neurons. Besides, the neurons in the same channel share the same set of weights. This design utilizes the local and “stationary” properties of spacial data and consequently forms effective feature extractors. In addition, it also prevents CNNs from having an exploding number of parameters when the networks become deeper and deeper.
+
+However, in practice, there are also many data which are neither spacial nor sequential, and hence the only applicable neural networks are the standard feed-forward neural networks (FNNs). In contrast to CNN and RNN, FNN’s network structure is simple. It consists of multiple layers of neurons and each layer is fully connected to the next layer up, without considering any correlations in data or among neurons. The network structure has two main shortcomings. The first is that, there can be high connection redundancies. As the number of layers and the number of neuron at each layer increase, the number of parameters increases quickly, which can cause severe overfitting. The other shortcoming is that, ignoring all the correlations existing in data weakens the model’s strength (as a feature extractor) and hurts the model’s interpretability.
+
+We are interested in learning parsimonious deep feed-forward neural networks. The goal is to learn FNNs which contain as few parameters as possible. Parsimonious FNNs are desirable for several reasons. Firstly, fewer parameters can ease overfitting. Secondly, parsimonious FNNs require less storage and computation than FNNs, which makes it possible to be run on devices like mobile phones. Lastly, parsimonious FNNs can have very flexible and different structures from each other depending on the specific tasks and data. This would help the models fit the data well and also have good interpretability. In general, it is desirable to solve a problem using the simplest model possible because it implies a good understanding of the problem.
+
+![](images/333a9c4fb5cf8f596a69bdbdee6d7260ec7ae00c48fb7d378637c2ab79ff8d0c.jpg)  
+Figure 1: Model structure of Backbone-Skippath Neural Network. The wide layers with sparse connections $( x - h _ { 1 } , h _ { 1 } - h _ { 2 } )$ form the Backbone path. The narrow fully-connected layers $( x - h _ { 3 }$ , $h _ { 1 } - h _ { 3 }$ , $h _ { 2 } - h _ { 3 } )$ are the Skip-paths. The number of units at $h _ { 3 }$ is relatively smaller than that at $x$ , $h _ { 1 }$ and $h _ { 2 }$ .
+
+Learning parsimonious FNNs is challenging mainly because we need to determine the sparse connectivity between layers. Network pruning is a potential way to achieve this. However, it requires to start from a network which is much larger than necessary for the task at hand. This can cause a lot of computations wasted on those useless connections. In addition, network pruning is not able to learn the number of units and number of layers.
+
+In this paper, we assume that data are generated by a sparse probabilistic model with multiple layers of latent variables, and view the feed-forward network to be built as a way to approximate the relationships between the observed variables and the top-level latent variables in the probabilistic model. The level 1 latent variables induce correlations among the observed variables. Therefore, it is possible to determine them by analysing how the observed variables are correlated. Similarly, by analysing how the level 1 latent variables are correlated, we can determine the level 2 latent variables, and so on. We empirically show that our method can significantly reduce the number of parameters in FNNs, and the resulting model still achieves better or comparable results than FNNs in 17 classification tasks.
+
+# 2 RELATED WORKS
+
+Network Structure Learning One early attempt to learn network structure for FNNs is the approach based on constructive algorithms (Ash, 1989; Bello, 1992; Kwok & Yeung, 1997). These algorithms start from a small network and gradually add new neurons to the network until some stopping criterion are met (e.g. no more performance gain is observed). They require manuallydesigned strategies to decide how to connect new neurons to the existing network. Besides, each time when new neurons are introduced, the network needs to be retrained completely or partially. Lately, Adams et al. (2010) proposes to learn the structure of deep belief networks by using cascading Indian buffet process, which is very time-consuming. In Chen et al. (2017b), the authors propose a structure learning method, based on hierarchical latent tree analysis (Liu et al., 2014; Chen et al., 2016; 2017a), for RBM-like models. The method automatically determines the number of hidden units and the sparse connections between layers. However, it is not tested on deep models and in supervised learning tasks. Recently, reinforcement learning (Baker et al., 2017; Zoph & Le, 2017) and genetic algorithms (Real et al., 2017; Xie & Yuille, 2017) are also applied to learning complex structures for CNNs. Generally, these methods require tens of thousands of full training runs before giving a feasible network structure, which is prohibitive for many applications.
+
+Network Pruning In contrast to constructive algorithms, network pruning starts from a large network and prune connections or neurons to achieve structure learning. Optimal Brain Damage (Cun et al., 1990) and Optimal Brain Surgeon (Hassibi et al., 1993) prune connections based on the Hessian matrix of the loss function. Recently, Han et al. (2015) proposes to conduct pruning by iteratively pruning connections with absolute weight value smaller than a threshold and retraining the network. One drawback of the method is that the retraining process is time-consuming. Guo et al. (2016) proposes Dynamic Network Surgery which conducts parameter learning and connection pruning simultaneously and avoids the retraining process. Moreover, it also allows mistakenly pruned connections to be rebuilt in subsequent training. Similar to connection pruning, neurons pruning methods are proposed and tested in Srinivas & Babu (2015); Li et al. (2017). The main drawback of all these pruning methods is that, they require to start from a network which is larger than necessary for the task at hand. This causes some wasted computations on the useless connections or neurons. In addition, the number of layers is still set manually instead of learned from data.
+
+# 3 METHODS
+
+In this section, we present a method for learning parsimonious deep FNNs. The method is called Parsimonious Structure Analysis (PSA). PSA learns a model which contains two parts as shown in Figure 1. The first is the main part of the model, called the Backbone. It is a wide, deep but sparse feed-forward path in the network. The second part is the Skip-paths. It consists of multiple narrow paths, each of which is a fully-connected layer. We call the resulting model Backbone-Skippath Neural Network (BSNN). We will introduce how PSA learns the Backbone and the Skip-paths in Section 3.1 and Section 3.2 respectively.
+
+# 3.1 LEARNING THE BACKBONE
+
+Structure learning for neural networks is challenging since generally the features in data do not always have apparent relationships as the units in convolutional networks. In a convolutional layer, units in a feature map are only connected to a group of units strongly correlated in the spacial dimension at the layer below. This significantly reduces the number of parameters in CNNs and is essential if we want to learn a very sparse structure. The same intuition can be applied to general data other than images in feed-forward neural networks. A hidden unit, detecting one particular feature such as co-occurrence pattern, should only be connected to a group of units that are strongly correlated in the layer below. However, unlike CNNs where the spatial correlation is apparent, the correlations of units in feed-forward neural networks are not easy to discover. In PSA, we propose to apply Hierarchical Latent Tree Analysis (HLTA) (Liu et al., 2014; Chen et al., 2016; 2017a) to identify the co-occurrence patterns among units and construct hidden units to explain the co-occurrence patterns.
+
+# 3.1.1 LEARNING A TWO-LAYER STRUCTURE
+
+PSA treats the input features as a set of isolated random variables as in Figure 3(a). Although no apparent spacial or sequential relationships exist among the variables, PSA seeks to discover the correlations among the variables and groups the highly correlated ones together. It starts from finding two most correlated variables to form one group and keeps expanding the group if necessary. Let $S$ denotes the set of observed variables which haven’t been included into any variable groups.
+
+![](images/b90b7261dcbb1cd8991ccd4cc59a9bf00375b867b45504166123254c9987295e.jpg)  
+Figure 2: Example: (a) The best model with one latent variable for five observed variables. (b) The best model with two latent variables for five observed variables.
+
+![](images/af2b0fbfa98ce86a5194cc77219ca1cc12f14dbfa0f6baa3ee868b062112e634.jpg)  
+Figure 3: The structure learning steps of PSA. Black circles represent observed variables while white circles represent latent variables. (a) A set of observed variables. (b) Partitions the observed variables into groups. (c) Introduces a latent variable for each group and link the latent variables up as a Chow-Liu tree. (d) Converts the latent variables at layer 1 into observed variables and repeat the previous process on them. (e) Stacks the layer 2 latent variables on the top previous model.
+
+PSA firstly computes the mutual information between each pair of observed variables. Then it picks the pair in $S$ with the highest mutual information and uses them as the seeds of a new variable group $G$ . New variables from $S$ are then added to $G$ one by one in descending order of their mutual information with variables already in $G$ . Each time when a new variable is added into $G$ , PSA builds two models $\mathcal { M } _ { 1 }$ and $\mathcal { M } _ { 2 }$ ) with $G$ as the observed variables. The two models are the best models with one single latent variable and two latent variables respectively, as shown in Figure 2. PSA computes the BIC scores of the two models and tests whether the following condition is met:
+
+$$
+B I C ( \mathcal { M } _ { 2 } | D ) - B I C ( \mathcal { M } _ { 1 } | D ) \leq \delta ,
+$$
+
+where $D$ is the dataset and $\delta$ is a threshold which is usually set at 3 (Chen et al., 2017a). When the condition is met, the two latent variable model $\mathcal { M } _ { 2 }$ is not significantly better than the one latent variable model $\mathcal { M } _ { 1 }$ . Correlations among variables in $\mathbf { G }$ are still well modeled using a single latent variable. Then PSA keeps on adding new variables to $G$ . If the test fails, PSA takes the subtree in $\mathcal { M } _ { 2 }$ which doesn’t contain the newly added variable and identifies the observed variables in it as a finalized variable group. The group is then removed from $S$ . And the above process is repeated on $S$ until all the variables in $S$ are partitioned into disjoint groups. An efficient algorithm progressive EM (Chen et al., 2016) is used to estimate the parameters in $\mathcal { M } _ { 1 }$ and $\mathcal { M } _ { 2 }$ .
+
+As shown in Figure 2(b), after the above process, all the observed variables are partitioned into disjoint groups such that the variables in each group are strongly correlated and their correlations can be explained using a single latent variables. Then PSA introduces a latent variable for each group and computes the mutual information among the latent variables. After that, it links up the latent variables to form a Chow-Liu tree (Chow & Liu, 1968). The result is a latent tree model (Pearl, 1988; Zhang, 2004), as shown in Figure 2(c). Parameter estimation for the model is done using the EM algorithm. Since the model is tree-structured, EM is efficient in this process.
+
+![](images/fee4c49cd7403a11a15dde2a7df33190ba7cb78e6c98a466dde56e925944bf34.jpg)  
+Figure 4: Expanding the tree structure for the Backbone path: A three-layer structure is first learned (left). New connections are added to all the layers according to empirical conditional mutual information (middle). The connections between variables at the top layer are removed and the structure is finalized (right).
+
+# 3.1.2 LEARNING A DEEP STRUCTURE
+
+While the above procedure gives us a one-layer network, we seek to build deep model to capture the long-range correlations among variables. We perform the construction of deep structure in a layerwise manner. Using the obtained one-layer model, PSA converts the latent variables into observed ones through data completion. With this, another layer of latent variables can be learned in the same manner as the first layer by grouping the first-layer latent variables and linking up the groups, as in Figure 2(d). Then the two models can be stacked up to form a three-layer network, with the latent variables in the higher layer capturing longer-range correlations of the observed variables. This procedure can be recursively conducted to build deep hierarchy until the number of variables at the top layer falls below a threshold $K$ . And it results in a hierarchical latent tree model (Liu et al., 2014; Chen et al., 2016; 2017a).
+
+# 3.1.3 EXPANDING TREE STRUCTURE
+
+While the above deep structure captures the most important correlations among the observed variables, the tree structure might cause underfitting for discovering non-trivial correlations. Thus we introduce additional links to model the salient interactions that are not captured by the tree model. For each latent variable $V _ { l }$ at level $l$ , PSA considers adding connections to link it to more nodes at level $l - 1$ . To do so, PSA considers how closely $V _ { l }$ is related to each node $V _ { l - 1 }$ at level $l - 1$ given the parent variable $Z$ of $V _ { l - 1 }$ . The strength of correlation is measured using the conditional mutual information:
+
+$$
+I ( V _ { l } , V _ { l - 1 } | Z ) .
+$$
+
+The top $N$ nodes with the highest $I ( V _ { l } , V _ { l - 1 } | Z )$ are then connected to $V _ { l }$ . After expanding the connections for all the layers, PSA removes the links among the variables at the top layer and uses the resulting structure for the Backbone. The process of expanding tree structure is illustrated in Figure 4.
+
+# 3.2 SKIP-PATHS
+
+Although the Backbone path is deep and wide, its sparsity can easily lead to model which cannot capture global features. For example, suppose there is an essential feature which is correlated to all the input features. When the Backbone path is very sparse, even after multiple layers of projections, it is still unlikely that there will be a feature in the model which is projected from all the input features.
+
+To tackle the above problem, we introduce Skip-paths to our BSNN. Figure 1 shows the whole model structure of BSNN. The path from $x$ to $h _ { 2 }$ illustrates the Backbone path whose sparse structure is learned using the method we propose. To complement the the model’s power of extracting features, narrow Skip-paths $( x - h _ { 3 } , h _ { 1 } - h _ { 3 } , h _ { 2 } - h _ { 3 } )$ are added to the model. The Skip-paths take all the feature layers in the Backbone as input and compress them to layers with a small number of units through fully-connected projections.
+
+Table 1: Statistics of all the datasets.   
+
+<table><tr><td>Dataset</td><td>Task</td><td>Classes</td><td>Training Samples</td><td>Validation Samples</td><td>Test Samples</td></tr><tr><td>Tox21</td><td>Toxicity prediction</td><td>2</td><td>6,901~ 9,154</td><td>500</td><td>516~ 622</td></tr><tr><td>Yelp Review Full</td><td>Sentiment prediction</td><td>5</td><td>640,000</td><td>10,000</td><td>50,000</td></tr><tr><td>DBPedia</td><td>Topic classification</td><td>14</td><td>549,990</td><td>10,010</td><td>70.000</td></tr><tr><td>Sogou News</td><td>Topic classification</td><td>5</td><td>440,000</td><td>10,000</td><td>60,000</td></tr><tr><td>Yahoo!Answer</td><td>Topic classification</td><td>10</td><td>1,390,000</td><td>10,000</td><td>60.000</td></tr><tr><td>AG&#x27;s News</td><td>Topic classification</td><td>4</td><td>110,000</td><td>10,000</td><td>7,600</td></tr></table>
+
+# 3.3 BUILDING BSNN
+
+After the structure for the Backbone path and the Skip-paths are determined, a classification layer or regression layer can then be added to the top of all the paths, utilizing all the features extracted. The network can then be trained using back-propagation algorithms as in normal neural networks.
+
+# 4 EXPERIMENTS
+
+In experiment, we evaluate our method in 17 classification tasks. We consider applications where the data is neither spacial nor sequential. Unlike CNNs or RNNs where the structure is designed to exploit spatial or sequential correlation, few effort has been put to learn the structure of feedfoward neural networks, which have highly redudant parameters and is prone to overfit. Our proposed method learns the structure of feedforward neural network from data. It significantly reduces the model complexity and parameters while achieving better or comparable classification performance, and leads to models which are more interpretable.
+
+# 4.1 DATASETS
+
+Table 1 gives a summary of all the datasets used in the experiment. We choose 12 tasks for chemical compounds classification and 5 tasks for text classification. All the datasets are published by previous researchers and are available to the public.
+
+Tox21 challenge dataset. 1 There are about 12,000 environmental chemical compounds in the dataset, each represented as its chemical structure. The tasks are to predict 12 different toxic effects for the chemical compounds. We treat them as 12 binary classification tasks. We filter out sparse features which are present in fewer than $5 \%$ compounds, and rescale the remaining 1,644 features to zero mean and unit variance. The dataset contains a training set and a test set, and we randomly sample 500 compounds from training data to build the validation set. All the experiments are run for three times and we report the average AUC together with the standard deviations.
+
+Text classification datasets. 2 We use 5 text classification datasets from Zhang et al. (2015). After removing stop words, the top 10,000 frequent words in each dataset are selected as the vocabulary respectively and each document is represented as bag-of-words over the vocabulary. The validation set is randomly sampled from the original training samples. We run all the experiments for three times and report the average classification accuracies with the standard deviations.
+
+Table 2: Hyper-parameters for the structure of FNNs.   
+
+<table><tr><td>Hyper-parameter</td><td>Values considered</td></tr><tr><td>Number ofhiddenunits</td><td>{512,1024,2048}</td></tr><tr><td>Number of hidden layers</td><td>{1,2,3,4}</td></tr><tr><td>Network shape</td><td>{Rectangle, Conic}</td></tr></table>
+
+# 4.2 EXPERIMENT SETUP
+
+We compare our model with standard feed-forward neural networks (FNNs) and sparse neural networks whose weak connections are pruned (Pruned FNNs) in the 17 classification tasks. The models involved in the experiment are as follows:
+
+• BSNN: Backbone-Skippath Neural Network is the resulting model of our method PSA. For all the tasks, we keep only $5 \%$ of the connections in the Backbone path and limit the number of units in the narrow Skip-paths to 100. FNN: Feed-forward Neural Network is a standard fully-connected neural network. It is mainly composed of linear layers and activation functions. Each hidden unit is connected to all neurons in the previous layer. Information flows from low layers to high layers in a feed-forward manner. Pruned FNN: Pruned Feed-forward Neural Network is trained by using the method proposed in Han et al. (2015). We Firstly train a fully-connected FNN from scratch, and then prune out the weak connections with small absolute weight values. The pruned network is then retrained from the initial training phase by keeping the surviving weight parameters.
+
+We learn the structure of BSNNs using PSA. The number of layers, the number of hidden units in each layer and the sparse connections between adjacent layers are automatically determined. After structure learning, we train the sparse model from scratch by random initialization of weights. As for FNNs, we treat the number of hidden units and number of layers as hyper-parameters of network and determine the best structure by grid-search over all the combinations using validation data. Table 2 shows the space of network structures considered. Following the method in Klambauer et al. (2017) , both “rectangle ” and “conic” network shapes are tested. In FNNs with rectangle shape, all the hidden layers have constant number of units. FNNs with conic shape start with the given number of hidden units and decrease it layer by layer in a geometric progression manner towards the output layer. For Pruned FNNs, we take the best FNNs as the initial model and perform pruning as in Han et al. (2015). The pruned model is then retrained for final model.
+
+We implement all the experiments using PyTroch3 which is a flexible deep learning framework. We use ReLUs (Nair & Hinton, 2010; Glorot et al., 2011) as the non-linear activation functions in all the networks. Dropout (Hinton et al., 2012b; Srivastava et al., 2014) with rate 0.5 is applied after each non-linear projection. We use Adam (Kingma & Ba, 2014) as the optimizer to optimize the training objective function. During training, we select models by monitoring validation loss. Codes will be released after the paper is accepted to the conference.
+
+# 4.3 RESULTS
+
+# 4.3.1 BSNNS VS FNNS
+
+Table 3 shows the classification results of BSNNs and FNNs on Tox21 dataset. The structures of FNNs are tuned individually for each task. It is clear that BSNNs achieve better AUC scores on 10 out of the 12 classification tasks. Even when it is not better, the average AUC value of BSNNs, e.g. on task SR.MMP, is also very close to that of FNNs. More importantly, BSNNs always contain much fewer parameters than FNNs, with the ratios of parameter number ranging from $7 \%$ to $4 0 . 1 1 \%$ .
+
+Table 4 shows the results of BSNNs and FNNs over the 5 text classification tasks. Although BSNNs contain much fewer parameters than FNNs, BSNNs still achieve higher classification accuracy in the first two tasks, and comparable accuracy in the remaining tasks. Note that the ratios of parameter number ranges from $6 . 2 5 \%$ to $3 2 . 0 7 \%$ . This again confirms that our method learns good parsimonious deep models which can achieve high classification performance with much fewer parameters than standard FNNs.
+
+Table 3: Comparison between BSNNs and FNNs on $\mathrm { T o x } 2 1$ challenge dataset. The structures of FNNs are chosen by using validation data. Each experiment is run for three times.   
+
+<table><tr><td></td><td colspan="2">BSNNs</td><td colspan="2">FNNs</td></tr><tr><td></td><td colspan="3">Parameter#/</td><td></td></tr><tr><td>Task</td><td>AUC</td><td>Ratio W.r.t FNNs</td><td>AUC</td><td>Parameter #</td></tr><tr><td>NR.AhR</td><td>0.8930± 0.0014</td><td>338K/ 37.08%</td><td>0.8843 ± 0.0030</td><td>912K</td></tr><tr><td>NR.AR</td><td>0.7316 ± 0.0245</td><td>338K/ 20.05%</td><td>0.6629 ± 0.0155</td><td>1.69M</td></tr><tr><td>NR.AR.LBD</td><td>0.7827 ± 0.0200</td><td>338K/ 20.05%</td><td>0.7216 ± 0.0245</td><td>1.69M</td></tr><tr><td>NR.Aromatase</td><td>0.7854 ± 0.0098</td><td>338K/ 40.11%</td><td>0.7834 ± 0.0046</td><td>843K</td></tr><tr><td>NR.ER</td><td>0.7804 ± 0.0042</td><td>338K/ 12.36%</td><td>0.7671 ± 0.0090</td><td>2.73M</td></tr><tr><td>NR.ER.LBD</td><td>0.7772 ± 0.0088</td><td>338K/ 20.75%</td><td>0.8145 ± 0.0035</td><td>1.63M</td></tr><tr><td>NR.PPAR.gamma</td><td>0.8232 ± 0.0019</td><td>338K/ 39.38%</td><td>0.8024 ± 0.0098</td><td>858K</td></tr><tr><td>SR.ARE</td><td>0.7877 ± 0.0036</td><td>338K/ 7.00%</td><td>0.7809 ± 0.0092</td><td>4.83M</td></tr><tr><td>SR.ATAD5</td><td>0.8188 ± 0.0085</td><td>338K/ 40.11%</td><td>0.7980 ± 0.0014</td><td>843K</td></tr><tr><td>SR.HSE</td><td>0.8330 ± 0.0053</td><td>338K/ 30.59%</td><td>0.8318 ± 0.0047</td><td>1.10M</td></tr><tr><td>SR.MMP</td><td>0.9249 ± 0.0014</td><td>338K/ 20.05%</td><td>0.9253 ± 0.0038</td><td>1.69M</td></tr><tr><td>SR.p53</td><td>0.8425 ± 0.0023</td><td>338K/ 40.11%</td><td>0.8401 ± 0.0049</td><td>843K</td></tr><tr><td>Average</td><td>0.8150 ± 0.0038</td><td>27.30%</td><td>0.8010± 0.0017</td><td></td></tr></table>
+
+Table 4: Comparison between BSNNs and FNNs on 5 text classification datasets. The structures of FNNs are chosen by using validation data. Each experiment is run for three times.   
+
+<table><tr><td></td><td colspan="3">BSNNs</td><td colspan="2">FNNs</td></tr><tr><td>Task</td><td></td><td>Parameter#/</td><td></td><td></td><td></td></tr><tr><td>Yelp Review Full</td><td>Accuracy 59.14% ± 0.06%</td><td>Ratio w.r.t FNNs</td><td>32.07%</td><td>Accuracy</td><td>Parameter #</td></tr><tr><td>DBPedia</td><td>98.11% ± 0.03%</td><td>1.73M/ 1.78M /</td><td>17.13%</td><td>59.13% ± 0.14% 97.99% ± 0.04%</td><td>5.38M 10.36M</td></tr><tr><td>Sogou News</td><td>96.09% ± 0.06%</td><td>1.84M /</td><td>13.77%</td><td>96.12% ± 0.06%</td><td>13.39M</td></tr><tr><td>Yahoo!Answer</td><td>71.42% ± 0.06%</td><td>1.69M /</td><td>31.42%</td><td>71.84% ± 0.07 %</td><td></td></tr><tr><td>AG&#x27;s News</td><td>91.39% ± 0.03%</td><td>1.81M /</td><td>6.25%</td><td>91.61% ± 0.01%</td><td>5.39M 28.88M</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+# 4.3.2 CONTRIBUTION OF THE BACKBONE
+
+Table 5: Comparison between BSNNs and BSNNs with only the backbone path. Tox21 Average corresponds to the result averaged over the 12 tasks in Tox21 dataset. Each experiment is run for three times.   
+
+<table><tr><td></td><td>BSNNs</td><td colspan="3">Backbone Path in BSNNs</td></tr><tr><td></td><td></td><td></td><td>Parameterratio</td><td>Parameterratio</td></tr><tr><td>Task Tox21 Average</td><td>AUC/Accuracy</td><td>AUC/Accuracy</td><td>w.r.t BSNNs</td><td>w.r.t FNNs</td></tr><tr><td>Yelp Review Full</td><td>0.8150± 0.0038 59.14% ± 0.06%</td><td>0.7839± 0.0076 58.63% ± 0.13%</td><td>30.47% 35.47%</td><td>8.32% 11.38%</td></tr><tr><td>DBPedia</td><td>98.11% ± 0.03%</td><td></td><td>36.67%</td><td></td></tr><tr><td>Sogou News</td><td>96.09% ± 0.06%</td><td>97.91% ± 0.04%</td><td>38.63%</td><td>6.28%</td></tr><tr><td>Yahoo!Answer</td><td>71.42% ± 0.06%</td><td>95.67% ± 0.04%</td><td>34.39%</td><td>5.32%</td></tr><tr><td>AG&#x27;s News</td><td></td><td>69.95% ± 0.08%</td><td></td><td>10.80%</td></tr><tr><td></td><td>91.39% ± 0.03%</td><td>91.33% ± 0.03%</td><td>37.55%</td><td>2.35%</td></tr></table>
+
+To validate our assumption that the backbone path in BSNNs captures most of the information in data and acts as a main part of the model, we remove the narrow skip-paths in BSNNs and train the model to test its performance in classification tasks. Table 5 shows the results. As we can see from the results, the backbone path alone already achieves AUC scores or accuracies which are only slightly worse than BSNNs. Note that the number of parameters in the sparse path is even much smaller than BSNNs. Compared with FNNs, the number of parameters is only $2 \%$ $11 \%$ , significantly smaller than that of FNNs. However, without the backbone, the performance of the model will be significantly worse due to the insufficient capability of the other narrow path. The results not only show the importance of the backbone path in BSNNs, but also shows that our structure learning method in the backbone path is effective enough.
+
+Table 6: AUC scores of BSNNs, BSNN-FCs and Pruned FNNs on Tox21 dataset. For each task, better result between BSNNs and BSNN-FCs is underlined, while better result between BSNNs and Pruned FNNs is bold.   
+
+<table><tr><td>Task</td><td>BSNNs</td><td>BSNN-FCs</td><td>Pruned FNNs</td></tr><tr><td>NR.AhR</td><td>0.8930± 0.0014</td><td>0.8910±0.0014</td><td>0.8845 ± 0.0047</td></tr><tr><td>NR.AR</td><td>0.7316 ± 0.0245</td><td>0.6780 ± 0.0252</td><td>0.6660 ± 0.0206</td></tr><tr><td>NR.AR.LBD</td><td>0.7827 ± 0.0200</td><td>0.7796 ± 0.0136</td><td>0.7475 ± 0.0356</td></tr><tr><td>NR.Aromatase</td><td>0.7854 ± 0.0098</td><td>0.7757 ± 0.0124</td><td>0.7782 ± 0.0069</td></tr><tr><td>NR.ER</td><td>0.7804 士 0.0042</td><td>0.7693 ± 0.0049</td><td>0.7767 ± 0.0059</td></tr><tr><td>NR.ER.LBD</td><td>0.7772 士 0.0088</td><td>0.7970 ± 0.0057</td><td>0.8054 ± 0.0071</td></tr><tr><td>NR.PPAR.gamma</td><td>0.8232 士 0.0019</td><td>0.8136 ±0.0032</td><td>0.7803 ± 0.0045</td></tr><tr><td>SR.ARE</td><td>0.7877 士 0.0036</td><td>0.7771 士 0.0058</td><td>0.7812 ± 0.0024</td></tr><tr><td>SR.ATAD5</td><td>0.8188 士 0.0085</td><td>0.8162 士 ：0.0062</td><td>0.7924 ± 0.0051</td></tr><tr><td>SR.HSE</td><td>0.8330 ± 0.0053</td><td>0.8453 土 0.0072</td><td>0.8308 ± 0.0103</td></tr><tr><td>SR.MMP</td><td>0.9249 ± 0.0014</td><td>0.9219 ±0.0004</td><td>0.9262 ± 0.0036</td></tr><tr><td>SR.p53</td><td>0.8425 ± 0.0023</td><td>0.8194± ：0.0010</td><td>0.8278 ± 0.0090</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Average</td><td>0.8150± 0.0038</td><td>0.8070± 0.0002</td><td>0.7998 ± 0.0034</td></tr></table>
+
+# 4.3.3 EFFECTIVENESS OF OUR STRUCTURE LEARNING
+
+To further show the effectiveness of our structure learning method, we introduce a new model called BSNN-FC. For each specific task, the structure of BSNN-FC is completely the same as that of BSNN, except that the layers in the sparse Backbone path are changed to fully-connected layers. We train BSNN-FC for all the tasks in Tox21 dataset and the results are shown in Table 6. From the table we can see that, although BSNN keeps only $5 \%$ of the connections in the sparse path, it gives classification results which are very similar to that of BSNN-FC. It shows that our structure learning method successfully removes the useless connections in BSNN-FC.
+
+We also compare BSNNs with Pruned FNNs whose weak connections are pruned using the method in Han et al. (2015). We start from the fully pretrained FNNs reported in Table 3, and prune the connections with the smallest absolute weight values. After pruning, the number of remaining parameters in each FNN is the same as that in the corresponding BSNN for the same task. The comparison between BSNNs and pruned FNNs is shown in Table 6. Again BSNNs give higher AUC scores than pruned FNNs in 10 of the 12 classification tasks.
+
+# 4.3.4 INTERPRETABILITY
+
+Next we compare the interpretability of BSNNs with FNNs and Pruned FNNs on the text datasets. Here is how we interpret hidden units. We feed the data to the networks and do forward propagation to get the values of the hidden units corresponding to each data sample. Then for each hidden unit, we sort the words in descending order of the correlations between the words and the hidden unit. The top 10 words with the highest correlations are chosen to characterize the hidden unit. Following Chen et al. (2017b), we measure the interpretability of a hidden unit by considering how similar pairs of words in the top-10 list are. The similarity between two words is determined using a word2vec model (Mikolov et al., 2013a;b) trained on part of the Google News datasets, where each word is mapped to a high dimensional vector. The similarity between two words is defined as the cosine similarity of the two corresponding vectors. High similarity suggests that the two words appear in similar contexts. The interpretability score of a hidden unit is defined as the compactness of its characterizing words and is computed as the average similarity of all pairs of words. The interpretability score of a model is defined as the average of interpretability scores of all hidden units.
+
+Table 7: Interpretability scores of BSNNS, FNNs and Pruned FNNs on different datasets   
+
+<table><tr><td>Task</td><td>BSNNs</td><td>FNNs</td><td>Pruned FNNs</td></tr><tr><td>Yelp Review Full</td><td>0.1632</td><td>0.1117</td><td>0.1</td></tr><tr><td>DBPedia</td><td>0.0609</td><td>0.0497</td><td>0.0553</td></tr><tr><td>Yahoo!Answer</td><td>0.1729</td><td>0.1632</td><td>0.1553</td></tr><tr><td>AG&#x27;s News</td><td>0.0531</td><td>0.0595</td><td>0.0561</td></tr></table>
+
+Table 8: Qualitative interpretability results of hidden units in BSNNs. Each line corresponds to one hidden unit.   
+
+<table><tr><td>Task</td><td>BSNNs</td></tr><tr><td>Yelp Review Full</td><td>tastelessunseasoned flavorlessblandlacked paprika panko crusts unagi crumb vindaloo tortas spicey wink drapes</td></tr><tr><td>DBPedia</td><td>album songwriting chet saxophone thrash hurling backstroke badminton skier outfelder journalists hardcover editors reprinted republished</td></tr><tr><td>Yahoo!Answer</td><td>harddrive antispyware wifi mcafee routers javascript linux tcp linksys laptops romantic dating foreplay flirt boyfriend</td></tr><tr><td>AG&#x27;s News</td><td>mozilla mainframe designs collaborate microprocessors republicans prosecutor argument jfk protesters noted furious harsh concessions apologizes</td></tr></table>
+
+Table 7 reports the interpretability scores of BSNNs, FNNs and Pruned FNNs for different datasets. Sogounews dataset is not included in the experiment since its vocabulary are Chinese pingyin characters and most of them do not appear in the Google News word2vec model. We measure the interpretability scores by considering the top-layer hidden units. For the fair of comparison, all models have approximately the same number of top-layer hidden units. As it can be seen that BSNNs significantly outperform the FNNs and Pruned FNNs in most cases and is comparable if not better, showing superior coherency and compactness in the characterizations of the hidden units and thus better model interpretability. Pruned FNNs, on the other hand, reduce the interpretability of FNNs with the pruning strategy. Table 8 shows the qualitative interpretability results by presenting the characterization words of hidden units with high interpretability scores in BSNNs. The hidden units are very meaningful for different datasets. For example, in Yelp Review dataset, the first hidden unit represents negative opinions on food with words “tasteless” and“flavorless”; the second hidden unit is more related to food like “paprika”, “crust” and “unagi”. In DBPedia, the first hidden unit is found out to have closer relationship with music, while the second one is more closely related to sport. Similar phenomena can be found in the rest of the table. This shows that the proposed BSNNs, with the statistical property, have better model interpretability and make a step further towards understandable deep learning models.
+
+# 5 CONCLUSIONS
+
+Structure learning for deep neural network is a challenging and interesting research problem. We have proposed an unsupervised structure learning method which utilizes the correlation information in data for learning parsimonious deep feed-forward networks. In comparison with standard FNN, although the resulting model of our method contains much fewer parameters, it achieves better or comparable classification performance in all kinds of tasks. Our method is also shown to learn models with better interpretability, which is also an important problem in deep learning. In the future, we will generalize our method to other networks like RNNs and CNNs.
+
+# REFERENCES
+
+Ryan Prescott Adams, Hanna M Wallach, and Zoubin Ghahramani. Learning the structure of deep sparse graphical models. In AISTATS, 2010.
+
+Timur Ash. Dynamic node creation in backpropagation networks. Connection science, 1(4):365– 375, 1989.
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. In ICLR, 2017.
+
+Martin G Bello. Enhanced training algorithms, and integrated training/architecture selection for multilayer perceptron networks. IEEE Transactions on Neural networks, 3(6):864–875, 1992.
+
+Peixian Chen, Nevin L Zhang, Leonard KM Poon, and Zhourong Chen. Progressive em for latent tree models and hierarchical topic detection. In AAAI, 2016.
+
+Peixian Chen, Nevin L Zhang, Tengfei Liu, Leonard KM Poon, Zhourong Chen, and Farhan Khawar. Latent tree models for hierarchical topic detection. Artificial Intelligence, 250:105–124, 2017a.
+
+Zhourong Chen, Nevin L Zhang, Dit-Yan Yeung, and Peixian Chen. Sparse boltzmann machines with structure learning as applied to text analysis. In AAAI, 2017b.
+
+C Chow and Cong Liu. Approximating discrete probability distributions with dependence trees. IEEE transactions on Information Theory, 14(3):462–467, 1968.
+
+Yann Le Cun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS, 1990.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In AISTATS, 2011.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In NIPS, 2016.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015.
+
+Babak Hassibi, David G. Stork, and Stork Crc. Ricoh. Com. Second order derivatives for network pruning: Optimal brain surgeon. In NIPS, 1993.
+
+Geoffrey E Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012a.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012b.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. In NIPS, 2017.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Tin-Yau Kwok and Dit-Yan Yeung. Constructive algorithms for structure learning in feedforward neural networks for regression problems. IEEE Transactions on Neural Networks, 8(3):630–645, 1997.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.
+
+Tengfei Liu, Nevin L. Zhang, and Peixian Chen. Hierarchical latent tree analysis for topic detection. In ECML/PKDD, 2014.
+
+Toma´s Mikolov, Anoop Deoras, Daniel Povey, Luk ˇ a´s Burget, and Jan ˇ Cernock ˇ y. Strategies for \` training large scale neural network language models. In IEEE Workshop on Automatic Speech Recognition and Understanding, pp. 196–201, 2011.
+
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. In International Conference on Learning Representations Workshops, 2013a.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013b.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Judea Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1988. ISBN 0-934613-73-7.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. In ICML, 2017.
+
+Suraj Srinivas and R. Venkatesh Babu. Data-free parameter pruning for deep neural networks. In Proceedings of the British Machine Vision Conference, 2015.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, 2014.
+
+Lingxi Xie and Alan Yuille. Genetic cnn. arXiv preprint arXiv:1703.01513, 2017.
+
+Nevin L Zhang. Hierarchical latent class models for cluster analysis. Journal of Machine Learning Research, 5(6):697–723, 2004.
+
+Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In NIPS, 2015.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In ICLR, 2017.

parse/train/HJMN-xWC-/HJMN-xWC-_content_list.json

@@ -0,0 +1,1326 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING PARSIMONIOUS DEEP FEED-FORWARD NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks and recurrent neural networks are designed with network structures well suited to the nature of spacial and sequential data respectively. However, the structure of standard feed-forward neural networks (FNNs) is simply a stack of fully connected layers, regardless of the feature correlations in data. In addition, the number of layers and the number of neurons are manually tuned on validation data, which is time-consuming and may lead to suboptimal networks. In this paper, we propose an unsupervised structure learning method for learning parsimonious deep FNNs. Our method determines the number of layers, the number of neurons at each layer, and the sparse connectivity between adjacent layers automatically from data. The resulting models are called Backbone-Skippath Neural Networks (BSNNs). Experiments on 17 tasks show that, in comparison with FNNs, BSNNs can achieve better or comparable classification performance with much fewer parameters. The interpretability of BSNNs is also shown to be better than that of FNNs. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            336,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have made breakthroughs in all kinds of machine learning tasks (LeCun et al., 2015; Hinton et al., 2012a; Mikolov et al., 2011), specifically with convolutional neural networks (CNNs) for tasks with spacial data (Krizhevsky et al., 2012) and recurrent neural networks (RNNs) for tasks with sequential data (Sutskever et al., 2014). One of the key reasons for the effectiveness of CNNs and RNNs is the well-designed network structures together with the parameter sharing schemes. For example, in the convolution layers of CNNs, each neuron is connected to a local region in the input volume instead of all the input neurons. Besides, the neurons in the same channel share the same set of weights. This design utilizes the local and “stationary” properties of spacial data and consequently forms effective feature extractors. In addition, it also prevents CNNs from having an exploding number of parameters when the networks become deeper and deeper. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            674
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, in practice, there are also many data which are neither spacial nor sequential, and hence the only applicable neural networks are the standard feed-forward neural networks (FNNs). In contrast to CNN and RNN, FNN’s network structure is simple. It consists of multiple layers of neurons and each layer is fully connected to the next layer up, without considering any correlations in data or among neurons. The network structure has two main shortcomings. The first is that, there can be high connection redundancies. As the number of layers and the number of neuron at each layer increase, the number of parameters increases quickly, which can cause severe overfitting. The other shortcoming is that, ignoring all the correlations existing in data weakens the model’s strength (as a feature extractor) and hurts the model’s interpretability. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We are interested in learning parsimonious deep feed-forward neural networks. The goal is to learn FNNs which contain as few parameters as possible. Parsimonious FNNs are desirable for several reasons. Firstly, fewer parameters can ease overfitting. Secondly, parsimonious FNNs require less storage and computation than FNNs, which makes it possible to be run on devices like mobile phones. Lastly, parsimonious FNNs can have very flexible and different structures from each other depending on the specific tasks and data. This would help the models fit the data well and also have good interpretability. In general, it is desirable to solve a problem using the simplest model possible because it implies a good understanding of the problem. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/333a9c4fb5cf8f596a69bdbdee6d7260ec7ae00c48fb7d378637c2ab79ff8d0c.jpg",
+        "image_caption": [
+            "Figure 1: Model structure of Backbone-Skippath Neural Network. The wide layers with sparse connections $( x - h _ { 1 } , h _ { 1 } - h _ { 2 } )$ form the Backbone path. The narrow fully-connected layers $( x - h _ { 3 }$ , $h _ { 1 } - h _ { 3 }$ , $h _ { 2 } - h _ { 3 } )$ are the Skip-paths. The number of units at $h _ { 3 }$ is relatively smaller than that at $x$ , $h _ { 1 }$ and $h _ { 2 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            292,
+            99,
+            709,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning parsimonious FNNs is challenging mainly because we need to determine the sparse connectivity between layers. Network pruning is a potential way to achieve this. However, it requires to start from a network which is much larger than necessary for the task at hand. This can cause a lot of computations wasted on those useless connections. In addition, network pruning is not able to learn the number of units and number of layers. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we assume that data are generated by a sparse probabilistic model with multiple layers of latent variables, and view the feed-forward network to be built as a way to approximate the relationships between the observed variables and the top-level latent variables in the probabilistic model. The level 1 latent variables induce correlations among the observed variables. Therefore, it is possible to determine them by analysing how the observed variables are correlated. Similarly, by analysing how the level 1 latent variables are correlated, we can determine the level 2 latent variables, and so on. We empirically show that our method can significantly reduce the number of parameters in FNNs, and the resulting model still achieves better or comparable results than FNNs in 17 classification tasks. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            354,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Network Structure Learning One early attempt to learn network structure for FNNs is the approach based on constructive algorithms (Ash, 1989; Bello, 1992; Kwok & Yeung, 1997). These algorithms start from a small network and gradually add new neurons to the network until some stopping criterion are met (e.g. no more performance gain is observed). They require manuallydesigned strategies to decide how to connect new neurons to the existing network. Besides, each time when new neurons are introduced, the network needs to be retrained completely or partially. Lately, Adams et al. (2010) proposes to learn the structure of deep belief networks by using cascading Indian buffet process, which is very time-consuming. In Chen et al. (2017b), the authors propose a structure learning method, based on hierarchical latent tree analysis (Liu et al., 2014; Chen et al., 2016; 2017a), for RBM-like models. The method automatically determines the number of hidden units and the sparse connections between layers. However, it is not tested on deep models and in supervised learning tasks. Recently, reinforcement learning (Baker et al., 2017; Zoph & Le, 2017) and genetic algorithms (Real et al., 2017; Xie & Yuille, 2017) are also applied to learning complex structures for CNNs. Generally, these methods require tens of thousands of full training runs before giving a feasible network structure, which is prohibitive for many applications. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Network Pruning In contrast to constructive algorithms, network pruning starts from a large network and prune connections or neurons to achieve structure learning. Optimal Brain Damage (Cun et al., 1990) and Optimal Brain Surgeon (Hassibi et al., 1993) prune connections based on the Hessian matrix of the loss function. Recently, Han et al. (2015) proposes to conduct pruning by iteratively pruning connections with absolute weight value smaller than a threshold and retraining the network. One drawback of the method is that the retraining process is time-consuming. Guo et al. (2016) proposes Dynamic Network Surgery which conducts parameter learning and connection pruning simultaneously and avoids the retraining process. Moreover, it also allows mistakenly pruned connections to be rebuilt in subsequent training. Similar to connection pruning, neurons pruning methods are proposed and tested in Srinivas & Babu (2015); Li et al. (2017). The main drawback of all these pruning methods is that, they require to start from a network which is larger than necessary for the task at hand. This causes some wasted computations on the useless connections or neurons. In addition, the number of layers is still set manually instead of learned from data. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            318,
+            290,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present a method for learning parsimonious deep FNNs. The method is called Parsimonious Structure Analysis (PSA). PSA learns a model which contains two parts as shown in Figure 1. The first is the main part of the model, called the Backbone. It is a wide, deep but sparse feed-forward path in the network. The second part is the Skip-paths. It consists of multiple narrow paths, each of which is a fully-connected layer. We call the resulting model Backbone-Skippath Neural Network (BSNN). We will introduce how PSA learns the Backbone and the Skip-paths in Section 3.1 and Section 3.2 respectively. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 LEARNING THE BACKBONE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            405,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Structure learning for neural networks is challenging since generally the features in data do not always have apparent relationships as the units in convolutional networks. In a convolutional layer, units in a feature map are only connected to a group of units strongly correlated in the spacial dimension at the layer below. This significantly reduces the number of parameters in CNNs and is essential if we want to learn a very sparse structure. The same intuition can be applied to general data other than images in feed-forward neural networks. A hidden unit, detecting one particular feature such as co-occurrence pattern, should only be connected to a group of units that are strongly correlated in the layer below. However, unlike CNNs where the spatial correlation is apparent, the correlations of units in feed-forward neural networks are not easy to discover. In PSA, we propose to apply Hierarchical Latent Tree Analysis (HLTA) (Liu et al., 2014; Chen et al., 2016; 2017a) to identify the co-occurrence patterns among units and construct hidden units to explain the co-occurrence patterns. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 LEARNING A TWO-LAYER STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            495,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "PSA treats the input features as a set of isolated random variables as in Figure 3(a). Although no apparent spacial or sequential relationships exist among the variables, PSA seeks to discover the correlations among the variables and groups the highly correlated ones together. It starts from finding two most correlated variables to form one group and keeps expanding the group if necessary. Let $S$ denotes the set of observed variables which haven’t been included into any variable groups. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b90b7261dcbb1cd8991ccd4cc59a9bf00375b867b45504166123254c9987295e.jpg",
+        "image_caption": [
+            "Figure 2: Example: (a) The best model with one latent variable for five observed variables. (b) The best model with two latent variables for five observed variables. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            313,
+            792,
+            681,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/af2b0fbfa98ce86a5194cc77219ca1cc12f14dbfa0f6baa3ee868b062112e634.jpg",
+        "image_caption": [
+            "Figure 3: The structure learning steps of PSA. Black circles represent observed variables while white circles represent latent variables. (a) A set of observed variables. (b) Partitions the observed variables into groups. (c) Introduces a latent variable for each group and link the latent variables up as a Chow-Liu tree. (d) Converts the latent variables at layer 1 into observed variables and repeat the previous process on them. (e) Stacks the layer 2 latent variables on the top previous model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            98,
+            686,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PSA firstly computes the mutual information between each pair of observed variables. Then it picks the pair in $S$ with the highest mutual information and uses them as the seeds of a new variable group $G$ . New variables from $S$ are then added to $G$ one by one in descending order of their mutual information with variables already in $G$ . Each time when a new variable is added into $G$ , PSA builds two models $\\mathcal { M } _ { 1 }$ and $\\mathcal { M } _ { 2 }$ ) with $G$ as the observed variables. The two models are the best models with one single latent variable and two latent variables respectively, as shown in Figure 2. PSA computes the BIC scores of the two models and tests whether the following condition is met: ",
+        "bbox": [
+            173,
+            621,
+            825,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6549e666debe5b54b4f4cdaf15c305e8205669d9edc88ead5a99bee2f9751250.jpg",
+        "text": "$$\nB I C ( \\mathcal { M } _ { 2 } | D ) - B I C ( \\mathcal { M } _ { 1 } | D ) \\leq \\delta ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            726,
+            619,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $D$ is the dataset and $\\delta$ is a threshold which is usually set at 3 (Chen et al., 2017a). When the condition is met, the two latent variable model $\\mathcal { M } _ { 2 }$ is not significantly better than the one latent variable model $\\mathcal { M } _ { 1 }$ . Correlations among variables in $\\mathbf { G }$ are still well modeled using a single latent variable. Then PSA keeps on adding new variables to $G$ . If the test fails, PSA takes the subtree in $\\mathcal { M } _ { 2 }$ which doesn’t contain the newly added variable and identifies the observed variables in it as a finalized variable group. The group is then removed from $S$ . And the above process is repeated on $S$ until all the variables in $S$ are partitioned into disjoint groups. An efficient algorithm progressive EM (Chen et al., 2016) is used to estimate the parameters in $\\mathcal { M } _ { 1 }$ and $\\mathcal { M } _ { 2 }$ . ",
+        "bbox": [
+            173,
+            748,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2(b), after the above process, all the observed variables are partitioned into disjoint groups such that the variables in each group are strongly correlated and their correlations can be explained using a single latent variables. Then PSA introduces a latent variable for each group and computes the mutual information among the latent variables. After that, it links up the latent variables to form a Chow-Liu tree (Chow & Liu, 1968). The result is a latent tree model (Pearl, 1988; Zhang, 2004), as shown in Figure 2(c). Parameter estimation for the model is done using the EM algorithm. Since the model is tree-structured, EM is efficient in this process. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fee4c49cd7403a11a15dde2a7df33190ba7cb78e6c98a466dde56e925944bf34.jpg",
+        "image_caption": [
+            "Figure 4: Expanding the tree structure for the Backbone path: A three-layer structure is first learned (left). New connections are added to all the layers according to empirical conditional mutual information (middle). The connections between variables at the top layer are removed and the structure is finalized (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            118,
+            813,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            303,
+            823,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 LEARNING A DEEP STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            362,
+            447,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the above procedure gives us a one-layer network, we seek to build deep model to capture the long-range correlations among variables. We perform the construction of deep structure in a layerwise manner. Using the obtained one-layer model, PSA converts the latent variables into observed ones through data completion. With this, another layer of latent variables can be learned in the same manner as the first layer by grouping the first-layer latent variables and linking up the groups, as in Figure 2(d). Then the two models can be stacked up to form a three-layer network, with the latent variables in the higher layer capturing longer-range correlations of the observed variables. This procedure can be recursively conducted to build deep hierarchy until the number of variables at the top layer falls below a threshold $K$ . And it results in a hierarchical latent tree model (Liu et al., 2014; Chen et al., 2016; 2017a). ",
+        "bbox": [
+            173,
+            387,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 EXPANDING TREE STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            442,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the above deep structure captures the most important correlations among the observed variables, the tree structure might cause underfitting for discovering non-trivial correlations. Thus we introduce additional links to model the salient interactions that are not captured by the tree model. For each latent variable $V _ { l }$ at level $l$ , PSA considers adding connections to link it to more nodes at level $l - 1$ . To do so, PSA considers how closely $V _ { l }$ is related to each node $V _ { l - 1 }$ at level $l - 1$ given the parent variable $Z$ of $V _ { l - 1 }$ . The strength of correlation is measured using the conditional mutual information: ",
+        "bbox": [
+            173,
+            569,
+            825,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0785c4bef9cf5e059b3d9855f2ef454e8b7c1d947e4b81cbdab84b3f7f10b5f4.jpg",
+        "text": "$$\nI ( V _ { l } , V _ { l - 1 } | Z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            666,
+            549,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The top $N$ nodes with the highest $I ( V _ { l } , V _ { l - 1 } | Z )$ are then connected to $V _ { l }$ . After expanding the connections for all the layers, PSA removes the links among the variables at the top layer and uses the resulting structure for the Backbone. The process of expanding tree structure is illustrated in Figure 4. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 SKIP-PATHS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            295,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although the Backbone path is deep and wide, its sparsity can easily lead to model which cannot capture global features. For example, suppose there is an essential feature which is correlated to all the input features. When the Backbone path is very sparse, even after multiple layers of projections, it is still unlikely that there will be a feature in the model which is projected from all the input features. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To tackle the above problem, we introduce Skip-paths to our BSNN. Figure 1 shows the whole model structure of BSNN. The path from $x$ to $h _ { 2 }$ illustrates the Backbone path whose sparse structure is learned using the method we propose. To complement the the model’s power of extracting features, narrow Skip-paths $( x - h _ { 3 } , h _ { 1 } - h _ { 3 } , h _ { 2 } - h _ { 3 } )$ are added to the model. The Skip-paths take all the feature layers in the Backbone as input and compress them to layers with a small number of units through fully-connected projections. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e7cad3d180a7d9e7aa9f1a89deab091cff10184235de007f7eeb5829e94fb98.jpg",
+        "table_caption": [
+            "Table 1: Statistics of all the datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Task</td><td>Classes</td><td>Training Samples</td><td>Validation Samples</td><td>Test Samples</td></tr><tr><td>Tox21</td><td>Toxicity prediction</td><td>2</td><td>6,901~ 9,154</td><td>500</td><td>516~ 622</td></tr><tr><td>Yelp Review Full</td><td>Sentiment prediction</td><td>5</td><td>640,000</td><td>10,000</td><td>50,000</td></tr><tr><td>DBPedia</td><td>Topic classification</td><td>14</td><td>549,990</td><td>10,010</td><td>70.000</td></tr><tr><td>Sogou News</td><td>Topic classification</td><td>5</td><td>440,000</td><td>10,000</td><td>60,000</td></tr><tr><td>Yahoo!Answer</td><td>Topic classification</td><td>10</td><td>1,390,000</td><td>10,000</td><td>60.000</td></tr><tr><td>AG&#x27;s News</td><td>Topic classification</td><td>4</td><td>110,000</td><td>10,000</td><td>7,600</td></tr></table>",
+        "bbox": [
+            176,
+            130,
+            823,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            281,
+            823,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 BUILDING BSNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            338,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After the structure for the Backbone path and the Skip-paths are determined, a classification layer or regression layer can then be added to the top of all the paths, utilizing all the features extracted. The network can then be trained using back-propagation algorithms as in normal neural networks. ",
+        "bbox": [
+            176,
+            363,
+            825,
+            405
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            433,
+            326,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In experiment, we evaluate our method in 17 classification tasks. We consider applications where the data is neither spacial nor sequential. Unlike CNNs or RNNs where the structure is designed to exploit spatial or sequential correlation, few effort has been put to learn the structure of feedfoward neural networks, which have highly redudant parameters and is prone to overfit. Our proposed method learns the structure of feedforward neural network from data. It significantly reduces the model complexity and parameters while achieving better or comparable classification performance, and leads to models which are more interpretable. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            287,
+            604
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 gives a summary of all the datasets used in the experiment. We choose 12 tasks for chemical compounds classification and 5 tasks for text classification. All the datasets are published by previous researchers and are available to the public. ",
+        "bbox": [
+            174,
+            618,
+            823,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Tox21 challenge dataset. 1 There are about 12,000 environmental chemical compounds in the dataset, each represented as its chemical structure. The tasks are to predict 12 different toxic effects for the chemical compounds. We treat them as 12 binary classification tasks. We filter out sparse features which are present in fewer than $5 \\%$ compounds, and rescale the remaining 1,644 features to zero mean and unit variance. The dataset contains a training set and a test set, and we randomly sample 500 compounds from training data to build the validation set. All the experiments are run for three times and we report the average AUC together with the standard deviations. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Text classification datasets. 2 We use 5 text classification datasets from Zhang et al. (2015). After removing stop words, the top 10,000 frequent words in each dataset are selected as the vocabulary respectively and each document is represented as bag-of-words over the vocabulary. The validation set is randomly sampled from the original training samples. We run all the experiments for three times and report the average classification accuracies with the standard deviations. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8723225d3ef8da221ab0fb1fa7033585ef91ef255a8fa29b0bc8749d82b2fdf0.jpg",
+        "table_caption": [
+            "Table 2: Hyper-parameters for the structure of FNNs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyper-parameter</td><td>Values considered</td></tr><tr><td>Number ofhiddenunits</td><td>{512,1024,2048}</td></tr><tr><td>Number of hidden layers</td><td>{1,2,3,4}</td></tr><tr><td>Network shape</td><td>{Rectangle, Conic}</td></tr></table>",
+        "bbox": [
+            331,
+            131,
+            665,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENT SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            357,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our model with standard feed-forward neural networks (FNNs) and sparse neural networks whose weak connections are pruned (Pruned FNNs) in the 17 classification tasks. The models involved in the experiment are as follows: ",
+        "bbox": [
+            176,
+            250,
+            823,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• BSNN: Backbone-Skippath Neural Network is the resulting model of our method PSA. For all the tasks, we keep only $5 \\%$ of the connections in the Backbone path and limit the number of units in the narrow Skip-paths to 100. FNN: Feed-forward Neural Network is a standard fully-connected neural network. It is mainly composed of linear layers and activation functions. Each hidden unit is connected to all neurons in the previous layer. Information flows from low layers to high layers in a feed-forward manner. Pruned FNN: Pruned Feed-forward Neural Network is trained by using the method proposed in Han et al. (2015). We Firstly train a fully-connected FNN from scratch, and then prune out the weak connections with small absolute weight values. The pruned network is then retrained from the initial training phase by keeping the surviving weight parameters. ",
+        "bbox": [
+            215,
+            304,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We learn the structure of BSNNs using PSA. The number of layers, the number of hidden units in each layer and the sparse connections between adjacent layers are automatically determined. After structure learning, we train the sparse model from scratch by random initialization of weights. As for FNNs, we treat the number of hidden units and number of layers as hyper-parameters of network and determine the best structure by grid-search over all the combinations using validation data. Table 2 shows the space of network structures considered. Following the method in Klambauer et al. (2017) , both “rectangle ” and “conic” network shapes are tested. In FNNs with rectangle shape, all the hidden layers have constant number of units. FNNs with conic shape start with the given number of hidden units and decrease it layer by layer in a geometric progression manner towards the output layer. For Pruned FNNs, we take the best FNNs as the initial model and perform pruning as in Han et al. (2015). The pruned model is then retrained for final model. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We implement all the experiments using PyTroch3 which is a flexible deep learning framework. We use ReLUs (Nair & Hinton, 2010; Glorot et al., 2011) as the non-linear activation functions in all the networks. Dropout (Hinton et al., 2012b; Srivastava et al., 2014) with rate 0.5 is applied after each non-linear projection. We use Adam (Kingma & Ba, 2014) as the optimizer to optimize the training objective function. During training, we select models by monitoring validation loss. Codes will be released after the paper is accepted to the conference. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            277,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 BSNNS VS FNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            352,
+            782
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the classification results of BSNNs and FNNs on Tox21 dataset. The structures of FNNs are tuned individually for each task. It is clear that BSNNs achieve better AUC scores on 10 out of the 12 classification tasks. Even when it is not better, the average AUC value of BSNNs, e.g. on task SR.MMP, is also very close to that of FNNs. More importantly, BSNNs always contain much fewer parameters than FNNs, with the ratios of parameter number ranging from $7 \\%$ to $4 0 . 1 1 \\%$ . ",
+        "bbox": [
+            174,
+            792,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the results of BSNNs and FNNs over the 5 text classification tasks. Although BSNNs contain much fewer parameters than FNNs, BSNNs still achieve higher classification accuracy in the first two tasks, and comparable accuracy in the remaining tasks. Note that the ratios of parameter number ranges from $6 . 2 5 \\%$ to $3 2 . 0 7 \\%$ . This again confirms that our method learns good parsimonious deep models which can achieve high classification performance with much fewer parameters than standard FNNs. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3994f291cb7012f619e48fa0433fb91477d0d775feff0c0a89a41bf9c87b8189.jpg",
+        "table_caption": [
+            "Table 3: Comparison between BSNNs and FNNs on $\\mathrm { T o x } 2 1$ challenge dataset. The structures of FNNs are chosen by using validation data. Each experiment is run for three times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">BSNNs</td><td colspan=\"2\">FNNs</td></tr><tr><td></td><td colspan=\"3\">Parameter#/</td><td></td></tr><tr><td>Task</td><td>AUC</td><td>Ratio W.r.t FNNs</td><td>AUC</td><td>Parameter #</td></tr><tr><td>NR.AhR</td><td>0.8930± 0.0014</td><td>338K/ 37.08%</td><td>0.8843 ± 0.0030</td><td>912K</td></tr><tr><td>NR.AR</td><td>0.7316 ± 0.0245</td><td>338K/ 20.05%</td><td>0.6629 ± 0.0155</td><td>1.69M</td></tr><tr><td>NR.AR.LBD</td><td>0.7827 ± 0.0200</td><td>338K/ 20.05%</td><td>0.7216 ± 0.0245</td><td>1.69M</td></tr><tr><td>NR.Aromatase</td><td>0.7854 ± 0.0098</td><td>338K/ 40.11%</td><td>0.7834 ± 0.0046</td><td>843K</td></tr><tr><td>NR.ER</td><td>0.7804 ± 0.0042</td><td>338K/ 12.36%</td><td>0.7671 ± 0.0090</td><td>2.73M</td></tr><tr><td>NR.ER.LBD</td><td>0.7772 ± 0.0088</td><td>338K/ 20.75%</td><td>0.8145 ± 0.0035</td><td>1.63M</td></tr><tr><td>NR.PPAR.gamma</td><td>0.8232 ± 0.0019</td><td>338K/ 39.38%</td><td>0.8024 ± 0.0098</td><td>858K</td></tr><tr><td>SR.ARE</td><td>0.7877 ± 0.0036</td><td>338K/ 7.00%</td><td>0.7809 ± 0.0092</td><td>4.83M</td></tr><tr><td>SR.ATAD5</td><td>0.8188 ± 0.0085</td><td>338K/ 40.11%</td><td>0.7980 ± 0.0014</td><td>843K</td></tr><tr><td>SR.HSE</td><td>0.8330 ± 0.0053</td><td>338K/ 30.59%</td><td>0.8318 ± 0.0047</td><td>1.10M</td></tr><tr><td>SR.MMP</td><td>0.9249 ± 0.0014</td><td>338K/ 20.05%</td><td>0.9253 ± 0.0038</td><td>1.69M</td></tr><tr><td>SR.p53</td><td>0.8425 ± 0.0023</td><td>338K/ 40.11%</td><td>0.8401 ± 0.0049</td><td>843K</td></tr><tr><td>Average</td><td>0.8150 ± 0.0038</td><td>27.30%</td><td>0.8010± 0.0017</td><td></td></tr></table>",
+        "bbox": [
+            179,
+            145,
+            818,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf2921ff83f18239f5ac8d2966e2c0dfdfa8baaa5e6db1bc11c1a76ce6e5ae4c.jpg",
+        "table_caption": [
+            "Table 4: Comparison between BSNNs and FNNs on 5 text classification datasets. The structures of FNNs are chosen by using validation data. Each experiment is run for three times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">BSNNs</td><td colspan=\"2\">FNNs</td></tr><tr><td>Task</td><td></td><td>Parameter#/</td><td></td><td></td><td></td></tr><tr><td>Yelp Review Full</td><td>Accuracy 59.14% ± 0.06%</td><td>Ratio w.r.t FNNs</td><td>32.07%</td><td>Accuracy</td><td>Parameter #</td></tr><tr><td>DBPedia</td><td>98.11% ± 0.03%</td><td>1.73M/ 1.78M /</td><td>17.13%</td><td>59.13% ± 0.14% 97.99% ± 0.04%</td><td>5.38M 10.36M</td></tr><tr><td>Sogou News</td><td>96.09% ± 0.06%</td><td>1.84M /</td><td>13.77%</td><td>96.12% ± 0.06%</td><td>13.39M</td></tr><tr><td>Yahoo!Answer</td><td>71.42% ± 0.06%</td><td>1.69M /</td><td>31.42%</td><td>71.84% ± 0.07 %</td><td></td></tr><tr><td>AG&#x27;s News</td><td>91.39% ± 0.03%</td><td>1.81M /</td><td>6.25%</td><td>91.61% ± 0.01%</td><td>5.39M 28.88M</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            444,
+            825,
+            561
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            590,
+            825,
+            646
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 CONTRIBUTION OF THE BACKBONE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            475,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae462a69b977c69b17cbd318d9dd4116db9f80b58cfd8eb07abef5d2469bc618.jpg",
+        "table_caption": [
+            "Table 5: Comparison between BSNNs and BSNNs with only the backbone path. Tox21 Average corresponds to the result averaged over the 12 tasks in Tox21 dataset. Each experiment is run for three times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>BSNNs</td><td colspan=\"3\">Backbone Path in BSNNs</td></tr><tr><td></td><td></td><td></td><td>Parameterratio</td><td>Parameterratio</td></tr><tr><td>Task Tox21 Average</td><td>AUC/Accuracy</td><td>AUC/Accuracy</td><td>w.r.t BSNNs</td><td>w.r.t FNNs</td></tr><tr><td>Yelp Review Full</td><td>0.8150± 0.0038 59.14% ± 0.06%</td><td>0.7839± 0.0076 58.63% ± 0.13%</td><td>30.47% 35.47%</td><td>8.32% 11.38%</td></tr><tr><td>DBPedia</td><td>98.11% ± 0.03%</td><td></td><td>36.67%</td><td></td></tr><tr><td>Sogou News</td><td>96.09% ± 0.06%</td><td>97.91% ± 0.04%</td><td>38.63%</td><td>6.28%</td></tr><tr><td>Yahoo!Answer</td><td>71.42% ± 0.06%</td><td>95.67% ± 0.04%</td><td>34.39%</td><td>5.32%</td></tr><tr><td>AG&#x27;s News</td><td></td><td>69.95% ± 0.08%</td><td></td><td>10.80%</td></tr><tr><td></td><td>91.39% ± 0.03%</td><td>91.33% ± 0.03%</td><td>37.55%</td><td>2.35%</td></tr></table>",
+        "bbox": [
+            178,
+            744,
+            821,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To validate our assumption that the backbone path in BSNNs captures most of the information in data and acts as a main part of the model, we remove the narrow skip-paths in BSNNs and train the model to test its performance in classification tasks. Table 5 shows the results. As we can see from the results, the backbone path alone already achieves AUC scores or accuracies which are only slightly worse than BSNNs. Note that the number of parameters in the sparse path is even much smaller than BSNNs. Compared with FNNs, the number of parameters is only $2 \\%$ $11 \\%$ , significantly smaller than that of FNNs. However, without the backbone, the performance of the model will be significantly worse due to the insufficient capability of the other narrow path. The results not only show the importance of the backbone path in BSNNs, but also shows that our structure learning method in the backbone path is effective enough. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c20e3fc5eea7c0b8bf58f212aaa759e7482d1585dfaa07e29486232484d70675.jpg",
+        "table_caption": [
+            "Table 6: AUC scores of BSNNs, BSNN-FCs and Pruned FNNs on Tox21 dataset. For each task, better result between BSNNs and BSNN-FCs is underlined, while better result between BSNNs and Pruned FNNs is bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>BSNNs</td><td>BSNN-FCs</td><td>Pruned FNNs</td></tr><tr><td>NR.AhR</td><td>0.8930± 0.0014</td><td>0.8910±0.0014</td><td>0.8845 ± 0.0047</td></tr><tr><td>NR.AR</td><td>0.7316 ± 0.0245</td><td>0.6780 ± 0.0252</td><td>0.6660 ± 0.0206</td></tr><tr><td>NR.AR.LBD</td><td>0.7827 ± 0.0200</td><td>0.7796 ± 0.0136</td><td>0.7475 ± 0.0356</td></tr><tr><td>NR.Aromatase</td><td>0.7854 ± 0.0098</td><td>0.7757 ± 0.0124</td><td>0.7782 ± 0.0069</td></tr><tr><td>NR.ER</td><td>0.7804 士 0.0042</td><td>0.7693 ± 0.0049</td><td>0.7767 ± 0.0059</td></tr><tr><td>NR.ER.LBD</td><td>0.7772 士 0.0088</td><td>0.7970 ± 0.0057</td><td>0.8054 ± 0.0071</td></tr><tr><td>NR.PPAR.gamma</td><td>0.8232 士 0.0019</td><td>0.8136 ±0.0032</td><td>0.7803 ± 0.0045</td></tr><tr><td>SR.ARE</td><td>0.7877 士 0.0036</td><td>0.7771 士 0.0058</td><td>0.7812 ± 0.0024</td></tr><tr><td>SR.ATAD5</td><td>0.8188 士 0.0085</td><td>0.8162 士 ：0.0062</td><td>0.7924 ± 0.0051</td></tr><tr><td>SR.HSE</td><td>0.8330 ± 0.0053</td><td>0.8453 土 0.0072</td><td>0.8308 ± 0.0103</td></tr><tr><td>SR.MMP</td><td>0.9249 ± 0.0014</td><td>0.9219 ±0.0004</td><td>0.9262 ± 0.0036</td></tr><tr><td>SR.p53</td><td>0.8425 ± 0.0023</td><td>0.8194± ：0.0010</td><td>0.8278 ± 0.0090</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Average</td><td>0.8150± 0.0038</td><td>0.8070± 0.0002</td><td>0.7998 ± 0.0034</td></tr></table>",
+        "bbox": [
+            232,
+            285,
+            764,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3.3 EFFECTIVENESS OF OUR STRUCTURE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            530,
+            568,
+            544
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To further show the effectiveness of our structure learning method, we introduce a new model called BSNN-FC. For each specific task, the structure of BSNN-FC is completely the same as that of BSNN, except that the layers in the sparse Backbone path are changed to fully-connected layers. We train BSNN-FC for all the tasks in Tox21 dataset and the results are shown in Table 6. From the table we can see that, although BSNN keeps only $5 \\%$ of the connections in the sparse path, it gives classification results which are very similar to that of BSNN-FC. It shows that our structure learning method successfully removes the useless connections in BSNN-FC. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also compare BSNNs with Pruned FNNs whose weak connections are pruned using the method in Han et al. (2015). We start from the fully pretrained FNNs reported in Table 3, and prune the connections with the smallest absolute weight values. After pruning, the number of remaining parameters in each FNN is the same as that in the corresponding BSNN for the same task. The comparison between BSNNs and pruned FNNs is shown in Table 6. Again BSNNs give higher AUC scores than pruned FNNs in 10 of the 12 classification tasks. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3.4 INTERPRETABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            760,
+            362,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next we compare the interpretability of BSNNs with FNNs and Pruned FNNs on the text datasets. Here is how we interpret hidden units. We feed the data to the networks and do forward propagation to get the values of the hidden units corresponding to each data sample. Then for each hidden unit, we sort the words in descending order of the correlations between the words and the hidden unit. The top 10 words with the highest correlations are chosen to characterize the hidden unit. Following Chen et al. (2017b), we measure the interpretability of a hidden unit by considering how similar pairs of words in the top-10 list are. The similarity between two words is determined using a word2vec model (Mikolov et al., 2013a;b) trained on part of the Google News datasets, where each word is mapped to a high dimensional vector. The similarity between two words is defined as the cosine similarity of the two corresponding vectors. High similarity suggests that the two words appear in similar contexts. The interpretability score of a hidden unit is defined as the compactness of its characterizing words and is computed as the average similarity of all pairs of words. The interpretability score of a model is defined as the average of interpretability scores of all hidden units. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d410d0c4de1ed568462aa35d5b9b7d0938e5382c58f83ba0e9c84bb70cf52be3.jpg",
+        "table_caption": [
+            "Table 7: Interpretability scores of BSNNS, FNNs and Pruned FNNs on different datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>BSNNs</td><td>FNNs</td><td>Pruned FNNs</td></tr><tr><td>Yelp Review Full</td><td>0.1632</td><td>0.1117</td><td>0.1</td></tr><tr><td>DBPedia</td><td>0.0609</td><td>0.0497</td><td>0.0553</td></tr><tr><td>Yahoo!Answer</td><td>0.1729</td><td>0.1632</td><td>0.1553</td></tr><tr><td>AG&#x27;s News</td><td>0.0531</td><td>0.0595</td><td>0.0561</td></tr></table>",
+        "bbox": [
+            308,
+            131,
+            686,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/07bc66a7b444c59232b9786f355b25db69b65ead74b85b06b84cbab9bdd0c6b3.jpg",
+        "table_caption": [
+            "Table 8: Qualitative interpretability results of hidden units in BSNNs. Each line corresponds to one hidden unit. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>BSNNs</td></tr><tr><td>Yelp Review Full</td><td>tastelessunseasoned flavorlessblandlacked paprika panko crusts unagi crumb vindaloo tortas spicey wink drapes</td></tr><tr><td>DBPedia</td><td>album songwriting chet saxophone thrash hurling backstroke badminton skier outfelder journalists hardcover editors reprinted republished</td></tr><tr><td>Yahoo!Answer</td><td>harddrive antispyware wifi mcafee routers javascript linux tcp linksys laptops romantic dating foreplay flirt boyfriend</td></tr><tr><td>AG&#x27;s News</td><td>mozilla mainframe designs collaborate microprocessors republicans prosecutor argument jfk protesters noted furious harsh concessions apologizes</td></tr></table>",
+        "bbox": [
+            238,
+            272,
+            759,
+            457
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            493,
+            825,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 7 reports the interpretability scores of BSNNs, FNNs and Pruned FNNs for different datasets. Sogounews dataset is not included in the experiment since its vocabulary are Chinese pingyin characters and most of them do not appear in the Google News word2vec model. We measure the interpretability scores by considering the top-layer hidden units. For the fair of comparison, all models have approximately the same number of top-layer hidden units. As it can be seen that BSNNs significantly outperform the FNNs and Pruned FNNs in most cases and is comparable if not better, showing superior coherency and compactness in the characterizations of the hidden units and thus better model interpretability. Pruned FNNs, on the other hand, reduce the interpretability of FNNs with the pruning strategy. Table 8 shows the qualitative interpretability results by presenting the characterization words of hidden units with high interpretability scores in BSNNs. The hidden units are very meaningful for different datasets. For example, in Yelp Review dataset, the first hidden unit represents negative opinions on food with words “tasteless” and“flavorless”; the second hidden unit is more related to food like “paprika”, “crust” and “unagi”. In DBPedia, the first hidden unit is found out to have closer relationship with music, while the second one is more closely related to sport. Similar phenomena can be found in the rest of the table. This shows that the proposed BSNNs, with the statistical property, have better model interpretability and make a step further towards understandable deep learning models. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            328,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Structure learning for deep neural network is a challenging and interesting research problem. We have proposed an unsupervised structure learning method which utilizes the correlation information in data for learning parsimonious deep feed-forward networks. In comparison with standard FNN, although the resulting model of our method contains much fewer parameters, it achieves better or comparable classification performance in all kinds of tasks. Our method is also shown to learn models with better interpretability, which is also an important problem in deep learning. In the future, we will generalize our method to other networks like RNNs and CNNs. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            287,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Prescott Adams, Hanna M Wallach, and Zoubin Ghahramani. Learning the structure of deep sparse graphical models. In AISTATS, 2010. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timur Ash. Dynamic node creation in backpropagation networks. Connection science, 1(4):365– 375, 1989. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            251,
+            823,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin G Bello. Enhanced training algorithms, and integrated training/architecture selection for multilayer perceptron networks. IEEE Transactions on Neural networks, 3(6):864–875, 1992. ",
+        "bbox": [
+            173,
+            289,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peixian Chen, Nevin L Zhang, Leonard KM Poon, and Zhourong Chen. Progressive em for latent tree models and hierarchical topic detection. In AAAI, 2016. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            356
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peixian Chen, Nevin L Zhang, Tengfei Liu, Leonard KM Poon, Zhourong Chen, and Farhan Khawar. Latent tree models for hierarchical topic detection. Artificial Intelligence, 250:105–124, 2017a. ",
+        "bbox": [
+            174,
+            363,
+            821,
+            393
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhourong Chen, Nevin L Zhang, Dit-Yan Yeung, and Peixian Chen. Sparse boltzmann machines with structure learning as applied to text analysis. In AAAI, 2017b. ",
+        "bbox": [
+            173,
+            401,
+            821,
+            431
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C Chow and Cong Liu. Approximating discrete probability distributions with dependence trees. IEEE transactions on Information Theory, 14(3):462–467, 1968. ",
+        "bbox": [
+            173,
+            439,
+            821,
+            468
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann Le Cun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS, 1990. ",
+        "bbox": [
+            169,
+            477,
+            756,
+            492
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In AISTATS, 2011. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            539,
+            823,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi, David G. Stork, and Stork Crc. Ricoh. Com. Second order derivatives for network pruning: Optimal brain surgeon. In NIPS, 1993. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012a. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012b. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            768,
+            823,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tin-Yau Kwok and Dit-Yan Yeung. Constructive algorithms for structure learning in feedforward neural networks for regression problems. IEEE Transactions on Neural Networks, 8(3):630–645, 1997. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tengfei Liu, Nevin L. Zhang, and Peixian Chen. Hierarchical latent tree analysis for topic detection. In ECML/PKDD, 2014. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Toma´s Mikolov, Anoop Deoras, Daniel Povey, Luk ˇ a´s Burget, and Jan ˇ Cernock ˇ y. Strategies for \\` training large scale neural network language models. In IEEE Workshop on Automatic Speech Recognition and Understanding, pp. 196–201, 2011. ",
+        "bbox": [
+            176,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. In International Conference on Learning Representations Workshops, 2013a. ",
+        "bbox": [
+            176,
+            267,
+            821,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013b. ",
+        "bbox": [
+            173,
+            319,
+            820,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            176,
+            357,
+            820,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Judea Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1988. ISBN 0-934613-73-7. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. In ICML, 2017. ",
+        "bbox": [
+            174,
+            433,
+            821,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Suraj Srinivas and R. Venkatesh Babu. Data-free parameter pruning for deep neural networks. In Proceedings of the British Machine Vision Conference, 2015. ",
+        "bbox": [
+            173,
+            469,
+            823,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, 2014. ",
+        "bbox": [
+            174,
+            559,
+            821,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lingxi Xie and Alan Yuille. Genetic cnn. arXiv preprint arXiv:1703.01513, 2017. ",
+        "bbox": [
+            173,
+            597,
+            715,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nevin L Zhang. Hierarchical latent class models for cluster analysis. Journal of Machine Learning Research, 5(6):697–723, 2004. ",
+        "bbox": [
+            173,
+            621,
+            820,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            659,
+            821,
+            689
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In ICLR, 2017. ",
+        "bbox": [
+            169,
+            696,
+            821,
+            713
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HkcdHtqlx/HkcdHtqlx.md

@@ -0,0 +1,317 @@
+# GATED-ATTENTION READERS FOR TEXT COMPREHENSION
+
+Bhuwan Dhingra∗, Hanxiao Liu∗, Zhilin Yang, William W. Cohen & Ruslan Salakhutdinov
+
+School of Computer Science   
+Carnegie Mellon University   
+{bdhingra,hanxiaol,zhiliny,wcohen,rsalakhu}@cs.cmu.edu
+
+# ABSTRACT
+
+In this paper we study the problem of answering cloze-style questions over documents. Our model, the Gated-Attention (GA) Reader, integrates a multi-hop architecture with a novel attention mechanism, which is based on multiplicative interactions between the query embedding and the intermediate states of a recurrent neural network document reader. This enables the reader to build query-specific representations of tokens in the document for accurate answer selection. The GA Reader obtains state-of-the-art results on three benchmarks for this task–the CNN & Daily Mail news stories and the Who Did What dataset. The effectiveness of multiplicative interaction is demonstrated by an ablation study, and by comparing to alternative compositional operators for implementing the gated-attention.
+
+# 1 INTRODUCTION
+
+A recent trend to measure progress towards machine reading is to test a system’s ability to answer questions about a document it has to comprehend. Towards this end, several large-scale datasets of cloze-style questions over a context document have been introduced recently, which allow the training of supervised machine learning systems (Hermann et al., 2015; Hill et al., 2015; Onishi et al., 2016). Such datasets can be easily constructed automatically and the unambiguous nature of their queries provides an objective benchmark to measure a system’s performance at text comprehension.
+
+Deep learning models have recently been shown to outperform traditional shallow approaches on text comprehension tasks (Hermann et al., 2015). The success of many recent models can be attributed primarily to two factors: (1) Multi-hop architectures allow a (Weston et al., 2014; Sordoni et al., 2016; Shen et al., 2016), model to scan the document and the question iteratively for multiple passes. (2) Attention mechanisms, (Weston et al., 2014; Chen et al., 2016; Hermann et al., 2015) borrowed from the machine translation literature (Bahdanau et al., 2014), allow the model to focus on appropriate subparts of the context document. Intuitively, the multi-hop architecture allows the reader to incrementally refine token representations, and the attention mechanism re-weights different parts in the document according to their relevance to the query.
+
+The effectiveness of multi-hop reasoning and attentions have been explored orthogonally so far in the literature. In this paper, we focus on combining both in a complementary manner, by designing a novel attention mechanism which gates the evolving token representations across hops. More specifically, unlike existing models where the query attention is applied either token-wise (Hermann et al., 2015; Kadlec et al., 2016; Chen et al., 2016; Hill et al., 2015) or sentence-wise (Weston et al., 2014; Sukhbaatar et al., 2015) to allow weighted aggregation, the Gated-Attention (GA) module proposed in this work allows the query to directly interact with each dimension of the token embeddings at the semantic-level, and is applied layer-wise as information filters during the multi-hop representation learning process. Such a fine-grained attention enables our model to learn conditional token representations with respect to the given question, leading to accurate answer selections.
+
+We show in our experiments that the proposed GA reader, despite its relative simplicity, consistently improves over a variety of strong baselines on three benchmark datasets1. Our key contribution, the GA module, provides a significant improvement when the dataset size is large. Qualitatively, visualization of the attentions at intermediate layers of the GA reader shows that in each layer the GA reader attends to distinct salient aspects of the query which help in determining the answer.
+
+# 2 RELATED WORK
+
+The cloze-style QA task involves tuples of the form $( d , q , a , \mathcal { C } )$ , where $d$ is a document (context), $q$ is a query over the contents of $d$ , in which a phrase is replaced with a placeholder, and $a$ is the answer to $q$ , which comes from a set of candidates $\mathcal { C }$ . In this work we consider datasets where each candidate $c \in { \mathcal { C } }$ has at least one token which also appears in the document. The task can then be described as: given a document-query pair $( d , q )$ , find $a \in { \mathcal { C } }$ which answers $q$ . Below we provide an overview of representative neural network architectures which have been applied to this problem.
+
+LSTMs with Attention: Several architectures introduced in (Hermann et al., 2015) employ LSTM units to compute a combined document-query representation $g ( d , q )$ , which is used to rank the candidate answers. Their techniques include the DeepLSTM Reader which performs a single forward pass through the concatenated (document, query) pair to obtain $g ( d , q )$ ; the Attentive Reader which first computes a document vector $d ( q )$ by a weighted aggregation of words according to attentions based on $q$ , and then combines $d ( q )$ and $q$ to obtain their joint representation $g ( d ( q ) , q )$ ; and the Impatient Reader where the document representation is built incrementally. The architecture of the Attentive Reader has been simplified recently in Stanford Attentive Reader, where shallower recurrent units were used with a bilinear form for the query-document attention (Chen et al., 2016).
+
+Attention Sum: The Attention-Sum (AS) Reader (Kadlec et al., 2016) uses two bi-directional GRU networks (Cho et al., 2014) to encode both $d$ and $q$ into vectors, similar to Stanford AR. A probability distribution over the entities in $d$ is obtained by computing dot products between $q$ and the entity embeddings and taking a softmax. An aggregation scheme named pointer-sum attention is further applied to sum the probabilities of the same entity, so that frequent entities the document will be favored compared to rare ones. Building on the AS Reader, the Attention-over-Attention (AoA) Reader (Cui et al., 2016) introduces a two-way attention mechanism where the query and the document are mutually attentive to each other.
+
+Mulit-hop Architectures: Memory Networks (MemNets) were proposed in (Weston et al., 2014), where each sentence in the document is encoded to a memory by aggregating nearby words. Attention over the memory slots given the query is used to compute an overall memory and to renew the query representation over multiple iterations, allowing certain types of reasoning over the salient facts in the memory and the query. Neural Semantic Encoders (NSE) (Munkhdalai & Yu, 2016a) extended MemNets by introducing a write operation which can evolve the memory over time during the course of reading. Iterative reasoning has been found effective in several more recent models, including the Iterative Attentive Reader (Sordoni et al., 2016) and ReasoNet (Shen et al., 2016). The latter allows a dynamic number of reasoning steps and is trained with reinforcement learning.
+
+Other related works include Dynamic Entity Representation network (DER) (Kobayashi et al., 2016), which builds dynamic representations of the candidate answers while reading the document, and accumulates the information about an entity by max-pooling. EpiReader (Trischler et al., 2016) consists of two networks, where one proposes a small set of candidate answers, and the other reranks the proposed candidates conditioned on the query and the context. (Bajgar et al., 2016) showed a $10 \%$ improvement on the CBT corpus (Hill et al., 2015) by training the AS Reader on an augmented training set of about 14 million examples, making a case for community to exploit data abundance. The focus of this paper, however, is on designing models which exploit the available data efficiently.
+
+# 3 GATED-ATTENTION READER
+
+# 3.1 MOTIVATION
+
+Our proposed GA readers perform multiple hops over the document (context), similar to the Memory Networks architecture (Sukhbaatar et al., 2015). Multi-hop architectures mimic the multi-step comprehension process of human readers, and have shown promising results in several recent models for text comprehension (Sordoni et al., 2016; Kumar et al., 2015; Shen et al., 2016). The contextual representations in GA readers, namely the embeddings of words in the document, are iteratively refined across hops until reaching a final attention-sum module (Kadlec et al., 2016) which maps the contextual representations in the last hop to a probability distribution over candidate answers.
+
+The attention mechanism has been introduced recently to model human focus, leading to significant improvement in machine translation and image captioning (Bahdanau et al., 2014; Mnih et al., 2014). In reading comprehension tasks, ideally, the semantic meanings carried by the contextual embeddings should be aware of the query across hops. As an example, human readers are able to keep the question in mind during multiple passes of reading, to successively mask away information irrelevant to the query. However, existing neural network readers are restricted to either attend to tokens (Hermann et al., 2015; Chen et al., 2016) or entire sentences (Weston et al., 2014), with the assumption that certain sub-parts of the document are more important than others. In contrast, we propose a finer-grained model which attends to components of the semantic representation being built up by the GRU. The new attention mechanism, called gated-attention, is implemented based on multiplicative interactions between the query and the contextual embeddings, and is applied per hop to act as fine-grained information filters during the multi-step reasoning. The filters weigh individual components of the vector representation of each token in the document separately.
+
+The design of gated-attention layers is motivated by the effectiveness of multiplicative interaction among vector-space representations, e.g., in various types of recurrent units (Hochreiter & Schmidhuber, 1997; Wu et al., 2016) and in relational learning (Yang et al., 2014; Kiros et al., 2014). While other types of compositional operators are possible, such as concatenation or addition (Mitchell & Lapata, 2008), we find that multiplication has strong empirical performance (section 4.4). Intuitively, multiplicative interaction $e \odot q$ between two word embeddings $e$ and $q$ adjusts the semantic meaning of $e$ towards $q$ , keeping the compositionality of the original embeddings preserved.2
+
+# 3.2 MODEL DETAILS
+
+Several components of the model use a Gated Recurrent Unit (GRU) (Cho et al., 2014) which maps an input sequence $X = [ x _ { 1 } , x _ { 2 } , \dots , x _ { T } ]$ to an ouput sequence $H = [ h _ { 1 } , h _ { 2 } , \ldots , h _ { T } ]$ as follows:
+
+$$
+\begin{array} { r l } & { { \boldsymbol r } _ { t } = \sigma ( { \boldsymbol W } _ { r } { \boldsymbol x } _ { t } + { \boldsymbol U } _ { r } h _ { t - 1 } + b _ { r } ) , } \\ & { \boldsymbol z _ { t } = \sigma ( { \boldsymbol W } _ { z } { \boldsymbol x } _ { t } + { \boldsymbol U } _ { z } h _ { t - 1 } + b _ { z } ) , } \\ & { \tilde { \boldsymbol h } _ { t } = \operatorname { t a n h } ( { \boldsymbol W } _ { h } { \boldsymbol x } _ { t } + { \boldsymbol U } _ { h } ( r _ { t } \odot h _ { t - 1 } ) + b _ { h } ) , } \\ & { \boldsymbol h _ { t } = ( 1 - z _ { t } ) \odot h _ { t - 1 } + z _ { t } \odot \tilde { \boldsymbol h } _ { t } . } \end{array}
+$$
+
+where $\odot$ denotes the Hadamard product or the element-wise multiplication. $r _ { t }$ and $z _ { t }$ are called the reset and update gates respectively, and $\tilde { h } _ { t }$ the candidate output. A Bi-directional GRU (BiGRU) processes the sequence in both forward and backward directions to produce two sequences $[ h _ { 1 } ^ { f } , h _ { 2 } ^ { f } , \ldots , h _ { T } ^ { f } ]$ and $[ h _ { 1 } ^ { b } , h _ { 2 } ^ { b } , \ldots , h _ { T } ^ { b } ]$ , which are concatenated at the output
+
+$$
+\overleftrightarrow { \mathrm { G R U } } ( X ) = [ h _ { 1 } ^ { f } \| h _ { T } ^ { b } , \dots , h _ { T } ^ { f } \| h _ { 1 } ^ { b } ]
+$$
+
+where ${ \stackrel { \longleftrightarrow } { \operatorname { G R U } } } ( X )$ denotes the full output of the Bi-GRU obtained by concatenating each forward state $h _ { i } ^ { f }$ and backward state $h _ { T - i + 1 } ^ { b }$ at time-step $i$ given the input $X$ . Note ${ \stackrel { \longleftrightarrow } { \operatorname { G R U } } } ( X )$ is a matrix in $\mathbb { R } ^ { 2 n _ { h } \times T }$ where $n _ { h }$ stands for the number of hidden units in GRU.
+
+Let $X ^ { ( 0 ) } = [ x _ { 1 } ^ { ( 0 ) } , x _ { 2 } ^ { ( 0 ) } , \dots x _ { | D | } ^ { ( 0 ) } ]$ denote the token embeddings of the document, which are also inputs at layer 1 for the document reader below, and $Y = [ y _ { 1 } , y _ { 2 } , \dots y _ { | Q | } ]$ denote the token embeddings of the query. Here $| D |$ and $| Q |$ denote the document and query lengths respectively.
+
+# 3.2.1 MULTI-HOP ARCHITECTURE
+
+Figure 1 illustrates the Gated-Attention (GA) reader. The model reads the document and the query over $K$ horizontal layers, where layer $k$ receives the contextual embeddings $X ^ { ( k - 1 ) }$ of the document from the previous layer. The document embeddings are transformed by taking the full output of a document Bi-GRU (indicated in blue in Figure 1):
+
+$$
+\frac { D ^ { ( k ) } = \overset { \longleftrightarrow } { \mathrm { G R U } } _ { D } ^ { ( k ) } \left( X ^ { ( k - 1 ) } \right) } { \mathrm { \Lambda } ^ { 2 } e _ { 1 } \odot q + e _ { 2 } \odot q = \left( e _ { 1 } + e _ { 2 } \right) \odot q , \forall e _ { 1 } , e _ { 2 } . }
+$$
+
+![](images/798d2ce30dc9cfc27adf2a52fc6e853076cd73ff93e13b9c2c3ceaf20c05ce09.jpg)  
+Figure 1: Gated-Attention Reader. Dashed lines represent dropout connections.
+
+At the same time, a layer-specific query representation is computed as the full output of a separate query Bi-GRU (indicated in green in Figure 1):
+
+$$
+Q ^ { ( k ) } = \overleftrightarrow { \mathrm { G R U } } _ { Q } ^ { ( k ) } ( Y )
+$$
+
+Next, Gated-Attention is applied to $D ^ { ( k ) }$ and $Q ^ { ( k ) }$ to compute inputs for the next layer $X ^ { ( k ) }$ .
+
+$$
+X ^ { ( k ) } = \mathrm { G A } ( D ^ { ( k ) } , Q ^ { ( k ) } )
+$$
+
+where GA is defined in the following subsection.
+
+# 3.2.2 GATED-ATTENTION MODULE
+
+For brevity, let us drop the superscript $k$ in this subsection as we are focusing on a particular layer. For each token $d _ { i }$ in $D$ , the GA module forms a token-specific representation of the query $\tilde { q } _ { i }$ using soft attention, and then multiplies the query representation element-wise with the document token representation. Specifically, for $i = 1 , \ldots , | D |$ :
+
+$$
+\begin{array} { r l } & { \alpha _ { i } = \operatorname { s o f t m a x } ( Q ^ { \top } d _ { i } ) } \\ & { { \tilde { q } } _ { i } = Q \alpha _ { i } } \\ & { x _ { i } = d _ { i } \odot { \tilde { q } } _ { i } } \end{array}
+$$
+
+In equation (6) we use the multiplication operator to model the interactions between $d _ { i }$ and $\tilde { q } _ { i }$ . In the experiments section, we also report results for other choices of gating functions, including addition $x _ { i } = d _ { i } + \tilde { q } _ { i }$ and concatenation $x _ { i } = d _ { i } \| \tilde { q } _ { i }$ .
+
+# 3.2.3 ANSWER PREDICTION
+
+Let q(\` $q _ { \ell } ^ { ( K ) } = q _ { \ell } ^ { f } \| q _ { T - \ell + 1 } ^ { b }$ be an intermediate output of the final layer query Bi-GRU at the location $\ell$ of the cloze token in the query, and $D ^ { ( K ) } = \overleftrightarrow { \mathrm { G R U } } _ { D } ^ { ( K ) } ( X ^ { ( K - 1 ) } )$ be the full output of final layer document Bi-GRU. To obtain the probability that a particular token in the document answers the query, we take an inner-product between these two, and pass through a softmax layer:
+
+$$
+s = \mathrm { s o f t m a x } ( ( q _ { \ell } ^ { ( K ) } ) ^ { T } D ^ { ( K ) } )
+$$
+
+where vector $s$ defines a probability distribution over the $| D |$ tokens in the document. The probability of a particular candidate $c \in { \mathcal { C } }$ as being the answer is then computed by aggregating the probabilities of all document tokens which appear in $c$ and renormalizing over the candidates:
+
+$$
+\operatorname* { P r } ( c | d , q ) \propto \sum _ { i \in \mathbb { I } ( c , d ) } s _ { i }
+$$
+
+Table 1: Dataset statistics.   
+
+<table><tr><td></td><td>CNN</td><td>Daily Mail</td><td>CBT-NE</td><td>CBT-CN</td><td> WDW-Strict</td><td>WDW-Relaxed</td></tr><tr><td># train</td><td>380,298</td><td>879,450</td><td>108,719</td><td>120,769</td><td>127,786</td><td>185,978</td></tr><tr><td># validation</td><td>3,924</td><td>64,835</td><td>2.000</td><td>2,000</td><td>10,000</td><td>10,000</td></tr><tr><td>#test</td><td>3,198</td><td>53,182</td><td>2,500</td><td>2.500</td><td>10,000</td><td>10,000</td></tr><tr><td># vocab</td><td>118,497</td><td>208.045</td><td>53,063</td><td>53,185</td><td>347,406</td><td>308,602</td></tr><tr><td>max doc length</td><td>2,000</td><td>2,000</td><td>1,338</td><td>1,338</td><td>3,085</td><td>3,085</td></tr></table>
+
+where $\mathbb { I } ( c , d )$ is the set of positions where a token in $c$ appears in the document $d$ . This aggregation operation is the same as the pointer sum attention applied in the AS Reader (Kadlec et al., 2016).
+
+Finally, the candidate with maximum probability is selected as the predicted answer:
+
+$$
+a ^ { * } = \mathrm { a r g m a x } _ { c \in { \mathcal C } } ~ \operatorname* { P r } ( c | d , q ) .
+$$
+
+During the training phase, model parameters of the GA reader are updated w.r.t. a cross-entropy loss between the predicted probabilities and the true answers.
+
+# 3.2.4 FURTHER ENHANCEMENTS
+
+Character-level Embeddings: Given a token $w$ from the document or query, its vector space representation is computed as $x = L ( w ) | | C ( w )$ . $L ( w )$ retrieves the word-embedding for $w$ from a lookup table $L \in \mathbb { R } ^ { | V | \times n _ { l } }$ , whose rows hold a vector for each unique token in the vocabulary. We also utilize a character composition model $C ( w )$ which generates an orthographic embedding of the token. Such embeddings have been previously shown to be helpful for tasks like Named Entity Recognition (Yang et al., 2016) and dealing with OOV tokens at test time (Dhingra et al., 2016). The embedding $C ( w )$ is generated by taking the final outputs $z _ { n _ { c } } ^ { f }$ and $z _ { n _ { c } } ^ { b }$ of a Bi-GRU applied to embeddings from a lookup table of characters in the token, and applying a linear transformation:
+
+$$
+\begin{array} { r } { z = z _ { n _ { c } } ^ { f } \vert \vert z _ { n _ { c } } ^ { b } } \\ { C ( w ) = W z + b } \end{array}
+$$
+
+Question Evidence Common Word Feature (qe-comm): (Li et al., 2016) recently proposed a simple token level indicator feature which significantly boosts reading comprehension performance in some cases. For each token in the document we construct a one-hot vector $f _ { i } \in \{ 0 , 1 \bar  \} ^ { 2 }$ indicating whether that token is present in the query or not. It can be incorporated into the GA reader by assigning a feature lookup table $F \in \bar { \mathbb { R } ^ { n _ { F } \times 2 } }$ (we use $n _ { F } = 2 $ ), taking the feature embedding $e _ { i } = f _ { i } ^ { \underline { { { T } } } } F$ and appending it to the inputs of the last layer document BiGRU as, $x _ { i } ^ { ( K ) } \| f _ { i }$ for all $i$ . We conducted several experiments both with and without this feature and observed some interesting trends, which are discussed below. Henceforth, we refer to this feature as the qe-comm feature or just feature.
+
+# 4 EXPERIMENTS AND RESULTS
+
+# 4.1 DATASETS
+
+We evaluate the GA reader on five large-scale datasets recently proposed in the literature. The first two, CNN and Daily Mail news stories3 consist of articles from the popular CNN and Daily Mail websites (Hermann et al., 2015). A query over each article is formed by removing an entity from the short summary which follows the article. Further, entities within each article were anonymized to make the task purely a comprehension one. N-gram statistics, for instance, computed over the entire corpus are no longer useful in such an anonymized corpus.
+
+The next two datasets are formed from two different subsets of the Children’s Book Test (CBT)4 (Hill et al., 2015). Documents consist of 20 contiguous sentences from the body of a popular children’s book, and queries are formed by deleting a token from the $2 1 ^ { \mathrm { s t } }$ sentence. We only focus on subsets where the deleted token is either a common noun (CN) or named entity (NE) since simple language models already give human-level performance on the other types (cf. (Hill et al., 2015)).
+
+Table 2: Hyperparameter settings for each dataset. $\dim ( )$ indicates hidden state size of GRU.   
+
+<table><tr><td>Hyperparameter</td><td>CNN</td><td>Daily Mail</td><td>CBT-NE</td><td>CBT-CN</td><td>WDW-Strict</td><td>WDW-Relaxed</td></tr><tr><td>Dropout</td><td>0.2</td><td>0.1</td><td>0.4</td><td>0.4</td><td>0.3</td><td>0.3</td></tr><tr><td>dim(GRU*)</td><td>256</td><td>256</td><td>128</td><td>128</td><td>128</td><td>128</td></tr></table>
+
+The final dataset we evaluate on is Who Did What5 (WDW) (Onishi et al., 2016), constructed from the LDC English Gigaword newswire corpus. First, article pairs which appeared around the same time and with overlapping entities are chosen, and then one article forms the document and a cloze query is constructed from the other. Missing tokens are always person named entities. Questions which are easily answered by simple baselines are filtered out, to make the task more challenging. There are two versions of the training set—a small but focused “Strict” version and a large but noisy “Relaxed” version. We report results on both settings which share the same validation and test sets. Statistics of all the datasets used in our experiments are summarized in Table 1.
+
+# 4.2 IMPLEMENTATION DETAILS
+
+Our model was implemented using the Theano (Theano Development Team, 2016) and Lasagne6 Python libraries. We used stochastic gradient descent with ADAM updates for optimization, which combines classical momentum and adaptive gradients (Kingma & Ba, 2014). The batch size was 32 and the initial learning rate was $5 \times 1 0 ^ { - 4 }$ which was halved every epoch after the second epoch. The same setting is applied to all models and datasets. We also used gradient clipping with a threshold of 10 to stabilize GRU training (Pascanu et al., 2012). We set the number of layers $K$ to be 3 for all experiments, and provide further analysis below. The number of hidden units for the character GRU was set to 50. The remaining two hyperparameters—size of document and query GRUs, and dropout rate—were tuned on the validation set, and their optimal values are shown in Table 2. In general, the optimal GRU size increases and the dropout rate decreases as the corpus size increases.
+
+The word lookup table was initialized with $1 0 0 d$ GloVe vectors7 (Pennington et al., 2014) and OOV tokens at test time were assigned unique random vectors. We empirically observed that initializing with pre-trained embeddings gives higher performance compared to random initialization for all datasets. Furthermore, for smaller datasets (WDW and CBT) we found that fixing these embeddings to their pretrained values led to higher test performance, possibly since it avoids overfitting. We do not use the character composition model for CNN and Daily Mail, since entities (and hence candidate answers) are anonymized to generic tokens in these datasets. For other datasets the character lookup table was randomly initialized with $2 5 d$ vectors. All other parameters were initialized to their default values as specified in the Lasagne library.
+
+# 4.3 PERFORMANCE COMPARISON
+
+Tables 3 and 5 show a comparison of the performance of GA Reader with previously published results on WDW and CNN, Daily Mail, CBT datasets respectively. The numbers reported for GA Reader are for single best models, though we compare to both ensembles and single models from prior work. GA Reader-- refers to an earlier version of the model, unpublished but described in a preprint, with the following differences—(1) it does not utilize token-specific attentions within the GA module, as described in equation (5), (2) it does not use a character composition model, (3) it is initialized with word embeddings pretrained on the corpus itself rather than GloVe. A detailed analysis of these differences is studied in the next section. Here we present 4 variants of the latest GA Reader, using combinations of whether the qe-comm feature is used (+feature) or not, and whether the word lookup table $L ( w )$ is updated during training or fixed to its initial value.
+
+Interestingly, we observe that feature engineering leads to significant improvements for WDW and CBT datasets, but not for CNN and Daily Mail datasets. We note that anonymization of the latter datasets means that there is already some feature engineering (it adds hints about whether a token is an entity), and these are much larger than the other four. In machine learning it is common to see the effect of feature engineering diminish with increasing data size. Similarly, fixing the word
+
+Table 3: Validation/Test accuracy $( \% )$ on WDW dataset for both “Strict” and “Relaxed” settings. Results marked with $^ \dagger$ are cf previously published works.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Strict</td><td colspan="2">Relaxed</td></tr><tr><td>Val</td><td>Test</td><td>Val</td><td>Test</td></tr><tr><td>Human †</td><td></td><td>84</td><td></td><td>/</td></tr><tr><td>Attentive Reader t AS Reader †</td><td></td><td>53 57</td><td></td><td>55 59</td></tr><tr><td>Stanford AR † NSE +</td><td>66.5</td><td>64 66.2</td><td>67.0</td><td>65 66.7</td></tr><tr><td>GA-- t</td><td>1</td><td>57</td><td>1</td><td>60.0</td></tr><tr><td>GA (update L(w))</td><td>67.8</td><td>67.0</td><td>67.0</td><td>66.6</td></tr><tr><td>GA (fix L(ω))</td><td>68.3</td><td>68.0</td><td></td><td>69.1</td></tr><tr><td></td><td></td><td></td><td>69.6</td><td></td></tr><tr><td>GA (+feature, update L(w))</td><td>70.1</td><td>69.5</td><td>70.9</td><td>71.0</td></tr><tr><td>GA (+feature, fix L(w))</td><td>71.6</td><td>71.2</td><td>72.6</td><td>72.6</td></tr></table>
+
+Table 4: Top: Performance of different gating functions. Bottom: Effect of varying the number of hops $K$ . Results on WDW dataset without using the qe-comm feature and with fixed $L ( w )$ .   
+
+<table><tr><td rowspan=2 colspan=1>Gating Function</td><td rowspan=1 colspan=2> Accuracy</td></tr><tr><td rowspan=1 colspan=1>Val</td><td rowspan=1 colspan=1>Test</td></tr><tr><td rowspan=2 colspan=1>SumConcatenateMultiply</td><td rowspan=2 colspan=1>64.964.468.3</td><td rowspan=1 colspan=1>64.5</td></tr><tr><td rowspan=1 colspan=1>63.768.0</td></tr><tr><td rowspan=1 colspan=1>K</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>1 (AS) t234</td><td rowspan=2 colspan=1>65.668.368.3</td><td rowspan=1 colspan=1>5765.668.0</td></tr><tr><td rowspan=1 colspan=1>68.2</td></tr></table>
+
+Table 5: Validation/Test accuracy $( \% )$ on CNN, Daily Mail and CBT. Results marked with $^ \dagger$ are cf previously published works. Results marked with $^ \ddag$ were obtained by training on a larger training set. Best performance on standard training sets is in bold, and on larger training sets in italics.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">CNN</td><td colspan="2">Daily Mail</td><td colspan="2">CBT-NE</td><td colspan="2">CBT-CN</td></tr><tr><td>Val</td><td>Test Val</td><td>Test</td><td>Val</td><td>Test</td><td>Val</td><td></td><td>Test</td></tr><tr><td>Humans (query) †</td><td></td><td></td><td></td><td></td><td>一</td><td>52.0</td><td>1</td><td>64.4</td></tr><tr><td>Humans (context + query) +</td><td>1</td><td>1</td><td>1</td><td>1 一</td><td>1 51.2</td><td>81.6 41.8</td><td>1 62.6</td><td>81.6 56.0</td></tr><tr><td>LSTMs (context + query) t</td><td>1 55.0</td><td>1 57.0</td><td>1 63.3</td><td>62.2</td><td>1</td><td>1</td><td></td><td></td></tr><tr><td>Deep LSTM Reader t Attentive Reader †</td><td>61.6</td><td>63.0</td><td>70.5</td><td>69.0</td><td>1</td><td>1</td><td>1 1</td><td>1 1</td></tr><tr><td>Impatient Reader +</td><td>61.8</td><td>63.8</td><td>69.0</td><td>68.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>MemNets †</td><td>63.4</td><td>66.8</td><td></td><td></td><td>70.4</td><td>66.6</td><td>64.2</td><td>63.0</td></tr><tr><td>AS Reader †</td><td>68.6</td><td>69.5</td><td>75.0</td><td>73.9</td><td>73.8</td><td>68.6</td><td>68.8</td><td>63.4</td></tr><tr><td>DER Network †</td><td>71.3</td><td>72.9</td><td></td><td>1</td><td></td><td></td><td></td><td></td></tr><tr><td>Stanford AR (relabeling) t</td><td>73.8</td><td>73.6</td><td>1 77.6</td><td>76.6</td><td>1</td><td>1 1</td><td>1</td><td>1</td></tr><tr><td>Iterative Attentive Reader †</td><td>72.6</td><td>73.3</td><td></td><td></td><td>75.2</td><td>68.6</td><td>1 72.1</td><td>1 69.2</td></tr><tr><td></td><td>73.4</td><td>74.0</td><td>1</td><td>1</td><td>75.3</td><td>69.7</td><td></td><td></td></tr><tr><td>EpiReader †</td><td>73.1</td><td>74.4</td><td>1</td><td>1</td><td></td><td></td><td>71.5</td><td>67.4</td></tr><tr><td>AoA Reader †</td><td></td><td>74.7</td><td></td><td>76.6</td><td>77.8</td><td>72.0</td><td>72.2</td><td>69.4</td></tr><tr><td>ReasoNet † NSE †</td><td>72.9</td><td></td><td>77.6</td><td></td><td>1 78.2</td><td>1 73.2</td><td>1</td><td>1</td></tr><tr><td></td><td>1</td><td>1</td><td>1</td><td>1</td><td></td><td></td><td>74.3</td><td>71.9</td></tr><tr><td>MemNets (ensemble) † AS Reader (ensemble) t</td><td>66.2 73.9</td><td>69.4 75.4</td><td></td><td>77.7</td><td>一</td><td></td><td>1</td><td>1</td></tr><tr><td></td><td></td><td></td><td>78.7</td><td>79.2</td><td>76.2</td><td>71.0</td><td>71.1</td><td>68.9</td></tr><tr><td>Stanford AR (relabeling,ensemble) †</td><td>77.2</td><td>77.6</td><td>80.2</td><td></td><td>一</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Iterative Attentive Reader (ensemble) †</td><td>75.2</td><td>76.1</td><td>1</td><td>1</td><td>76.9</td><td>72.0</td><td>74.1</td><td>71.0</td></tr><tr><td>EpiReader (ensemble) †</td><td>1</td><td>1</td><td>1</td><td>1</td><td>76.6</td><td>71.8</td><td>73.6</td><td>70.6</td></tr><tr><td>AS Reader (+BookTest) † ‡</td><td>1</td><td>一</td><td>1</td><td>一</td><td>80.5</td><td>76.2</td><td>83.2</td><td>80.8</td></tr><tr><td>AS Reader (+BookTest,ensemble) † ‡</td><td>1</td><td>一</td><td>1</td><td>1</td><td>82.3</td><td>78.4</td><td>85.7</td><td>83.7</td></tr><tr><td>GA--</td><td>73.0</td><td>73.8</td><td>76.7</td><td>75.7</td><td>74.9</td><td>69.0</td><td>69.0</td><td>63.9</td></tr><tr><td>GA (update L(w))</td><td>77.9</td><td>77.9</td><td>81.5</td><td>80.9</td><td>76.7</td><td>70.1</td><td>69.8</td><td>67.3</td></tr><tr><td>GA (fix L(w))</td><td>77.9</td><td>77.8</td><td>80.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>77.3</td><td>76.9</td><td></td><td>79.6</td><td>77.2</td><td>71.4</td><td>71.6</td><td>68.0</td></tr><tr><td>GA (+feature, update L(w))</td><td>76.7</td><td>77.4</td><td>80.7</td><td>80.0 79.3</td><td>77.2</td><td>73.3 74.9</td><td>73.0 74.4</td><td>69.8</td></tr><tr><td>GA (+feature, fix L(w))</td><td></td><td></td><td>80.0</td><td></td><td>78.5</td><td></td><td></td><td>70.7</td></tr></table>
+
+![](images/22ee30a141039c16bafb5ce3cf871edadd5cd3505e0c1b36fdae035d42bfa778.jpg)  
+Figure 2: Performance in accuracy with and without the Gated-Attention module over different amounts of training data. $p$ -values for an exact one-sided Mcnemar’s test are given inside the parentheses for each setting.
+
+embeddings provides an improvement for the WDW and CBT, but not for CNN and Daily Mail.   
+This is not surprising given that the latter datasets are larger and less prone to overfitting.
+
+Comparing with prior work, on the WDW dataset the basic version of the GA Reader outperforms all previously published models when trained on the Strict setting. By adding the qe-comm feature the performance increases by $3 . 2 \%$ and $3 . 5 \%$ on the Strict and Relaxed settings respectively to set a new state of the art on this dataset. On the CNN and Daily Mail datasets the GA Reader leads to an improvement of $3 . 2 \%$ and $4 . 3 \%$ respectively over the best previous single models. They also outperform previous ensemble models, setting a new state of that art for both datasets. For CBT-NE, GA Reader with the qe-comm feature outperforms all previous single and ensemble models except the AS Reader trained on the much larger BookTest Corpus (Bajgar et al., 2016). Lastly, on CBTCN the GA Reader with the qe-comm feature outperforms all previously published single models except the NSE, and AS Reader trained on a larger corpus.
+
+# 4.4 GA READER ANALYSIS
+
+In this section we do an ablation study to see the effect of Gated Attention. We compare the GA Reader as described here to a model which is exactly the same in all aspects, except that it passes document embeddings $D ^ { ( k ) }$ in each layer directly to the inputs of the next layer without using the GA module. In other words $X ^ { ( k ) } = D ^ { ( k ) }$ for all $k > 0$ . This model ends up using only one query GRU at the output layer for selecting the answer from the document. We compare these two variants both with and without the qe-comm feature on CNN and WDW datasets for three subsets of the training data - $50 \%$ , $7 5 \%$ and $100 \%$ . Test set accuracies for these settings are shown in Figure 2. On CNN when tested without feature engineering, we observe that GA provides a significant boost in performance compared to without GA. When tested with the feature it still gives an improvement, but the improvement is significant only with $100 \%$ training data. On WDW-Strict, which is a third of the size of CNN, without the feature we see an improvement when using GA versus without using GA, which becomes significant as the training set size increases. When tested with the feature on WDW, for a small data size without GA does better than with GA, but as the dataset size increases they become equivalent. We conclude that Gated Attention provides a boost in the absence of feature engineering, or as the training set size increases.
+
+Next we look at the question of how to gate intermediate document reader states from the query, i.e. what operation to use in equation 6. Table 4 (top) shows the performance on WDW dataset for three common choices – sum $( x = d + q )$ ), concatenate $( x = d \lVert q )$ and multiply $( x = d \odot q )$ . Empirically we find that element-wise multiplication does significantly better than the other two, which justifies our motivation to “filter” out document features which are irrelevant to the query.
+
+At the bottom of Table 4 we show the effect of varying the number of hops $K$ of the GA Reader on the final performance. We note that for $K = 1$ , our model is equivalent to the AS Reader without any GA modules. We see a steep and steady rise in accuracy as the number of hops is increased from $K = 1$ to $K = 3$ , which remains constant beyond that. This is a fairly common trend in machine learning as model complexity is increased, however we note that a multi-hop architecture is important to achieve a high performance for this task, and provide further evidence for this in the next section.
+
+![](images/6f8e9d096218e2ae030199722811c00bc1d2d924d84eb2352c9a940674bfe3d1.jpg)  
+Figure 3: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details.   
+DOCjapaesei avetompilatdaiefdfisdsi nsotolsafee entblamedll ncialifelieedosoald new global financial regulatory standardsat the london summit.   
+QRYbegupsicilaoadi <end> ANS:timothy geithner
+
+Lastly, we perform an ablation study for the three components of the GA Reader which were absent in the preprint version (GA Reader--). Table 6 shows accuracy on WDW by removing one component at a time. The steepest reduction is observed when we replace pretrained GloVe vectors with those pretrained on the corpus itself. GloVe vectors were trained on a large corpus of about 6 billion tokens (Pennington et al., 2014), and provide an important source of prior knowledge for the model. We note here that the strongest baseline on WDW, NSE (Munkhdalai & Yu, 2016b), also uses pretrained GloVe vectors, hence the comparison is fair in that respect. Next, we observe a substantial drop when removing token-specific attentions over the query in the GA module, which allow gating indi
+
+Table 6: Ablation study on WDW dataset, without using the qe-comm feature and with fixed $L ( w )$ . Results marked with $^ \dagger$ are cf Onishi et al. (2016).
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>AccuracyVal  Test</td></tr><tr><td rowspan=2 colspan=1>GA-char-token-attentions (eq. 5)-glove,+corpus</td><td rowspan=1 colspan=1>68.366.9</td><td rowspan=1 colspan=1>68.066.9</td></tr><tr><td rowspan=1 colspan=1>65.764.0</td><td rowspan=1 colspan=1>65.062.5</td></tr><tr><td rowspan=1 colspan=1>GA--t</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>57</td></tr></table>
+
+vidual tokens in the document only by parts of the query relevant to that token rather than the overall query representation. Finally, removing the character embeddings, which were only used for WDW and CBT datasets, leads to a reduction of about $1 \%$ in the performance.
+
+# 4.5 ATTENTION VISUALIZATION
+
+To gain an insight into the reading process employed by the model we analyzed the attention distributions at intermediate layers of the reader. Figure 3 shows an example from the validation set of WDW dataset (several more are in the Appendix). In each figure, the left and middle plots visualize attention over the query (equation 5) for candidates in the document after layers $1 \ \& \ 2$ respectively. The right plot shows attention over candidates in the document of cloze placeholder (XXX) in the query at the final layer. The full document, query and correct answer are shown at the bottom.
+
+A generic pattern observed in these examples is that in intermediate layers, candidates in the document (shown along rows) tend to pick out salient tokens in the query which provide clues about the cloze, and in the final layer the candidate with the highest match with these tokens is selected as the answer. In Figure 3 there is a high attention of the correct answer on financial regulatory standards in the first layer, and on us president in the second layer. The incorrect answer, in contrast, only attends to one of these aspects, and hence receives a lower score in the final layer despite the n-gram overlap it has with the cloze token in the query. Importantly, different layers tend to focus on different tokens in the query, which supports the hypothesis that the multi-hop architecture of GA Reader is able to combine distinct pieces of information to answer the query.
+
+# 5 CONCLUSION
+
+We presented the Gated-Attention reader for answering cloze-style questions over documents. The GA reader features a novel multiplicative gating mechanism, combined with a multi-hop architecture. Our model achieves state-of-the-art performance on several large-scale benchmark datasets with more than $4 \%$ improvements over competitive baselines. Our model design is backed up by an ablation study showing statistically significant improvements of using Gated Attention as information filters. We also showed empirically that multiplicative gating is superior to addition and concatenation operations for implementing gated-attentions, though a theoretical justification remains part of future research goals. Analysis of document and query attentions in intermediate layers of the reader further reveals that the model iteratively attends to different aspects of the query to arrive at the final answer. In this paper we have focused on text comprehension, but we believe that the Gated-Attention mechanism may benefit other tasks as well where multiple sources of information interact. Concurrent to our work (Chu et al., 2016) have also shown the effectiveness of GA Readers on the LAMBADA dataset (Paperno et al., 2016) for language modeling.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.   
+Ondrej Bajgar, Rudolf Kadlec, and Jan Kleindienst. Embracing data abundance: Booktest dataset for reading comprehension. arXiv preprint arXiv:1610.00956, 2016.   
+Danqi Chen, Jason Bolton, and Christopher D Manning. A thorough examination of the cnn/daily mail reading comprehension task. arXiv preprint arXiv:1606.02858, 2016.   
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.   
+Zewei Chu, Hai Wang, Kevin Gimpel, and David McAllester. Broad context language modeling as reading comprehension. arXiv preprint arXiv:1610.08431, 2016.   
+Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016.   
+Bhuwan Dhingra, Zhong Zhou, Dylan Fitzpatrick, Michael Muehl, and William W Cohen. Tweet2vec: Character-based distributed representations for social media. ACL, 2016.   
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1684–1692, 2015.   
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. arXiv preprint arXiv:1511.02301, 2015.   
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   
+Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. arXiv preprint arXiv:1603.01547, 2016.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Ryan Kiros, Richard Zemel, and Ruslan R Salakhutdinov. A multiplicative model for learning distributed text-based attribute representations. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2014.   
+Sosuke Kobayashi, Ran Tian, Naoaki Okazaki, and Kentaro Inui. Dynamic entity representations with max-pooling improves machine reading. In NAACL-HLT, 2016.
+
+Ankit Kumar, Ozan Irsoy, Jonathan Su, James Bradbury, Robert English, Brian Pierce, Peter Ondruska, Ishaan Gulrajani, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. arXiv preprint arXiv:1506.07285, 2015.
+
+Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. arXiv preprint arXiv:1607.06275, 2016.
+
+Jeff Mitchell and Mirella Lapata. Vector-based models of semantic composition. In ACL, pp. 236– 244, 2008.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014.
+
+Tsendsuren Munkhdalai and Hong Yu. Neural semantic encoders. arXiv preprint arXiv:1607.04315, 2016a.
+
+Tsendsuren Munkhdalai and Hong Yu. Reasoning with memory augmented neural networks for language comprehension. arXiv preprint arXiv:1610.06454, 2016b.
+
+Takeshi Onishi, Hai Wang, Mohit Bansal, Kevin Gimpel, and David McAllester. Who did what: A large-scale person-centered cloze dataset. EMNLP, 2016.
+
+Denis Paperno, German Kruszewski, Angeliki Lazaridou, Quan Ngoc Pham, Raffaella Bernardi, ´ Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: ´ Word prediction requiring a broad discourse context. arXiv preprint arXiv:1606.06031, 2016.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. arXiv preprint arXiv:1211.5063, 2012.
+
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. In Empirical Methods in Natural Language Processing (EMNLP), pp. 1532–1543, 2014. URL http://www.aclweb.org/anthology/D14-1162.
+
+Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. arXiv preprint arXiv:1609.05284, 2016.
+
+Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016.
+
+Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in Neural Information Processing Systems, pp. 2431–2439, 2015.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688.
+
+Adam Trischler, Zheng Ye, Xingdi Yuan, and Kaheer Suleman. Natural language comprehension with the epireader. arXiv preprint arXiv:1606.02270, 2016.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
+
+Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On multiplicative integration with recurrent neural networks. arXiv preprint arXiv:1606.06630, 2016.
+
+Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Learning multi-relational semantics using neural-embedding models. arXiv preprint arXiv:1411.4072, 2014.
+
+Zhilin Yang, Ruslan Salakhutdinov, and William Cohen. Multi-task cross-lingual sequence tagging from scratch. arXiv preprint arXiv:1603.06270, 2016.
+
+# A ATTENTION PLOTS
+
+![](images/adf33e0be85832bf009f0ec63c93c9014820a80ea3d60d4742ea55f938febdf7.jpg)  
+Figure 4: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details.
+
+![](images/cefbea117fe6dc7325aeb7af5004d024973c73342c74371ee5b5f5407fcaa704.jpg)  
+DOC:resultsundfrothe（uro）5（\$97tptudodcourtevetataaisssports（edisite $) :$ singl efinalmij ulian knowle,austria and robert lindstedt,sweden（1）,6-4,6-3.   
+QRY:<beg> france 's michael llodra beat his compatriot and doubles partner XXX.<end> ANS: julien benneteau
+
+DOC:englandatsatdilo gonedayerdalod'sadfiealfdebo treelyosiveoineioodidespaewastaltersic pontingsoaieettieddtfiris forkshiessil ybodisfocusdeidtheseitseetfaideino sstringprospeast sdees lot'shappenedtomeinthelast sixmonths.ifthechancecomes-ryan'sgotaniggle,butidon'tthinkit $\cdot _ { \mathsf { S } }$ too bad -i've just got toput inadecen tpeforncentsddetb can get the nod."
+
+QRY:<beg>yrksowdaldd‘soteatdfdamstrd> ANS:ryan sidebottom
+
+![](images/ca73735c6ab32c366436c7abe9bdeb033fd3a9d8084fc1d20cfa1ecfa5ef3327.jpg)  
+Figure 5: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details.   
+DOC:usseeaitotitee"tt twaswhatitsotindssfiisteoaditteifis uxuryotelinrliausresidetdeiuriofeet ythattheistdooittotiad ouldworktogddseprofedtitttserelaoil togetherdgutodetset sianword.doyou thinkwegot it $? ^ { n }$ clintonaskedlavrov.yougotitwrong，"herespondedas theyboth laughed.it shouldbe'perezagrouzka‘(t e thattous"lsaeaatastaedrasdo k.
+
+![](images/24b87083c88cfb287c692bad420caadb8c78c69d4a10b21a28e88f405531d122.jpg)  
+QRY:<beg>usecrearyfstatehilaryinonmeetsXXofiddsesidseissureteywillotoveromealldifereesed> ANS:sergei lavrov   
+DOC: illinois governor arrested on corruption charges chicago,dec.9（ xinhua $textsc { -- } u . s .$ federal prosecutors on tuesday arrested illinois governor rod blagojevich a nhischiefofdsds ingtoeoeateatcntsittacifoaaitsfdelfoo alsochargdimia tabout6sp ansaid he did not know the development.
+
+QRY:<beg>rescddf $" { \mathsf { s } }$ senate seat   
+.<end>   
+ANS: rod blagojevich   
+QRY: ${ \tt { < b e g > } }$ europeancmmissocejemaroaldxprssthu’appnt"taffisiua   
+,an aide said.<end>   
+ANS:vladimirputin
+
+![](images/f08ba88bc4fe942a603910024c19103ce309f3443aae883fdfaf9abc9e874962.jpg)  
+Figure 6: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details.   
+DC:europealpldttcffirosr threaerosteos ingdisapomettcfaturafoeodedtlitsifoei barososteitheondtcsfotispac rdingtoisidutiaettpdstso ukraianouteostart hcausesdatsl iistlsteetacsi moshenkoprteodasorotilo wednesdayamidapricingdisputewithukranethecutoffleftanumberofeuropeancountriesinlackofheatinggasamidfrezingeather
+
+![](images/3d252657462e0a42705ed2845cb58b6b1654fe004341e86a994dc6d08466176e.jpg)
+
+DC:presidftabliil eetecti eepeteti wseportetlipsaorucftfoe subectofurtatetei thepalestinll cess between israel and palestine.this has been abbas'third oficial visit to france since 2007.
+
+QRYbeg   
+reconsideringa freeze.<end>   
+ANS:benjaminnetanyahu
+
+![](images/f9ae4c27f3f191602816b9263ac6237a0097fa3ec21c84536266f1c656b6d025.jpg)  
+Figure 7: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details.   
+DC:iftheredooid intinge evenofthmrrididldidfdt losnddadrdebarsidoidth d,bytakingolndaingosdeableutiacesideo'sltiveilloko
+
+![](images/d1691bec6ae8d76535f606c73cfd5ad5b2a7fbf2c39f4aa66ae03343812da35f.jpg)  
+ORYbi from Xxx.<end> ANS: lionel messi
+
+DOC:dinarafetsedtfidtoebf forcederorscadlastli）afi teroftwotiampaaiodtrilduedfa eadowsece he u.s.openand has won one grand slam match.she never has defeated anyone ranked better than 47th.
+
+QRYbeg>rbilrstiffsdi same wayXXX did in 20o0.<end>

parse/train/HkcdHtqlx/HkcdHtqlx_content_list.json

@@ -0,0 +1,1538 @@
+[
+    {
+        "type": "text",
+        "text": "GATED-ATTENTION READERS FOR TEXT COMPREHENSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            589,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bhuwan Dhingra∗, Hanxiao Liu∗, Zhilin Yang, William W. Cohen & Ruslan Salakhutdinov ",
+        "bbox": [
+            183,
+            170,
+            810,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "School of Computer Science   \nCarnegie Mellon University   \n{bdhingra,hanxiaol,zhiliny,wcohen,rsalakhu}@cs.cmu.edu ",
+        "bbox": [
+            184,
+            186,
+            715,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we study the problem of answering cloze-style questions over documents. Our model, the Gated-Attention (GA) Reader, integrates a multi-hop architecture with a novel attention mechanism, which is based on multiplicative interactions between the query embedding and the intermediate states of a recurrent neural network document reader. This enables the reader to build query-specific representations of tokens in the document for accurate answer selection. The GA Reader obtains state-of-the-art results on three benchmarks for this task–the CNN & Daily Mail news stories and the Who Did What dataset. The effectiveness of multiplicative interaction is demonstrated by an ablation study, and by comparing to alternative compositional operators for implementing the gated-attention. ",
+        "bbox": [
+            233,
+            294,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            336,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A recent trend to measure progress towards machine reading is to test a system’s ability to answer questions about a document it has to comprehend. Towards this end, several large-scale datasets of cloze-style questions over a context document have been introduced recently, which allow the training of supervised machine learning systems (Hermann et al., 2015; Hill et al., 2015; Onishi et al., 2016). Such datasets can be easily constructed automatically and the unambiguous nature of their queries provides an objective benchmark to measure a system’s performance at text comprehension. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            574
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning models have recently been shown to outperform traditional shallow approaches on text comprehension tasks (Hermann et al., 2015). The success of many recent models can be attributed primarily to two factors: (1) Multi-hop architectures allow a (Weston et al., 2014; Sordoni et al., 2016; Shen et al., 2016), model to scan the document and the question iteratively for multiple passes. (2) Attention mechanisms, (Weston et al., 2014; Chen et al., 2016; Hermann et al., 2015) borrowed from the machine translation literature (Bahdanau et al., 2014), allow the model to focus on appropriate subparts of the context document. Intuitively, the multi-hop architecture allows the reader to incrementally refine token representations, and the attention mechanism re-weights different parts in the document according to their relevance to the query. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of multi-hop reasoning and attentions have been explored orthogonally so far in the literature. In this paper, we focus on combining both in a complementary manner, by designing a novel attention mechanism which gates the evolving token representations across hops. More specifically, unlike existing models where the query attention is applied either token-wise (Hermann et al., 2015; Kadlec et al., 2016; Chen et al., 2016; Hill et al., 2015) or sentence-wise (Weston et al., 2014; Sukhbaatar et al., 2015) to allow weighted aggregation, the Gated-Attention (GA) module proposed in this work allows the query to directly interact with each dimension of the token embeddings at the semantic-level, and is applied layer-wise as information filters during the multi-hop representation learning process. Such a fine-grained attention enables our model to learn conditional token representations with respect to the given question, leading to accurate answer selections. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show in our experiments that the proposed GA reader, despite its relative simplicity, consistently improves over a variety of strong baselines on three benchmark datasets1. Our key contribution, the GA module, provides a significant improvement when the dataset size is large. Qualitatively, visualization of the attentions at intermediate layers of the GA reader shows that in each layer the GA reader attends to distinct salient aspects of the query which help in determining the answer. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            165,
+            344,
+            181
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The cloze-style QA task involves tuples of the form $( d , q , a , \\mathcal { C } )$ , where $d$ is a document (context), $q$ is a query over the contents of $d$ , in which a phrase is replaced with a placeholder, and $a$ is the answer to $q$ , which comes from a set of candidates $\\mathcal { C }$ . In this work we consider datasets where each candidate $c \\in { \\mathcal { C } }$ has at least one token which also appears in the document. The task can then be described as: given a document-query pair $( d , q )$ , find $a \\in { \\mathcal { C } }$ which answers $q$ . Below we provide an overview of representative neural network architectures which have been applied to this problem. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            280
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "LSTMs with Attention: Several architectures introduced in (Hermann et al., 2015) employ LSTM units to compute a combined document-query representation $g ( d , q )$ , which is used to rank the candidate answers. Their techniques include the DeepLSTM Reader which performs a single forward pass through the concatenated (document, query) pair to obtain $g ( d , q )$ ; the Attentive Reader which first computes a document vector $d ( q )$ by a weighted aggregation of words according to attentions based on $q$ , and then combines $d ( q )$ and $q$ to obtain their joint representation $g ( d ( q ) , q )$ ; and the Impatient Reader where the document representation is built incrementally. The architecture of the Attentive Reader has been simplified recently in Stanford Attentive Reader, where shallower recurrent units were used with a bilinear form for the query-document attention (Chen et al., 2016). ",
+        "bbox": [
+            173,
+            287,
+            825,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Attention Sum: The Attention-Sum (AS) Reader (Kadlec et al., 2016) uses two bi-directional GRU networks (Cho et al., 2014) to encode both $d$ and $q$ into vectors, similar to Stanford AR. A probability distribution over the entities in $d$ is obtained by computing dot products between $q$ and the entity embeddings and taking a softmax. An aggregation scheme named pointer-sum attention is further applied to sum the probabilities of the same entity, so that frequent entities the document will be favored compared to rare ones. Building on the AS Reader, the Attention-over-Attention (AoA) Reader (Cui et al., 2016) introduces a two-way attention mechanism where the query and the document are mutually attentive to each other. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Mulit-hop Architectures: Memory Networks (MemNets) were proposed in (Weston et al., 2014), where each sentence in the document is encoded to a memory by aggregating nearby words. Attention over the memory slots given the query is used to compute an overall memory and to renew the query representation over multiple iterations, allowing certain types of reasoning over the salient facts in the memory and the query. Neural Semantic Encoders (NSE) (Munkhdalai & Yu, 2016a) extended MemNets by introducing a write operation which can evolve the memory over time during the course of reading. Iterative reasoning has been found effective in several more recent models, including the Iterative Attentive Reader (Sordoni et al., 2016) and ReasoNet (Shen et al., 2016). The latter allows a dynamic number of reasoning steps and is trained with reinforcement learning. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other related works include Dynamic Entity Representation network (DER) (Kobayashi et al., 2016), which builds dynamic representations of the candidate answers while reading the document, and accumulates the information about an entity by max-pooling. EpiReader (Trischler et al., 2016) consists of two networks, where one proposes a small set of candidate answers, and the other reranks the proposed candidates conditioned on the query and the context. (Bajgar et al., 2016) showed a $10 \\%$ improvement on the CBT corpus (Hill et al., 2015) by training the AS Reader on an augmented training set of about 14 million examples, making a case for community to exploit data abundance. The focus of this paper, however, is on designing models which exploit the available data efficiently. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 GATED-ATTENTION READER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            444,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            305,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed GA readers perform multiple hops over the document (context), similar to the Memory Networks architecture (Sukhbaatar et al., 2015). Multi-hop architectures mimic the multi-step comprehension process of human readers, and have shown promising results in several recent models for text comprehension (Sordoni et al., 2016; Kumar et al., 2015; Shen et al., 2016). The contextual representations in GA readers, namely the embeddings of words in the document, are iteratively refined across hops until reaching a final attention-sum module (Kadlec et al., 2016) which maps the contextual representations in the last hop to a probability distribution over candidate answers. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The attention mechanism has been introduced recently to model human focus, leading to significant improvement in machine translation and image captioning (Bahdanau et al., 2014; Mnih et al., 2014). In reading comprehension tasks, ideally, the semantic meanings carried by the contextual embeddings should be aware of the query across hops. As an example, human readers are able to keep the question in mind during multiple passes of reading, to successively mask away information irrelevant to the query. However, existing neural network readers are restricted to either attend to tokens (Hermann et al., 2015; Chen et al., 2016) or entire sentences (Weston et al., 2014), with the assumption that certain sub-parts of the document are more important than others. In contrast, we propose a finer-grained model which attends to components of the semantic representation being built up by the GRU. The new attention mechanism, called gated-attention, is implemented based on multiplicative interactions between the query and the contextual embeddings, and is applied per hop to act as fine-grained information filters during the multi-step reasoning. The filters weigh individual components of the vector representation of each token in the document separately. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The design of gated-attention layers is motivated by the effectiveness of multiplicative interaction among vector-space representations, e.g., in various types of recurrent units (Hochreiter & Schmidhuber, 1997; Wu et al., 2016) and in relational learning (Yang et al., 2014; Kiros et al., 2014). While other types of compositional operators are possible, such as concatenation or addition (Mitchell & Lapata, 2008), we find that multiplication has strong empirical performance (section 4.4). Intuitively, multiplicative interaction $e \\odot q$ between two word embeddings $e$ and $q$ adjusts the semantic meaning of $e$ towards $q$ , keeping the compositionality of the original embeddings preserved.2 ",
+        "bbox": [
+            174,
+            325,
+            825,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 MODEL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            334,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Several components of the model use a Gated Recurrent Unit (GRU) (Cho et al., 2014) which maps an input sequence $X = [ x _ { 1 } , x _ { 2 } , \\dots , x _ { T } ]$ to an ouput sequence $H = [ h _ { 1 } , h _ { 2 } , \\ldots , h _ { T } ]$ as follows: ",
+        "bbox": [
+            174,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ab077682cd17a2abf295546afe2abaaef7529cda1cb4524672eb1cc5deca749.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\boldsymbol r } _ { t } = \\sigma ( { \\boldsymbol W } _ { r } { \\boldsymbol x } _ { t } + { \\boldsymbol U } _ { r } h _ { t - 1 } + b _ { r } ) , } \\\\ & { \\boldsymbol z _ { t } = \\sigma ( { \\boldsymbol W } _ { z } { \\boldsymbol x } _ { t } + { \\boldsymbol U } _ { z } h _ { t - 1 } + b _ { z } ) , } \\\\ & { \\tilde { \\boldsymbol h } _ { t } = \\operatorname { t a n h } ( { \\boldsymbol W } _ { h } { \\boldsymbol x } _ { t } + { \\boldsymbol U } _ { h } ( r _ { t } \\odot h _ { t - 1 } ) + b _ { h } ) , } \\\\ & { \\boldsymbol h _ { t } = ( 1 - z _ { t } ) \\odot h _ { t - 1 } + z _ { t } \\odot \\tilde { \\boldsymbol h } _ { t } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            496,
+            637,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ denotes the Hadamard product or the element-wise multiplication. $r _ { t }$ and $z _ { t }$ are called the reset and update gates respectively, and $\\tilde { h } _ { t }$ the candidate output. A Bi-directional GRU (BiGRU) processes the sequence in both forward and backward directions to produce two sequences $[ h _ { 1 } ^ { f } , h _ { 2 } ^ { f } , \\ldots , h _ { T } ^ { f } ]$ and $[ h _ { 1 } ^ { b } , h _ { 2 } ^ { b } , \\ldots , h _ { T } ^ { b } ]$ , which are concatenated at the output ",
+        "bbox": [
+            173,
+            575,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9e6cffd31ee768f3afe20d86a979e13799c875a4295968e158a609b01669b96.jpg",
+        "text": "$$\n\\overleftrightarrow { \\mathrm { G R U } } ( X ) = [ h _ { 1 } ^ { f } \\| h _ { T } ^ { b } , \\dots , h _ { T } ^ { f } \\| h _ { 1 } ^ { b } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            638,
+            614,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\stackrel { \\longleftrightarrow } { \\operatorname { G R U } } } ( X )$ denotes the full output of the Bi-GRU obtained by concatenating each forward state $h _ { i } ^ { f }$ and backward state $h _ { T - i + 1 } ^ { b }$ at time-step $i$ given the input $X$ . Note ${ \\stackrel { \\longleftrightarrow } { \\operatorname { G R U } } } ( X )$ is a matrix in $\\mathbb { R } ^ { 2 n _ { h } \\times T }$ where $n _ { h }$ stands for the number of hidden units in GRU. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $X ^ { ( 0 ) } = [ x _ { 1 } ^ { ( 0 ) } , x _ { 2 } ^ { ( 0 ) } , \\dots x _ { | D | } ^ { ( 0 ) } ]$ denote the token embeddings of the document, which are also inputs at layer 1 for the document reader below, and $Y = [ y _ { 1 } , y _ { 2 } , \\dots y _ { | Q | } ]$ denote the token embeddings of the query. Here $| D |$ and $| Q |$ denote the document and query lengths respectively. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 MULTI-HOP ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            429,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates the Gated-Attention (GA) reader. The model reads the document and the query over $K$ horizontal layers, where layer $k$ receives the contextual embeddings $X ^ { ( k - 1 ) }$ of the document from the previous layer. The document embeddings are transformed by taking the full output of a document Bi-GRU (indicated in blue in Figure 1): ",
+        "bbox": [
+            173,
+            815,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8145691757d79379de83cd81cc9763893a1441c372960fa2122f5ef65623cbc7.jpg",
+        "text": "$$\n\\frac { D ^ { ( k ) } = \\overset { \\longleftrightarrow } { \\mathrm { G R U } } _ { D } ^ { ( k ) } \\left( X ^ { ( k - 1 ) } \\right) } { \\mathrm { \\Lambda } ^ { 2 } e _ { 1 } \\odot q + e _ { 2 } \\odot q = \\left( e _ { 1 } + e _ { 2 } \\right) \\odot q , \\forall e _ { 1 } , e _ { 2 } . }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            876,
+            598,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/798d2ce30dc9cfc27adf2a52fc6e853076cd73ff93e13b9c2c3ceaf20c05ce09.jpg",
+        "image_caption": [
+            "Figure 1: Gated-Attention Reader. Dashed lines represent dropout connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            131,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the same time, a layer-specific query representation is computed as the full output of a separate query Bi-GRU (indicated in green in Figure 1): ",
+        "bbox": [
+            174,
+            375,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/560bc3e01b8457e79ec71e033a4cffb0ee040ae59c8b030fc99cd1e3cca5fb0d.jpg",
+        "text": "$$\nQ ^ { ( k ) } = \\overleftrightarrow { \\mathrm { G R U } } _ { Q } ^ { ( k ) } ( Y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            406,
+            568,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, Gated-Attention is applied to $D ^ { ( k ) }$ and $Q ^ { ( k ) }$ to compute inputs for the next layer $X ^ { ( k ) }$ . ",
+        "bbox": [
+            171,
+            446,
+            781,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f54f5fba34f9af15d66dbfe399f025a829f1a3b10719bf0032f511fb67acac9.jpg",
+        "text": "$$\nX ^ { ( k ) } = \\mathrm { G A } ( D ^ { ( k ) } , Q ^ { ( k ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            468,
+            583,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where GA is defined in the following subsection. ",
+        "bbox": [
+            174,
+            492,
+            495,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 GATED-ATTENTION MODULE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            433,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For brevity, let us drop the superscript $k$ in this subsection as we are focusing on a particular layer. For each token $d _ { i }$ in $D$ , the GA module forms a token-specific representation of the query $\\tilde { q } _ { i }$ using soft attention, and then multiplies the query representation element-wise with the document token representation. Specifically, for $i = 1 , \\ldots , | D |$ : ",
+        "bbox": [
+            173,
+            546,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6058a8e3fcd31c66ccf0de7b6580497f1c84da3d6e3eed26a8550c7a5901c77e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\alpha _ { i } = \\operatorname { s o f t m a x } ( Q ^ { \\top } d _ { i } ) } \\\\ & { { \\tilde { q } } _ { i } = Q \\alpha _ { i } } \\\\ & { x _ { i } = d _ { i } \\odot { \\tilde { q } } _ { i } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            607,
+            571,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In equation (6) we use the multiplication operator to model the interactions between $d _ { i }$ and $\\tilde { q } _ { i }$ . In the experiments section, we also report results for other choices of gating functions, including addition $x _ { i } = d _ { i } + \\tilde { q } _ { i }$ and concatenation $x _ { i } = d _ { i } \\| \\tilde { q } _ { i }$ . ",
+        "bbox": [
+            173,
+            666,
+            825,
+            709
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 ANSWER PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            383,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let q(\\` $q _ { \\ell } ^ { ( K ) } = q _ { \\ell } ^ { f } \\| q _ { T - \\ell + 1 } ^ { b }$ be an intermediate output of the final layer query Bi-GRU at the location $\\ell$ of the cloze token in the query, and $D ^ { ( K ) } = \\overleftrightarrow { \\mathrm { G R U } } _ { D } ^ { ( K ) } ( X ^ { ( K - 1 ) } )$ be the full output of final layer document Bi-GRU. To obtain the probability that a particular token in the document answers the query, we take an inner-product between these two, and pass through a softmax layer: ",
+        "bbox": [
+            173,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad453698fe367be79470cd90b29d2ffe598bcb260d411e19036db352174bf749.jpg",
+        "text": "$$\ns = \\mathrm { s o f t m a x } ( ( q _ { \\ell } ^ { ( K ) } ) ^ { T } D ^ { ( K ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            819,
+            593,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where vector $s$ defines a probability distribution over the $| D |$ tokens in the document. The probability of a particular candidate $c \\in { \\mathcal { C } }$ as being the answer is then computed by aggregating the probabilities of all document tokens which appear in $c$ and renormalizing over the candidates: ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6df165432197c22260c247857f199b5192694cfd467593d6cfbc110e4b40376.jpg",
+        "text": "$$\n\\operatorname* { P r } ( c | d , q ) \\propto \\sum _ { i \\in \\mathbb { I } ( c , d ) } s _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            892,
+            575,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/5cb1903c97b0eb166ebc89a2195965aa59c37a6d372ddf9b783d1923e1b098e4.jpg",
+        "table_caption": [
+            "Table 1: Dataset statistics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CNN</td><td>Daily Mail</td><td>CBT-NE</td><td>CBT-CN</td><td> WDW-Strict</td><td>WDW-Relaxed</td></tr><tr><td># train</td><td>380,298</td><td>879,450</td><td>108,719</td><td>120,769</td><td>127,786</td><td>185,978</td></tr><tr><td># validation</td><td>3,924</td><td>64,835</td><td>2.000</td><td>2,000</td><td>10,000</td><td>10,000</td></tr><tr><td>#test</td><td>3,198</td><td>53,182</td><td>2,500</td><td>2.500</td><td>10,000</td><td>10,000</td></tr><tr><td># vocab</td><td>118,497</td><td>208.045</td><td>53,063</td><td>53,185</td><td>347,406</td><td>308,602</td></tr><tr><td>max doc length</td><td>2,000</td><td>2,000</td><td>1,338</td><td>1,338</td><td>3,085</td><td>3,085</td></tr></table>",
+        "bbox": [
+            194,
+            121,
+            805,
+            214
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { I } ( c , d )$ is the set of positions where a token in $c$ appears in the document $d$ . This aggregation operation is the same as the pointer sum attention applied in the AS Reader (Kadlec et al., 2016). ",
+        "bbox": [
+            176,
+            239,
+            823,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, the candidate with maximum probability is selected as the predicted answer: ",
+        "bbox": [
+            174,
+            275,
+            728,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb527552d76b8a5d42d2da8cf5a6fad030e1078dea0d482d7b4bf5b017356f61.jpg",
+        "text": "$$\na ^ { * } = \\mathrm { a r g m a x } _ { c \\in { \\mathcal C } } ~ \\operatorname* { P r } ( c | d , q ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            296,
+            598,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During the training phase, model parameters of the GA reader are updated w.r.t. a cross-entropy loss between the predicted probabilities and the true answers. ",
+        "bbox": [
+            176,
+            328,
+            823,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.4 FURTHER ENHANCEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            416,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Character-level Embeddings: Given a token $w$ from the document or query, its vector space representation is computed as $x = L ( w ) | | C ( w )$ . $L ( w )$ retrieves the word-embedding for $w$ from a lookup table $L \\in \\mathbb { R } ^ { | V | \\times n _ { l } }$ , whose rows hold a vector for each unique token in the vocabulary. We also utilize a character composition model $C ( w )$ which generates an orthographic embedding of the token. Such embeddings have been previously shown to be helpful for tasks like Named Entity Recognition (Yang et al., 2016) and dealing with OOV tokens at test time (Dhingra et al., 2016). The embedding $C ( w )$ is generated by taking the final outputs $z _ { n _ { c } } ^ { f }$ and $z _ { n _ { c } } ^ { b }$ of a Bi-GRU applied to embeddings from a lookup table of characters in the token, and applying a linear transformation: ",
+        "bbox": [
+            173,
+            391,
+            825,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbb576ff26673f40b54fb9e23034dbe135c1de823313120fffeb74528d761a6f.jpg",
+        "text": "$$\n\\begin{array} { r } { z = z _ { n _ { c } } ^ { f } \\vert \\vert z _ { n _ { c } } ^ { b } } \\\\ { C ( w ) = W z + b } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            511,
+            558,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Question Evidence Common Word Feature (qe-comm): (Li et al., 2016) recently proposed a simple token level indicator feature which significantly boosts reading comprehension performance in some cases. For each token in the document we construct a one-hot vector $f _ { i } \\in \\{ 0 , 1 \\bar  \\} ^ { 2 }$ indicating whether that token is present in the query or not. It can be incorporated into the GA reader by assigning a feature lookup table $F \\in \\bar { \\mathbb { R } ^ { n _ { F } \\times 2 } }$ (we use $n _ { F } = 2 $ ), taking the feature embedding $e _ { i } = f _ { i } ^ { \\underline { { { T } } } } F$ and appending it to the inputs of the last layer document BiGRU as, $x _ { i } ^ { ( K ) } \\| f _ { i }$ for all $i$ . We conducted several experiments both with and without this feature and observed some interesting trends, which are discussed below. Henceforth, we refer to this feature as the qe-comm feature or just feature. ",
+        "bbox": [
+            173,
+            564,
+            826,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            447,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            287,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the GA reader on five large-scale datasets recently proposed in the literature. The first two, CNN and Daily Mail news stories3 consist of articles from the popular CNN and Daily Mail websites (Hermann et al., 2015). A query over each article is formed by removing an entity from the short summary which follows the article. Further, entities within each article were anonymized to make the task purely a comprehension one. N-gram statistics, for instance, computed over the entire corpus are no longer useful in such an anonymized corpus. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The next two datasets are formed from two different subsets of the Children’s Book Test (CBT)4 (Hill et al., 2015). Documents consist of 20 contiguous sentences from the body of a popular children’s book, and queries are formed by deleting a token from the $2 1 ^ { \\mathrm { s t } }$ sentence. We only focus on subsets where the deleted token is either a common noun (CN) or named entity (NE) since simple language models already give human-level performance on the other types (cf. (Hill et al., 2015)). ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/2aba0440ee9c9fc07e6f1f710ae7b62244a349a0cd7d00d76acbfb75f5119d5e.jpg",
+        "table_caption": [
+            "Table 2: Hyperparameter settings for each dataset. $\\dim ( )$ indicates hidden state size of GRU. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>CNN</td><td>Daily Mail</td><td>CBT-NE</td><td>CBT-CN</td><td>WDW-Strict</td><td>WDW-Relaxed</td></tr><tr><td>Dropout</td><td>0.2</td><td>0.1</td><td>0.4</td><td>0.4</td><td>0.3</td><td>0.3</td></tr><tr><td>dim(GRU*)</td><td>256</td><td>256</td><td>128</td><td>128</td><td>128</td><td>128</td></tr></table>",
+        "bbox": [
+            194,
+            121,
+            803,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The final dataset we evaluate on is Who Did What5 (WDW) (Onishi et al., 2016), constructed from the LDC English Gigaword newswire corpus. First, article pairs which appeared around the same time and with overlapping entities are chosen, and then one article forms the document and a cloze query is constructed from the other. Missing tokens are always person named entities. Questions which are easily answered by simple baselines are filtered out, to make the task more challenging. There are two versions of the training set—a small but focused “Strict” version and a large but noisy “Relaxed” version. We report results on both settings which share the same validation and test sets. Statistics of all the datasets used in our experiments are summarized in Table 1. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            405,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our model was implemented using the Theano (Theano Development Team, 2016) and Lasagne6 Python libraries. We used stochastic gradient descent with ADAM updates for optimization, which combines classical momentum and adaptive gradients (Kingma & Ba, 2014). The batch size was 32 and the initial learning rate was $5 \\times 1 0 ^ { - 4 }$ which was halved every epoch after the second epoch. The same setting is applied to all models and datasets. We also used gradient clipping with a threshold of 10 to stabilize GRU training (Pascanu et al., 2012). We set the number of layers $K$ to be 3 for all experiments, and provide further analysis below. The number of hidden units for the character GRU was set to 50. The remaining two hyperparameters—size of document and query GRUs, and dropout rate—were tuned on the validation set, and their optimal values are shown in Table 2. In general, the optimal GRU size increases and the dropout rate decreases as the corpus size increases. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The word lookup table was initialized with $1 0 0 d$ GloVe vectors7 (Pennington et al., 2014) and OOV tokens at test time were assigned unique random vectors. We empirically observed that initializing with pre-trained embeddings gives higher performance compared to random initialization for all datasets. Furthermore, for smaller datasets (WDW and CBT) we found that fixing these embeddings to their pretrained values led to higher test performance, possibly since it avoids overfitting. We do not use the character composition model for CNN and Daily Mail, since entities (and hence candidate answers) are anonymized to generic tokens in these datasets. For other datasets the character lookup table was randomly initialized with $2 5 d$ vectors. All other parameters were initialized to their default values as specified in the Lasagne library. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 PERFORMANCE COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            419,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Tables 3 and 5 show a comparison of the performance of GA Reader with previously published results on WDW and CNN, Daily Mail, CBT datasets respectively. The numbers reported for GA Reader are for single best models, though we compare to both ensembles and single models from prior work. GA Reader-- refers to an earlier version of the model, unpublished but described in a preprint, with the following differences—(1) it does not utilize token-specific attentions within the GA module, as described in equation (5), (2) it does not use a character composition model, (3) it is initialized with word embeddings pretrained on the corpus itself rather than GloVe. A detailed analysis of these differences is studied in the next section. Here we present 4 variants of the latest GA Reader, using combinations of whether the qe-comm feature is used (+feature) or not, and whether the word lookup table $L ( w )$ is updated during training or fixed to its initial value. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, we observe that feature engineering leads to significant improvements for WDW and CBT datasets, but not for CNN and Daily Mail datasets. We note that anonymization of the latter datasets means that there is already some feature engineering (it adds hints about whether a token is an entity), and these are much larger than the other four. In machine learning it is common to see the effect of feature engineering diminish with increasing data size. Similarly, fixing the word ",
+        "bbox": [
+            174,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8198bc019b168a5dbd2a087c9482cd3bfeed2cd3c9cc2c1f1912be0ebbb84435.jpg",
+        "table_caption": [
+            "Table 3: Validation/Test accuracy $( \\% )$ on WDW dataset for both “Strict” and “Relaxed” settings. Results marked with $^ \\dagger$ are cf previously published works. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Strict</td><td colspan=\"2\">Relaxed</td></tr><tr><td>Val</td><td>Test</td><td>Val</td><td>Test</td></tr><tr><td>Human †</td><td></td><td>84</td><td></td><td>/</td></tr><tr><td>Attentive Reader t AS Reader †</td><td></td><td>53 57</td><td></td><td>55 59</td></tr><tr><td>Stanford AR † NSE +</td><td>66.5</td><td>64 66.2</td><td>67.0</td><td>65 66.7</td></tr><tr><td>GA-- t</td><td>1</td><td>57</td><td>1</td><td>60.0</td></tr><tr><td>GA (update L(w))</td><td>67.8</td><td>67.0</td><td>67.0</td><td>66.6</td></tr><tr><td>GA (fix L(ω))</td><td>68.3</td><td>68.0</td><td></td><td>69.1</td></tr><tr><td></td><td></td><td></td><td>69.6</td><td></td></tr><tr><td>GA (+feature, update L(w))</td><td>70.1</td><td>69.5</td><td>70.9</td><td>71.0</td></tr><tr><td>GA (+feature, fix L(w))</td><td>71.6</td><td>71.2</td><td>72.6</td><td>72.6</td></tr></table>",
+        "bbox": [
+            173,
+            147,
+            573,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/df029c3c44954f5b749eb63e2ea8e7651dc51f83bf5f06aab72a2b6b074b0cdc.jpg",
+        "table_caption": [
+            "Table 4: Top: Performance of different gating functions. Bottom: Effect of varying the number of hops $K$ . Results on WDW dataset without using the qe-comm feature and with fixed $L ( w )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Gating Function</td><td rowspan=1 colspan=2> Accuracy</td></tr><tr><td rowspan=1 colspan=1>Val</td><td rowspan=1 colspan=1>Test</td></tr><tr><td rowspan=2 colspan=1>SumConcatenateMultiply</td><td rowspan=2 colspan=1>64.964.468.3</td><td rowspan=1 colspan=1>64.5</td></tr><tr><td rowspan=1 colspan=1>63.768.0</td></tr><tr><td rowspan=1 colspan=1>K</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>1 (AS) t234</td><td rowspan=2 colspan=1>65.668.368.3</td><td rowspan=1 colspan=1>5765.668.0</td></tr><tr><td rowspan=1 colspan=1>68.2</td></tr></table>",
+        "bbox": [
+            591,
+            172,
+            810,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/71e4a478c127dc0c6f3384f61e07d386aac6714ecf99d0ec58cb92b9d5223b8b.jpg",
+        "table_caption": [
+            "Table 5: Validation/Test accuracy $( \\% )$ on CNN, Daily Mail and CBT. Results marked with $^ \\dagger$ are cf previously published works. Results marked with $^ \\ddag$ were obtained by training on a larger training set. Best performance on standard training sets is in bold, and on larger training sets in italics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">CNN</td><td colspan=\"2\">Daily Mail</td><td colspan=\"2\">CBT-NE</td><td colspan=\"2\">CBT-CN</td></tr><tr><td>Val</td><td>Test Val</td><td>Test</td><td>Val</td><td>Test</td><td>Val</td><td></td><td>Test</td></tr><tr><td>Humans (query) †</td><td></td><td></td><td></td><td></td><td>一</td><td>52.0</td><td>1</td><td>64.4</td></tr><tr><td>Humans (context + query) +</td><td>1</td><td>1</td><td>1</td><td>1 一</td><td>1 51.2</td><td>81.6 41.8</td><td>1 62.6</td><td>81.6 56.0</td></tr><tr><td>LSTMs (context + query) t</td><td>1 55.0</td><td>1 57.0</td><td>1 63.3</td><td>62.2</td><td>1</td><td>1</td><td></td><td></td></tr><tr><td>Deep LSTM Reader t Attentive Reader †</td><td>61.6</td><td>63.0</td><td>70.5</td><td>69.0</td><td>1</td><td>1</td><td>1 1</td><td>1 1</td></tr><tr><td>Impatient Reader +</td><td>61.8</td><td>63.8</td><td>69.0</td><td>68.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>MemNets †</td><td>63.4</td><td>66.8</td><td></td><td></td><td>70.4</td><td>66.6</td><td>64.2</td><td>63.0</td></tr><tr><td>AS Reader †</td><td>68.6</td><td>69.5</td><td>75.0</td><td>73.9</td><td>73.8</td><td>68.6</td><td>68.8</td><td>63.4</td></tr><tr><td>DER Network †</td><td>71.3</td><td>72.9</td><td></td><td>1</td><td></td><td></td><td></td><td></td></tr><tr><td>Stanford AR (relabeling) t</td><td>73.8</td><td>73.6</td><td>1 77.6</td><td>76.6</td><td>1</td><td>1 1</td><td>1</td><td>1</td></tr><tr><td>Iterative Attentive Reader †</td><td>72.6</td><td>73.3</td><td></td><td></td><td>75.2</td><td>68.6</td><td>1 72.1</td><td>1 69.2</td></tr><tr><td></td><td>73.4</td><td>74.0</td><td>1</td><td>1</td><td>75.3</td><td>69.7</td><td></td><td></td></tr><tr><td>EpiReader †</td><td>73.1</td><td>74.4</td><td>1</td><td>1</td><td></td><td></td><td>71.5</td><td>67.4</td></tr><tr><td>AoA Reader †</td><td></td><td>74.7</td><td></td><td>76.6</td><td>77.8</td><td>72.0</td><td>72.2</td><td>69.4</td></tr><tr><td>ReasoNet † NSE †</td><td>72.9</td><td></td><td>77.6</td><td></td><td>1 78.2</td><td>1 73.2</td><td>1</td><td>1</td></tr><tr><td></td><td>1</td><td>1</td><td>1</td><td>1</td><td></td><td></td><td>74.3</td><td>71.9</td></tr><tr><td>MemNets (ensemble) † AS Reader (ensemble) t</td><td>66.2 73.9</td><td>69.4 75.4</td><td></td><td>77.7</td><td>一</td><td></td><td>1</td><td>1</td></tr><tr><td></td><td></td><td></td><td>78.7</td><td>79.2</td><td>76.2</td><td>71.0</td><td>71.1</td><td>68.9</td></tr><tr><td>Stanford AR (relabeling,ensemble) †</td><td>77.2</td><td>77.6</td><td>80.2</td><td></td><td>一</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Iterative Attentive Reader (ensemble) †</td><td>75.2</td><td>76.1</td><td>1</td><td>1</td><td>76.9</td><td>72.0</td><td>74.1</td><td>71.0</td></tr><tr><td>EpiReader (ensemble) †</td><td>1</td><td>1</td><td>1</td><td>1</td><td>76.6</td><td>71.8</td><td>73.6</td><td>70.6</td></tr><tr><td>AS Reader (+BookTest) † ‡</td><td>1</td><td>一</td><td>1</td><td>一</td><td>80.5</td><td>76.2</td><td>83.2</td><td>80.8</td></tr><tr><td>AS Reader (+BookTest,ensemble) † ‡</td><td>1</td><td>一</td><td>1</td><td>1</td><td>82.3</td><td>78.4</td><td>85.7</td><td>83.7</td></tr><tr><td>GA--</td><td>73.0</td><td>73.8</td><td>76.7</td><td>75.7</td><td>74.9</td><td>69.0</td><td>69.0</td><td>63.9</td></tr><tr><td>GA (update L(w))</td><td>77.9</td><td>77.9</td><td>81.5</td><td>80.9</td><td>76.7</td><td>70.1</td><td>69.8</td><td>67.3</td></tr><tr><td>GA (fix L(w))</td><td>77.9</td><td>77.8</td><td>80.4</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>77.3</td><td>76.9</td><td></td><td>79.6</td><td>77.2</td><td>71.4</td><td>71.6</td><td>68.0</td></tr><tr><td>GA (+feature, update L(w))</td><td>76.7</td><td>77.4</td><td>80.7</td><td>80.0 79.3</td><td>77.2</td><td>73.3 74.9</td><td>73.0 74.4</td><td>69.8</td></tr><tr><td>GA (+feature, fix L(w))</td><td></td><td></td><td>80.0</td><td></td><td>78.5</td><td></td><td></td><td>70.7</td></tr></table>",
+        "bbox": [
+            173,
+            395,
+            821,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/22ee30a141039c16bafb5ce3cf871edadd5cd3505e0c1b36fdae035d42bfa778.jpg",
+        "image_caption": [
+            "Figure 2: Performance in accuracy with and without the Gated-Attention module over different amounts of training data. $p$ -values for an exact one-sided Mcnemar’s test are given inside the parentheses for each setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            138,
+            823,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "embeddings provides an improvement for the WDW and CBT, but not for CNN and Daily Mail.   \nThis is not surprising given that the latter datasets are larger and less prone to overfitting. ",
+        "bbox": [
+            173,
+            315,
+            821,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing with prior work, on the WDW dataset the basic version of the GA Reader outperforms all previously published models when trained on the Strict setting. By adding the qe-comm feature the performance increases by $3 . 2 \\%$ and $3 . 5 \\%$ on the Strict and Relaxed settings respectively to set a new state of the art on this dataset. On the CNN and Daily Mail datasets the GA Reader leads to an improvement of $3 . 2 \\%$ and $4 . 3 \\%$ respectively over the best previous single models. They also outperform previous ensemble models, setting a new state of that art for both datasets. For CBT-NE, GA Reader with the qe-comm feature outperforms all previous single and ensemble models except the AS Reader trained on the much larger BookTest Corpus (Bajgar et al., 2016). Lastly, on CBTCN the GA Reader with the qe-comm feature outperforms all previously published single models except the NSE, and AS Reader trained on a larger corpus. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 GA READER ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            379,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section we do an ablation study to see the effect of Gated Attention. We compare the GA Reader as described here to a model which is exactly the same in all aspects, except that it passes document embeddings $D ^ { ( k ) }$ in each layer directly to the inputs of the next layer without using the GA module. In other words $X ^ { ( k ) } = D ^ { ( k ) }$ for all $k > 0$ . This model ends up using only one query GRU at the output layer for selecting the answer from the document. We compare these two variants both with and without the qe-comm feature on CNN and WDW datasets for three subsets of the training data - $50 \\%$ , $7 5 \\%$ and $100 \\%$ . Test set accuracies for these settings are shown in Figure 2. On CNN when tested without feature engineering, we observe that GA provides a significant boost in performance compared to without GA. When tested with the feature it still gives an improvement, but the improvement is significant only with $100 \\%$ training data. On WDW-Strict, which is a third of the size of CNN, without the feature we see an improvement when using GA versus without using GA, which becomes significant as the training set size increases. When tested with the feature on WDW, for a small data size without GA does better than with GA, but as the dataset size increases they become equivalent. We conclude that Gated Attention provides a boost in the absence of feature engineering, or as the training set size increases. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next we look at the question of how to gate intermediate document reader states from the query, i.e. what operation to use in equation 6. Table 4 (top) shows the performance on WDW dataset for three common choices – sum $( x = d + q )$ ), concatenate $( x = d \\lVert q )$ and multiply $( x = d \\odot q )$ . Empirically we find that element-wise multiplication does significantly better than the other two, which justifies our motivation to “filter” out document features which are irrelevant to the query. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "At the bottom of Table 4 we show the effect of varying the number of hops $K$ of the GA Reader on the final performance. We note that for $K = 1$ , our model is equivalent to the AS Reader without any GA modules. We see a steep and steady rise in accuracy as the number of hops is increased from $K = 1$ to $K = 3$ , which remains constant beyond that. This is a fairly common trend in machine learning as model complexity is increased, however we note that a multi-hop architecture is important to achieve a high performance for this task, and provide further evidence for this in the next section. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f8e9d096218e2ae030199722811c00bc1d2d924d84eb2352c9a940674bfe3d1.jpg",
+        "image_caption": [
+            "Figure 3: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details. ",
+            "DOCjapaesei avetompilatdaiefdfisdsi nsotolsafee entblamedll ncialifelieedosoald new global financial regulatory standardsat the london summit. ",
+            "QRYbegupsicilaoadi <end> ANS:timothy geithner "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            131,
+            826,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we perform an ablation study for the three components of the GA Reader which were absent in the preprint version (GA Reader--). Table 6 shows accuracy on WDW by removing one component at a time. The steepest reduction is observed when we replace pretrained GloVe vectors with those pretrained on the corpus itself. GloVe vectors were trained on a large corpus of about 6 billion tokens (Pennington et al., 2014), and provide an important source of prior knowledge for the model. We note here that the strongest baseline on WDW, NSE (Munkhdalai & Yu, 2016b), also uses pretrained GloVe vectors, hence the comparison is fair in that respect. Next, we observe a substantial drop when removing token-specific attentions over the query in the GA module, which allow gating indi",
+        "bbox": [
+            174,
+            415,
+            529,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Ablation study on WDW dataset, without using the qe-comm feature and with fixed $L ( w )$ . Results marked with $^ \\dagger$ are cf Onishi et al. (2016). ",
+        "bbox": [
+            544,
+            417,
+            823,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/521628dd9d1aa56795daea2f9219bb405ebf6351e5b95c141f7e293f063aede4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>AccuracyVal  Test</td></tr><tr><td rowspan=2 colspan=1>GA-char-token-attentions (eq. 5)-glove,+corpus</td><td rowspan=1 colspan=1>68.366.9</td><td rowspan=1 colspan=1>68.066.9</td></tr><tr><td rowspan=1 colspan=1>65.764.0</td><td rowspan=1 colspan=1>65.062.5</td></tr><tr><td rowspan=1 colspan=1>GA--t</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>57</td></tr></table>",
+        "bbox": [
+            542,
+            476,
+            825,
+            601
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "vidual tokens in the document only by parts of the query relevant to that token rather than the overall query representation. Finally, removing the character embeddings, which were only used for WDW and CBT datasets, leads to a reduction of about $1 \\%$ in the performance. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 ATTENTION VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            411,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To gain an insight into the reading process employed by the model we analyzed the attention distributions at intermediate layers of the reader. Figure 3 shows an example from the validation set of WDW dataset (several more are in the Appendix). In each figure, the left and middle plots visualize attention over the query (equation 5) for candidates in the document after layers $1 \\ \\& \\ 2$ respectively. The right plot shows attention over candidates in the document of cloze placeholder (XXX) in the query at the final layer. The full document, query and correct answer are shown at the bottom. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A generic pattern observed in these examples is that in intermediate layers, candidates in the document (shown along rows) tend to pick out salient tokens in the query which provide clues about the cloze, and in the final layer the candidate with the highest match with these tokens is selected as the answer. In Figure 3 there is a high attention of the correct answer on financial regulatory standards in the first layer, and on us president in the second layer. The incorrect answer, in contrast, only attends to one of these aspects, and hence receives a lower score in the final layer despite the n-gram overlap it has with the cloze token in the query. Importantly, different layers tend to focus on different tokens in the query, which supports the hypothesis that the multi-hop architecture of GA Reader is able to combine distinct pieces of information to answer the query. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented the Gated-Attention reader for answering cloze-style questions over documents. The GA reader features a novel multiplicative gating mechanism, combined with a multi-hop architecture. Our model achieves state-of-the-art performance on several large-scale benchmark datasets with more than $4 \\%$ improvements over competitive baselines. Our model design is backed up by an ablation study showing statistically significant improvements of using Gated Attention as information filters. We also showed empirically that multiplicative gating is superior to addition and concatenation operations for implementing gated-attentions, though a theoretical justification remains part of future research goals. Analysis of document and query attentions in intermediate layers of the reader further reveals that the model iteratively attends to different aspects of the query to arrive at the final answer. In this paper we have focused on text comprehension, but we believe that the Gated-Attention mechanism may benefit other tasks as well where multiple sources of information interact. Concurrent to our work (Chu et al., 2016) have also shown the effectiveness of GA Readers on the LAMBADA dataset (Paperno et al., 2016) for language modeling. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            285,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.   \nOndrej Bajgar, Rudolf Kadlec, and Jan Kleindienst. Embracing data abundance: Booktest dataset for reading comprehension. arXiv preprint arXiv:1610.00956, 2016.   \nDanqi Chen, Jason Bolton, and Christopher D Manning. A thorough examination of the cnn/daily mail reading comprehension task. arXiv preprint arXiv:1606.02858, 2016.   \nKyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.   \nZewei Chu, Hai Wang, Kevin Gimpel, and David McAllester. Broad context language modeling as reading comprehension. arXiv preprint arXiv:1610.08431, 2016.   \nYiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016.   \nBhuwan Dhingra, Zhong Zhou, Dylan Fitzpatrick, Michael Muehl, and William W Cohen. Tweet2vec: Character-based distributed representations for social media. ACL, 2016.   \nKarl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1684–1692, 2015.   \nFelix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. arXiv preprint arXiv:1511.02301, 2015.   \nSepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   \nRudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. arXiv preprint arXiv:1603.01547, 2016.   \nDiederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nRyan Kiros, Richard Zemel, and Ruslan R Salakhutdinov. A multiplicative model for learning distributed text-based attribute representations. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2014.   \nSosuke Kobayashi, Ran Tian, Naoaki Okazaki, and Kentaro Inui. Dynamic entity representations with max-pooling improves machine reading. In NAACL-HLT, 2016. ",
+        "bbox": [
+            171,
+            358,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ankit Kumar, Ozan Irsoy, Jonathan Su, James Bradbury, Robert English, Brian Pierce, Peter Ondruska, Ishaan Gulrajani, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. arXiv preprint arXiv:1506.07285, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. arXiv preprint arXiv:1607.06275, 2016. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeff Mitchell and Mirella Lapata. Vector-based models of semantic composition. In ACL, pp. 236– 244, 2008. ",
+        "bbox": [
+            173,
+            205,
+            821,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014. ",
+        "bbox": [
+            174,
+            243,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsendsuren Munkhdalai and Hong Yu. Neural semantic encoders. arXiv preprint arXiv:1607.04315, 2016a. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsendsuren Munkhdalai and Hong Yu. Reasoning with memory augmented neural networks for language comprehension. arXiv preprint arXiv:1610.06454, 2016b. ",
+        "bbox": [
+            174,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeshi Onishi, Hai Wang, Mohit Bansal, Kevin Gimpel, and David McAllester. Who did what: A large-scale person-centered cloze dataset. EMNLP, 2016. ",
+        "bbox": [
+            173,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Denis Paperno, German Kruszewski, Angeliki Lazaridou, Quan Ngoc Pham, Raffaella Bernardi, ´ Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: ´ Word prediction requiring a broad discourse context. arXiv preprint arXiv:1606.06031, 2016. ",
+        "bbox": [
+            176,
+            395,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. arXiv preprint arXiv:1211.5063, 2012. ",
+        "bbox": [
+            173,
+            446,
+            821,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. In Empirical Methods in Natural Language Processing (EMNLP), pp. 1532–1543, 2014. URL http://www.aclweb.org/anthology/D14-1162. ",
+        "bbox": [
+            174,
+            484,
+            823,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. arXiv preprint arXiv:1609.05284, 2016. ",
+        "bbox": [
+            176,
+            535,
+            823,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in Neural Information Processing Systems, pp. 2431–2439, 2015. ",
+        "bbox": [
+            174,
+            611,
+            823,
+            641
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688. ",
+        "bbox": [
+            173,
+            648,
+            823,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Trischler, Zheng Ye, Xingdi Yuan, and Kaheer Suleman. Natural language comprehension with the epireader. arXiv preprint arXiv:1606.02270, 2016. ",
+        "bbox": [
+            169,
+            700,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On multiplicative integration with recurrent neural networks. arXiv preprint arXiv:1606.06630, 2016. ",
+        "bbox": [
+            171,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Learning multi-relational semantics using neural-embedding models. arXiv preprint arXiv:1411.4072, 2014. ",
+        "bbox": [
+            173,
+            814,
+            821,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Ruslan Salakhutdinov, and William Cohen. Multi-task cross-lingual sequence tagging from scratch. arXiv preprint arXiv:1603.06270, 2016. ",
+        "bbox": [
+            173,
+            852,
+            823,
+            881
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ATTENTION PLOTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            367,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/adf33e0be85832bf009f0ec63c93c9014820a80ea3d60d4742ea55f938febdf7.jpg",
+        "image_caption": [
+            "Figure 4: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            166,
+            828,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/cefbea117fe6dc7325aeb7af5004d024973c73342c74371ee5b5f5407fcaa704.jpg",
+        "image_caption": [
+            "DOC:resultsundfrothe（uro）5（\\$97tptudodcourtevetataaisssports（edisite $) :$ singl efinalmij ulian knowle,austria and robert lindstedt,sweden（1）,6-4,6-3. ",
+            "QRY:<beg> france 's michael llodra beat his compatriot and doubles partner XXX.<end> ANS: julien benneteau "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            439,
+            826,
+            602
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "DOC:englandatsatdilo gonedayerdalod'sadfiealfdebo treelyosiveoineioodidespaewastaltersic pontingsoaieettieddtfiris forkshiessil ybodisfocusdeidtheseitseetfaideino sstringprospeast sdees lot'shappenedtomeinthelast sixmonths.ifthechancecomes-ryan'sgotaniggle,butidon'tthinkit $\\cdot _ { \\mathsf { S } }$ too bad -i've just got toput inadecen tpeforncentsddetb can get the nod.\" ",
+        "bbox": [
+            176,
+            604,
+            812,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "QRY:<beg>yrksowdaldd‘soteatdfdamstrd> ANS:ryan sidebottom ",
+        "bbox": [
+            174,
+            689,
+            781,
+            705
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca73735c6ab32c366436c7abe9bdeb033fd3a9d8084fc1d20cfa1ecfa5ef3327.jpg",
+        "image_caption": [
+            "Figure 5: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details. ",
+            "DOC:usseeaitotitee\"tt twaswhatitsotindssfiisteoaditteifis uxuryotelinrliausresidetdeiuriofeet ythattheistdooittotiad ouldworktogddseprofedtitttserelaoil togetherdgutodetset sianword.doyou thinkwegot it $? ^ { n }$ clintonaskedlavrov.yougotitwrong，\"herespondedas theyboth laughed.it shouldbe'perezagrouzka‘(t e thattous\"lsaeaatastaedrasdo k. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            257,
+            826,
+            431
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/24b87083c88cfb287c692bad420caadb8c78c69d4a10b21a28e88f405531d122.jpg",
+        "image_caption": [
+            "QRY:<beg>usecrearyfstatehilaryinonmeetsXXofiddsesidseissureteywillotoveromealldifereesed> ANS:sergei lavrov ",
+            "DOC: illinois governor arrested on corruption charges chicago,dec.9（ xinhua $textsc { -- } u . s .$ federal prosecutors on tuesday arrested illinois governor rod blagojevich a nhischiefofdsds ingtoeoeateatcntsittacifoaaitsfdelfoo alsochargdimia tabout6sp ansaid he did not know the development. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            530,
+            813,
+            719
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "QRY:<beg>rescddf $\" { \\mathsf { s } }$ senate seat   \n.<end>   \nANS: rod blagojevich   \nQRY: ${ \\tt { < b e g > } }$ europeancmmissocejemaroaldxprssthu’appnt\"taffisiua   \n,an aide said.<end>   \nANS:vladimirputin ",
+        "bbox": [
+            179,
+            768,
+            820,
+            790
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f08ba88bc4fe942a603910024c19103ce309f3443aae883fdfaf9abc9e874962.jpg",
+        "image_caption": [
+            "Figure 6: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details. ",
+            "DC:europealpldttcffirosr threaerosteos ingdisapomettcfaturafoeodedtlitsifoei barososteitheondtcsfotispac rdingtoisidutiaettpdstso ukraianouteostart hcausesdatsl iistlsteetacsi moshenkoprteodasorotilo wednesdayamidapricingdisputewithukranethecutoffleftanumberofeuropeancountriesinlackofheatinggasamidfrezingeather "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            257,
+            826,
+            422
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            501,
+            820,
+            518
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d252657462e0a42705ed2845cb58b6b1654fe004341e86a994dc6d08466176e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            530,
+            818,
+            707
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "DC:presidftabliil eetecti eepeteti wseportetlipsaorucftfoe subectofurtatetei thepalestinll cess between israel and palestine.this has been abbas'third oficial visit to france since 2007. ",
+        "bbox": [
+            178,
+            713,
+            812,
+            763
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "QRYbeg   \nreconsideringa freeze.<end>   \nANS:benjaminnetanyahu ",
+        "bbox": [
+            176,
+            770,
+            821,
+            789
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9ae4c27f3f191602816b9263ac6237a0097fa3ec21c84536266f1c656b6d025.jpg",
+        "image_caption": [
+            "Figure 7: Layer-wise attention visualization of GA Reader trained on WDW-Strict. See text for details. ",
+            "DC:iftheredooid intinge evenofthmrrididldidfdt losnddadrdebarsidoidth d,bytakingolndaingosdeableutiacesideo'sltiveilloko "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            260,
+            812,
+            450
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1691bec6ae8d76535f606c73cfd5ad5b2a7fbf2c39f4aa66ae03343812da35f.jpg",
+        "image_caption": [
+            "ORYbi from Xxx.<end> ANS: lionel messi "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            525,
+            826,
+            712
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "DOC:dinarafetsedtfidtoebf forcederorscadlastli）afi teroftwotiampaaiodtrilduedfa eadowsece he u.s.openand has won one grand slam match.she never has defeated anyone ranked better than 47th. ",
+        "bbox": [
+            181,
+            726,
+            815,
+            762
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "QRYbeg>rbilrstiffsdi same wayXXX did in 20o0.<end> ",
+        "bbox": [
+            179,
+            767,
+            800,
+            784
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HknbyQbC-/HknbyQbC-.md

@@ -0,0 +1,359 @@
+# GENERATING ADVERSARIAL EXAMPLES WITH ADVERSARIAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep neural networks (DNNs) have been found to be vulnerable to adversarial examples resulting from adding small-magnitude perturbations to inputs. Such adversarial examples can mislead DNNs to produce adversary-selected results. Different attack strategies have been proposed to generate adversarial examples, but how to produce them with high perceptual quality and more efficiently requires more research efforts. In this paper, we propose AdvGAN to generate adversarial examples with generative adversarial networks (GANs), which can learn and approximate the distribution of original instances. For AdvGAN, once the generator is trained, it can generate adversarial perturbations efficiently for any instance, so as to potentially accelerate adversarial training as defenses. We apply AdvGAN in both semi-whitebox and black-box attack settings. In semi-whitebox attacks, there is no need to access the original target model after the generator is trained, in contrast to traditional white-box attacks. In black-box attacks, we dynamically train a distilled model for the black-box model and optimize the generator accordingly. Adversarial examples generated by AdvGAN on different target models have high attack success rate under state-of-the-art defenses compared to other attacks. Our attack has placed the first with $9 2 . 7 6 \%$ accuracy on a public MNIST black-box attack challenge (M ˛adry et al., 2017b).
+
+# 1 INTRODUCTION
+
+Deep Neural Networks (DNNs) have achieved great successes in a variety of applications ranging from image recognition (Krizhevsky et al., 2012; He et al., 2016) to speech processing (Hinton et al., 2012) and from robotics training (Levine et al., 2016) to medical diagnostics (Ciresan et al., 2012). However, recent work has demonstrated that DNNs are vulnerable to adversarial perturbations (Szegedy et al., 2014; Goodfellow et al., 2015). An adversary can add small-magnitude perturbations to inputs and generate adversarial examples to mislead DNNs. Such maliciously perturbed instances can cause the learning system to misclassify them into either a maliciously-chosen target class (in a targeted attack) or classes that are different from the ground truth (in an untargeted attack). Different algorithms have been proposed for generating such adversarial examples, such as the fast gradient sign method (FGSM) (Goodfellow et al., 2015) and optimization-based methods (Opt.) (Carlini & Wagner, 2017a; Liu et al., 2017).
+
+Most of the the current attack algorithms (Carlini & Wagner, 2017a; Liu et al., 2017) rely on optimization schemes with simple pixel space metrics, such as $L _ { \infty }$ distance from a benign image, to encourage visual realism. To generate more perceptually realistic adversarial examples, in this paper, we propose to train a feed-forward network to generate perturbations such that the resulting example must be realistic according to a discriminator network. We apply generative adversarial networks (GANs) (Goodfellow et al., 2014) to produce adversarial examples in both the semi-whitebox and black-box settings. As conditional GANs are capable of producing high-quality images (Isola et al., 2017), we apply a similar paradigm to produce perceptually realistic adversarial instances. We name our method AdvGAN.
+
+Note that in the previous white-box attacks, such as FGSM and optimization methods, the adversary needs to have white-box access to the architecture and parameters of the model all the time. However, by deploying AdvGAN, once the feed-forward network is trained, it can instantly produce adversarial perturbations for any input instances without requiring access to the model itself anymore. We name this attack setting semi-whitebox.
+
+To evaluate the effectiveness of our attack strategy AdvGAN, we first generate adversarial instances based on AdvGAN and other attack strategies on different target models. We then apply the stateof-the-art defenses to defend against these generated adversarial examples (Goodfellow et al., 2015; Tramèr et al., 2017a; M ˛adry et al., 2017a). We evaluate these attack strategies in both semi-whitebox and black-box settings. We show that adversarial examples generated by AdvGAN can achieve a high attack success rate, potentially due to the fact that these adversarial instances appear closer to real instances compared to other recent attack strategies.
+
+Our contributions are listed as follows.
+
+• Different from the previous optimization-based methods, we train a conditional adversarial network to directly produce adversarial examples, which are both perceptually realistic and achieve state-of-the-art attack success rate against different target models. • We show that AdvGAN can attack black-box models by training a distilled model. We propose to dynamically train the distilled model with query information and achieve high black-box attack success rate and targeted black-box attack, which is difficult to achieve for transferability-based black-box attacks. We use the state-of-the-art defense methods to defend against adversarial examples and show that AdvGAN achieves much higher attack success rate under current defenses. We apply AdvGAN on M ˛adry et al.’s MNIST challenge (2017a) and achieve $8 8 . 9 3 \%$ accuracy on the published robust model in the semi-whitebox setting and $9 2 . 7 6 \%$ in the blackbox setting, which wins the top position in the challenge (M ˛adry et al., 2017b).
+
+# 2 RELATED WORK
+
+Here we review recent work on adversarial examples and generative adversarial networks.
+
+Adversarial Examples A number of attack strategies to generate adversarial examples have been proposed in the white-box setting, where the adversary has full access to the classifier (Szegedy et al., 2014; Goodfellow et al., 2015; Carlini & Wagner, 2017a; Moosavi-Dezfooli et al., 2015; Papernot et al., 2016; Biggio et al., 2013; Kurakin et al., 2016). Goodfellow et al. propose the fast gradient sign method (FGSM), which applies a first-order approximation of the loss function to construct adversarial samples. Formally, given an instance $x$ , an adversary generates adversarial example $x _ { A } = x + \eta$ with $L _ { \infty }$ constraints in the untargeted attack setting as $\eta = \epsilon \cdot \mathrm { s i g n } ( \nabla _ { x } \ell _ { f } ( x , y ) )$ , where $\ell _ { f } ( \cdot )$ is the cross-entropy loss used to train the neural network $f$ , and $y$ represents the ground truth of $x$ . Optimization based methods have also been proposed to optimize adversarial perturbation for targeted attacks while satisfying certain constraints (Carlini & Wagner, 2017a; Liu et al., 2017). Its goal is to minimize the objective function as $| | \eta | | + \lambda \ell _ { f } ( x _ { A } , y )$ , where $| | \cdot | |$ is an appropriately chosen norm function. However, the optimization process is slow and can only optimize perturbation for one specific instance each time. In contrast, our feed-forward network can produce perturbation for any instance. It achieves higher attack success rate against different defenses and performs much faster than the current attack algorithms.
+
+Independently from our work, feed-forward networks have been applied to generate adversarial perturbation (Baluja & Fischer, 2017). However, Baluja & Fischer combine the re-ranking loss and an $L _ { 2 }$ norm loss, aiming to constrain the generated adversarial instance to be close to the original one in terms of $L _ { 2 }$ ; while we apply a deep neural network as a discriminator to help distinguish the instance with other real images to encourage the perceptual quality of the generated adversarial examples.
+
+Black-box Attacks Current learning systems usually do not allow white-box accesses against the model for security reasons. Therefore, there is a great need for black-box attacks analysis. Most of the black-box attack strategies are based on the transferability phenomenon (Papernot et al., 2017), where an adversary can train a local model first and generate adversarial examples against it, hoping the same adversarial examples will also be able to attack the other models. Many learning systems allow query accesses to the model. However, there is little work that can leverage query-based access to target models to construct adversarial samples and move beyond transferability. Papernot et al. (2017) proposed to train a local substitute model with queries to the target model to generate adversarial samples, but this strategy still relies on transferability. In contrast, we show that the proposed AdvGAN can perform black-box attacks without depending on transferability.
+
+![](images/962027a6b691cc62b440a07546f5c99eb4c6a04c47fbbbe54c1dfb515202872c.jpg)  
+Figure 1: Overview of AdvGAN
+
+Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have achieved visually appealing results in both image generation (Radford et al., 2015; Gulrajani et al., 2017; Berthelot et al., 2017) and manipulation (Zhu et al., 2016) settings. Recently, image-to-image conditional GANs have further improved the quality of synthesis results (Isola et al., 2017; Zhu et al., 2017). We adopt a similar adversarial loss and image-to-image network architecture to learn the mapping from an original image to a perturbed output such that the perturbed image cannot be distinguished from real images in the original class. Different from prior work, we aim to produce output results that are not only visually realistic but also able to mislead target learning models.
+
+# 3 GENERATING ADVERSARIAL EXAMPLES WITH ADVERSARIAL NETWORKS
+
+# 3.1 PROBLEM DEFINITION
+
+Let ${ \mathcal { X } } \subseteq { \mathcal { R } } ^ { n }$ be the feature space, with $n$ the number of features. Suppose that $( x _ { i } , y _ { i } )$ is the ith instance within the training set, which is comprised of feature vectors $x _ { i } \in \mathcal X$ , generated according to some unknown distribution $x _ { i } \sim \mathcal { P } _ { \mathrm { d a t a } }$ , and $y _ { i } ~ \in ~ \mathcal { V }$ the corresponding true class labels. The learning system aims to learn a classifier $f : \mathcal { X }  \mathcal { Y }$ from the domain $\mathcal { X }$ to the set of classification outputs $\mathcal { V }$ , where $| \mathcal { V } |$ denotes the number of possible classification outputs. Given an instance $x$ , the goal of an adversary is to generate adversarial example $x _ { A }$ , which is classified as $f ( x _ { A } ) \neq y$ (untargeted attack), where $y$ denotes the true label; or $f ( x _ { A } ) = t$ (targeted attack) where $t$ is the target class. $x _ { A }$ should also be close to the original instance $x$ in terms of $L _ { 2 }$ or other distance metric.
+
+# 3.2 ADVGAN FRAMEWORK
+
+Figure 1 illustrates the overall architecture of AdvGAN, which mainly consists of three parts: a generator $\mathcal { G }$ , a discriminator $\mathcal { D }$ , and the target neural network $f$ . Here the generator $\mathcal { G }$ takes the original instance $x$ as its input and generates a perturbation $\mathcal G ( x )$ . Then $x + \mathcal { G } ( x )$ will be sent to the discriminator $\mathcal { D }$ , which is used to distinguish the generated data and the original instance $x$ . The goal of $\mathcal { D }$ is to encourage that the generated instance is indistinguishable with the data from its original class. To fulfill the goal of fooling a learning model, we first perform the white-box attack, where the target model is $f$ in this case. $f$ takes $x + \mathcal { G } ( x )$ as its input and outputs its loss $\mathcal { L } _ { a d v }$ , which represents the distance between the prediction and the target class $t$ (targeted attack), or the opposite of the distance between the prediction and the ground truth class (untargeted attack).
+
+The adversarial loss (Goodfellow et al., 2014) can be written as: 1
+
+$$
+\mathcal { L } _ { \mathrm { G A N } } = \mathbb { E } _ { x } \log \mathcal { D } ( x ) + \mathbb { E } _ { x } \log ( 1 - \mathcal { D } ( x + \mathcal { G } ( x ) ) ) .
+$$
+
+Here, the discriminator $\mathcal { D }$ aims to distinguish the perturbed data $x + \mathcal { G } ( x )$ from the original data $x$ . 2 Note that the real data is sampled from the true class, so as to encourage that the generated instances are close to data from the original class.
+
+The loss for fooling the target model $f$ in a targeted attack is:
+
+$$
+\mathcal { L } _ { \mathrm { a d v } } ^ { f } = \mathbb { E } _ { x } \ell _ { f } ( x + \mathcal { G } ( x ) , t ) ,
+$$
+
+where origin $t$ is the t model get cl. The nd lo $\ell _ { f }$ denotes the loss function (e.g., cross-entropy loss) used to train t encourages the perturbed image to be misclassified as target class . $f$ $\mathcal { L } _ { a d v } ^ { f }$ $t$ Here we can also perform the untargeted attack by maximizing the distance between the prediction and the ground truth, but we will focus on the targeted attack in the rest of the paper.
+
+To bound the magnitude of the perturbation, which is a common practice in prior work (Carlini & Wagner, $2 0 1 7 \mathrm { a }$ ; Liu et al., 2017; Bartlett & Wegkamp, 2008), we add a soft hinge loss on the $L _ { 2 }$ norm as
+
+$$
+\mathcal { L } _ { \mathrm { h i n g e } } = \mathbb { E } _ { x } \operatorname* { m a x } ( 0 , \| \mathcal { G } ( x ) \| _ { 2 } - c ) ,
+$$
+
+where $c$ denotes a user-specified bound. This can also stabilize the GAN’s training, as shown in Isola et al. (2017). Finally, our full objective can be expressed as
+
+$$
+\mathcal { L } = \mathcal { L } _ { \mathrm { a d v } } ^ { f } + \alpha \mathcal { L } _ { \mathrm { G A N } } + \beta \mathcal { L } _ { \mathrm { h i n g e } } ,
+$$
+
+where $\alpha$ and $\beta$ control the relative importance of each objective. Note that ${ \mathcal { L } } _ { \mathrm { G A N } }$ here is used to encourage the perturbed data to appear similar to the original data $x$ , while $\mathcal { L } _ { \mathrm { a d v } } ^ { f }$ is leveraged to generate adversarial examples, optimizing for the high attack success rate. We obtain our $\mathcal { G }$ and $\mathcal { D }$ by solving the minmax game arg $\operatorname* { m i n } _ { \mathcal { G } } \operatorname* { m a x } _ { \mathcal { D } } \mathcal { L }$ .
+
+# 3.3 BLACK-BOX ATTACKS WITH ADVERSARIAL NETWORKS
+
+Static Distillation For black-box attack, we assume adversaries have no prior knowledge of training data or the model itself. In our experiments in Section 4, we randomly draw data that is disjoint from the training data of the black-box model to distill it, since we assume the adversaries have no prior knowledge about the training data or the model. To achieve black-box attacks, we first build a distilled network $f$ based on the output of the black-box model $b$ (Hinton et al., 2015). Once we obtain the distilled network $f$ , we carry out the same attack strategy as described in the white-box setting (see Equation (4)). Here, we minimize the following network distillation objective:
+
+$$
+\arg \operatorname* { m i n } _ { \boldsymbol { f } } \mathbb { E } _ { \boldsymbol { x } } \mathcal { H } ( \boldsymbol { f } ( \boldsymbol { x } ) , \boldsymbol { b } ( \boldsymbol { x } ) ) ,
+$$
+
+where $f ( x )$ and $b ( x )$ denote the output from the distilled model and black-box model respectively for the given training image $x$ , and $\mathcal { H }$ denotes the commonly used cross-entropy loss. By optimizing the objective over all the training images, we can obtain a model $f$ which behaves very close to the black-box model $b$ . We then carry out the attack on the distilled network.
+
+Note that unlike training the discriminator $\mathcal { D }$ , where we only use the real data from the original class to encourage that the generated instance is close to its original class, here we train the distilled model with data from all classes.
+
+Dynamic Distillation Only training the distilled model with all the pristine training data is not enough, since it is unclear how close the black-box and distilled model perform on the generated adversarial examples, which have not appeared in the training set before. Here we propose an alternative minimization approach to dynamically make queries and train the distilled model $f$ and our generator $\mathcal { G }$ jointly. We perform the following two steps in each iteration. During iteration $i$ :
+
+Table 1: Comparison with the state-of-the-art attack methods. Run time is measured for generating 1,000 adversarial instances during test time. Opt. represents the optimization based method, and Trans. denotes black-box attacks based on transferability.   
+
+<table><tr><td></td><td>FGSM</td><td>Opt.</td><td>Trans.</td><td>AdvGAN</td></tr><tr><td>Run time</td><td>0.06s</td><td>&gt;3h</td><td>1</td><td>&lt;0.01s</td></tr><tr><td>Targeted Attack</td><td>√</td><td>√</td><td>Ens.</td><td>√</td></tr><tr><td>Black-box Attack</td><td></td><td></td><td>√</td><td>&lt;</td></tr></table>
+
+1. Update $\mathcal { G } _ { i }$ given a fixed network $f _ { i - 1 }$ : We follow the white-box setting (see Equation 4) and train the generator and discriminator based on a previously distilled model $f _ { i - 1 }$ . We initialize the weights $\mathcal { G } _ { i }$ as $\mathcal { G } _ { i - 1 }$ .
+
+$$
+\mathcal { G } _ { i } , D _ { i } = \arg \operatorname* { m i n } _ { \mathcal { G } } \operatorname* { m a x } _ { \mathcal { D } } \mathcal { L } _ { \mathrm { a d v } } ^ { f _ { i - 1 } } + \alpha \mathcal { L } _ { \mathrm { G A N } } + \beta \mathcal { L } _ { \mathrm { h i n g e } }
+$$
+
+2. Update $f _ { i }$ given a fixed generator $\mathcal { G } _ { i }$ : First, we use $f _ { i - 1 }$ to initialize $f _ { i }$ . Then, given the generated adversarial examples $x + \mathcal { G } _ { i } ( x )$ from $\mathcal { G } _ { i }$ , the distilled model $f _ { i }$ will be updated based on the set of new query results for the generated adversarial examples against the black-box model, as well as the original training images.
+
+$$
+f _ { i } = \arg \operatorname* { m i n } _ { f } \mathbb { E } _ { x } \mathcal { H } ( f ( x ) , b ( x ) ) + \mathbb { E } _ { x } \mathcal { H } ( f ( x + \mathcal { G } _ { i } ( x ) ) , b ( x + \mathcal { G } _ { i } ( x ) ) ) ,
+$$
+
+where we use both the original images $x$ and the newly generated adversarial examples $x + s \mathcal { G } _ { i } ( x )$ to update $f$ .
+
+In the experiment section, we compare the performance of both the static and dynamic distillation approaches and observe that simultaneously updating $\mathcal { G }$ and $f$ produces higher attack performance. See Table 2 for more details.
+
+# 4 EXPERIMENTAL RESULTS
+
+In this section, we first evaluate AdvGAN for both semi-whitebox and black-box settings on MNIST (LeCun & Cortes, 1998) and CIFAR-10 (Krizhevsky et al., 2014). We also perform a semi-whitebox attack on the ImageNet dataset(Deng et al., 2009). We then apply AdvGAN to generate adversarial examples on different target models and test the attack success rate for them under the state-of-theart defenses and show that our method can achieve higher attack success rates compared to other existing attack strategies. We generate all adversarial examples for different attack methods based on the under $L _ { \infty }$ bound of 0.3 on MNIST and 8 on CIFAR-10, for a fair comparison.
+
+In general, as shown in Table 1, AdvGAN has several advantages over other white-box and blackbox attacks. For instance, regarding computation efficiency, AdvGAN performs much faster than others even including the efficient FGSM, although AdvGAN needs extra training time to train the generator. All these strategies can perform targeted attack except transferability based attack, although the ensemble strategy can help to improve. Besides, FGSM and optimization methods can only perform white-box attack, while AdvGAN is able to attack in semi-whitebox setting.
+
+Implementation Details Our code and models will be available upon publication. We adopt a similar architecture from image-to-image translation literature (Isola et al., 2017; Zhu et al., 2017). In particular, we use the architecture of generator $\mathcal { G }$ from Johnson et al. (2016), and our discriminator $\mathcal { D }$ ’s architecture is similar to model C for MNIST and ResNet-32 for CIFAR-10. We apply the loss in Carlini & Wagner (2017c) as our loss $\begin{array} { r } { \mathcal { L } _ { a d v } ^ { f } = \operatorname* { m a x } ( \operatorname* { m a x } _ { i \neq t } f ( x _ { A } ) _ { i } - f ( x _ { A } ) _ { t } , \kappa ) } \end{array}$ , where $t$ is the represents the target network in the semi-whitebox setting and the distilled model in the black-box setting. We set the confidence $\kappa = 0$ for both Opt. and AdvGAN. We use Adam as our solver (Kingma & Ba, 2014), with a batch size of 128 and a learning rate of 0.001. For GANs training, we use the least squares objective proposed by LSGAN (Mao et al., 2016), as it has been shown to produce better results with more stable training.
+
+Table 2: Accuracy of different models on pristine data, and the attack success rate of adversarial examples generated against different models by AdvGAN on MNIST and CIFAR-10. p: pristine test data; w: semi-whitebox attack; b-D: black-box attack with dynamic distillation strategy; b-S: black-box attack with static distillation strategy.   
+
+<table><tr><td>Model</td><td>MNIST A B</td><td>C</td><td>ResNet-32</td><td>CIFAR-10 Wide ResNet-34</td></tr><tr><td>Accuracy (p)</td><td>98.97% 99.17%</td><td>99.09%</td><td>92.41%</td><td>95.01%</td></tr><tr><td>Attack Success Rate (w)</td><td>97.9% 97.1%</td><td>98.3%</td><td>94.71%</td><td>99.30%</td></tr><tr><td>Attack Success Rate (b-D)</td><td>93.4% 90.1%</td><td>94.02%</td><td>78.47 %</td><td>81.81%</td></tr><tr><td>Attack Success Rate (b-S)</td><td>30.7% 66.63%</td><td>87.3%</td><td>10.3%</td><td>13.3%</td></tr></table>
+
+Models Used in the Experiments For MNIST, in all of our experiments, we generate adversarial examples for three models whose architectures are shown in Appendix A. Models A and B are used in Tramèr et al. (2017b), which represent different architectures. Model C is the target network architecture used in (Carlini & Wagner, 2017a) for evaluating optimization based strategy. For CIFAR-10, we select ResNet-32 and Wide ResNet-34 (He et al., 2016; Zagoruyko & Komodakis, 2016) for our experiments. Specifically, we use a 32-layer ResNet implemented in TensorFlow3 and Wide ResNet derived from the variant of “w32-10 wide.”4 We show the classification accuracy of pristine MNIST and CIFAR-10 test data (p) and attack success rate of adversarial examples generated by AdvGAN on different models in Table 2.
+
+# 4.1 ADVGAN IN SEMI-WHITEBOX SETTING
+
+First, we apply different architectures for the target model $f$ as listed in Appendix A for MNIST and with ResNet and Wide ResNet for CIFAR-10. We first apply AdvGAN to perform semi-whitebox attack against each model on MNIST dataset. From the performance of semi-whitebox attack (Attack Rate (w)) in Table 2, we can see that AdvGAN is able to generate adversarial instances to attack all models with high attack success rate.
+
+We also generate adversarial examples from the same original instance $x$ , targeting other different classes, as shown in Figures 2. In the semi-whitebox setting on MNIST (a)-(c), we can see that the generated adversarial examples for different models appear close to the ground truth/pristine images (lying on the diagonal of the matrix). Figure 2 (d)-(f) show the generated adversarial examples on MNIST in black-box setting. These adversarial examples generated by AdvGAN can successfully fool the black-box model and be misclassified as the target class shown on the top. The original images are shown on the diagonal. We also generate adversarial examples based on random original images, and results are shown in Appendix C.
+
+In addition, we analyze the attack success rate based on different loss functions on MNIST. Under the same bounded perturbations (0.3), if we replace the full loss function in (4) with $\mathcal { L } = | | \mathcal { G } ( \boldsymbol { x } ) | | _ { 2 } +$ $\mathcal { L } _ { \mathrm { a d v } } ^ { f }$ , which is similar to the objective used in Baluja & Fischer (2017), the attack success rate becomes $8 6 . 2 \%$ . If we replace the loss function with $\begin{array} { r } { \mathcal { L } = \mathcal { L } _ { \mathrm { h i n g e } } + \mathcal { L } _ { \mathrm { a d v } } ^ { f } } \end{array}$ , the attack success rate is $9 1 . 1 \%$ , compared to that of AdvGAN, $9 8 . 3 \%$ .
+
+Similarly, on CIFAR-10, we apply the same semi-whitebox attack for ResNet and Wide ResNet based on AdvGAN, and Figure 3(a) shows some adversarial examples, which are perceptually realistic. We show adversarial examples for the same original instance targeting different other classes. It is clear that with different targets, the adversarial examples keep similar visual quality compared to the pristine instances on the diagonal.
+
+We also apply AdvGAN to generate adversarial examples on the ImageNet as shown in Figure 4 with $L _ { \infty }$ bound as 8. The added perturbation is unnoticeable while all the adversarial instances are misclassified into other target classes with high confidence.
+
+![](images/682afc908e1ede58b1cf160920b1c8236d341ba7e9d24b4538484ada1a44cea0.jpg)  
+Figure 2: Adversarial examples generated from the same original image to different targets by AdvGAN on MNIST with semi-whitebox attack, (a), (b), and (c), and black-box attack, (c), (d), and (e). On the diagonal, the original images are shown.
+
+# 4.2 ADVGAN IN BLACK-BOX SETTING
+
+In this section, we evaluate the performance of AdvGAN for the black-box attack. Our black-box attack here is based on the dynamic distillation strategy. We construct a local model to distill model $f$ , and we select the architecture of Model C as our local model. Note that we randomly select a subset of instances disjoint from the training data of AdvGAN to train the local model; that is, we assume the adversaries do not have any prior knowledge of the training data or the model itself. With the dynamic distillation strategy, the adversarial examples generated by AdvGAN achieve an attack success rate, above $9 0 \%$ for MNIST and $8 0 \%$ for CIFAR-10, compared to $3 0 \%$ and $1 0 \%$ with the static distillation approach, as shown in Table 2.
+
+We apply AdvGAN to generate adversarial examples for the same instance targeting different classes on MNIST and randomly select some instances to show in Figure 2 (d)-(f). By comparing with the pristine instances on the diagonal, we can see that these adversarial instances can achieve high perceptual quality as the original digits. Specifically, the original digit is somewhat highlighted by adversarial perturbations, which implies a type of perceptually realistic manipulation. Figure 3 (b) shows similar results for adversarial examples generated on CIFAR-10. These adversarial instances appear photo-realistic compared with the original ones on the diagonal. We show additional results in Appendix C.
+
+# 4.3 ATTACK EFFECTIVENESS UNDER DEFENSES
+
+Facing different types of attack strategies, various defenses have been provided. Among them, different types of adversarial training methods are the most effective. Goodfellow et al. (2015) first propose adversarial training as an effective way to improve the robustness of DNNs, and Tramèr et al. (2017a) extend it to ensemble adversarial learning. M ˛adry et al. (2017a) have also proposed robust networks against adversarial examples based on well-defined adversaries. Given the fact that AdvGAN strives to generate adversarial instances from the underlying true data distribution, it can essentially produce more photo-realistic adversarial perturbations compared with other attack strategies. Thus, AdvGAN could have a higher chance to produce adversarial examples that are resilient under different defense methods. In this section, we quantitatively evaluate this property for AdvGAN compared with other attack strategies.
+
+![](images/4ed73940ec085e1c29093ce0e17afda0492ab15f317029fccb34c22d69c061ae.jpg)  
+Figure 3: Adversarial examples generated by AdvGAN on CIFAR-10 for (a) semi-whitebox attack and (b) black-box attack. Image from each class is perturbed to other different classes. On the diagonal, the original images are shown. The corresponding perturbations (amplified by $1 0 \times$ ) are shown in (c) and (d).
+
+Threat Model As shown in the literature, most of the current defense strategies are not robust when attacking against them (Carlini & Wagner, 2017b; He et al., 2017). Here we consider a weaker threat model, where the adversary is not aware of the defenses and directly tries to attack the original learning model, which is also the first threat model analyzed in Carlini & Wagner (2017b). In this case, if an adversary can still successfully attack the model, it implies the robustness of the attack strategy. Under this setting, we first apply different attack methods to generate adversarial examples based on the original model without being aware of any defense. Then we apply different defenses to directly defend against these adversarial instances.
+
+![](images/b8b9cc18178e63fab14c1b03eec87c7d7cb01efcaad9010d7e693bc9b3473c5f.jpg)  
+Figure 4: Adversarial examples (a) generated by AdvGAN on ImageNet in the semi-whitebox setting, which are classified as (from left to right) poodle, ambulance, basketball, and electric guitar. Corresponding perturbations are visualized in (b).
+
+Semi-whitebox Attack First, we consider the semi-whitebox attack setting, where the adversary has white-box access to the model architecture as well as the parameters. Here, we replace $f$ in Figure 1 with our model A, B, and C, respectively. As a result, adversarial examples will be generated against different models. We use three adversarial training defenses to train different models for each model architecture: standard FGSM adversarial training (Adv.) (Goodfellow et al., 2015), ensemble adversarial training (Ensemble) (Tramèr et al., 2017b), and iterative training (Iter. Adv.) (M ˛adry et al., 2017a).5 We evaluate the effectiveness of these attacks against these defended models. In Table 3, we show that the attack success rate of adversarial examples generated by AdvGAN on different models is higher than those of the fast gradient sign method (FGSM) and optimization methods (Opt.) (Carlini & Wagner, 2017a).
+
+Black-box Attack For AdvGAN, we use model B as the black-box model and train a distilled model to perform black-box attack against model B and report the attack success rate in Table 4. For the black-box attack comparison purpose, transferability based attack is applied for FGSM and optimization-based methods (Opt.). We use FGSM and optimization-based methods (Opt.) to attack model A on MNIST, and we use these adversarial examples to test on model B and report the corresponding classification accuracy. We can see that the adversarial examples generated by the black-box AdvGAN consistently achieve much higher attack success rate compared with other attack methods. For CIFAR-10, we use ResNet as black-box model and train a distilled model to perform black-box attack against ResNet. To evaluate black-box attack for optimization method and FGSM, we use adversarial examples generated by attacking Wide ResNet and test them on ResNet to report black-box attack results for these two methods.
+
+In addition, we apply AdvGAN to the MNIST challenge (M ˛adry et al., 2017b). Among all the methods, for white-box attack we achieve $8 8 . 9 3 \%$ accuracy on the published local model as shown in Table 5. For the reported black-box attack, we achieved the accuracy as $9 2 . 7 6 \%$ , outperforming all other state-of-the-art attack strategies.
+
+Table 3: Attack success rate of adversarial examples generated by AdvGAN in semi-whitebox setting, and other white-box attacks under defenses on MNIST and CIFAR-10.   
+
+<table><tr><td>Data</td><td>Model</td><td>Defense</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td></tr><tr><td rowspan="4">MNIST</td><td>A</td><td>Adv. Ensemble</td><td>4.3% 1.6%</td><td>4.6% 4.2%</td><td>8.0% 6.3%</td></tr><tr><td>B</td><td>Iter.Adv. Adv. Ensemble</td><td>4.4% 6.0% 2.7%</td><td>2.96% 4.5%</td><td>5.6% 7.2%</td></tr><tr><td></td><td>Iter.Adv. Adv.</td><td>9.0% 2.7%</td><td>3.18% 3.0% 2.95%</td><td>5.8% 6.6%</td></tr><tr><td>C</td><td>Ensemble Iter.Adv.</td><td>1.6% 1.6%</td><td>2.2% 1.9%</td><td>18.7% 13.5% 12.6%</td></tr><tr><td rowspan="2">CIFAR</td><td>ResNet</td><td>Adv. Ensemble. Iter.Adv</td><td>13.10% 10.00% 22.8%</td><td>11.9% 10.3% 21.4%</td><td>16.03% 14.32 % 29.47 %</td></tr><tr><td>WideResNet</td><td>Adv. Ensemble Iter.Adv.</td><td>5.04% 4.65% 14.9%</td><td>7.61% 8.43% 13.90%</td><td>14.26% 13.94 % 20.75%</td></tr></table>
+
+Table 4: Attack success rate of adversarial examples generated by different black-box adversarial strategies under defenses on MNIST and CIFAR-10   
+
+<table><tr><td></td><td colspan="3">MNIST</td><td colspan="3">CIFAR-10</td></tr><tr><td>Defense</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td></tr><tr><td>Adv.</td><td>3.1%</td><td>3.5%</td><td>11.5%</td><td>13.58%</td><td>10.8%</td><td>15.96%</td></tr><tr><td>Ensemble</td><td>2.5%</td><td>3.4%</td><td>10.3%</td><td>10.49%</td><td>9.6%</td><td>12.47 %</td></tr><tr><td>Iterative Adv.</td><td>2.4%</td><td>2.5%</td><td>12.2%</td><td>22.96%</td><td>21.70%</td><td>24.28%</td></tr></table>
+
+Table 5: Accuracy of the MadryLab public model under different attacks in white-box setting. The AdvGAN here achieved the best performance.   
+
+<table><tr><td>Method</td><td>Accuracy (xent loss)</td><td>Accuracy (cw loss)</td></tr><tr><td>FGSM</td><td>95.23%</td><td>96.29%</td></tr><tr><td>PGD</td><td>93.66%</td><td>93.79%</td></tr><tr><td>Opt</td><td>1</td><td>91.69%</td></tr><tr><td>AdvGAN</td><td>1</td><td>88.93%</td></tr></table>
+
+# 4.4 ADVERSARIAL PERTURBATION ANALYSIS.
+
+To understand the adversarial perturbation pattern better, we plot out corresponding perturbations (amplified by a factor of 10) for CIFAR-10 in Figure 3 (c) and (d) and ImageNet in Figure 4 (b). From the visualization of perturbation, it shows that the perturbations do not resemble anything in particular about the original image or the target class. Although training AdvGAN exposes it to realistic instances, the perturbations it generates do not simply interpolate towards an example of the target class.
+
+# 4.5 HIGH RESOLUTION ADVERSARIAL EXAMPLES ANALYSIS
+
+To evaluate AdvGAN’s ability to generate high resolution adversarial examples, we generate the high resolution adversarial examples for Inception_v3 and quantify their attack success rate and perceptual realism.
+
+Experiment settings. In the following experiments, we select toy poodle as our target label for all images. We select 100 benign images from the DEV set of the NIPS 2017 targeted adversarial attack competition.6 This competition provided a dataset compatible with ImageNet. We generate adversarial examples $2 9 9 \times 2 9 9$ pixels) under an $L _ { \infty }$ perturbation bound of 0.01 (pixels values are in the range $\in \ [ 0 , 1 ] )$ for the Inception_v3 model, whose input size is $2 9 9 \times 2 9 9$ . The details of architectures for generator and discriminator we used are listed in Appendix D.
+
+Table 6: Parameters of generated high resolution adversarial examples   
+
+<table><tr><td>Dateset</td><td>Model</td><td>Target Label</td><td>Resolution</td><td>Loo bound</td><td>Attack Success Rate</td></tr><tr><td>ImageNet</td><td>Inception_v3</td><td>toy poodle</td><td>299×299</td><td>0.01</td><td>100%</td></tr></table>
+
+In Figure 8 in the appendix, we show the original images on the left with the correct label, and we show adversarial examples generated by AdvGAN on the right with the target label.
+
+Human Perceptual Study. We validate the realism of AdvGAN’s adversarial examples with a user study on Amazon Mechanical Turk (AMT). We use 100 pairs of original images and adversarial examples (generated as described above) and ask workers to choose which image of a pair is more visually realistic.
+
+Our study follows a protocol from Zhang et al. (2016) and Isola et al. (2017), where a worker is shown a pair of images for 2 seconds, then the worker has unlimited time to choose. We limit each worker to at most 20 of these tasks. We collected 500 choices, about 5 per pair of images, from 50 workers on AMT.
+
+The AdvGAN examples were chosen as more realistic than the original image in $4 9 . 4 \% \pm 1 . 9 6 \%$ of the tasks (random guessing would result in about $5 0 \%$ ). This result show that these high-resolution AdvGAN adversarial examples are about as realistic as benign images.
+
+# 5 CONCLUSION
+
+In this paper, we propose AdvGAN to generate adversarial examples using generative adversarial networks (GANs). In our AdvGAN framework, once trained, the feed-forward generator can produce adversarial perturbations efficiently. It can also perform both semi-whitebox and black-box attacks with high attack success rate. In addition, when we apply AdvGAN to generate adversarial instances on different models without knowledge of the defenses in place, the generated adversarial examples can attack the state-of-the-art defenses with higher attack success rate than examples generated by the competing methods. This property makes AdvGAN a promising candidate for improving adversarial training defense methods. The generated adversarial examples produced by AdvGAN preserve high perceptual quality due to GANs’ distribution approximation property.
+
+# REFERENCES
+
+Shumeet Baluja and Ian Fischer. Adversarial transformation networks: Learning to generate adversarial examples. arXiv preprint arXiv:1703.09387, 2017.
+
+Peter L Bartlett and Marten H Wegkamp. Classification with a reject option using a hinge loss. JMLR, 9(Aug):1823–1840, 2008.
+
+David Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017, 2017a.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017b.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pp. 39–57. IEEE, 2017c.
+
+Dan Ciresan, Alessandro Giusti, Luca M Gambardella, and Jürgen Schmidhuber. Deep neural networks segment neuronal membranes in electron microscopy images. In NIPS, pp. 2843–2851, 2012.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. IEEE, 2009.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In NIPS, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. CVPR, 2017.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV, pp. 694–711. Springer, 2016.
+
+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 NIPS, pp. 1097–1105, 2012.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Yann LeCun and Corrina Cortes. The MNIST database of handwritten digits. 1998.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuo motor policies. JMLR, 17(39):1–40, 2016.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. arXiv preprint ArXiv:1611.04076, 2016.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015.
+
+Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083 [cs, stat], June 2017a.
+
+Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu, 2017b. URL https://github.com/MadryLab/mnist_challenge.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. In Proceedings of the 2017 ACM Asia Conference on Computer and Communications Security, 2017.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017a.
+
+Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European Conference on Computer Vision, pp. 649–666. Springer, 2016.
+
+Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A Efros. Generative visual manipulation on the natural image manifold. In ECCV, pp. 597–613. Springer, 2016.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. ICCV, 2017.
+
+# A ARCHITECTURE OF MODELS
+
+Table 7: Model architectures for the MNIST   
+
+<table><tr><td>A</td><td>B</td><td>C</td></tr><tr><td>Conv(64,5,5)+Relu</td><td>Conv(64,8,8)+Relu</td><td>Conv(32,3,3)+Relu</td></tr><tr><td>Conv(64,5,5)+Relu</td><td>Dropout(0.2)</td><td>Conv(32,3,3)+Relu</td></tr><tr><td>Dropout(0.25)</td><td>Conv(128,6,6)+Relu</td><td>MaxPooling(2,2)</td></tr><tr><td>FC(128)+Relu</td><td>Conv(128,5,5)+Relu</td><td>Conv(64,3,3)+Relu</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(64,3,3)+Relu</td></tr><tr><td>FC(10)+Softmax</td><td>FC(10)+Softma</td><td>MaxPooling(2,2) FC(200)+Relu</td></tr></table>
+
+# B NETWORK ARCHITECTURES
+
+Generator architecture We follow the naming rules used in Johnson et al. (2016)’s Github repository7 as well as Zhu et al. (2017) . Let $\mathrm { c } 3 \mathrm { s } 1 \mathrm { - } \mathrm { k }$ denotes $3 \times 3$ Convolution-InstanceNorm-ReLU layer with $\mathbf { k }$ filter and stride 1. Rk means residual block that contains two $3 \times 3$ convolution layers with the same numbers of filters. dk denotes the $3 \times 3$ Convolution-InstanceNorm-ReLU layer with $\mathbf { k }$ filters and stride 2. uk denotes a $3 \times 3$ fractional-strided-ConvolutionInstanceNorm-ReLU layer with $\mathbf { k }$ filters, and stride $\textstyle { \frac { 1 } { 2 } }$ . .
+
+The generator structures consists of: $\mathbf { \Delta } _ { \mathbf { C } } 3 \mathbf { s } 1 - 8$ , d16, d32, $\tt { r 3 2 }$ , $\tt { r 3 2 }$ , r32, r32, u16, u8, c3s1-3
+
+Discriminator architecture We use CNNs as our discriminator network (Radford et al., 2015). Let Ck denote a $4 \times 4$ Convolution-InstanceNorm-LeakyReLU layer with k filters and stride 2. After the last conv layer, we apply a FC layer to produce a 1 dimensional output. We do not use InstanceNorm for the first C8 layer. We use leaky ReLUs with slope 0.2.
+
+The discriminator architecture is: C8, C16, C32, FC
+
+# C ADDITIONAL ADVERSARIAL EXAMPLES
+
+![](images/3d6603f8f30a10bd160872a041fd3503c880598dbe2986db5e5b61e2ae7cd2b2.jpg)  
+Figure 5: Adversarial examples generated by AdvGAN on MNIST against different models in the semi-whitebox setting. Here the adversarial examples are randomly sampled corresponding to different original images.
+
+![](images/83cf82e9646715d4fc96e4169e9001270b630eccde2bc6b3d2b4caa276f39bd1.jpg)  
+Figure 6: Adversarial examples generated by AdvGAN on MNIST against different models in the black-box setting. Here the adversarial examples are randomly sampled corresponding to different original images.
+
+![](images/7db0ea2139df48b84ff791fe02289dfc63411c037ad9016c7dc98191287ad5fb.jpg)  
+Figure 7: Adversarial examples generated by AdvGAN on CIFAR-10. Here the adversarial examples are randomly sampled corresponding to different original images.
+
+Table 8: Comparisons of perturbations generated by AdvGAN and the state-of-the-art algorithms on MNIST and CIFAR-10. We report the mean value of perturbation amount as “mean” and attack success rate as “prob.”   
+
+<table><tr><td rowspan="3">Method</td><td colspan="6">MNIST</td><td colspan="4">CIFAR-10</td></tr><tr><td colspan="2">A</td><td colspan="2">B</td><td colspan="2">C</td><td colspan="2">ResNet-32</td><td colspan="2">Wide ResNet-34</td></tr><tr><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td></tr><tr><td>AdvGAN</td><td>0.149</td><td>98%</td><td>0.157</td><td>97%</td><td>0.144</td><td>98%</td><td>0.025</td><td>95%</td><td>0.024</td><td>99%</td></tr><tr><td>Cw</td><td>0.089</td><td>99%</td><td>0.100</td><td>99%</td><td>0.070</td><td>100%</td><td>0.023</td><td>100%</td><td>0.020</td><td>98%</td></tr><tr><td>FGSM</td><td>0.202</td><td>55%</td><td>0.193</td><td>49%</td><td>0.192</td><td>18%</td><td>0.0301</td><td>23%</td><td>0.031</td><td>26%</td></tr></table>
+
+# D HIGH RESOLUTION ADVERSARIAL EXAMPLES FOR AN IMAGENET-COMPATIBLE SET
+
+The structure of generator for ImageNet consists of:   
+c7s1-8, d16, d32, d64, d64, d64, d64, r64, r64, r64, r64, u64,   
+u64, u64, u64, u32, u16, u8, c7s1-3
+
+The architecture of discriminator for ImageNet is: C8, C16, C32, FC
+
+![](images/9730668c51e1158dadda4590219f0f491bbbd60e3cc4294952b9291bb01bcaa0.jpg)
+
+![](images/25b492d9080fb93b0b223db6e44aec1e9ecd53f13d3f9a71ba9f7fcd1998ac4f.jpg)  
+(a) Benign image (labeled as dung beetle)
+
+![](images/23d88a112b1223fecfb5fd2eb94392f68017091a4e7c9631858e8a5bd52ec39e.jpg)  
+(c) Benign image (labeled as vase)   
+(e) Benign image (labeled as bottlecap)
+
+![](images/a830a3d1f73ac0064b9f8e20b96ba7263591a779f3a70a8014b5beb10954573f.jpg)
+
+![](images/bdaa26e2e524bf217f22362e92d77f074649cbd63e9e742d6786776de01d9641.jpg)  
+(b) Adversarial image (labeled as toy poodle)
+
+![](images/df73bfbea9a160a3e15af046424cabbd90c2ef43c112f54cf76aa831759163a1.jpg)  
+(d) Adversarial image (labeled as toy poodle)   
+(f) Adversarial image (labeled as toy poodle)
+
+![](images/e4040e1bd945975b1fb1b0396236238e0307e1ee64a1c146e47a79c43a7e851c.jpg)
+
+![](images/85f72c189c85c3510417d4c0c8e68340f952613b6decc91ca3610644e34a8abb.jpg)  
+(g) Benign image (labeled as folding chair)
+
+![](images/155da9e4c49eafd0bf0d6a0e252d1064a6c2d71babb8f44c410bd725bdea2f29.jpg)  
+(i) Benign image (labeled as yurt)   
+(k) Benign image (labeled as buckeye)
+
+![](images/268f722d5667e7f6f26b6e2183dd439775b42309f58c3bcd9d7b5c48b88911ba.jpg)
+
+![](images/3e542907348d217b0bfc04a996a47ea7c12df9e0b87749d6d4bdd01a2a6a21ab.jpg)  
+(h) Adversarial image (labeled as toy poodle)
+
+![](images/e661b5da4fcf41026d84f88d729ace61ece3e5352ae16dcc1ca74695244076ac.jpg)  
+(j) Adversarial image (labeled as toy poodle)   
+(l) Adversarial image (labeled as toy poodle)
+
+![](images/88b4ed4a959209e8d4d00935dc495b3a24290fedf63e1b9723792abbc8fbb5b3.jpg)  
+Figure 8: Examples from an ImageNet-compatible set. Left: original image; right: adversaria image generated by AdvGAN against Inception_v3.

parse/train/HknbyQbC-/HknbyQbC-_content_list.json

@@ -0,0 +1,1901 @@
+[
+    {
+        "type": "text",
+        "text": "GENERATING ADVERSARIAL EXAMPLES WITH ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have been found to be vulnerable to adversarial examples resulting from adding small-magnitude perturbations to inputs. Such adversarial examples can mislead DNNs to produce adversary-selected results. Different attack strategies have been proposed to generate adversarial examples, but how to produce them with high perceptual quality and more efficiently requires more research efforts. In this paper, we propose AdvGAN to generate adversarial examples with generative adversarial networks (GANs), which can learn and approximate the distribution of original instances. For AdvGAN, once the generator is trained, it can generate adversarial perturbations efficiently for any instance, so as to potentially accelerate adversarial training as defenses. We apply AdvGAN in both semi-whitebox and black-box attack settings. In semi-whitebox attacks, there is no need to access the original target model after the generator is trained, in contrast to traditional white-box attacks. In black-box attacks, we dynamically train a distilled model for the black-box model and optimize the generator accordingly. Adversarial examples generated by AdvGAN on different target models have high attack success rate under state-of-the-art defenses compared to other attacks. Our attack has placed the first with $9 2 . 7 6 \\%$ accuracy on a public MNIST black-box attack challenge (M ˛adry et al., 2017b). ",
+        "bbox": [
+            233,
+            270,
+            764,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            334,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Neural Networks (DNNs) have achieved great successes in a variety of applications ranging from image recognition (Krizhevsky et al., 2012; He et al., 2016) to speech processing (Hinton et al., 2012) and from robotics training (Levine et al., 2016) to medical diagnostics (Ciresan et al., 2012). However, recent work has demonstrated that DNNs are vulnerable to adversarial perturbations (Szegedy et al., 2014; Goodfellow et al., 2015). An adversary can add small-magnitude perturbations to inputs and generate adversarial examples to mislead DNNs. Such maliciously perturbed instances can cause the learning system to misclassify them into either a maliciously-chosen target class (in a targeted attack) or classes that are different from the ground truth (in an untargeted attack). Different algorithms have been proposed for generating such adversarial examples, such as the fast gradient sign method (FGSM) (Goodfellow et al., 2015) and optimization-based methods (Opt.) (Carlini & Wagner, 2017a; Liu et al., 2017). ",
+        "bbox": [
+            174,
+            589,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most of the the current attack algorithms (Carlini & Wagner, 2017a; Liu et al., 2017) rely on optimization schemes with simple pixel space metrics, such as $L _ { \\infty }$ distance from a benign image, to encourage visual realism. To generate more perceptually realistic adversarial examples, in this paper, we propose to train a feed-forward network to generate perturbations such that the resulting example must be realistic according to a discriminator network. We apply generative adversarial networks (GANs) (Goodfellow et al., 2014) to produce adversarial examples in both the semi-whitebox and black-box settings. As conditional GANs are capable of producing high-quality images (Isola et al., 2017), we apply a similar paradigm to produce perceptually realistic adversarial instances. We name our method AdvGAN. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Note that in the previous white-box attacks, such as FGSM and optimization methods, the adversary needs to have white-box access to the architecture and parameters of the model all the time. However, by deploying AdvGAN, once the feed-forward network is trained, it can instantly produce adversarial perturbations for any input instances without requiring access to the model itself anymore. We name this attack setting semi-whitebox. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of our attack strategy AdvGAN, we first generate adversarial instances based on AdvGAN and other attack strategies on different target models. We then apply the stateof-the-art defenses to defend against these generated adversarial examples (Goodfellow et al., 2015; Tramèr et al., 2017a; M ˛adry et al., 2017a). We evaluate these attack strategies in both semi-whitebox and black-box settings. We show that adversarial examples generated by AdvGAN can achieve a high attack success rate, potentially due to the fact that these adversarial instances appear closer to real instances compared to other recent attack strategies. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are listed as follows. ",
+        "bbox": [
+            176,
+            243,
+            428,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Different from the previous optimization-based methods, we train a conditional adversarial network to directly produce adversarial examples, which are both perceptually realistic and achieve state-of-the-art attack success rate against different target models. • We show that AdvGAN can attack black-box models by training a distilled model. We propose to dynamically train the distilled model with query information and achieve high black-box attack success rate and targeted black-box attack, which is difficult to achieve for transferability-based black-box attacks. We use the state-of-the-art defense methods to defend against adversarial examples and show that AdvGAN achieves much higher attack success rate under current defenses. We apply AdvGAN on M ˛adry et al.’s MNIST challenge (2017a) and achieve $8 8 . 9 3 \\%$ accuracy on the published robust model in the semi-whitebox setting and $9 2 . 7 6 \\%$ in the blackbox setting, which wins the top position in the challenge (M ˛adry et al., 2017b). ",
+        "bbox": [
+            215,
+            268,
+            825,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            344,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here we review recent work on adversarial examples and generative adversarial networks. ",
+        "bbox": [
+            171,
+            498,
+            761,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Examples A number of attack strategies to generate adversarial examples have been proposed in the white-box setting, where the adversary has full access to the classifier (Szegedy et al., 2014; Goodfellow et al., 2015; Carlini & Wagner, 2017a; Moosavi-Dezfooli et al., 2015; Papernot et al., 2016; Biggio et al., 2013; Kurakin et al., 2016). Goodfellow et al. propose the fast gradient sign method (FGSM), which applies a first-order approximation of the loss function to construct adversarial samples. Formally, given an instance $x$ , an adversary generates adversarial example $x _ { A } = x + \\eta$ with $L _ { \\infty }$ constraints in the untargeted attack setting as $\\eta = \\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { x } \\ell _ { f } ( x , y ) )$ , where $\\ell _ { f } ( \\cdot )$ is the cross-entropy loss used to train the neural network $f$ , and $y$ represents the ground truth of $x$ . Optimization based methods have also been proposed to optimize adversarial perturbation for targeted attacks while satisfying certain constraints (Carlini & Wagner, 2017a; Liu et al., 2017). Its goal is to minimize the objective function as $| | \\eta | | + \\lambda \\ell _ { f } ( x _ { A } , y )$ , where $| | \\cdot | |$ is an appropriately chosen norm function. However, the optimization process is slow and can only optimize perturbation for one specific instance each time. In contrast, our feed-forward network can produce perturbation for any instance. It achieves higher attack success rate against different defenses and performs much faster than the current attack algorithms. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Independently from our work, feed-forward networks have been applied to generate adversarial perturbation (Baluja & Fischer, 2017). However, Baluja & Fischer combine the re-ranking loss and an $L _ { 2 }$ norm loss, aiming to constrain the generated adversarial instance to be close to the original one in terms of $L _ { 2 }$ ; while we apply a deep neural network as a discriminator to help distinguish the instance with other real images to encourage the perceptual quality of the generated adversarial examples. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Black-box Attacks Current learning systems usually do not allow white-box accesses against the model for security reasons. Therefore, there is a great need for black-box attacks analysis. Most of the black-box attack strategies are based on the transferability phenomenon (Papernot et al., 2017), where an adversary can train a local model first and generate adversarial examples against it, hoping the same adversarial examples will also be able to attack the other models. Many learning systems allow query accesses to the model. However, there is little work that can leverage query-based access to target models to construct adversarial samples and move beyond transferability. Papernot et al. (2017) proposed to train a local substitute model with queries to the target model to generate adversarial samples, but this strategy still relies on transferability. In contrast, we show that the proposed AdvGAN can perform black-box attacks without depending on transferability. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/962027a6b691cc62b440a07546f5c99eb4c6a04c47fbbbe54c1dfb515202872c.jpg",
+        "image_caption": [
+            "Figure 1: Overview of AdvGAN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            103,
+            794,
+            294
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            356,
+            821,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have achieved visually appealing results in both image generation (Radford et al., 2015; Gulrajani et al., 2017; Berthelot et al., 2017) and manipulation (Zhu et al., 2016) settings. Recently, image-to-image conditional GANs have further improved the quality of synthesis results (Isola et al., 2017; Zhu et al., 2017). We adopt a similar adversarial loss and image-to-image network architecture to learn the mapping from an original image to a perturbed output such that the perturbed image cannot be distinguished from real images in the original class. Different from prior work, we aim to produce output results that are not only visually realistic but also able to mislead target learning models. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 GENERATING ADVERSARIAL EXAMPLES WITH ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            821,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            370,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let ${ \\mathcal { X } } \\subseteq { \\mathcal { R } } ^ { n }$ be the feature space, with $n$ the number of features. Suppose that $( x _ { i } , y _ { i } )$ is the ith instance within the training set, which is comprised of feature vectors $x _ { i } \\in \\mathcal X$ , generated according to some unknown distribution $x _ { i } \\sim \\mathcal { P } _ { \\mathrm { d a t a } }$ , and $y _ { i } ~ \\in ~ \\mathcal { V }$ the corresponding true class labels. The learning system aims to learn a classifier $f : \\mathcal { X }  \\mathcal { Y }$ from the domain $\\mathcal { X }$ to the set of classification outputs $\\mathcal { V }$ , where $| \\mathcal { V } |$ denotes the number of possible classification outputs. Given an instance $x$ , the goal of an adversary is to generate adversarial example $x _ { A }$ , which is classified as $f ( x _ { A } ) \\neq y$ (untargeted attack), where $y$ denotes the true label; or $f ( x _ { A } ) = t$ (targeted attack) where $t$ is the target class. $x _ { A }$ should also be close to the original instance $x$ in terms of $L _ { 2 }$ or other distance metric. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADVGAN FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            382,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates the overall architecture of AdvGAN, which mainly consists of three parts: a generator $\\mathcal { G }$ , a discriminator $\\mathcal { D }$ , and the target neural network $f$ . Here the generator $\\mathcal { G }$ takes the original instance $x$ as its input and generates a perturbation $\\mathcal G ( x )$ . Then $x + \\mathcal { G } ( x )$ will be sent to the discriminator $\\mathcal { D }$ , which is used to distinguish the generated data and the original instance $x$ . The goal of $\\mathcal { D }$ is to encourage that the generated instance is indistinguishable with the data from its original class. To fulfill the goal of fooling a learning model, we first perform the white-box attack, where the target model is $f$ in this case. $f$ takes $x + \\mathcal { G } ( x )$ as its input and outputs its loss $\\mathcal { L } _ { a d v }$ , which represents the distance between the prediction and the target class $t$ (targeted attack), or the opposite of the distance between the prediction and the ground truth class (untargeted attack). ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The adversarial loss (Goodfellow et al., 2014) can be written as: 1 ",
+        "bbox": [
+            173,
+            102,
+            602,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fc1decc30b0a133039532e5cbc884c734d2b8971c60565e92eb657f1f068b18.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { G A N } } = \\mathbb { E } _ { x } \\log \\mathcal { D } ( x ) + \\mathbb { E } _ { x } \\log ( 1 - \\mathcal { D } ( x + \\mathcal { G } ( x ) ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            126,
+            668,
+            143
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, the discriminator $\\mathcal { D }$ aims to distinguish the perturbed data $x + \\mathcal { G } ( x )$ from the original data $x$ . 2 Note that the real data is sampled from the true class, so as to encourage that the generated instances are close to data from the original class. ",
+        "bbox": [
+            176,
+            151,
+            825,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The loss for fooling the target model $f$ in a targeted attack is: ",
+        "bbox": [
+            173,
+            200,
+            576,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fb52c30b683a0fbf336af6fe86dd7f00e8812b103fdcb79258364256e7e57ab.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { a d v } } ^ { f } = \\mathbb { E } _ { x } \\ell _ { f } ( x + \\mathcal { G } ( x ) , t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            223,
+            588,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where origin $t$ is the t model get cl. The nd lo $\\ell _ { f }$ denotes the loss function (e.g., cross-entropy loss) used to train t encourages the perturbed image to be misclassified as target class . $f$ $\\mathcal { L } _ { a d v } ^ { f }$ $t$ Here we can also perform the untargeted attack by maximizing the distance between the prediction and the ground truth, but we will focus on the targeted attack in the rest of the paper. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To bound the magnitude of the perturbation, which is a common practice in prior work (Carlini & Wagner, $2 0 1 7 \\mathrm { a }$ ; Liu et al., 2017; Bartlett & Wegkamp, 2008), we add a soft hinge loss on the $L _ { 2 }$ norm as ",
+        "bbox": [
+            176,
+            318,
+            825,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3edc6249ab67305cbb82f3812ac3e19f40e5c7640bbb01e0e2e3634be6385c57.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { h i n g e } } = \\mathbb { E } _ { x } \\operatorname* { m a x } ( 0 , \\| \\mathcal { G } ( x ) \\| _ { 2 } - c ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            361,
+            614,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c$ denotes a user-specified bound. This can also stabilize the GAN’s training, as shown in Isola et al. (2017). Finally, our full objective can be expressed as ",
+        "bbox": [
+            174,
+            382,
+            823,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ccfa7a4bc87012b92cc2db0f839dd59e9521efa08c80e97b2d9647dd84a2d88.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathcal { L } _ { \\mathrm { a d v } } ^ { f } + \\alpha \\mathcal { L } _ { \\mathrm { G A N } } + \\beta \\mathcal { L } _ { \\mathrm { h i n g e } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            419,
+            599,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ and $\\beta$ control the relative importance of each objective. Note that ${ \\mathcal { L } } _ { \\mathrm { G A N } }$ here is used to encourage the perturbed data to appear similar to the original data $x$ , while $\\mathcal { L } _ { \\mathrm { a d v } } ^ { f }$ is leveraged to generate adversarial examples, optimizing for the high attack success rate. We obtain our $\\mathcal { G }$ and $\\mathcal { D }$ by solving the minmax game arg $\\operatorname* { m i n } _ { \\mathcal { G } } \\operatorname* { m a x } _ { \\mathcal { D } } \\mathcal { L }$ . ",
+        "bbox": [
+            173,
+            446,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 BLACK-BOX ATTACKS WITH ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            602,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Static Distillation For black-box attack, we assume adversaries have no prior knowledge of training data or the model itself. In our experiments in Section 4, we randomly draw data that is disjoint from the training data of the black-box model to distill it, since we assume the adversaries have no prior knowledge about the training data or the model. To achieve black-box attacks, we first build a distilled network $f$ based on the output of the black-box model $b$ (Hinton et al., 2015). Once we obtain the distilled network $f$ , we carry out the same attack strategy as described in the white-box setting (see Equation (4)). Here, we minimize the following network distillation objective: ",
+        "bbox": [
+            173,
+            550,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8030dfa2afcd1a8cbc1a4ff77cd661f577b0145e5b6cb1fb7dfddb6de2030bed.jpg",
+        "text": "$$\n\\arg \\operatorname* { m i n } _ { \\boldsymbol { f } } \\mathbb { E } _ { \\boldsymbol { x } } \\mathcal { H } ( \\boldsymbol { f } ( \\boldsymbol { x } ) , \\boldsymbol { b } ( \\boldsymbol { x } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            656,
+            589,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f ( x )$ and $b ( x )$ denote the output from the distilled model and black-box model respectively for the given training image $x$ , and $\\mathcal { H }$ denotes the commonly used cross-entropy loss. By optimizing the objective over all the training images, we can obtain a model $f$ which behaves very close to the black-box model $b$ . We then carry out the attack on the distilled network. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that unlike training the discriminator $\\mathcal { D }$ , where we only use the real data from the original class to encourage that the generated instance is close to its original class, here we train the distilled model with data from all classes. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dynamic Distillation Only training the distilled model with all the pristine training data is not enough, since it is unclear how close the black-box and distilled model perform on the generated adversarial examples, which have not appeared in the training set before. Here we propose an alternative minimization approach to dynamically make queries and train the distilled model $f$ and our generator $\\mathcal { G }$ jointly. We perform the following two steps in each iteration. During iteration $i$ : ",
+        "bbox": [
+            173,
+            813,
+            825,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/7cfe05b493a85242f8766bc1698958a88dd3cadcfd6a87bd3911f18b1719ab6c.jpg",
+        "table_caption": [
+            "Table 1: Comparison with the state-of-the-art attack methods. Run time is measured for generating 1,000 adversarial instances during test time. Opt. represents the optimization based method, and Trans. denotes black-box attacks based on transferability. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FGSM</td><td>Opt.</td><td>Trans.</td><td>AdvGAN</td></tr><tr><td>Run time</td><td>0.06s</td><td>&gt;3h</td><td>1</td><td>&lt;0.01s</td></tr><tr><td>Targeted Attack</td><td>√</td><td>√</td><td>Ens.</td><td>√</td></tr><tr><td>Black-box Attack</td><td></td><td></td><td>√</td><td>&lt;</td></tr></table>",
+        "bbox": [
+            302,
+            154,
+            696,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. Update $\\mathcal { G } _ { i }$ given a fixed network $f _ { i - 1 }$ : We follow the white-box setting (see Equation 4) and train the generator and discriminator based on a previously distilled model $f _ { i - 1 }$ . We initialize the weights $\\mathcal { G } _ { i }$ as $\\mathcal { G } _ { i - 1 }$ . ",
+        "bbox": [
+            215,
+            251,
+            821,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6aab68a8ea5e398adec3b23ea4db79ae3db8b47567aa33cdb790ae9b11d2fa10.jpg",
+        "text": "$$\n\\mathcal { G } _ { i } , D _ { i } = \\arg \\operatorname* { m i n } _ { \\mathcal { G } } \\operatorname* { m a x } _ { \\mathcal { D } } \\mathcal { L } _ { \\mathrm { a d v } } ^ { f _ { i - 1 } } + \\alpha \\mathcal { L } _ { \\mathrm { G A N } } + \\beta \\mathcal { L } _ { \\mathrm { h i n g e } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            303,
+            692,
+            329
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Update $f _ { i }$ given a fixed generator $\\mathcal { G } _ { i }$ : First, we use $f _ { i - 1 }$ to initialize $f _ { i }$ . Then, given the generated adversarial examples $x + \\mathcal { G } _ { i } ( x )$ from $\\mathcal { G } _ { i }$ , the distilled model $f _ { i }$ will be updated based on the set of new query results for the generated adversarial examples against the black-box model, as well as the original training images. ",
+        "bbox": [
+            214,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5adbb8333e34ea2099d6319076528ff3f201ec963ad00be9e23011ff35153948.jpg",
+        "text": "$$\nf _ { i } = \\arg \\operatorname* { m i n } _ { f } \\mathbb { E } _ { x } \\mathcal { H } ( f ( x ) , b ( x ) ) + \\mathbb { E } _ { x } \\mathcal { H } ( f ( x + \\mathcal { G } _ { i } ( x ) ) , b ( x + \\mathcal { G } _ { i } ( x ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            416,
+            756,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we use both the original images $x$ and the newly generated adversarial examples $x + s \\mathcal { G } _ { i } ( x )$ to update $f$ . ",
+        "bbox": [
+            228,
+            446,
+            825,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the experiment section, we compare the performance of both the static and dynamic distillation approaches and observe that simultaneously updating $\\mathcal { G }$ and $f$ produces higher attack performance. See Table 2 for more details. ",
+        "bbox": [
+            176,
+            489,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            419,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first evaluate AdvGAN for both semi-whitebox and black-box settings on MNIST (LeCun & Cortes, 1998) and CIFAR-10 (Krizhevsky et al., 2014). We also perform a semi-whitebox attack on the ImageNet dataset(Deng et al., 2009). We then apply AdvGAN to generate adversarial examples on different target models and test the attack success rate for them under the state-of-theart defenses and show that our method can achieve higher attack success rates compared to other existing attack strategies. We generate all adversarial examples for different attack methods based on the under $L _ { \\infty }$ bound of 0.3 on MNIST and 8 on CIFAR-10, for a fair comparison. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In general, as shown in Table 1, AdvGAN has several advantages over other white-box and blackbox attacks. For instance, regarding computation efficiency, AdvGAN performs much faster than others even including the efficient FGSM, although AdvGAN needs extra training time to train the generator. All these strategies can perform targeted attack except transferability based attack, although the ensemble strategy can help to improve. Besides, FGSM and optimization methods can only perform white-box attack, while AdvGAN is able to attack in semi-whitebox setting. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details Our code and models will be available upon publication. We adopt a similar architecture from image-to-image translation literature (Isola et al., 2017; Zhu et al., 2017). In particular, we use the architecture of generator $\\mathcal { G }$ from Johnson et al. (2016), and our discriminator $\\mathcal { D }$ ’s architecture is similar to model C for MNIST and ResNet-32 for CIFAR-10. We apply the loss in Carlini & Wagner (2017c) as our loss $\\begin{array} { r } { \\mathcal { L } _ { a d v } ^ { f } = \\operatorname* { m a x } ( \\operatorname* { m a x } _ { i \\neq t } f ( x _ { A } ) _ { i } - f ( x _ { A } ) _ { t } , \\kappa ) } \\end{array}$ , where $t$ is the represents the target network in the semi-whitebox setting and the distilled model in the black-box setting. We set the confidence $\\kappa = 0$ for both Opt. and AdvGAN. We use Adam as our solver (Kingma & Ba, 2014), with a batch size of 128 and a learning rate of 0.001. For GANs training, we use the least squares objective proposed by LSGAN (Mao et al., 2016), as it has been shown to produce better results with more stable training. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/05aae1264e475df90a3c9ea69f276a41844806e036fe5a9bed8715fe195bd177.jpg",
+        "table_caption": [
+            "Table 2: Accuracy of different models on pristine data, and the attack success rate of adversarial examples generated against different models by AdvGAN on MNIST and CIFAR-10. p: pristine test data; w: semi-whitebox attack; b-D: black-box attack with dynamic distillation strategy; b-S: black-box attack with static distillation strategy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>MNIST A B</td><td>C</td><td>ResNet-32</td><td>CIFAR-10 Wide ResNet-34</td></tr><tr><td>Accuracy (p)</td><td>98.97% 99.17%</td><td>99.09%</td><td>92.41%</td><td>95.01%</td></tr><tr><td>Attack Success Rate (w)</td><td>97.9% 97.1%</td><td>98.3%</td><td>94.71%</td><td>99.30%</td></tr><tr><td>Attack Success Rate (b-D)</td><td>93.4% 90.1%</td><td>94.02%</td><td>78.47 %</td><td>81.81%</td></tr><tr><td>Attack Success Rate (b-S)</td><td>30.7% 66.63%</td><td>87.3%</td><td>10.3%</td><td>13.3%</td></tr></table>",
+        "bbox": [
+            210,
+            169,
+            784,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Models Used in the Experiments For MNIST, in all of our experiments, we generate adversarial examples for three models whose architectures are shown in Appendix A. Models A and B are used in Tramèr et al. (2017b), which represent different architectures. Model C is the target network architecture used in (Carlini & Wagner, 2017a) for evaluating optimization based strategy. For CIFAR-10, we select ResNet-32 and Wide ResNet-34 (He et al., 2016; Zagoruyko & Komodakis, 2016) for our experiments. Specifically, we use a 32-layer ResNet implemented in TensorFlow3 and Wide ResNet derived from the variant of “w32-10 wide.”4 We show the classification accuracy of pristine MNIST and CIFAR-10 test data (p) and attack success rate of adversarial examples generated by AdvGAN on different models in Table 2. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 ADVGAN IN SEMI-WHITEBOX SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            488,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, we apply different architectures for the target model $f$ as listed in Appendix A for MNIST and with ResNet and Wide ResNet for CIFAR-10. We first apply AdvGAN to perform semi-whitebox attack against each model on MNIST dataset. From the performance of semi-whitebox attack (Attack Rate (w)) in Table 2, we can see that AdvGAN is able to generate adversarial instances to attack all models with high attack success rate. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also generate adversarial examples from the same original instance $x$ , targeting other different classes, as shown in Figures 2. In the semi-whitebox setting on MNIST (a)-(c), we can see that the generated adversarial examples for different models appear close to the ground truth/pristine images (lying on the diagonal of the matrix). Figure 2 (d)-(f) show the generated adversarial examples on MNIST in black-box setting. These adversarial examples generated by AdvGAN can successfully fool the black-box model and be misclassified as the target class shown on the top. The original images are shown on the diagonal. We also generate adversarial examples based on random original images, and results are shown in Appendix C. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition, we analyze the attack success rate based on different loss functions on MNIST. Under the same bounded perturbations (0.3), if we replace the full loss function in (4) with $\\mathcal { L } = | | \\mathcal { G } ( \\boldsymbol { x } ) | | _ { 2 } +$ $\\mathcal { L } _ { \\mathrm { a d v } } ^ { f }$ , which is similar to the objective used in Baluja & Fischer (2017), the attack success rate becomes $8 6 . 2 \\%$ . If we replace the loss function with $\\begin{array} { r } { \\mathcal { L } = \\mathcal { L } _ { \\mathrm { h i n g e } } + \\mathcal { L } _ { \\mathrm { a d v } } ^ { f } } \\end{array}$ , the attack success rate is $9 1 . 1 \\%$ , compared to that of AdvGAN, $9 8 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            670,
+            825,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similarly, on CIFAR-10, we apply the same semi-whitebox attack for ResNet and Wide ResNet based on AdvGAN, and Figure 3(a) shows some adversarial examples, which are perceptually realistic. We show adversarial examples for the same original instance targeting different other classes. It is clear that with different targets, the adversarial examples keep similar visual quality compared to the pristine instances on the diagonal. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            823
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also apply AdvGAN to generate adversarial examples on the ImageNet as shown in Figure 4 with $L _ { \\infty }$ bound as 8. The added perturbation is unnoticeable while all the adversarial instances are misclassified into other target classes with high confidence. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/682afc908e1ede58b1cf160920b1c8236d341ba7e9d24b4538484ada1a44cea0.jpg",
+        "image_caption": [
+            "Figure 2: Adversarial examples generated from the same original image to different targets by AdvGAN on MNIST with semi-whitebox attack, (a), (b), and (c), and black-box attack, (c), (d), and (e). On the diagonal, the original images are shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            98,
+            815,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 ADVGAN IN BLACK-BOX SETTING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            575,
+            459,
+            589
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the performance of AdvGAN for the black-box attack. Our black-box attack here is based on the dynamic distillation strategy. We construct a local model to distill model $f$ , and we select the architecture of Model C as our local model. Note that we randomly select a subset of instances disjoint from the training data of AdvGAN to train the local model; that is, we assume the adversaries do not have any prior knowledge of the training data or the model itself. With the dynamic distillation strategy, the adversarial examples generated by AdvGAN achieve an attack success rate, above $9 0 \\%$ for MNIST and $8 0 \\%$ for CIFAR-10, compared to $3 0 \\%$ and $1 0 \\%$ with the static distillation approach, as shown in Table 2. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We apply AdvGAN to generate adversarial examples for the same instance targeting different classes on MNIST and randomly select some instances to show in Figure 2 (d)-(f). By comparing with the pristine instances on the diagonal, we can see that these adversarial instances can achieve high perceptual quality as the original digits. Specifically, the original digit is somewhat highlighted by adversarial perturbations, which implies a type of perceptually realistic manipulation. Figure 3 (b) shows similar results for adversarial examples generated on CIFAR-10. These adversarial instances appear photo-realistic compared with the original ones on the diagonal. We show additional results in Appendix C. ",
+        "bbox": [
+            174,
+            720,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 ATTACK EFFECTIVENESS UNDER DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            853,
+            519,
+            867
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Facing different types of attack strategies, various defenses have been provided. Among them, different types of adversarial training methods are the most effective. Goodfellow et al. (2015) first propose adversarial training as an effective way to improve the robustness of DNNs, and Tramèr et al. (2017a) extend it to ensemble adversarial learning. M ˛adry et al. (2017a) have also proposed robust networks against adversarial examples based on well-defined adversaries. Given the fact that AdvGAN strives to generate adversarial instances from the underlying true data distribution, it can essentially produce more photo-realistic adversarial perturbations compared with other attack strategies. Thus, AdvGAN could have a higher chance to produce adversarial examples that are resilient under different defense methods. In this section, we quantitatively evaluate this property for AdvGAN compared with other attack strategies. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ed73940ec085e1c29093ce0e17afda0492ab15f317029fccb34c22d69c061ae.jpg",
+        "image_caption": [
+            "Figure 3: Adversarial examples generated by AdvGAN on CIFAR-10 for (a) semi-whitebox attack and (b) black-box attack. Image from each class is perturbed to other different classes. On the diagonal, the original images are shown. The corresponding perturbations (amplified by $1 0 \\times$ ) are shown in (c) and (d). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            823,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            727,
+            825,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Threat Model As shown in the literature, most of the current defense strategies are not robust when attacking against them (Carlini & Wagner, 2017b; He et al., 2017). Here we consider a weaker threat model, where the adversary is not aware of the defenses and directly tries to attack the original learning model, which is also the first threat model analyzed in Carlini & Wagner (2017b). In this case, if an adversary can still successfully attack the model, it implies the robustness of the attack strategy. Under this setting, we first apply different attack methods to generate adversarial examples based on the original model without being aware of any defense. Then we apply different defenses to directly defend against these adversarial instances. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8b9cc18178e63fab14c1b03eec87c7d7cb01efcaad9010d7e693bc9b3473c5f.jpg",
+        "image_caption": [
+            "Figure 4: Adversarial examples (a) generated by AdvGAN on ImageNet in the semi-whitebox setting, which are classified as (from left to right) poodle, ambulance, basketball, and electric guitar. Corresponding perturbations are visualized in (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            818,
+            366
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            453,
+            823,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Semi-whitebox Attack First, we consider the semi-whitebox attack setting, where the adversary has white-box access to the model architecture as well as the parameters. Here, we replace $f$ in Figure 1 with our model A, B, and C, respectively. As a result, adversarial examples will be generated against different models. We use three adversarial training defenses to train different models for each model architecture: standard FGSM adversarial training (Adv.) (Goodfellow et al., 2015), ensemble adversarial training (Ensemble) (Tramèr et al., 2017b), and iterative training (Iter. Adv.) (M ˛adry et al., 2017a).5 We evaluate the effectiveness of these attacks against these defended models. In Table 3, we show that the attack success rate of adversarial examples generated by AdvGAN on different models is higher than those of the fast gradient sign method (FGSM) and optimization methods (Opt.) (Carlini & Wagner, 2017a). ",
+        "bbox": [
+            173,
+            502,
+            825,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Black-box Attack For AdvGAN, we use model B as the black-box model and train a distilled model to perform black-box attack against model B and report the attack success rate in Table 4. For the black-box attack comparison purpose, transferability based attack is applied for FGSM and optimization-based methods (Opt.). We use FGSM and optimization-based methods (Opt.) to attack model A on MNIST, and we use these adversarial examples to test on model B and report the corresponding classification accuracy. We can see that the adversarial examples generated by the black-box AdvGAN consistently achieve much higher attack success rate compared with other attack methods. For CIFAR-10, we use ResNet as black-box model and train a distilled model to perform black-box attack against ResNet. To evaluate black-box attack for optimization method and FGSM, we use adversarial examples generated by attacking Wide ResNet and test them on ResNet to report black-box attack results for these two methods. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition, we apply AdvGAN to the MNIST challenge (M ˛adry et al., 2017b). Among all the methods, for white-box attack we achieve $8 8 . 9 3 \\%$ accuracy on the published local model as shown in Table 5. For the reported black-box attack, we achieved the accuracy as $9 2 . 7 6 \\%$ , outperforming all other state-of-the-art attack strategies. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a81ce36ab9ad5aee695377d88ec856a94f149ca70da9a1c02575b1f5d6332422.jpg",
+        "table_caption": [
+            "Table 3: Attack success rate of adversarial examples generated by AdvGAN in semi-whitebox setting, and other white-box attacks under defenses on MNIST and CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data</td><td>Model</td><td>Defense</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td></tr><tr><td rowspan=\"4\">MNIST</td><td>A</td><td>Adv. Ensemble</td><td>4.3% 1.6%</td><td>4.6% 4.2%</td><td>8.0% 6.3%</td></tr><tr><td>B</td><td>Iter.Adv. Adv. Ensemble</td><td>4.4% 6.0% 2.7%</td><td>2.96% 4.5%</td><td>5.6% 7.2%</td></tr><tr><td></td><td>Iter.Adv. Adv.</td><td>9.0% 2.7%</td><td>3.18% 3.0% 2.95%</td><td>5.8% 6.6%</td></tr><tr><td>C</td><td>Ensemble Iter.Adv.</td><td>1.6% 1.6%</td><td>2.2% 1.9%</td><td>18.7% 13.5% 12.6%</td></tr><tr><td rowspan=\"2\">CIFAR</td><td>ResNet</td><td>Adv. Ensemble. Iter.Adv</td><td>13.10% 10.00% 22.8%</td><td>11.9% 10.3% 21.4%</td><td>16.03% 14.32 % 29.47 %</td></tr><tr><td>WideResNet</td><td>Adv. Ensemble Iter.Adv.</td><td>5.04% 4.65% 14.9%</td><td>7.61% 8.43% 13.90%</td><td>14.26% 13.94 % 20.75%</td></tr></table>",
+        "bbox": [
+            251,
+            141,
+            745,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/ffaefcf80c6828ace5b541c7e98baeb4b45a5ceb719b4e64afc962a1c57ab234.jpg",
+        "table_caption": [
+            "Table 4: Attack success rate of adversarial examples generated by different black-box adversarial strategies under defenses on MNIST and CIFAR-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">MNIST</td><td colspan=\"3\">CIFAR-10</td></tr><tr><td>Defense</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td><td>FGSM</td><td>Opt.</td><td>AdvGAN</td></tr><tr><td>Adv.</td><td>3.1%</td><td>3.5%</td><td>11.5%</td><td>13.58%</td><td>10.8%</td><td>15.96%</td></tr><tr><td>Ensemble</td><td>2.5%</td><td>3.4%</td><td>10.3%</td><td>10.49%</td><td>9.6%</td><td>12.47 %</td></tr><tr><td>Iterative Adv.</td><td>2.4%</td><td>2.5%</td><td>12.2%</td><td>22.96%</td><td>21.70%</td><td>24.28%</td></tr></table>",
+        "bbox": [
+            230,
+            433,
+            766,
+            516
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/229aeb68910cece2ba896517d5f9fbbaf42daf5efbe1716582f1873057ab13e1.jpg",
+        "table_caption": [
+            "Table 5: Accuracy of the MadryLab public model under different attacks in white-box setting. The AdvGAN here achieved the best performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Accuracy (xent loss)</td><td>Accuracy (cw loss)</td></tr><tr><td>FGSM</td><td>95.23%</td><td>96.29%</td></tr><tr><td>PGD</td><td>93.66%</td><td>93.79%</td></tr><tr><td>Opt</td><td>1</td><td>91.69%</td></tr><tr><td>AdvGAN</td><td>1</td><td>88.93%</td></tr></table>",
+        "bbox": [
+            305,
+            571,
+            691,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4 ADVERSARIAL PERTURBATION ANALYSIS. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            509,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To understand the adversarial perturbation pattern better, we plot out corresponding perturbations (amplified by a factor of 10) for CIFAR-10 in Figure 3 (c) and (d) and ImageNet in Figure 4 (b). From the visualization of perturbation, it shows that the perturbations do not resemble anything in particular about the original image or the target class. Although training AdvGAN exposes it to realistic instances, the perturbations it generates do not simply interpolate towards an example of the target class. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 HIGH RESOLUTION ADVERSARIAL EXAMPLES ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            819,
+            612,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To evaluate AdvGAN’s ability to generate high resolution adversarial examples, we generate the high resolution adversarial examples for Inception_v3 and quantify their attack success rate and perceptual realism. ",
+        "bbox": [
+            174,
+            845,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Experiment settings. In the following experiments, we select toy poodle as our target label for all images. We select 100 benign images from the DEV set of the NIPS 2017 targeted adversarial attack competition.6 This competition provided a dataset compatible with ImageNet. We generate adversarial examples $2 9 9 \\times 2 9 9$ pixels) under an $L _ { \\infty }$ perturbation bound of 0.01 (pixels values are in the range $\\in \\ [ 0 , 1 ] )$ for the Inception_v3 model, whose input size is $2 9 9 \\times 2 9 9$ . The details of architectures for generator and discriminator we used are listed in Appendix D. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/37846b8fd635c424d6c64e6d649f2c986f968d7f8480533f8d4655e8f29f21e8.jpg",
+        "table_caption": [
+            "Table 6: Parameters of generated high resolution adversarial examples "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dateset</td><td>Model</td><td>Target Label</td><td>Resolution</td><td>Loo bound</td><td>Attack Success Rate</td></tr><tr><td>ImageNet</td><td>Inception_v3</td><td>toy poodle</td><td>299×299</td><td>0.01</td><td>100%</td></tr></table>",
+        "bbox": [
+            184,
+            196,
+            813,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8 in the appendix, we show the original images on the left with the correct label, and we show adversarial examples generated by AdvGAN on the right with the target label. ",
+        "bbox": [
+            171,
+            256,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Human Perceptual Study. We validate the realism of AdvGAN’s adversarial examples with a user study on Amazon Mechanical Turk (AMT). We use 100 pairs of original images and adversarial examples (generated as described above) and ask workers to choose which image of a pair is more visually realistic. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our study follows a protocol from Zhang et al. (2016) and Isola et al. (2017), where a worker is shown a pair of images for 2 seconds, then the worker has unlimited time to choose. We limit each worker to at most 20 of these tasks. We collected 500 choices, about 5 per pair of images, from 50 workers on AMT. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The AdvGAN examples were chosen as more realistic than the original image in $4 9 . 4 \\% \\pm 1 . 9 6 \\%$ of the tasks (random guessing would result in about $5 0 \\%$ ). This result show that these high-resolution AdvGAN adversarial examples are about as realistic as benign images. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            318,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose AdvGAN to generate adversarial examples using generative adversarial networks (GANs). In our AdvGAN framework, once trained, the feed-forward generator can produce adversarial perturbations efficiently. It can also perform both semi-whitebox and black-box attacks with high attack success rate. In addition, when we apply AdvGAN to generate adversarial instances on different models without knowledge of the defenses in place, the generated adversarial examples can attack the state-of-the-art defenses with higher attack success rate than examples generated by the competing methods. This property makes AdvGAN a promising candidate for improving adversarial training defense methods. The generated adversarial examples produced by AdvGAN preserve high perceptual quality due to GANs’ distribution approximation property. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            662,
+            285,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shumeet Baluja and Ian Fischer. Adversarial transformation networks: Learning to generate adversarial examples. arXiv preprint arXiv:1703.09387, 2017. ",
+        "bbox": [
+            173,
+            685,
+            821,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter L Bartlett and Marten H Wegkamp. Classification with a reject option using a hinge loss. JMLR, 9(Aug):1823–1840, 2008. ",
+        "bbox": [
+            173,
+            720,
+            820,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017. ",
+        "bbox": [
+            173,
+            757,
+            820,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013. ",
+        "bbox": [
+            176,
+            795,
+            823,
+            852
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017, 2017a. ",
+        "bbox": [
+            178,
+            861,
+            820,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017b. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pp. 39–57. IEEE, 2017c. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dan Ciresan, Alessandro Giusti, Luca M Gambardella, and Jürgen Schmidhuber. Deep neural networks segment neuronal membranes in electron microscopy images. In NIPS, pp. 2843–2851, 2012. ",
+        "bbox": [
+            176,
+            178,
+            821,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "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 CVPR, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            171,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            318,
+            825,
+            348
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            356,
+            820,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            393,
+            821,
+            422
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017. ",
+        "bbox": [
+            173,
+            430,
+            820,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            525
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            174,
+            534,
+            821,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. CVPR, 2017. ",
+        "bbox": [
+            173,
+            570,
+            823,
+            601
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In ECCV, pp. 694–711. Springer, 2016. ",
+        "bbox": [
+            173,
+            608,
+            823,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            646,
+            823,
+            675
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, pp. 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            683,
+            823,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014. ",
+        "bbox": [
+            173,
+            720,
+            821,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            173,
+            758,
+            821,
+            787
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corrina Cortes. The MNIST database of handwritten digits. 1998. ",
+        "bbox": [
+            174,
+            796,
+            725,
+            813
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuo motor policies. JMLR, 17(39):1–40, 2016. ",
+        "bbox": [
+            173,
+            820,
+            818,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017. ",
+        "bbox": [
+            176,
+            857,
+            820,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. arXiv preprint ArXiv:1611.04076, 2016. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083 [cs, stat], June 2017a. ",
+        "bbox": [
+            176,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu, 2017b. URL https://github.com/MadryLab/mnist_challenge. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016. ",
+        "bbox": [
+            176,
+            231,
+            823,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. In Proceedings of the 2017 ACM Asia Conference on Computer and Communications Security, 2017. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            174,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014. ",
+        "bbox": [
+            174,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017a. ",
+        "bbox": [
+            174,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b. ",
+        "bbox": [
+            173,
+            460,
+            821,
+            489
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European Conference on Computer Vision, pp. 649–666. Springer, 2016. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A Efros. Generative visual manipulation on the natural image manifold. In ECCV, pp. 597–613. Springer, 2016. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. ICCV, 2017. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            641
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A ARCHITECTURE OF MODELS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            449,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f02610ba9ab6c092d475e01b96ed2d24617be86a93bc447a23f0ea1ab53805a.jpg",
+        "table_caption": [
+            "Table 7: Model architectures for the MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>A</td><td>B</td><td>C</td></tr><tr><td>Conv(64,5,5)+Relu</td><td>Conv(64,8,8)+Relu</td><td>Conv(32,3,3)+Relu</td></tr><tr><td>Conv(64,5,5)+Relu</td><td>Dropout(0.2)</td><td>Conv(32,3,3)+Relu</td></tr><tr><td>Dropout(0.25)</td><td>Conv(128,6,6)+Relu</td><td>MaxPooling(2,2)</td></tr><tr><td>FC(128)+Relu</td><td>Conv(128,5,5)+Relu</td><td>Conv(64,3,3)+Relu</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Conv(64,3,3)+Relu</td></tr><tr><td>FC(10)+Softmax</td><td>FC(10)+Softma</td><td>MaxPooling(2,2) FC(200)+Relu</td></tr></table>",
+        "bbox": [
+            302,
+            164,
+            687,
+            291
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            321,
+            444,
+            338
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Generator architecture We follow the naming rules used in Johnson et al. (2016)’s Github repository7 as well as Zhu et al. (2017) . Let $\\mathrm { c } 3 \\mathrm { s } 1 \\mathrm { - } \\mathrm { k }$ denotes $3 \\times 3$ Convolution-InstanceNorm-ReLU layer with $\\mathbf { k }$ filter and stride 1. Rk means residual block that contains two $3 \\times 3$ convolution layers with the same numbers of filters. dk denotes the $3 \\times 3$ Convolution-InstanceNorm-ReLU layer with $\\mathbf { k }$ filters and stride 2. uk denotes a $3 \\times 3$ fractional-strided-ConvolutionInstanceNorm-ReLU layer with $\\mathbf { k }$ filters, and stride $\\textstyle { \\frac { 1 } { 2 } }$ . . ",
+        "bbox": [
+            173,
+            353,
+            825,
+            439
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The generator structures consists of: $\\mathbf { \\Delta } _ { \\mathbf { C } } 3 \\mathbf { s } 1 - 8$ , d16, d32, $\\tt { r 3 2 }$ , $\\tt { r 3 2 }$ , r32, r32, u16, u8, c3s1-3 ",
+        "bbox": [
+            174,
+            445,
+            694,
+            473
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Discriminator architecture We use CNNs as our discriminator network (Radford et al., 2015). Let Ck denote a $4 \\times 4$ Convolution-InstanceNorm-LeakyReLU layer with k filters and stride 2. After the last conv layer, we apply a FC layer to produce a 1 dimensional output. We do not use InstanceNorm for the first C8 layer. We use leaky ReLUs with slope 0.2. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            536
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The discriminator architecture is: C8, C16, C32, FC ",
+        "bbox": [
+            174,
+            542,
+            392,
+            571
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            544,
+            608
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d6603f8f30a10bd160872a041fd3503c880598dbe2986db5e5b61e2ae7cd2b2.jpg",
+        "image_caption": [
+            "Figure 5: Adversarial examples generated by AdvGAN on MNIST against different models in the semi-whitebox setting. Here the adversarial examples are randomly sampled corresponding to different original images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            623,
+            815,
+            837
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/83cf82e9646715d4fc96e4169e9001270b630eccde2bc6b3d2b4caa276f39bd1.jpg",
+        "image_caption": [
+            "Figure 6: Adversarial examples generated by AdvGAN on MNIST against different models in the black-box setting. Here the adversarial examples are randomly sampled corresponding to different original images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            101,
+            815,
+            281
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7db0ea2139df48b84ff791fe02289dfc63411c037ad9016c7dc98191287ad5fb.jpg",
+        "image_caption": [
+            "Figure 7: Adversarial examples generated by AdvGAN on CIFAR-10. Here the adversarial examples are randomly sampled corresponding to different original images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            353,
+            794,
+            598
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/56a047c178b40e6d8d351d20b2d66609411ca8b02636a82d77650d130d2bffd1.jpg",
+        "table_caption": [
+            "Table 8: Comparisons of perturbations generated by AdvGAN and the state-of-the-art algorithms on MNIST and CIFAR-10. We report the mean value of perturbation amount as “mean” and attack success rate as “prob.” "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Method</td><td colspan=\"6\">MNIST</td><td colspan=\"4\">CIFAR-10</td></tr><tr><td colspan=\"2\">A</td><td colspan=\"2\">B</td><td colspan=\"2\">C</td><td colspan=\"2\">ResNet-32</td><td colspan=\"2\">Wide ResNet-34</td></tr><tr><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td><td>mean</td><td>prob</td></tr><tr><td>AdvGAN</td><td>0.149</td><td>98%</td><td>0.157</td><td>97%</td><td>0.144</td><td>98%</td><td>0.025</td><td>95%</td><td>0.024</td><td>99%</td></tr><tr><td>Cw</td><td>0.089</td><td>99%</td><td>0.100</td><td>99%</td><td>0.070</td><td>100%</td><td>0.023</td><td>100%</td><td>0.020</td><td>98%</td></tr><tr><td>FGSM</td><td>0.202</td><td>55%</td><td>0.193</td><td>49%</td><td>0.192</td><td>18%</td><td>0.0301</td><td>23%</td><td>0.031</td><td>26%</td></tr></table>",
+        "bbox": [
+            173,
+            708,
+            838,
+            805
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D HIGH RESOLUTION ADVERSARIAL EXAMPLES FOR AN IMAGENET-COMPATIBLE SET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            666,
+            864
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The structure of generator for ImageNet consists of:   \nc7s1-8, d16, d32, d64, d64, d64, d64, r64, r64, r64, r64, u64,   \nu64, u64, u64, u32, u16, u8, c7s1-3 ",
+        "bbox": [
+            174,
+            882,
+            779,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The architecture of discriminator for ImageNet is: C8, C16, C32, FC ",
+        "bbox": [
+            173,
+            103,
+            503,
+            132
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/9730668c51e1158dadda4590219f0f491bbbd60e3cc4294952b9291bb01bcaa0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            496,
+            357
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/25b492d9080fb93b0b223db6e44aec1e9ecd53f13d3f9a71ba9f7fcd1998ac4f.jpg",
+        "image_caption": [
+            "(a) Benign image (labeled as dung beetle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            380,
+            436,
+            625
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/23d88a112b1223fecfb5fd2eb94392f68017091a4e7c9631858e8a5bd52ec39e.jpg",
+        "image_caption": [
+            "(c) Benign image (labeled as vase) ",
+            "(e) Benign image (labeled as bottlecap) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            643,
+            496,
+            890
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/a830a3d1f73ac0064b9f8e20b96ba7263591a779f3a70a8014b5beb10954573f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            111,
+            818,
+            357
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/bdaa26e2e524bf217f22362e92d77f074649cbd63e9e742d6786776de01d9641.jpg",
+        "image_caption": [
+            "(b) Adversarial image (labeled as toy poodle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            380,
+            756,
+            623
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/df73bfbea9a160a3e15af046424cabbd90c2ef43c112f54cf76aa831759163a1.jpg",
+        "image_caption": [
+            "(d) Adversarial image (labeled as toy poodle) ",
+            "(f) Adversarial image (labeled as toy poodle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            645,
+            818,
+            890
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4040e1bd945975b1fb1b0396236238e0307e1ee64a1c146e47a79c43a7e851c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            112,
+            498,
+            357
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/85f72c189c85c3510417d4c0c8e68340f952613b6decc91ca3610644e34a8abb.jpg",
+        "image_caption": [
+            "(g) Benign image (labeled as folding chair) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            378,
+            498,
+            625
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/155da9e4c49eafd0bf0d6a0e252d1064a6c2d71babb8f44c410bd725bdea2f29.jpg",
+        "image_caption": [
+            "(i) Benign image (labeled as yurt) ",
+            "(k) Benign image (labeled as buckeye) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            643,
+            496,
+            890
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/268f722d5667e7f6f26b6e2183dd439775b42309f58c3bcd9d7b5c48b88911ba.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            112,
+            816,
+            357
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e542907348d217b0bfc04a996a47ea7c12df9e0b87749d6d4bdd01a2a6a21ab.jpg",
+        "image_caption": [
+            "(h) Adversarial image (labeled as toy poodle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            378,
+            818,
+            625
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/e661b5da4fcf41026d84f88d729ace61ece3e5352ae16dcc1ca74695244076ac.jpg",
+        "image_caption": [
+            "(j) Adversarial image (labeled as toy poodle) ",
+            "(l) Adversarial image (labeled as toy poodle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            645,
+            818,
+            890
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/88b4ed4a959209e8d4d00935dc495b3a24290fedf63e1b9723792abbc8fbb5b3.jpg",
+        "image_caption": [
+            "Figure 8: Examples from an ImageNet-compatible set. Left: original image; right: adversaria image generated by AdvGAN against Inception_v3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            42,
+            821,
+            916
+        ],
+        "page_idx": 18
+    }
+]