Add files using upload-large-folder tool

parse/train/4cEapqXfP30/4cEapqXfP30.md

@@ -0,0 +1,266 @@
+# Adversarial Neuron Pruning Purifies Backdoored Deep Models
+
+Dongxian $\mathbf { W _ { u } 1 * }$ Yisen Wang2,3† 1Dept. of Computer Science and Technology, Tsinghua University, China 2Key Lab. of Machine Perception, School of Artificial Intelligence, Peking Univesity, China 3Institute for Artificial Intelligence, Peking Univesity, China
+
+# Abstract
+
+As deep neural networks (DNNs) are growing larger, their requirements for computational resources become huge, which makes outsourcing training more popular. Training in a third-party platform, however, may introduce potential risks that a malicious trainer will return backdoored DNNs, which behave normally on clean samples but output targeted misclassifications whenever a trigger appears at the test time. Without any knowledge of the trigger, it is difficult to distinguish or recover benign DNNs from backdoored ones. In this paper, we first identify an unexpected sensitivity of backdoored DNNs, that is, they are much easier to collapse and tend to predict the target label on clean samples when their neurons are adversarially perturbed. Based on these observations, we propose a novel model repairing method, termed Adversarial Neuron Pruning (ANP), which prunes some sensitive neurons to purify the injected backdoor. Experiments show, even with only an extremely small amount of clean data (e.g., $1 \%$ ), ANP effectively removes the injected backdoor without causing obvious performance degradation. Our code is available at https://github.com/csdongxian/ANP_backdoor.
+
+# 1 Introduction
+
+In recent years, deep neural networks (DNNs) achieve satisfactory performance in many tasks, including computer vision [15], speech recognition [45], and gaming agents [36]. However, their success heavily relies on a large amount of computation and data, forcing researchers to outsource the training in “Machine Learning as a Service” (MLaaS) platforms or download pretrained models from the Internet, which brings potential risks of training-time attacks [17, 35, 2]. Among them, backdoor attack [14, 6, 42] is remarkably dangerous because it stealthily builds a strong relationship between a trigger pattern and a target label inside DNNs by poisoning a small proportion of the training data. As a result, the returned model always behaves normally on the clean data but is controlled to make target misclassification by presenting the trigger pattern such as a specific single-pixel [41] or a black-white checkerboard [14] at the test time.
+
+Since DNNs are deployed in many real-world and safety-critical applications, it is urgent to defend against backdoor attacks. While there are many defense methods during training [38, 41, 8, 29, 20], this work focuses on a more realistic scenario in outsourcing training that repairs models after training. In particular, the defenders try to remove the injected backdoor without access to the model training process. Without knowledge of the trigger pattern, previous methods only achieve limited robustness [7, 24, 22]. Some works try to reconstruct the trigger [43, 5, 33, 50, 44], however, the trigger pattern in brand-new attacks becomes natural [26], invisible [49], and dynamic [30], leading to the reconstruction infeasible. Different from them, in this paper, we turn to explore whether we can successfully remove the injected backdoor even without knowing the trigger pattern.
+
+Usually, the adversary perturbs inputs to cause misclassification, e.g., attaching triggers for backdoored models or adding adversarial perturbations. Parallel to this, we are also able to cause misclassification by perturbing neurons of DNNs [47]. For any neuron inside DNN, we could perturb its weight and bias by multiplying a relatively small number, to change its output. Similar to adversarial perturbations, we can optimize the neuron perturbations to increase its classification loss. Surprisingly, we find that, within the same perturbation budget, backdoored DNNs are much easier to collapse and prone to output the target label than normal DNNs even without the presence of the trigger. That is, the neurons that are sensitive to adversarial neuron perturbation are strongly related to the injected backdoor. Motivated by this, we propose a novel model repairing method, named Adversarial Neuron Pruning (ANP), which prunes most sensitive neurons under the adversarial neuron perturbation. Since the number of neurons is much smaller than weight parameters, e.g., only 4810 neurons for ResNet-18 while 11M parameters for the same model, our method can work well only based on $1 \%$ of clean data. Our main contributions are summarized as follows:
+
+• We find that through adversarially perturbing neurons, backdoored DNNs can present backdoor behaviors even without the presence of the trigger patterns and are much easier to output misclassification than normal DNNs.   
+• To defend backdoor attacks, we propose a simple yet effective model repairing method, Adversarial Neuron Pruning (ANP), which prunes the most sensitive neurons under adversarial neuron perturbations without fine-tuning.   
+• Extensive experiments demonstrate that ANP consistently provides state-of-the-art defense performance against various backdoor attacks, even using an extremely small amount of clean data.
+
+# 2 Related Work
+
+# 2.1 Backdoor Attacks
+
+The backdoor attack is a type of attacks occurring during DNN training. The adversary usually poisons a fraction of training data via attaching a predefined trigger and relabeling them as target labels (dirty-label setting) [14, 6]. All poisoned samples can be relabeled as a single target class (all-to-one), or poisoned samples from different source classes are relabeled as different target classes (all-to-all) [30]. After training, the model can be controlled to predict the target label in the presence of the trigger at the test time. Different from evasion attacks (e.g., adversarial attacks) [3, 39, 13], backdoor attacks aim to embed a input- and model-agnostic trigger into the model, which is a severe threat to the applications of deep learning [12]. Since incorrectly-labeled samples are easy to be detected, some attacks attach the trigger to samples from the target class (clean-label setting) [35, 42, 1]. Apart from simple forms like a single-pixel [41] or a black-and-white checkerboard [14], the trigger patterns can be more complex such as a sinusoidal strip [1] and a dynamic pattern [30]. These triggers in recent attacks become more natural [26] and human-imperceptible [49, 31], making them stealthy and hard to be detected by human inspection. Besides, powerful adversaries who have access to the model can optimize the trigger pattern [25], and even co-optimize the trigger pattern and the model together to enhance the power of backdoor attacks [32].
+
+# 2.2 Backdoor Defense
+
+Defense during Training. With access to training, the defender is able to detect the poisoned data or make poisoning invalid during the training process. Regarding poisoned data as outliers, we can detect and filter them out using robust statistics in the input space [38, 18, 8, 9] or the feature space [17, 41, 28, 10]. Meanwhile, other studies focus on training strategies to make the poisoned data have little or no effect on the trained model [23, 40] through randomized smoothing [34, 46], majority vote [21], differential privacy [29], and input preprocessing [27, 4].
+
+Defense after Training. For a downloaded model, we have lost control of its training. To repair the risk model, one direct way is to first reconstruct an approximation of the backdoor trigger via adversarial perturbation [43] or generative adversarial network (GAN) [5, 33, 50]. Once the trigger is reconstructed, it is feasible to prune neurons that are activated in the presence of the trigger, or fine-tune the model to unlearn the trigger [43]. As the trigger patterns in recently proposed attacks become more complicated such as the dynamics trigger [30] or natural phenomenon-based trigger [26], reconstruction becomes increasingly difficult. There are other studies on trigger-agnostic repairing via model pruning [24] or fine-tuning [7, 22] on the clean data. While they may suffer from severe accuracy degradation when only small clean data are available [7]. Unlike previous defensive pruning methods which are based on the rule-of-thumb, our proposed method is data-driven and does not require additional fine-tuning.
+
+# 3 The Proposed Method
+
+# 3.1 Preliminary
+
+Deep Neural Network and Its Neurons. In this paper, we take a fully-connected network as an example (other convolutional networks are also applicable). Its layers are numbered from 0 (input) to $L$ (output) and each layer contains $n _ { 0 } , \cdots , n _ { L }$ neurons. The network has $n = n _ { 1 } + n _ { 2 } + \cdot \cdot \cdot + n _ { L }$ parameterized neurons in total3. We denote the weight parameters of the $k$ -th neuron in $l$ -th layer as w(l)k , the bias as b $b _ { k } ^ { ( l ) }$ , and its output is
+
+$$
+h _ { k } ^ { ( l ) } = \sigma ( \mathbf { w } _ { k } ^ { ( l ) \top } \mathbf { h } ^ { ( l - 1 ) } + b _ { k } ^ { ( l ) } ) ,
+$$
+
+where $\sigma ( \cdot )$ is the nonlinear function and $\mathbf { h } ^ { ( l - 1 ) }$ is the outputs of all neurons in the previous layer, $i . e . , { \bf h } ^ { ( l - 1 ) } = [ h _ { 1 } ^ { ( l - 1 ) } , \cdot \cdot \cdot , h _ { n _ { l } } ^ { ( l - 1 ) } ]$ . For simplicity, we denote all weights of the network as $\mathbf { w } =$ $\begin{array} { r l r } { } & { } & { [ { \bf w } _ { 1 } ^ { ( 1 ) } , \cdot \cdot \cdot , { \bf w } _ { n _ { 1 } } ^ { ( 1 ) } , \cdot \cdot \cdot , { \bf w } _ { 1 } ^ { ( L ) } , \cdot \cdot \cdot , { \bf w } _ { n _ { L } } ^ { ( L ) } ] } \end{array}$ , and all biases as $\mathbf { b } = [ b _ { 1 } ^ { ( 1 ) } , \cdots , b _ { n _ { l } } ^ { ( 1 ) } , \cdots , b _ { 1 } ^ { ( L ) } , \cdots , b _ { n _ { L } } ^ { ( L ) } ]$ For a given input $\mathbf { x }$ , the network makes the prediction $f ( \mathbf { x } ; \mathbf { w } , \mathbf { b } )$ .
+
+DNN Training. We consider a $c$ -class classification problem. The parameters of weights and biases in DNN are learned on a training dataset $\mathcal { D } _ { \mathcal { T } } = \{ ( \bar { \bf x } _ { 1 } , \bar { y } _ { 1 } ) , \cdot \cdot \cdot , ( \bar { \bf x } _ { s } , \bar { y } _ { s } ) \}$ containing $s$ inputs, where each input is $\mathbf { x } _ { i } \in \mathbb { R } ^ { d } , i = 1 , \cdots , s .$ , and its ground-truth label is $y _ { i } \in \{ 1 , \cdots , c \}$ . The training procedure tries to find the optimal $( \mathbf { w } ^ { \star } , \mathbf { b } ^ { \star } )$ which minimize the training loss on the training data $\mathcal { D } _ { \mathcal { T } }$ ,
+
+$$
+\mathcal { L } _ { \mathcal { D } _ { T } } ( \mathbf { w } , \mathbf { b } ) = \underset { \mathbf { x } , y \sim \mathcal { D } _ { T } } { \mathbb { E } } \ell ( f ( \mathbf { x } ; \mathbf { w } , \mathbf { b } ) , y ) ,
+$$
+
+where $\ell ( \cdot , \cdot )$ is usually cross entropy loss.
+
+Defense Setting. We adopt a typical defense setting that an untrustworthy model is downloaded from a third party (e.g., outsourcing training) without knowledge of the training data $\mathcal { D } _ { \mathcal { T } }$ . For defense, we are assumed to have a small amount of clean data $\mathcal { D } _ { \mathcal { V } }$ . The goals of model repairing are to remove the backdoor behavior while keeping the accuracy on clean samples.
+
+# 3.2 Adversarial Neuron Perturbations
+
+In previous studies, the adversary causes misclassification by perturbing inputs before feeding them to DNNs. For example, attaching triggers to inputs to make backdoored DNN output the target label or adversarially perturbing inputs to make normal/backdoored DNN output incorrectly.
+
+Here, we try another direction to perturb DNN neurons to cause misclassification. Given the $k$ -th neuron in the $l$ -th layers, we can perturb its weight $\mathbf { w } _ { k } ^ { ( l ) }$ and bias $b _ { k } ^ { ( l ) }$ by multiplying a small number respectively. As a result, the perturbed weight is and the output of the perturbed neuron becomes $( 1 + \delta _ { k } ^ { ( l ) } ) \mathbf { w } _ { k } ^ { ( l ) }$ , the perturbed bias is $( 1 + \xi _ { k } ^ { ( l ) } ) b _ { k } ^ { ( l ) }$
+
+$$
+h _ { k } ^ { ( l ) } = \sigma \big ( ( 1 + \delta _ { k } ^ { ( l ) } ) \mathbf { w } _ { k } ^ { ( l ) \top } \mathbf { h } ^ { ( l - 1 ) } + ( 1 + \xi _ { k } ^ { ( l ) } ) b _ { k } ^ { ( l ) } \big ) ,
+$$
+
+where δ(l)k and $\xi _ { k } ^ { ( l ) }$ indicate the relative sizes of the perturbations to the weight and bias respectively. Similarly, all neurons can be perturbed like Eq. (3). We denote the relative weight perturbation size of all neurons as $\pmb { \delta } = [ \delta _ { 1 } ^ { ( 1 ) } , \cdots , \delta _ { n _ { 1 } } ^ { ( 1 ) } , \cdots , \delta _ { 1 } ^ { ( L ) } , \cdots , \delta _ { n _ { L } } ^ { ( L ) } ] ,$ , and the relative bias perturbation
+
+![](images/6ac1e440c839cc232f6a83883b01fc0b0c8fea8f16523aab7310035f8bb29735.jpg)
+
+Figure 1: The performance of neuron-perturbed models with different perturbation budgets.
+
+size as $\pmb { \xi } = [ \xi _ { 1 } ^ { ( 1 ) } , \cdots , \xi _ { n _ { 1 } } ^ { ( 1 ) } , \cdots , \xi _ { 1 } ^ { ( L ) } , \cdots , \xi _ { n _ { L } } ^ { ( L ) } ]$ for simplicity. For a clean input $\mathbf { x }$ , the output of the perturbed model is
+
+$$
+f ( \mathbf { x } ; ( 1 + \delta ) \odot \mathbf { w } , ( 1 + \pmb { \xi } ) \odot \mathbf { b } ) ,
+$$
+
+where neuron-wise multiplication $\odot$ multiplies the parameters by the perturbation sizes belonging to the same neuron as follows:
+
+$$
+( 1 + \pmb \delta ) \odot \mathbf { w } = \big [ ( 1 + \delta _ { 1 } ^ { ( 1 ) } ) \mathbf { w } _ { 1 } ^ { ( 1 ) } , \cdots , ( 1 + \delta _ { n _ { 1 } } ^ { ( 1 ) } ) \mathbf { w } _ { n _ { 1 } } ^ { ( 1 ) } , \cdots , ( 1 + \delta _ { 1 } ^ { ( L ) } ) \mathbf { w } _ { 1 } ^ { ( L ) } , \cdots , ( 1 + \delta _ { n _ { L } } ^ { ( L ) } ) \mathbf { w } _ { n _ { L } } ^ { ( L ) } \big ] ,
+$$
+
+$$
+( 1 + \pmb { \xi } ) \odot \mathbf { b } = \big [ ( 1 + \xi _ { 1 } ^ { ( 1 ) } ) b _ { 1 } ^ { ( 1 ) } , \cdots , ( 1 + \xi _ { n _ { 1 } } ^ { ( 1 ) } ) b _ { n _ { 1 } } ^ { ( 1 ) } , \cdots , ( 1 + \xi _ { 1 } ^ { ( L ) } ) b _ { 1 } ^ { ( L ) } , \cdots , ( 1 + \xi _ { n _ { L } } ^ { ( L ) } ) b _ { n _ { L } } ^ { ( L ) } \big ] .
+$$
+
+Given a trained model, similar to adversarial perturbations [39, 13], we optimize the neuron perturbations $\delta$ and $\boldsymbol { \xi }$ to increase the classification loss on the clean data:
+
+$$
+\operatorname* { m a x } _ { \delta , \xi \in [ - \epsilon , \epsilon ] ^ { n } } \mathcal { L } _ { \mathcal { D } _ { \mathcal { V } } } \big ( ( 1 + \delta ) \odot \mathbf { w } , ( 1 + \xi ) \odot \mathbf { b } \big ) ,
+$$
+
+where $\epsilon$ is the perturbation budget, which limits the maximum perturbation size.
+
+Specifically, we generate adversarial neuron perturbations for three ResNet-18 models [15] on CIFAR10 [19]: a benign model, a backdoored one with a predefined trigger (Badnets [14]), and a backdoored one with a dynamic trigger (Input-aware Backdoor Attack [30], IAB). We all set the target label in backdoor as class 0. We solve the maximization in Eq. (7) using project gradient descent (PGD) with random initialization similar to generating adversarial examples. The number of iterations is 300 and the step size is 0.001. Figure 1(a) shows adversarial neuron perturbations leads to misclassification, and the larger the perturbation budget $\epsilon$ is, the larger the error rate is. In addition, backdoored models always have larger error rates with the same perturbation budget compared to the benign one. To explore the misclassification in detail, we illustrate the proportion of different classes in predictions by three models in Figure 1(b). For benign model, adversarial neuron perturbations mislead the model to output the untargeted class (e.g., class 3). While for backdoored models, the majority of misclassified samples are predicted as the target label (e.g., class 0) whose proportion rate is much higher than the benign model. More results to support these findings can be found in Appendix B. Therefore, even without the trigger, we can still induce the backdoor behaviours via adversarial neuron perturbations. The reasons can be explained as follows: assuming the $k$ -th neuron in $l$ -th layers is backdoor-related, it is dormant on clean sample [24] (i.e., output is close to 0: $h _ { k } ^ { ( l ) } \approx 0 ,$ ). If w(l)>k hl−1 > 0 and b(l)k > 0, we can increase its output by enlarging the norm of the weights (i.e., $\delta _ { k } ^ { ( l ) } > 0 \}$ ), and further continue to increase it by adding a larger bias (i.e., $\xi _ { k } ^ { ( l ) } > 0 ) ^ { 4 }$ . With suitable perturbations, the backdoor-related neuron is activated even on clean samples. Thus, the neurons that are sensitive to adversarial neuron perturbation are strongly related to the injected backdoor.
+
+# 3.3 The Proposed Adversarial Neuron Pruning (ANP)
+
+As mentioned above, the sensitivity under adversarial neuron perturbations is strongly related to the injected backdoor. Inspired by this, we try to prune some sensitive neurons to defend backdoor attacks, named Adversarial Neuron Pruning method (ANP). We denote the pruning masks as $\mathbf { m } =$ $[ m _ { 1 } ^ { ( 1 ) } , \cdots , m _ { n _ { 1 } } ^ { ( 1 ) } , \cdots , m _ { 1 } ^ { ( L ) } , \cdots , m _ { n _ { L } } ^ { ( L ) } ] \in \bar { \{ 0 , 1 \} } ^ { n }$ . For the $k$ -th neuron in the $l$ -th layer, we set its weight w(k l ) = 0 if m( l )k = L , and keep it unchanged if $m _ { k } ^ { ( l ) } = 1$ . Similar to Ghorbani and Zou [11], we always keep the bias $b _ { k } ^ { ( l ) }$ to avoid extra harm to the accuracy on clean data5.
+
+Continuous Relaxation and Optimization. Due to the binary masks, pruning is a discrete optimization problem that is difficult to solve within feasible time. To address this, we apply continuous relaxation to let $\mathbf { m } \in [ 0 , 1 ] ^ { n }$ and optimizes them using projected gradient descent (PGD). To restore the continuous masks to discreteness after optimization, we set all mask smaller than a threshold as 0 (prune neurons with small masks), and others as 1 (keep neurons with large masks). We expect the pruned model to not only behaves well on clean data but also keep stable under adversarial neuron perturbations. Therefore, we solve the following minimization problem,
+
+$$
+\operatorname* { m i n } _ { \mathbf { m } \in \left[ 0 , 1 \right] ^ { n } } \left[ \alpha \mathcal { L } _ { { D } _ { \mathcal { V } } } ( \mathbf { m } \odot \mathbf { w } , \mathbf { b } ) + \left( 1 - \alpha \right) \operatorname* { m a x } _ { \delta , \xi \in \left[ - \epsilon , \epsilon \right] ^ { n } } \mathcal { L } _ { { D } _ { \mathcal { V } } } ( ( \mathbf { m } + \delta ) \odot \mathbf { w } , ( 1 + \pm \xi ) \odot \mathbf { b } ) \right] ,
+$$
+
+where $\alpha \in [ 0 , 1 ]$ is a trade-off coefficient. If $\alpha$ is close to 1, the minimization object focuses more on accuracy of the pruned model on clean data, while if $\alpha$ is close to 0, it focuses more on robustness against backdoor attacks.
+
+Implementation of ANP. As shown in Algorithm 1, we start from an unpruned network, that is, initializing all masks as 1 (Line 2). We randomly initialize perturbations (Line 5), and update them using one step (Line 6-7), then project them onto the feasible regime (Line 8-9). Following that, we update mask values based on the adversarial neuron perturbation (Line 10) and project mask value onto [0, 1] (Line 11). As convergence after iterations, we pruned neurons with small mask value and keep others unchanged (Line 13). Note that the proposed ANP is data-driven, different from previous pruning-based defenses which are based on the thumb-of-rule [24, 43]. Besides, ANP can work well on an extremely small amount of clean data due to the small number of masks.
+
+# Algorithm 1 Adversarial Neuron Pruning (ANP)
+
+1: Input: Network $f ( \cdot ; { \bf w } , { \bf b } )$ , hyper-parameter $\alpha$ , learning rate $\eta$ , batch size $b$ , maximum perturba   
+tion size $\epsilon$   
+2: Initialize all elements in $\mathbf { m }$ as 1   
+3: repeat   
+4: Read mini-batch $B = \{ ( \mathbf { x } _ { 1 } , y _ { 1 } ) , . . . , ( \mathbf { x } _ { b } , y _ { b } ) \}$ from training set   
+5: $\delta _ { 0 } , \xi _ { 0 } \sim U ( - \epsilon , \epsilon )$ , where $U ( - \epsilon , \epsilon )$ is the uniform distribution   
+6: $\begin{array} { r } { \pmb { \delta }  \pmb { \delta } _ { 0 } + \epsilon \mathrm { s i g n } ( \nabla _ { \delta } \mathcal { L } ( ( \mathbf { m } + \pmb { \delta } _ { 0 } ) \odot \mathbf { w } , } \end{array}$ ， $( { \bf 1 } + { \pmb \xi } _ { 0 } ) \odot { \bf b } ) )$   
+7: $\pmb { \xi }  \pmb { \xi } _ { 0 } + \epsilon \mathrm { s i g n } ( \nabla _ { \pmb { \xi } } \mathcal { L } ( ( \mathbf { m } + \pmb { \delta } _ { 0 } ) \odot \mathbf { w }$ , $\left( \mathbf { 1 } + \pmb { \xi } _ { 0 } \right) \odot \mathbf { b } ) _ { }$ )   
+8: $\delta \gets \operatorname* { m a x } ( - \epsilon , \operatorname* { m i n } ( \delta , \epsilon ) )$   
+9: $\pmb { \xi } \gets \operatorname* { m a x } ( - \epsilon , \operatorname* { m i n } ( \pmb { \xi } , \epsilon ) )$   
+10: m ← m − η∇m[αL(m  w, b) + (1 − α)L((m + δ)  w, (1 + ξ)  b)]   
+11: $\mathbf { m } \gets \mathrm { m a x } ( 0 , \mathrm { m i n } ( \mathbf { m } , 1 ) )$   
+12: until training converged   
+13: $m _ { k } ^ { ( l ) } = \mathbb { I } ( m _ { k } ^ { ( \bar { l } ) } > t h r e s h o l d )$ , for all $k , l$   
+14: Output: A robust network $f ( \cdot ; \mathbf { m } \odot \mathbf { w } , \mathbf { b } )$ against backdoor attacks
+
+Adaptation to Batch Normalization. Batch Normalization (BatchNorm) [16] always normalizes its input and controls the mean and variance of the output by a pair of trainable parameters (scale $\gamma$ and shift $\beta$ ). If BatchNorm is inserted between matrix multiplication and the nonlinear activation, the perturbations to weight and bias may cancel each other out. For example, if we perturb the weight and bias of a neuron to the maximum by multiplying $( 1 + \epsilon )$ , the normalization offsets them and nothing changes after BatchNorm. To address this problem, we perturb the scale and shift parameters instead. We also make similar changes to the pruning masks.
+
+Table 1: Performance (average over 5 random runs) of 4 defense methods against 6 backdoor attacks on $1 \%$ (500 images) of clean data on CIFAR-10 training set using ResNet-18. The AvgDrop indicates the average changes in ACC or ASR over 6 backdoor attacks compared to no defense results (Before).   
+
+<table><tr><td rowspan=1 colspan=1>Metric</td><td rowspan=1 colspan=1>Defense</td><td rowspan=1 colspan=1>Badnets  Blend IAB-one IAB-all  CLB   SIG</td><td rowspan=1 colspan=1>AvgDrop</td></tr><tr><td rowspan=5 colspan=1>ACC</td><td rowspan=5 colspan=1>BeforeFT(lr = 0.01)FT(lr = 0.02)FPMCR(t = 0.3)ANP</td><td rowspan=1 colspan=1>93.73   94.82   93.89    94.10  93.78 93.64</td><td rowspan=1 colspan=1>一</td></tr><tr><td rowspan=1 colspan=1>90.48   92.12    88.68    89.06   91.26 91.19</td><td rowspan=1 colspan=1>↓3.53</td></tr><tr><td rowspan=1 colspan=1>87.23   88.98   84.85    83.77   88.25  88.63</td><td rowspan=1 colspan=1>↓7.04</td></tr><tr><td rowspan=2 colspan=1>92.18   92.40   91.57    92.28   91.91  91.6485.95   88.26   86.30    84.53   86.87 85.8890.20   93.44   92.62    92.79   92.67 93.40</td><td rowspan=1 colspan=1>↓2.00</td></tr><tr><td rowspan=1 colspan=1>7.70↓1.47</td></tr><tr><td rowspan=5 colspan=1>ASR</td><td rowspan=5 colspan=1>BeforeFT(lr = 0.01)FT(lr = 0.02)FPMCR(t = 0.3)ANP</td><td rowspan=1 colspan=1>99.97   100.0   98.49    92.88   99.94 94.2611.70   47.17    0.99      1.36   12.51  0.40</td><td rowspan=1 colspan=1>一↓85.24</td></tr><tr><td rowspan=2 colspan=1>2.95    10.20    1.70      1.83    1.17   0.395.34    65.39    20.73     32.36   3.40   0.32</td><td rowspan=1 colspan=1>↓94.55</td></tr><tr><td rowspan=1 colspan=1>↓76.33</td></tr><tr><td rowspan=1 colspan=1>5.70    13.57   30.23    35.17   12.77  0.52</td><td rowspan=1 colspan=1>←81.26</td></tr><tr><td rowspan=1 colspan=1>0.45    0.46    0.88     0.86    3.98   0.28</td><td rowspan=1 colspan=1>↓96.44</td></tr></table>
+
+# 4 Experiments
+
+In this section, we conduct comprehensive experiments to evaluate the effectiveness of ANP, including its benchmarking robustness, ablation studies and performance under limited computation resources.
+
+# 4.1 Experimental Settings
+
+Backdoor Attacks and Settings. We consider 5 state-of-the-art backdoor attacks: 1) BadNets [14], 2) Blend backdoor attack (Blend) [6], 3) Input-aware backdoor attack with all-to-one target label (IAB-one) or all-to-all target label (IAB-all) [30], 4) Clean-label backdoor (CLB) [42], and 5) Sinusoidal signal backdoor attack (SIG) [1]. For fair comparisons, we follow the default configuration in their original papers such as the trigger patterns, the trigger sizes and the target labels. We evaluate the performance of all attacks and defenses on CIFAR-10 [19] using ResNet-18 [15] as the base model. We use $9 0 \%$ training data to train the backdoored DNNs and use the all or part of the remaining $1 0 \%$ training data for defense. More details about implementation can be found in Appendix A.
+
+Backdoor Defenses and Settings. We compare our proposed ANP with 3 existing model repairing methods: 1) standard fine-tuning (FT), 2) fine-pruning (FP) [24], and 3) mode connectivity repair (MCR) [48]. All defense methods are assumed to have access to the same $1 \%$ of clean training data (500 images). The results based on $1 0 \%$ (5000 images) and $0 . 1 \%$ (50 images) of clean training data can be found in Appendix. For ANP, we optimize all masks using Stochastic Gradient Descent (SGD) with the perturbation budget $\epsilon = 0 . 4$ and the trade-off coefficient $\alpha = 0 . 2$ . We set the batch size 128, the constant learning rate 0.2, and the momentum 0.9 for 2000 iterations in total. Typical data augmentation like random crop and horizontal flipping are applied. After optimization, neurons with mask value smaller than 0.2 are pruned.
+
+Evaluation Metrics. We evaluate the performance of different defenses using two metrics: 1) the accuracy on clean data (ACC), and 2) and the attack success rate (ASR) that is the ratio of triggered samples that are misclassified as the target label. For better comparison between different strategies for the target label (e.g., all-to-one and all-to-all), we remove the samples whose ground-truth labels already belong to the target class in the all-to-one setting before calculating ASR. Therefore, an ideal defense always has close-to-zero ASR and high ACC.
+
+# 4.2 Benchmarking the State-of-the-art Robustness
+
+To verify the effectiveness of the proposed ANP, we compare its performance with other 3 existing model repairing methods using ACC and ASR in Table 1. All experiments are repeated over 5 runs with different random seeds, and we only report the average performance without the standard deviation due to the space constraint. More detailed results including the standard deviation can be found in Appendix C.
+
+Table 2: The average training time of defense method against 6 backdoor attacks on $1 \%$ (500 images) of clean data on CIFAR-10 training set using ResNet-18.   
+
+<table><tr><td>Defense</td><td>FT</td><td>FP</td><td>MCR</td><td>ANP</td></tr><tr><td>Time (s)</td><td>93.80</td><td>1427.1</td><td>286.1</td><td>241.5</td></tr></table>
+
+The experimental results show that the proposed ANP remarkably provides almost the highest robustness against several state-of-the-art backdoor attacks. In particular, in 5 of total 6 attacks, our proposed ANP successfully reduces the ASR to lower than $1 \%$ while only has a slight drop $( \sim 1 . 4 7 \%$ on average) in ACC. Note that we only use $1 \%$ of clean data from CIFAR-10 training set, which is extremely small. We find the standard fine-tuning (FT) with a larger learning rate ${ l r = 0 . 0 2 } )$ also provides strong robustness similar to ANP. However, it has an obvious drop in ACC since a large learning rate may destroy the features learned before and the new ones learned on limited data are poor in generalization. The poor accuracy hinders its usage in practical scenarios. In contrast, ANP has similar robustness against backdoor attacks while maintains ACC at a relatively high level at the same time. Similar to our method, Fine-pruning (FP) [24] also prunes some neurons and fine-tunes the pruned model on clean data. Specifically, It only prunes neurons in the last convolutional layer using a rule-of-thumb6, and provides limited robustness against backdoor attacks. Differently, the proposed ANP is data-driven (i.e., optimizing pruning masks based on data) and prunes neurons globally (i.e., pruning neurons in all layers), leading to higher ACC and lower ASR than FP. MCR suggests mitigating backdoor by using a curve model lying on a path connection between two backdoored models in the loss landscapes. However, with limited data, it fails in providing high robustness against complex triggers (e.g. a random trigger sampled from Gaussian in blend backdoor attack or the dynamic trigger in input-aware attack). By contrast, ANP always reduces ASR significantly no matter what the trigger looks like. Note that ANP only prunes neurons and never changes any parameters of backdoored DNNs, while other methods all fine-tune parameters. Under this situation, ANP still provides the almost best robustness against these state-of-the-art attacks, which indicates that pure pruning (without fine-tuning) is still a promising defense against backdoor attacks.
+
+We also compare the training time of ANP and other baselines in Table 2, which indicates the efficiency of the proposed ANP. In particular, we apply 2000 iterations for FT, FP, and ANP, and 200 epochs (i.e., 800 iterations) for MCR following the open-sourced code7. Note that ANP is not as slow as the vanilla adversarial training (AT) since ANP only requires one extra backpropagation while PGD inside AT usually needs 10 extra backpropagations (PGD-10) in each update of model parameters. Besides, although ANP takes $2 . 5 \times$ time compared to FT, it improves accuracy (e.g., $8 8 . 9 8 \%  9 3 . 4 4 \%$ for Blend) and reduce vulnerability $( e . g . , \bar { 1 0 . 2 0 \% } \to 0 . 4 6 \%$ for Blend) significantly, making the overhead caused by ANP acceptable.
+
+# 4.3 Ablation Studies
+
+Effect of Adversarial Neuron Perturbation. Recalling Section 3.2, we apply adversarial neuron perturbations to induce the injected backdoor and then defend against backdoor attacks. Here, we evaluate the effect of the adversarial neuron perturbation in our defense strategy. In the following experiments, we defend against Badnets attack by default, unless otherwise specified. First, we optimize masks with perturbations $\alpha = 0 . 2$ and $\epsilon = 0 . 4$ , i.e., ANP) and without perturbations $\alpha = 1 . 0$ , i.e., the vanilla pruning method). Figure 2(a) shows the ACC and ASR on the test set during optimization. We find the optimization under adversarial neuron perturbations helps the backdoored model suppress ASR significantly while the vanilla one always has high ASR throughout the training process. Next, we illustrate the mask distribution after optimization. Figure 2(b) illustrates a certain fraction of masks becomes zero, which means that adversarial neuron perturbations indeed find some sensitive neurons and helps the model to remove them. In contrast, there is no mask close to 0 for the vanilla pruning method in Figure 2(c). Finally, we prune different fractions of neurons according to their mask in Figure 2(d). For both methods, ASR becomes low after pruning more than $5 \%$ of neurons8. However, ACC also starts to degrade significantly for the vanilla pruning method with more than $5 \%$ of neurons pruned. Since backdoored-related neurons are still mixed with other neurons (e.g., discriminant neurons), the vanilla pruning method prunes some discriminant neurons incorrectly. Meanwhile, ANP always keeps ACC at a relatively high level. In conclusion, the adversarial neuron perturbation is the key to distinguish the backdoor-related neurons from the other neurons, which thereby successfully obtains high ACC as well as low ASR.
+
+![](images/cdbe97c81ddf9f981dadc8bb71c5c721160bf778af2dfe13da667aa21c43f690.jpg)  
+Figure 2: Comparison between optimization with and without adversarial neuron perturbations.
+
+Table 3: Results with small budget $\epsilon = 0 . 1$ against Blend attack on 500 clean images. “Neurons↓” indicates the number of neurons pruned by ANP.   
+
+<table><tr><td>Steps</td><td>1</td><td>2</td><td>5</td><td>10</td></tr><tr><td>Time (s)</td><td>239.9</td><td>359.2</td><td>551.8</td><td>943.9</td></tr><tr><td>Neurons↓</td><td>159</td><td>188</td><td>235</td><td>259</td></tr><tr><td>ASR (%)</td><td>65.19</td><td>13.40</td><td>1.06</td><td>0.90</td></tr><tr><td>ACC (%)</td><td>93.62</td><td>93.07</td><td>92.95</td><td>92.72</td></tr></table>
+
+Table 4: Results with large budget $\epsilon = 0 . 4$ against Blend attack on 500 clean images. “Neurons↓” indicates the number of neurons pruned by ANP.   
+
+<table><tr><td>Steps</td><td>1</td><td>2</td><td>5</td><td>10</td></tr><tr><td>Time (s)</td><td>241.5</td><td>357.2</td><td>557.1</td><td>950.1</td></tr><tr><td>Neurons↓</td><td>233</td><td>239</td><td>281</td><td>296</td></tr><tr><td>ASR (%)</td><td>0.46</td><td>1.30</td><td>5.30</td><td>31.34</td></tr><tr><td>ACC (%)</td><td>93.44</td><td>94.07</td><td>93.57</td><td>94.28</td></tr></table>
+
+In addition, we explore the effects of number of iterations in crafting adversarial neuron perturbations. We conduct experiments with varying numbers of steps (1/2/5/10) in ANP with a small perturbation budget $\mathit { \check { \Psi } } _ { \epsilon } = 0 . 1 $ ) and a large perturbation budget $\mathit { \check { \Psi } } \epsilon = 0 . 4$ ) respectively. The other settings are the same as Section 4.1. The experimental results are shown in Tables 3-4. Under a small perturbation budget, with more steps for ANP, the ASR decreases with a slight drop in ACC. This is because ANP with a single step and small size is too weak to distinguish benign neurons and backdoor-related neurons, while more steps can help ANP find more backdoor-related neurons. However, under a large perturbation budget, ANP with more steps has worse robustness. This is because, with a large perturbation budget, more neurons become sensitive. As a result, ANP with more steps finds too many “suspicious” neurons, and it is unable to identify backdoor-related neurons from them. In conclusion, we can strengthen the power of ANP to find backdoor-related neurons using a larger perturbation budget or more steps. Among them, single-step ANP with a slightly larger budget is more practical due to its time efficiency, and we adopt this by default.
+
+Results with Varying Hyperparameters. As mentioned in Section 3.3, the hyper-parameter $\alpha$ in ANP controls the trade-off between the accuracy on clean data and the robustness against backdoor attacks. To test the performance with different $\alpha$ , we optimize masks for a Badnets ResNet-18 based on $1 \%$ of clean data using different $\alpha \in [ 0 , 1 ]$ with a fixed budget $\epsilon = 0 . 4$ . In pruning, we always prune neurons by the threshold 0.2. As shown in the left plot of Figure 4, ANP is able to achieve a high robustness $\mathrm { \Delta A S R } < 4 \%$ ) when $\alpha \leq 0 . 6$ . Meanwhile, ANP maintains a high natural accuracy $( \mathrm { A C C } \geq 9 0 \% )$ as long as $\alpha \ge 0 . 1$ . As a result, ANP behaves well with high ACC and low ASR in a range of $\alpha \in [ 0 . 1 , 0 . 6 ]$ .
+
+Similarly, we also test the performance with different perturbation budgets $\epsilon$ . The experiment settings are almost the same except a fixed trade-off coefficient $\alpha = 0 . 2$ and varying budgets $\epsilon \in [ 0 , 1 ]$ . For example, we can provide obvious robustness (ASR becomes $7 . 4 5 \%$ ) with a small perturbation budget $\epsilon = 0 . 2$ ) as shown in the right plot of Figure 4. However, we find the accuracy on clean data degrades with a large perturbation budget. This is because too large perturbation budget brings much difficulty to converge well and ANP only finds a poor solution, which fails in identifying these discriminant and robust neurons and prunes part of them. As a result, ACC decreases significantly. In conclusion, the proposed ANP is stable in a large range of the trade-off coefficient $\alpha \in [ 0 . 1 , 0 . 6 ]$ and the perturbation budget $\epsilon \in [ 0 . 2 , 0 . 7 ]$ , demonstrating that ANP is not sensitive to hyper-parameters.
+
+![](images/8bf3858ee9e476f3adbe69766b659fe02bcb8becb61c2541e03275132706fc2f.jpg)  
+Figure 3: Performance $\pm$ std over 5 random runs) of pruned models using different architectures by different pruning fractions or different thresholds.
+
+From the discussion above, we find that the hyperparameters are insensitive as shown in Figure 4 and ANP performs well across a wide range of hyperparameters, e.g., trade-off coefficient $\alpha \in [ 0 . 1 , 0 . 6 ]$ against Badnets attack. In addition, with varying hyperparameters, the performance trends are very consistent across different backdoor attacks as shown in Figure $\mathrm { X }$ in Appendix C.1. As a result, even though the attack (e.g., Blend) is unknown, the defender could tune $\alpha$ against a known attack (e.g., Badnets) and find the 0.2 is a good choice. ANP with $\alpha = 0 . 2$ also achieves satisfactory performance against Blend attack. In conclusion, the selection of hyperparameters in ANP is not difficult.
+
+Pruning by Fraction or by Threshold. Different from previous pruning methods that use a fixed pruning fraction, the proposed ANP prunes neurons by a threshold when generalized across different model architectures. To verify this, we train different Badnets models using ResNet-18 [15], ResNet50 [15], and VGG-19 [37] with the same settings as Section 4.1. We also train a model with Badnets MobileNet-V2 with 300 epochs . We optimize the pruning masks for these models with $\epsilon = 0 . 4 , \alpha = 0 . 2$ for ResNet-18, ResNet-50, and VGG-19. For MobileNet-V2, we found the perturbation budget $\epsilon = 0 . 4$ is too large, leading to a failure in convergence. So we apply a smaller budget $\epsilon = 0 . 2$ and the same trade-off coefficient $\alpha = 0 . 2$ . We show the ACC and ASR after pruning by varying pruning fractions in Figure 3(a) and 3(b), which indicates that the suitable fraction varies across model architectures. For example, ResNet-18 only has low ASR after pruning $5 \%$ of neurons, while MobileNet-V2 has a large accuracy drop on clean samples with more than $5 \%$ neurons pruned. Figure 3(c) and Figure 3(d) show ACC and ASR after pruning by different thresholds respectively. When pruning by the threshold, we find there is a large overlap in [0.2, 0.5] (the gray zone) in which all models have high ACC and low ASR simultaneously. That is why we adopt the strategy of pruning by the threshold in ANP. Note that, even for low-capacity models as MobileNet-V2, it is still possible to remove the injected backdoor by neuron pruning (without the fine-tuning).
+
+Pruning on Different Components. We also compare the performance when applying ANP to different components inside DNNs. We prune a backdoored 4-layer CNN (2 conv layers $^ { + 1 }$ fullyconnected layer $^ +$ output layer) on MNIST, and find it more efficient to prune neurons in some layers. In particular, we achieve $0 . 4 3 \%$ of ASR $( 9 9 . 0 4 \%$ of ACC) when two neurons in the 2nd layer are pruned, while we only achieve $4 . 4 2 \%$ of ASR $( 9 2 . 4 8 \%$ of ACC) even after pruning 150 neurons in the fully-connected layer. The experimental settings and more results can be found in Appendix C.2. This indicates that the structure of components matter in pruning-based defense. We leave this in our future work.
+
+# 4.4 Performance under Limited Computation Resource
+
+In practical scenarios, the defender usually has limited clean data and computation resources, bringing more difficulty to repair backdoored models. While Section 4.2 has discussed the effectiveness of the proposed ANP on the extremely small amount of data, this part focuses on the performance with limited computation resources in defense.
+
+In particular, we optimize all masks for a Badnets ResNet-18 with varying number of iterations (20, 100, 400, and 2000) on $1 \%$ of clean data (500 images) and prune the model from neurons with the small mask to neurons with the large mask. Figure 5 shows the ACC and ASR with varying pruning fractions based on different numbers of iterations. We find that some backdoor-related neurons have already been distinguished just after 20 iterations. For example, after removing $4 \%$ of neurons with the smallest masks, the pruned model has $6 . 2 8 \%$ of ASR and $8 6 . 6 5 \%$ of ACC. As the pruning fraction increases, ASR falls significantly first and raises again after $1 0 \%$ of neurons are pruned. This is because ANP has not yet separated them completely due to extremely limited computation (only 20 iterations). With more than 100 iterations, this phenomenon disappears. And ANP based on 100 iterations already has comparable performance to ANP on 2000 iterations, especially when we have not pruned too many neurons $( < 8 \%$ ).
+
+![](images/93472c8a66980e364dd261efb96c5ac684e0055908acf754d698dfc147542165.jpg)  
+Figure 4: Performance ( $\pm$ std over 5 random runs) of the pruned model by a threshold 0.2 with different hyper-parameters (Left: trade-off coefficient $\alpha$ ; Right: perturbation budget $\dot { \epsilon }$ ).
+
+![](images/b26378fa2b0246eadadac2f1c4a88e337567f18989a4f533b8eb7e774663c072.jpg)  
+Figure 5: Performance ( $\pm$ std over 5 random runs) of the proposed ANP with varying pruning fractions based on different numbers of iterations.
+
+We also find that ANP with 2000 iterations should prune more $( + 1 \% )$ neurons to degrade ASR than ones with fewer iterations. We conjecture this is because there also exist some sensitive neurons that are unrelated to the injected backdoor9, which are assigned with small masks at the late optimization stage. Besides, for ACC, we can see that more iterations maintain a higher ACC than fewer iterations, especially when more neurons are pruned, as the left neurons are almost the discriminant and robust ones. In conclusion, even with extremely small number of iterations (e.g., 20 iterations), ANP is able to distinguish the backdoor-related neurons from other neurons and obtains satisfactory robustness against backdoor attacks.
+
+# 5 Conclusion
+
+In this paper, we identified a sensitivity of backdoored DNNs to adversarial neuron perturbations, which induces them to present backdoor behaviours even without the presence of the trigger patterns. Based on these findings, we proposed Adversarial Neuron Pruning (ANP) to prune the sensitive neurons under adversarial neuron perturbations. Comprehensive experiments show that ANP consistently removes the injected backdoor and provides the highest robustness against several state-of-the-art backdoor attacks even with a limited amount of clean data and computation resources. Finally, our work also reminds researchers that pruning (without fine-tuning) is still a promising defense against backdoor attacks.
+
+# Broader Impact
+
+The backdoor attack has become a threat to outsourcing training and open-sourcing models. We propose ANP to improve the robustness against these backdoor attacks, which may help to build a more secure model even trained in an untrustworthy third-party platform. Further, we do not want this paper to bring overoptimism about AI safety to the society. Since the backdoor attack is only a part of potential risks ( e.g., adversarial attacks, privacy leakage, and model extraction), there is still a long way towards secure AI and trustworthy AI.
+
+# Acknowledgments
+
+Yisen Wang is partially supported by the National Natural Science Foundation of China under Grant 62006153, and Project 2020BD006 supported by PKU-Baidu Fund.
+
+# References
+
+[1] Mauro Barni, Kassem Kallas, and Benedetta Tondi. A new backdoor attack in cnns by training set corruption without label poisoning. In ICIP, 2019.   
+[2] Battista Biggio, Blaine Nelson, and Pavel Laskov. Support vector machines under adversarial label noise. In ACML, 2011.   
+[3] Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, ´ Giorgio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In ECML/PKDD, 2013.   
+[4] Eitan Borgnia, Valeriia Cherepanova, Liam Fowl, Amin Ghiasi, Jonas Geiping, Micah Goldblum, Tom Goldstein, and Arjun Gupta. Strong data augmentation sanitizes poisoning and backdoor attacks without an accuracy tradeoff. In ICASSP, 2021.   
+[5] Huili Chen, Cheng Fu, Jishen Zhao, and Farinaz Koushanfar. Deepinspect: A black-box trojan detection and mitigation framework for deep neural networks. In IJCAI, 2019.   
+[6] Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017.   
+[7] Xinyun Chen, Wenxiao Wang, Chris Bender, Yiming Ding, Ruoxi Jia, Bo Li, and Dawn Song. Refit: a unified watermark removal framework for deep learning systems with limited data. arXiv preprint arXiv:1911.07205, 2019.   
+[8] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Jacob Steinhardt, and Alistair Stewart. Sever: A robust meta-algorithm for stochastic optimization. In ICML, 2019.   
+[9] Chao Gao, Yuan Yao, and Weizhi Zhu. Generative adversarial nets for robust scatter estimation: A proper scoring rule perspective. Journal of Machine Learning Research, 21(160):1–48, 2020.   
+[10] Yansong Gao, Change Xu, Derui Wang, Shiping Chen, Damith C Ranasinghe, and Surya Nepal. Strip: A defence against trojan attacks on deep neural networks. In ACSAC, 2019.   
+[11] Amirata Ghorbani and James Zou. Neuron shapley: Discovering the responsible neurons. In NeurIPS, 2021.   
+[12] Micah Goldblum, Dimitris Tsipras, Chulin Xie, Xinyun Chen, Avi Schwarzschild, Dawn Song, Aleksander Madry, Bo Li, and Tom Goldstein. Data security for machine learning: Data poisoning, backdoor attacks, and defenses. arXiv preprint arXiv:2012.10544, 2020.   
+[13] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.   
+[14] Tianyu Gu, Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Badnets: Evaluating backdooring attacks on deep neural networks. IEEE Access, 7:47230–47244, 2019.   
+[15] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[16] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   
+[17] Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In ICML, 2017.   
+[18] Pang Wei Koh, Jacob Steinhardt, and Percy Liang. Stronger data poisoning attacks break data sanitization defenses. arXiv preprint arXiv:1811.00741, 2018.   
+[19] Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical Report, University of Toronto, 2009.   
+[20] Alexander Levine and Soheil Feizi. Deep partition aggregation: Provable defense against general poisoning attacks. arXiv preprint arXiv:2006.14768, 2020.   
+[21] Alexander Levine and Soheil Feizi. Deep partition aggregation: Provable defense against general poisoning attacks. In ICLR, 2021.   
+[22] Yige Li, Nodens Koren, Lingjuan Lyu, Xixiang Lyu, Bo Li, and Xingjun Ma. Neural attention distillation: Erasing backdoor triggers from deep neural networks. In ICLR, 2021.   
+[23] Yige Li, Xixiang Lyu, Nodens Koren, Lingjuan Lyu, Bo Li, and Xingjun Ma. Anti-backdoor learning: Training clean models on poisoned data. In NeurIPS, 2021.   
+[24] Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Fine-pruning: Defending against backdooring attacks on deep neural networks. In RAID, 2018.   
+[25] Yingqi Liu, Shiqing Ma, Yousra Aafer, Wen-Chuan Lee, Juan Zhai, Weihang Wang, and Xiangyu Zhang. Trojaning attack on neural networks. In NDSS, 2018.   
+[26] Yunfei Liu, Xingjun Ma, James Bailey, and Feng Lu. Reflection backdoor: A natural backdoor attack on deep neural networks. In ECCV, 2020.   
+[27] Yuntao Liu, Yang Xie, and Ankur Srivastava. Neural trojans. In ICCD, 2017.   
+[28] Shiqing Ma and Yingqi Liu. Nic: Detecting adversarial samples with neural network invariant checking. In NDSS, 2019.   
+[29] Yuzhe Ma, Xiaojin Zhu Zhu, and Justin Hsu. Data poisoning against differentially-private learners: Attacks and defenses. In IJCAI, 2019.   
+[30] Anh Nguyen and Anh Tran. Input-aware dynamic backdoor attack. In NeurIPS, 2020.   
+[31] Anh Nguyen and Anh Tran. Wanet–imperceptible warping-based backdoor attack. In ICLR, 2021.   
+[32] Ren Pang, Hua Shen, Xinyang Zhang, Shouling Ji, Yevgeniy Vorobeychik, Xiapu Luo, Alex Liu, and Ting Wang. A tale of evil twins: Adversarial inputs versus poisoned models. In CCS, 2020.   
+[33] Ximing Qiao, Yukun Yang, and Hai Li. Defending neural backdoors via generative distribution modeling. In NeurIPS, 2019.   
+[34] Elan Rosenfeld, Ezra Winston, Pradeep Ravikumar, and Zico Kolter. Certified robustness to label-flipping attacks via randomized smoothing. In ICML, 2020.   
+[35] Ali Shafahi, W Ronny Huang, Mahyar Najibi, Octavian Suciu, Christoph Studer, Tudor Dumitras, and Tom Goldstein. Poison frogs! targeted clean-label poisoning attacks on neural networks. In NeurIPS, 2018.   
+[36] David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.   
+[37] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[38] Jacob Steinhardt, Pang Wei Koh, and Percy Liang. Certified defenses for data poisoning attacks. In NeurIPS, 2017.   
+[39] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.   
+[40] Lue Tao, Lei Feng, Jinfeng Yi, Sheng-Jun Huang, and Songcan Chen. Better safe than sorry: Preventing delusive adversaries with adversarial training. In NeurIPS, 2021.   
+[41] Brandon Tran, Jerry Li, and Aleksander Madry. Spectral signatures in backdoor attacks. In NeurIPS, 2018.   
+[42] Alexander Turner, Dimitris Tsipras, and Aleksander Madry. Label-consistent backdoor attacks. arXiv preprint arXiv:1912.02771, 2019.   
+[43] Bolun Wang, Yuanshun Yao, Shawn Shan, Huiying Li, Bimal Viswanath, Haitao Zheng, and Ben Y Zhao. Neural cleanse: Identifying and mitigating backdoor attacks in neural networks. In S&P, 2019.   
+[44] Ren Wang, Gaoyuan Zhang, Sijia Liu, Pin-Yu Chen, Jinjun Xiong, and Meng Wang. Practical detection of trojan neural networks: Data-limited and data-free cases. In ECCV, 2020.   
+[45] Yisen Wang, Xuejiao Deng, Songbai Pu, and Zhiheng Huang. Residual convolutional ctc networks for automatic speech recognition. arXiv preprint arXiv:1702.07793, 2017.   
+[46] Maurice Weber, Xiaojun Xu, Bojan Karlas, Ce Zhang, and Bo Li. Rab: Provable robustness against backdoor attacks. arXiv preprint arXiv:2003.08904, 2020.   
+[47] Dongxian Wu, Shu-Tao Xia, and Yisen Wang. Adversarial weight perturbation helps robust generalization. In NeurIPS, 2020.   
+[48] Pu Zhao, Pin-Yu Chen, Payel Das, Karthikeyan Natesan Ramamurthy, and Xue Lin. Bridging mode connectivity in loss landscapes and adversarial robustness. In ICLR, 2019.   
+[49] Haoti Zhong, Cong Liao, Anna Cinzia Squicciarini, Sencun Zhu, and David Miller. Backdoor embedding in convolutional neural network models via invisible perturbation. In CODASPY, 2020.   
+[50] Liuwan Zhu, Rui Ning, Cong Wang, Chunsheng Xin, and Hongyi Wu. Gangsweep: Sweep out neural backdoors by gan. In MM, 2020.

parse/train/4cEapqXfP30/4cEapqXfP30_content_list.json

@@ -0,0 +1,1121 @@
+[
+    {
+        "type": "text",
+        "text": "Adversarial Neuron Pruning Purifies Backdoored Deep Models ",
+        "text_level": 1,
+        "bbox": [
+            274,
+            122,
+            722,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dongxian $\\mathbf { W _ { u } 1 * }$ Yisen Wang2,3† 1Dept. of Computer Science and Technology, Tsinghua University, China 2Key Lab. of Machine Perception, School of Artificial Intelligence, Peking Univesity, China 3Institute for Artificial Intelligence, Peking Univesity, China ",
+        "bbox": [
+            196,
+            224,
+            802,
+            285
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            319,
+            535,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As deep neural networks (DNNs) are growing larger, their requirements for computational resources become huge, which makes outsourcing training more popular. Training in a third-party platform, however, may introduce potential risks that a malicious trainer will return backdoored DNNs, which behave normally on clean samples but output targeted misclassifications whenever a trigger appears at the test time. Without any knowledge of the trigger, it is difficult to distinguish or recover benign DNNs from backdoored ones. In this paper, we first identify an unexpected sensitivity of backdoored DNNs, that is, they are much easier to collapse and tend to predict the target label on clean samples when their neurons are adversarially perturbed. Based on these observations, we propose a novel model repairing method, termed Adversarial Neuron Pruning (ANP), which prunes some sensitive neurons to purify the injected backdoor. Experiments show, even with only an extremely small amount of clean data (e.g., $1 \\%$ ), ANP effectively removes the injected backdoor without causing obvious performance degradation. Our code is available at https://github.com/csdongxian/ANP_backdoor. ",
+        "bbox": [
+            233,
+            353,
+            766,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            310,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, deep neural networks (DNNs) achieve satisfactory performance in many tasks, including computer vision [15], speech recognition [45], and gaming agents [36]. However, their success heavily relies on a large amount of computation and data, forcing researchers to outsource the training in “Machine Learning as a Service” (MLaaS) platforms or download pretrained models from the Internet, which brings potential risks of training-time attacks [17, 35, 2]. Among them, backdoor attack [14, 6, 42] is remarkably dangerous because it stealthily builds a strong relationship between a trigger pattern and a target label inside DNNs by poisoning a small proportion of the training data. As a result, the returned model always behaves normally on the clean data but is controlled to make target misclassification by presenting the trigger pattern such as a specific single-pixel [41] or a black-white checkerboard [14] at the test time. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since DNNs are deployed in many real-world and safety-critical applications, it is urgent to defend against backdoor attacks. While there are many defense methods during training [38, 41, 8, 29, 20], this work focuses on a more realistic scenario in outsourcing training that repairs models after training. In particular, the defenders try to remove the injected backdoor without access to the model training process. Without knowledge of the trigger pattern, previous methods only achieve limited robustness [7, 24, 22]. Some works try to reconstruct the trigger [43, 5, 33, 50, 44], however, the trigger pattern in brand-new attacks becomes natural [26], invisible [49], and dynamic [30], leading to the reconstruction infeasible. Different from them, in this paper, we turn to explore whether we can successfully remove the injected backdoor even without knowing the trigger pattern. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            848
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Usually, the adversary perturbs inputs to cause misclassification, e.g., attaching triggers for backdoored models or adding adversarial perturbations. Parallel to this, we are also able to cause misclassification by perturbing neurons of DNNs [47]. For any neuron inside DNN, we could perturb its weight and bias by multiplying a relatively small number, to change its output. Similar to adversarial perturbations, we can optimize the neuron perturbations to increase its classification loss. Surprisingly, we find that, within the same perturbation budget, backdoored DNNs are much easier to collapse and prone to output the target label than normal DNNs even without the presence of the trigger. That is, the neurons that are sensitive to adversarial neuron perturbation are strongly related to the injected backdoor. Motivated by this, we propose a novel model repairing method, named Adversarial Neuron Pruning (ANP), which prunes most sensitive neurons under the adversarial neuron perturbation. Since the number of neurons is much smaller than weight parameters, e.g., only 4810 neurons for ResNet-18 while 11M parameters for the same model, our method can work well only based on $1 \\%$ of clean data. Our main contributions are summarized as follows: ",
+        "bbox": [
+            173,
+            140,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We find that through adversarially perturbing neurons, backdoored DNNs can present backdoor behaviors even without the presence of the trigger patterns and are much easier to output misclassification than normal DNNs.   \n• To defend backdoor attacks, we propose a simple yet effective model repairing method, Adversarial Neuron Pruning (ANP), which prunes the most sensitive neurons under adversarial neuron perturbations without fine-tuning.   \n• Extensive experiments demonstrate that ANP consistently provides state-of-the-art defense performance against various backdoor attacks, even using an extremely small amount of clean data. ",
+        "bbox": [
+            217,
+            330,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            321,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Backdoor Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            338,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The backdoor attack is a type of attacks occurring during DNN training. The adversary usually poisons a fraction of training data via attaching a predefined trigger and relabeling them as target labels (dirty-label setting) [14, 6]. All poisoned samples can be relabeled as a single target class (all-to-one), or poisoned samples from different source classes are relabeled as different target classes (all-to-all) [30]. After training, the model can be controlled to predict the target label in the presence of the trigger at the test time. Different from evasion attacks (e.g., adversarial attacks) [3, 39, 13], backdoor attacks aim to embed a input- and model-agnostic trigger into the model, which is a severe threat to the applications of deep learning [12]. Since incorrectly-labeled samples are easy to be detected, some attacks attach the trigger to samples from the target class (clean-label setting) [35, 42, 1]. Apart from simple forms like a single-pixel [41] or a black-and-white checkerboard [14], the trigger patterns can be more complex such as a sinusoidal strip [1] and a dynamic pattern [30]. These triggers in recent attacks become more natural [26] and human-imperceptible [49, 31], making them stealthy and hard to be detected by human inspection. Besides, powerful adversaries who have access to the model can optimize the trigger pattern [25], and even co-optimize the trigger pattern and the model together to enhance the power of backdoor attacks [32]. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Backdoor Defense ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            339,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Defense during Training. With access to training, the defender is able to detect the poisoned data or make poisoning invalid during the training process. Regarding poisoned data as outliers, we can detect and filter them out using robust statistics in the input space [38, 18, 8, 9] or the feature space [17, 41, 28, 10]. Meanwhile, other studies focus on training strategies to make the poisoned data have little or no effect on the trained model [23, 40] through randomized smoothing [34, 46], majority vote [21], differential privacy [29], and input preprocessing [27, 4]. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Defense after Training. For a downloaded model, we have lost control of its training. To repair the risk model, one direct way is to first reconstruct an approximation of the backdoor trigger via adversarial perturbation [43] or generative adversarial network (GAN) [5, 33, 50]. Once the trigger is reconstructed, it is feasible to prune neurons that are activated in the presence of the trigger, or fine-tune the model to unlearn the trigger [43]. As the trigger patterns in recently proposed attacks become more complicated such as the dynamics trigger [30] or natural phenomenon-based trigger [26], reconstruction becomes increasingly difficult. There are other studies on trigger-agnostic repairing via model pruning [24] or fine-tuning [7, 22] on the clean data. While they may suffer from severe accuracy degradation when only small clean data are available [7]. Unlike previous defensive pruning methods which are based on the rule-of-thumb, our proposed method is data-driven and does not require additional fine-tuning. ",
+        "bbox": [
+            173,
+            883,
+            820,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 The Proposed Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            234,
+            392,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            266,
+            295,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep Neural Network and Its Neurons. In this paper, we take a fully-connected network as an example (other convolutional networks are also applicable). Its layers are numbered from 0 (input) to $L$ (output) and each layer contains $n _ { 0 } , \\cdots , n _ { L }$ neurons. The network has $n = n _ { 1 } + n _ { 2 } + \\cdot \\cdot \\cdot + n _ { L }$ parameterized neurons in total3. We denote the weight parameters of the $k$ -th neuron in $l$ -th layer as w(l)k , the bias as b $b _ { k } ^ { ( l ) }$ , and its output is ",
+        "bbox": [
+            173,
+            291,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/271e33dc8b33af0bfb78aba2722af37574ad1eed153da4fb5baf8de4bdc8aa46.jpg",
+        "text": "$$\nh _ { k } ^ { ( l ) } = \\sigma ( \\mathbf { w } _ { k } ^ { ( l ) \\top } \\mathbf { h } ^ { ( l - 1 ) } + b _ { k } ^ { ( l ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            372,
+            598,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma ( \\cdot )$ is the nonlinear function and $\\mathbf { h } ^ { ( l - 1 ) }$ is the outputs of all neurons in the previous layer, $i . e . , { \\bf h } ^ { ( l - 1 ) } = [ h _ { 1 } ^ { ( l - 1 ) } , \\cdot \\cdot \\cdot , h _ { n _ { l } } ^ { ( l - 1 ) } ]$ . For simplicity, we denote all weights of the network as $\\mathbf { w } =$ $\\begin{array} { r l r } { } & { } & { [ { \\bf w } _ { 1 } ^ { ( 1 ) } , \\cdot \\cdot \\cdot , { \\bf w } _ { n _ { 1 } } ^ { ( 1 ) } , \\cdot \\cdot \\cdot , { \\bf w } _ { 1 } ^ { ( L ) } , \\cdot \\cdot \\cdot , { \\bf w } _ { n _ { L } } ^ { ( L ) } ] } \\end{array}$ , and all biases as $\\mathbf { b } = [ b _ { 1 } ^ { ( 1 ) } , \\cdots , b _ { n _ { l } } ^ { ( 1 ) } , \\cdots , b _ { 1 } ^ { ( L ) } , \\cdots , b _ { n _ { L } } ^ { ( L ) } ]$ For a given input $\\mathbf { x }$ , the network makes the prediction $f ( \\mathbf { x } ; \\mathbf { w } , \\mathbf { b } )$ . ",
+        "bbox": [
+            173,
+            401,
+            826,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNN Training. We consider a $c$ -class classification problem. The parameters of weights and biases in DNN are learned on a training dataset $\\mathcal { D } _ { \\mathcal { T } } = \\{ ( \\bar { \\bf x } _ { 1 } , \\bar { y } _ { 1 } ) , \\cdot \\cdot \\cdot , ( \\bar { \\bf x } _ { s } , \\bar { y } _ { s } ) \\}$ containing $s$ inputs, where each input is $\\mathbf { x } _ { i } \\in \\mathbb { R } ^ { d } , i = 1 , \\cdots , s .$ , and its ground-truth label is $y _ { i } \\in \\{ 1 , \\cdots , c \\}$ . The training procedure tries to find the optimal $( \\mathbf { w } ^ { \\star } , \\mathbf { b } ^ { \\star } )$ which minimize the training loss on the training data $\\mathcal { D } _ { \\mathcal { T } }$ , ",
+        "bbox": [
+            173,
+            473,
+            825,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3364f80e5b67dd56d21b64f0eee85cb357978fdb9182499adbbea91e6f0bedd.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathcal { D } _ { T } } ( \\mathbf { w } , \\mathbf { b } ) = \\underset { \\mathbf { x } , y \\sim \\mathcal { D } _ { T } } { \\mathbb { E } } \\ell ( f ( \\mathbf { x } ; \\mathbf { w } , \\mathbf { b } ) , y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            542,
+            627,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell ( \\cdot , \\cdot )$ is usually cross entropy loss. ",
+        "bbox": [
+            176,
+            570,
+            446,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Defense Setting. We adopt a typical defense setting that an untrustworthy model is downloaded from a third party (e.g., outsourcing training) without knowledge of the training data $\\mathcal { D } _ { \\mathcal { T } }$ . For defense, we are assumed to have a small amount of clean data $\\mathcal { D } _ { \\mathcal { V } }$ . The goals of model repairing are to remove the backdoor behavior while keeping the accuracy on clean samples. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Adversarial Neuron Perturbations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            664,
+            450,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In previous studies, the adversary causes misclassification by perturbing inputs before feeding them to DNNs. For example, attaching triggers to inputs to make backdoored DNN output the target label or adversarially perturbing inputs to make normal/backdoored DNN output incorrectly. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we try another direction to perturb DNN neurons to cause misclassification. Given the $k$ -th neuron in the $l$ -th layers, we can perturb its weight $\\mathbf { w } _ { k } ^ { ( l ) }$ and bias $b _ { k } ^ { ( l ) }$ by multiplying a small number respectively. As a result, the perturbed weight is and the output of the perturbed neuron becomes $( 1 + \\delta _ { k } ^ { ( l ) } ) \\mathbf { w } _ { k } ^ { ( l ) }$ , the perturbed bias is $( 1 + \\xi _ { k } ^ { ( l ) } ) b _ { k } ^ { ( l ) }$ ",
+        "bbox": [
+            173,
+            737,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bbdb534de652f2146abbf3f98ac580f7354f75dd735c92638536f552bd2b9755.jpg",
+        "text": "$$\nh _ { k } ^ { ( l ) } = \\sigma \\big ( ( 1 + \\delta _ { k } ^ { ( l ) } ) \\mathbf { w } _ { k } ^ { ( l ) \\top } \\mathbf { h } ^ { ( l - 1 ) } + ( 1 + \\xi _ { k } ^ { ( l ) } ) b _ { k } ^ { ( l ) } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            808,
+            663,
+            830
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where δ(l)k and $\\xi _ { k } ^ { ( l ) }$ indicate the relative sizes of the perturbations to the weight and bias respectively. Similarly, all neurons can be perturbed like Eq. (3). We denote the relative weight perturbation size of all neurons as $\\pmb { \\delta } = [ \\delta _ { 1 } ^ { ( 1 ) } , \\cdots , \\delta _ { n _ { 1 } } ^ { ( 1 ) } , \\cdots , \\delta _ { 1 } ^ { ( L ) } , \\cdots , \\delta _ { n _ { L } } ^ { ( L ) } ] ,$ , and the relative bias perturbation ",
+        "bbox": [
+            174,
+            838,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ac1e440c839cc232f6a83883b01fc0b0c8fea8f16523aab7310035f8bb29735.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            97,
+            820,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: The performance of neuron-perturbed models with different perturbation budgets. ",
+        "bbox": [
+            196,
+            257,
+            799,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "size as $\\pmb { \\xi } = [ \\xi _ { 1 } ^ { ( 1 ) } , \\cdots , \\xi _ { n _ { 1 } } ^ { ( 1 ) } , \\cdots , \\xi _ { 1 } ^ { ( L ) } , \\cdots , \\xi _ { n _ { L } } ^ { ( L ) } ]$ for simplicity. For a clean input $\\mathbf { x }$ , the output of the perturbed model is ",
+        "bbox": [
+            174,
+            294,
+            821,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a2800c50ea96b4168f8f72c505221fc8cb1a7eaddf035d70ab9c827a3a570b5.jpg",
+        "text": "$$\nf ( \\mathbf { x } ; ( 1 + \\delta ) \\odot \\mathbf { w } , ( 1 + \\pmb { \\xi } ) \\odot \\mathbf { b } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            324,
+            607,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where neuron-wise multiplication $\\odot$ multiplies the parameters by the perturbation sizes belonging to the same neuron as follows: ",
+        "bbox": [
+            176,
+            344,
+            823,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b737e9e5e17ed7d142d2b5e26aef86d52f922ee24349f7c5ee1faf97362bb57.jpg",
+        "text": "$$\n( 1 + \\pmb \\delta ) \\odot \\mathbf { w } = \\big [ ( 1 + \\delta _ { 1 } ^ { ( 1 ) } ) \\mathbf { w } _ { 1 } ^ { ( 1 ) } , \\cdots , ( 1 + \\delta _ { n _ { 1 } } ^ { ( 1 ) } ) \\mathbf { w } _ { n _ { 1 } } ^ { ( 1 ) } , \\cdots , ( 1 + \\delta _ { 1 } ^ { ( L ) } ) \\mathbf { w } _ { 1 } ^ { ( L ) } , \\cdots , ( 1 + \\delta _ { n _ { L } } ^ { ( L ) } ) \\mathbf { w } _ { n _ { L } } ^ { ( L ) } \\big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            375,
+            826,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1bcd1eceaae398c0951e86fbbc4af6fcbf8e19cdbd94e4eaff6cf704b519603a.jpg",
+        "text": "$$\n( 1 + \\pmb { \\xi } ) \\odot \\mathbf { b } = \\big [ ( 1 + \\xi _ { 1 } ^ { ( 1 ) } ) b _ { 1 } ^ { ( 1 ) } , \\cdots , ( 1 + \\xi _ { n _ { 1 } } ^ { ( 1 ) } ) b _ { n _ { 1 } } ^ { ( 1 ) } , \\cdots , ( 1 + \\xi _ { 1 } ^ { ( L ) } ) b _ { 1 } ^ { ( L ) } , \\cdots , ( 1 + \\xi _ { n _ { L } } ^ { ( L ) } ) b _ { n _ { L } } ^ { ( L ) } \\big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            412,
+            794,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a trained model, similar to adversarial perturbations [39, 13], we optimize the neuron perturbations $\\delta$ and $\\boldsymbol { \\xi }$ to increase the classification loss on the clean data: ",
+        "bbox": [
+            176,
+            440,
+            823,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a103abdea57a9e286ea31fc2de6f996314495bf31678be7f5a682aa0cc2a0a69.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\delta , \\xi \\in [ - \\epsilon , \\epsilon ] ^ { n } } \\mathcal { L } _ { \\mathcal { D } _ { \\mathcal { V } } } \\big ( ( 1 + \\delta ) \\odot \\mathbf { w } , ( 1 + \\xi ) \\odot \\mathbf { b } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            474,
+            643,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon$ is the perturbation budget, which limits the maximum perturbation size. ",
+        "bbox": [
+            176,
+            507,
+            696,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we generate adversarial neuron perturbations for three ResNet-18 models [15] on CIFAR10 [19]: a benign model, a backdoored one with a predefined trigger (Badnets [14]), and a backdoored one with a dynamic trigger (Input-aware Backdoor Attack [30], IAB). We all set the target label in backdoor as class 0. We solve the maximization in Eq. (7) using project gradient descent (PGD) with random initialization similar to generating adversarial examples. The number of iterations is 300 and the step size is 0.001. Figure 1(a) shows adversarial neuron perturbations leads to misclassification, and the larger the perturbation budget $\\epsilon$ is, the larger the error rate is. In addition, backdoored models always have larger error rates with the same perturbation budget compared to the benign one. To explore the misclassification in detail, we illustrate the proportion of different classes in predictions by three models in Figure 1(b). For benign model, adversarial neuron perturbations mislead the model to output the untargeted class (e.g., class 3). While for backdoored models, the majority of misclassified samples are predicted as the target label (e.g., class 0) whose proportion rate is much higher than the benign model. More results to support these findings can be found in Appendix B. Therefore, even without the trigger, we can still induce the backdoor behaviours via adversarial neuron perturbations. The reasons can be explained as follows: assuming the $k$ -th neuron in $l$ -th layers is backdoor-related, it is dormant on clean sample [24] (i.e., output is close to 0: $h _ { k } ^ { ( l ) } \\approx 0 ,$ ). If w(l)>k hl−1 > 0 and b(l)k > 0, we can increase its output by enlarging the norm of the weights (i.e., $\\delta _ { k } ^ { ( l ) } > 0 \\}$ ), and further continue to increase it by adding a larger bias (i.e., $\\xi _ { k } ^ { ( l ) } > 0 ) ^ { 4 }$ . With suitable perturbations, the backdoor-related neuron is activated even on clean samples. Thus, the neurons that are sensitive to adversarial neuron perturbation are strongly related to the injected backdoor. ",
+        "bbox": [
+            173,
+            526,
+            826,
+            816
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 The Proposed Adversarial Neuron Pruning (ANP) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            832,
+            562,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, the sensitivity under adversarial neuron perturbations is strongly related to the injected backdoor. Inspired by this, we try to prune some sensitive neurons to defend backdoor attacks, named Adversarial Neuron Pruning method (ANP). We denote the pruning masks as $\\mathbf { m } =$ $[ m _ { 1 } ^ { ( 1 ) } , \\cdots , m _ { n _ { 1 } } ^ { ( 1 ) } , \\cdots , m _ { 1 } ^ { ( L ) } , \\cdots , m _ { n _ { L } } ^ { ( L ) } ] \\in \\bar { \\{ 0 , 1 \\} } ^ { n }$ . For the $k$ -th neuron in the $l$ -th layer, we set its weight w(k l ) = 0 if m( l )k = L , and keep it unchanged if $m _ { k } ^ { ( l ) } = 1$ . Similar to Ghorbani and Zou [11], we always keep the bias $b _ { k } ^ { ( l ) }$ to avoid extra harm to the accuracy on clean data5. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Continuous Relaxation and Optimization. Due to the binary masks, pruning is a discrete optimization problem that is difficult to solve within feasible time. To address this, we apply continuous relaxation to let $\\mathbf { m } \\in [ 0 , 1 ] ^ { n }$ and optimizes them using projected gradient descent (PGD). To restore the continuous masks to discreteness after optimization, we set all mask smaller than a threshold as 0 (prune neurons with small masks), and others as 1 (keep neurons with large masks). We expect the pruned model to not only behaves well on clean data but also keep stable under adversarial neuron perturbations. Therefore, we solve the following minimization problem, ",
+        "bbox": [
+            173,
+            165,
+            825,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be916f3a3bfa01bbdbdeba9a9614f93c3d22339b730c0aacedbf416eef2b05fe.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { m } \\in \\left[ 0 , 1 \\right] ^ { n } } \\left[ \\alpha \\mathcal { L } _ { { D } _ { \\mathcal { V } } } ( \\mathbf { m } \\odot \\mathbf { w } , \\mathbf { b } ) + \\left( 1 - \\alpha \\right) \\operatorname* { m a x } _ { \\delta , \\xi \\in \\left[ - \\epsilon , \\epsilon \\right] ^ { n } } \\mathcal { L } _ { { D } _ { \\mathcal { V } } } ( ( \\mathbf { m } + \\delta ) \\odot \\mathbf { w } , ( 1 + \\pm \\xi ) \\odot \\mathbf { b } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            277,
+            781,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha \\in [ 0 , 1 ]$ is a trade-off coefficient. If $\\alpha$ is close to 1, the minimization object focuses more on accuracy of the pruned model on clean data, while if $\\alpha$ is close to 0, it focuses more on robustness against backdoor attacks. ",
+        "bbox": [
+            176,
+            328,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation of ANP. As shown in Algorithm 1, we start from an unpruned network, that is, initializing all masks as 1 (Line 2). We randomly initialize perturbations (Line 5), and update them using one step (Line 6-7), then project them onto the feasible regime (Line 8-9). Following that, we update mask values based on the adversarial neuron perturbation (Line 10) and project mask value onto [0, 1] (Line 11). As convergence after iterations, we pruned neurons with small mask value and keep others unchanged (Line 13). Note that the proposed ANP is data-driven, different from previous pruning-based defenses which are based on the thumb-of-rule [24, 43]. Besides, ANP can work well on an extremely small amount of clean data due to the small number of masks. ",
+        "bbox": [
+            173,
+            377,
+            826,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Adversarial Neuron Pruning (ANP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            496,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Network $f ( \\cdot ; { \\bf w } , { \\bf b } )$ , hyper-parameter $\\alpha$ , learning rate $\\eta$ , batch size $b$ , maximum perturba   \ntion size $\\epsilon$   \n2: Initialize all elements in $\\mathbf { m }$ as 1   \n3: repeat   \n4: Read mini-batch $B = \\{ ( \\mathbf { x } _ { 1 } , y _ { 1 } ) , . . . , ( \\mathbf { x } _ { b } , y _ { b } ) \\}$ from training set   \n5: $\\delta _ { 0 } , \\xi _ { 0 } \\sim U ( - \\epsilon , \\epsilon )$ , where $U ( - \\epsilon , \\epsilon )$ is the uniform distribution   \n6: $\\begin{array} { r } { \\pmb { \\delta }  \\pmb { \\delta } _ { 0 } + \\epsilon \\mathrm { s i g n } ( \\nabla _ { \\delta } \\mathcal { L } ( ( \\mathbf { m } + \\pmb { \\delta } _ { 0 } ) \\odot \\mathbf { w } , } \\end{array}$ ， $( { \\bf 1 } + { \\pmb \\xi } _ { 0 } ) \\odot { \\bf b } ) )$   \n7: $\\pmb { \\xi }  \\pmb { \\xi } _ { 0 } + \\epsilon \\mathrm { s i g n } ( \\nabla _ { \\pmb { \\xi } } \\mathcal { L } ( ( \\mathbf { m } + \\pmb { \\delta } _ { 0 } ) \\odot \\mathbf { w }$ , $\\left( \\mathbf { 1 } + \\pmb { \\xi } _ { 0 } \\right) \\odot \\mathbf { b } ) _ { }$ )   \n8: $\\delta \\gets \\operatorname* { m a x } ( - \\epsilon , \\operatorname* { m i n } ( \\delta , \\epsilon ) )$   \n9: $\\pmb { \\xi } \\gets \\operatorname* { m a x } ( - \\epsilon , \\operatorname* { m i n } ( \\pmb { \\xi } , \\epsilon ) )$   \n10: m ← m − η∇m[αL(m \f w, b) + (1 − α)L((m + δ) \f w, (1 + ξ) \f b)]   \n11: $\\mathbf { m } \\gets \\mathrm { m a x } ( 0 , \\mathrm { m i n } ( \\mathbf { m } , 1 ) )$   \n12: until training converged   \n13: $m _ { k } ^ { ( l ) } = \\mathbb { I } ( m _ { k } ^ { ( \\bar { l } ) } > t h r e s h o l d )$ , for all $k , l$   \n14: Output: A robust network $f ( \\cdot ; \\mathbf { m } \\odot \\mathbf { w } , \\mathbf { b } )$ against backdoor attacks ",
+        "bbox": [
+            178,
+            531,
+            821,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Adaptation to Batch Normalization. Batch Normalization (BatchNorm) [16] always normalizes its input and controls the mean and variance of the output by a pair of trainable parameters (scale $\\gamma$ and shift $\\beta$ ). If BatchNorm is inserted between matrix multiplication and the nonlinear activation, the perturbations to weight and bias may cancel each other out. For example, if we perturb the weight and bias of a neuron to the maximum by multiplying $( 1 + \\epsilon )$ , the normalization offsets them and nothing changes after BatchNorm. To address this problem, we perturb the scale and shift parameters instead. We also make similar changes to the pruning masks. ",
+        "bbox": [
+            173,
+            771,
+            825,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/01889cad0d7db84f889603a0e44f0bf8f015c137207a10a6a4dcb012cb6a0d94.jpg",
+        "table_caption": [
+            "Table 1: Performance (average over 5 random runs) of 4 defense methods against 6 backdoor attacks on $1 \\%$ (500 images) of clean data on CIFAR-10 training set using ResNet-18. The AvgDrop indicates the average changes in ACC or ASR over 6 backdoor attacks compared to no defense results (Before). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Metric</td><td rowspan=1 colspan=1>Defense</td><td rowspan=1 colspan=1>Badnets  Blend IAB-one IAB-all  CLB   SIG</td><td rowspan=1 colspan=1>AvgDrop</td></tr><tr><td rowspan=5 colspan=1>ACC</td><td rowspan=5 colspan=1>BeforeFT(lr = 0.01)FT(lr = 0.02)FPMCR(t = 0.3)ANP</td><td rowspan=1 colspan=1>93.73   94.82   93.89    94.10  93.78 93.64</td><td rowspan=1 colspan=1>一</td></tr><tr><td rowspan=1 colspan=1>90.48   92.12    88.68    89.06   91.26 91.19</td><td rowspan=1 colspan=1>↓3.53</td></tr><tr><td rowspan=1 colspan=1>87.23   88.98   84.85    83.77   88.25  88.63</td><td rowspan=1 colspan=1>↓7.04</td></tr><tr><td rowspan=2 colspan=1>92.18   92.40   91.57    92.28   91.91  91.6485.95   88.26   86.30    84.53   86.87 85.8890.20   93.44   92.62    92.79   92.67 93.40</td><td rowspan=1 colspan=1>↓2.00</td></tr><tr><td rowspan=1 colspan=1>7.70↓1.47</td></tr><tr><td rowspan=5 colspan=1>ASR</td><td rowspan=5 colspan=1>BeforeFT(lr = 0.01)FT(lr = 0.02)FPMCR(t = 0.3)ANP</td><td rowspan=1 colspan=1>99.97   100.0   98.49    92.88   99.94 94.2611.70   47.17    0.99      1.36   12.51  0.40</td><td rowspan=1 colspan=1>一↓85.24</td></tr><tr><td rowspan=2 colspan=1>2.95    10.20    1.70      1.83    1.17   0.395.34    65.39    20.73     32.36   3.40   0.32</td><td rowspan=1 colspan=1>↓94.55</td></tr><tr><td rowspan=1 colspan=1>↓76.33</td></tr><tr><td rowspan=1 colspan=1>5.70    13.57   30.23    35.17   12.77  0.52</td><td rowspan=1 colspan=1>←81.26</td></tr><tr><td rowspan=1 colspan=1>0.45    0.46    0.88     0.86    3.98   0.28</td><td rowspan=1 colspan=1>↓96.44</td></tr></table>",
+        "bbox": [
+            173,
+            137,
+            825,
+            339
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            364,
+            312,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct comprehensive experiments to evaluate the effectiveness of ANP, including its benchmarking robustness, ablation studies and performance under limited computation resources. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            441,
+            367,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Backdoor Attacks and Settings. We consider 5 state-of-the-art backdoor attacks: 1) BadNets [14], 2) Blend backdoor attack (Blend) [6], 3) Input-aware backdoor attack with all-to-one target label (IAB-one) or all-to-all target label (IAB-all) [30], 4) Clean-label backdoor (CLB) [42], and 5) Sinusoidal signal backdoor attack (SIG) [1]. For fair comparisons, we follow the default configuration in their original papers such as the trigger patterns, the trigger sizes and the target labels. We evaluate the performance of all attacks and defenses on CIFAR-10 [19] using ResNet-18 [15] as the base model. We use $9 0 \\%$ training data to train the backdoored DNNs and use the all or part of the remaining $1 0 \\%$ training data for defense. More details about implementation can be found in Appendix A. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Backdoor Defenses and Settings. We compare our proposed ANP with 3 existing model repairing methods: 1) standard fine-tuning (FT), 2) fine-pruning (FP) [24], and 3) mode connectivity repair (MCR) [48]. All defense methods are assumed to have access to the same $1 \\%$ of clean training data (500 images). The results based on $1 0 \\%$ (5000 images) and $0 . 1 \\%$ (50 images) of clean training data can be found in Appendix. For ANP, we optimize all masks using Stochastic Gradient Descent (SGD) with the perturbation budget $\\epsilon = 0 . 4$ and the trade-off coefficient $\\alpha = 0 . 2$ . We set the batch size 128, the constant learning rate 0.2, and the momentum 0.9 for 2000 iterations in total. Typical data augmentation like random crop and horizontal flipping are applied. After optimization, neurons with mask value smaller than 0.2 are pruned. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics. We evaluate the performance of different defenses using two metrics: 1) the accuracy on clean data (ACC), and 2) and the attack success rate (ASR) that is the ratio of triggered samples that are misclassified as the target label. For better comparison between different strategies for the target label (e.g., all-to-one and all-to-all), we remove the samples whose ground-truth labels already belong to the target class in the all-to-one setting before calculating ASR. Therefore, an ideal defense always has close-to-zero ASR and high ACC. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            799
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Benchmarking the State-of-the-art Robustness ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            535,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To verify the effectiveness of the proposed ANP, we compare its performance with other 3 existing model repairing methods using ACC and ASR in Table 1. All experiments are repeated over 5 runs with different random seeds, and we only report the average performance without the standard deviation due to the space constraint. More detailed results including the standard deviation can be found in Appendix C. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f8047a5753f3018f6176e6b7d756d668e01f922b5f5cd6e5c1ea85d6e78a16cd.jpg",
+        "table_caption": [
+            "Table 2: The average training time of defense method against 6 backdoor attacks on $1 \\%$ (500 images) of clean data on CIFAR-10 training set using ResNet-18. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Defense</td><td>FT</td><td>FP</td><td>MCR</td><td>ANP</td></tr><tr><td>Time (s)</td><td>93.80</td><td>1427.1</td><td>286.1</td><td>241.5</td></tr></table>",
+        "bbox": [
+            339,
+            119,
+            651,
+            165
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The experimental results show that the proposed ANP remarkably provides almost the highest robustness against several state-of-the-art backdoor attacks. In particular, in 5 of total 6 attacks, our proposed ANP successfully reduces the ASR to lower than $1 \\%$ while only has a slight drop $( \\sim 1 . 4 7 \\%$ on average) in ACC. Note that we only use $1 \\%$ of clean data from CIFAR-10 training set, which is extremely small. We find the standard fine-tuning (FT) with a larger learning rate ${ l r = 0 . 0 2 } )$ also provides strong robustness similar to ANP. However, it has an obvious drop in ACC since a large learning rate may destroy the features learned before and the new ones learned on limited data are poor in generalization. The poor accuracy hinders its usage in practical scenarios. In contrast, ANP has similar robustness against backdoor attacks while maintains ACC at a relatively high level at the same time. Similar to our method, Fine-pruning (FP) [24] also prunes some neurons and fine-tunes the pruned model on clean data. Specifically, It only prunes neurons in the last convolutional layer using a rule-of-thumb6, and provides limited robustness against backdoor attacks. Differently, the proposed ANP is data-driven (i.e., optimizing pruning masks based on data) and prunes neurons globally (i.e., pruning neurons in all layers), leading to higher ACC and lower ASR than FP. MCR suggests mitigating backdoor by using a curve model lying on a path connection between two backdoored models in the loss landscapes. However, with limited data, it fails in providing high robustness against complex triggers (e.g. a random trigger sampled from Gaussian in blend backdoor attack or the dynamic trigger in input-aware attack). By contrast, ANP always reduces ASR significantly no matter what the trigger looks like. Note that ANP only prunes neurons and never changes any parameters of backdoored DNNs, while other methods all fine-tune parameters. Under this situation, ANP still provides the almost best robustness against these state-of-the-art attacks, which indicates that pure pruning (without fine-tuning) is still a promising defense against backdoor attacks. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also compare the training time of ANP and other baselines in Table 2, which indicates the efficiency of the proposed ANP. In particular, we apply 2000 iterations for FT, FP, and ANP, and 200 epochs (i.e., 800 iterations) for MCR following the open-sourced code7. Note that ANP is not as slow as the vanilla adversarial training (AT) since ANP only requires one extra backpropagation while PGD inside AT usually needs 10 extra backpropagations (PGD-10) in each update of model parameters. Besides, although ANP takes $2 . 5 \\times$ time compared to FT, it improves accuracy (e.g., $8 8 . 9 8 \\%  9 3 . 4 4 \\%$ for Blend) and reduce vulnerability $( e . g . , \\bar { 1 0 . 2 0 \\% } \\to 0 . 4 6 \\%$ for Blend) significantly, making the overhead caused by ANP acceptable. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            328,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effect of Adversarial Neuron Perturbation. Recalling Section 3.2, we apply adversarial neuron perturbations to induce the injected backdoor and then defend against backdoor attacks. Here, we evaluate the effect of the adversarial neuron perturbation in our defense strategy. In the following experiments, we defend against Badnets attack by default, unless otherwise specified. First, we optimize masks with perturbations $\\alpha = 0 . 2$ and $\\epsilon = 0 . 4$ , i.e., ANP) and without perturbations $\\alpha = 1 . 0$ , i.e., the vanilla pruning method). Figure 2(a) shows the ACC and ASR on the test set during optimization. We find the optimization under adversarial neuron perturbations helps the backdoored model suppress ASR significantly while the vanilla one always has high ASR throughout the training process. Next, we illustrate the mask distribution after optimization. Figure 2(b) illustrates a certain fraction of masks becomes zero, which means that adversarial neuron perturbations indeed find some sensitive neurons and helps the model to remove them. In contrast, there is no mask close to 0 for the vanilla pruning method in Figure 2(c). Finally, we prune different fractions of neurons according to their mask in Figure 2(d). For both methods, ASR becomes low after pruning more than $5 \\%$ of neurons8. However, ACC also starts to degrade significantly for the vanilla pruning method with more than $5 \\%$ of neurons pruned. Since backdoored-related neurons are still mixed with other neurons (e.g., discriminant neurons), the vanilla pruning method prunes some discriminant neurons incorrectly. Meanwhile, ANP always keeps ACC at a relatively high level. In conclusion, the adversarial neuron perturbation is the key to distinguish the backdoor-related neurons from the other neurons, which thereby successfully obtains high ACC as well as low ASR. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdbe97c81ddf9f981dadc8bb71c5c721160bf778af2dfe13da667aa21c43f690.jpg",
+        "image_caption": [
+            "Figure 2: Comparison between optimization with and without adversarial neuron perturbations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            98,
+            813,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3256376efc1771b95e75397e179754596782b9606cff25fe03f9273f61db1245.jpg",
+        "table_caption": [
+            "Table 3: Results with small budget $\\epsilon = 0 . 1$ against Blend attack on 500 clean images. “Neurons↓” indicates the number of neurons pruned by ANP. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Steps</td><td>1</td><td>2</td><td>5</td><td>10</td></tr><tr><td>Time (s)</td><td>239.9</td><td>359.2</td><td>551.8</td><td>943.9</td></tr><tr><td>Neurons↓</td><td>159</td><td>188</td><td>235</td><td>259</td></tr><tr><td>ASR (%)</td><td>65.19</td><td>13.40</td><td>1.06</td><td>0.90</td></tr><tr><td>ACC (%)</td><td>93.62</td><td>93.07</td><td>92.95</td><td>92.72</td></tr></table>",
+        "bbox": [
+            173,
+            337,
+            485,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d6e7e34649de585125457cd9d72e41a00c6fe4f7582f02fc5e3ce420c48c159.jpg",
+        "table_caption": [
+            "Table 4: Results with large budget $\\epsilon = 0 . 4$ against Blend attack on 500 clean images. “Neurons↓” indicates the number of neurons pruned by ANP. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Steps</td><td>1</td><td>2</td><td>5</td><td>10</td></tr><tr><td>Time (s)</td><td>241.5</td><td>357.2</td><td>557.1</td><td>950.1</td></tr><tr><td>Neurons↓</td><td>233</td><td>239</td><td>281</td><td>296</td></tr><tr><td>ASR (%)</td><td>0.46</td><td>1.30</td><td>5.30</td><td>31.34</td></tr><tr><td>ACC (%)</td><td>93.44</td><td>94.07</td><td>93.57</td><td>94.28</td></tr></table>",
+        "bbox": [
+            509,
+            337,
+            820,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            435,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition, we explore the effects of number of iterations in crafting adversarial neuron perturbations. We conduct experiments with varying numbers of steps (1/2/5/10) in ANP with a small perturbation budget $\\mathit { \\check { \\Psi } } _ { \\epsilon } = 0 . 1 $ ) and a large perturbation budget $\\mathit { \\check { \\Psi } } \\epsilon = 0 . 4$ ) respectively. The other settings are the same as Section 4.1. The experimental results are shown in Tables 3-4. Under a small perturbation budget, with more steps for ANP, the ASR decreases with a slight drop in ACC. This is because ANP with a single step and small size is too weak to distinguish benign neurons and backdoor-related neurons, while more steps can help ANP find more backdoor-related neurons. However, under a large perturbation budget, ANP with more steps has worse robustness. This is because, with a large perturbation budget, more neurons become sensitive. As a result, ANP with more steps finds too many “suspicious” neurons, and it is unable to identify backdoor-related neurons from them. In conclusion, we can strengthen the power of ANP to find backdoor-related neurons using a larger perturbation budget or more steps. Among them, single-step ANP with a slightly larger budget is more practical due to its time efficiency, and we adopt this by default. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results with Varying Hyperparameters. As mentioned in Section 3.3, the hyper-parameter $\\alpha$ in ANP controls the trade-off between the accuracy on clean data and the robustness against backdoor attacks. To test the performance with different $\\alpha$ , we optimize masks for a Badnets ResNet-18 based on $1 \\%$ of clean data using different $\\alpha \\in [ 0 , 1 ]$ with a fixed budget $\\epsilon = 0 . 4$ . In pruning, we always prune neurons by the threshold 0.2. As shown in the left plot of Figure 4, ANP is able to achieve a high robustness $\\mathrm { \\Delta A S R } < 4 \\%$ ) when $\\alpha \\leq 0 . 6$ . Meanwhile, ANP maintains a high natural accuracy $( \\mathrm { A C C } \\geq 9 0 \\% )$ as long as $\\alpha \\ge 0 . 1$ . As a result, ANP behaves well with high ACC and low ASR in a range of $\\alpha \\in [ 0 . 1 , 0 . 6 ]$ . ",
+        "bbox": [
+            173,
+            696,
+            825,
+            809
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we also test the performance with different perturbation budgets $\\epsilon$ . The experiment settings are almost the same except a fixed trade-off coefficient $\\alpha = 0 . 2$ and varying budgets $\\epsilon \\in [ 0 , 1 ]$ . For example, we can provide obvious robustness (ASR becomes $7 . 4 5 \\%$ ) with a small perturbation budget $\\epsilon = 0 . 2$ ) as shown in the right plot of Figure 4. However, we find the accuracy on clean data degrades with a large perturbation budget. This is because too large perturbation budget brings much difficulty to converge well and ANP only finds a poor solution, which fails in identifying these discriminant and robust neurons and prunes part of them. As a result, ACC decreases significantly. In conclusion, the proposed ANP is stable in a large range of the trade-off coefficient $\\alpha \\in [ 0 . 1 , 0 . 6 ]$ and the perturbation budget $\\epsilon \\in [ 0 . 2 , 0 . 7 ]$ , demonstrating that ANP is not sensitive to hyper-parameters. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8bf3858ee9e476f3adbe69766b659fe02bcb8becb61c2541e03275132706fc2f.jpg",
+        "image_caption": [
+            "Figure 3: Performance $\\pm$ std over 5 random runs) of pruned models using different architectures by different pruning fractions or different thresholds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            97,
+            815,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            821,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "From the discussion above, we find that the hyperparameters are insensitive as shown in Figure 4 and ANP performs well across a wide range of hyperparameters, e.g., trade-off coefficient $\\alpha \\in [ 0 . 1 , 0 . 6 ]$ against Badnets attack. In addition, with varying hyperparameters, the performance trends are very consistent across different backdoor attacks as shown in Figure $\\mathrm { X }$ in Appendix C.1. As a result, even though the attack (e.g., Blend) is unknown, the defender could tune $\\alpha$ against a known attack (e.g., Badnets) and find the 0.2 is a good choice. ANP with $\\alpha = 0 . 2$ also achieves satisfactory performance against Blend attack. In conclusion, the selection of hyperparameters in ANP is not difficult. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pruning by Fraction or by Threshold. Different from previous pruning methods that use a fixed pruning fraction, the proposed ANP prunes neurons by a threshold when generalized across different model architectures. To verify this, we train different Badnets models using ResNet-18 [15], ResNet50 [15], and VGG-19 [37] with the same settings as Section 4.1. We also train a model with Badnets MobileNet-V2 with 300 epochs . We optimize the pruning masks for these models with $\\epsilon = 0 . 4 , \\alpha = 0 . 2$ for ResNet-18, ResNet-50, and VGG-19. For MobileNet-V2, we found the perturbation budget $\\epsilon = 0 . 4$ is too large, leading to a failure in convergence. So we apply a smaller budget $\\epsilon = 0 . 2$ and the same trade-off coefficient $\\alpha = 0 . 2$ . We show the ACC and ASR after pruning by varying pruning fractions in Figure 3(a) and 3(b), which indicates that the suitable fraction varies across model architectures. For example, ResNet-18 only has low ASR after pruning $5 \\%$ of neurons, while MobileNet-V2 has a large accuracy drop on clean samples with more than $5 \\%$ neurons pruned. Figure 3(c) and Figure 3(d) show ACC and ASR after pruning by different thresholds respectively. When pruning by the threshold, we find there is a large overlap in [0.2, 0.5] (the gray zone) in which all models have high ACC and low ASR simultaneously. That is why we adopt the strategy of pruning by the threshold in ANP. Note that, even for low-capacity models as MobileNet-V2, it is still possible to remove the injected backdoor by neuron pruning (without the fine-tuning). ",
+        "bbox": [
+            173,
+            425,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pruning on Different Components. We also compare the performance when applying ANP to different components inside DNNs. We prune a backdoored 4-layer CNN (2 conv layers $^ { + 1 }$ fullyconnected layer $^ +$ output layer) on MNIST, and find it more efficient to prune neurons in some layers. In particular, we achieve $0 . 4 3 \\%$ of ASR $( 9 9 . 0 4 \\%$ of ACC) when two neurons in the 2nd layer are pruned, while we only achieve $4 . 4 2 \\%$ of ASR $( 9 2 . 4 8 \\%$ of ACC) even after pruning 150 neurons in the fully-connected layer. The experimental settings and more results can be found in Appendix C.2. This indicates that the structure of components matter in pruning-based defense. We leave this in our future work. ",
+        "bbox": [
+            174,
+            652,
+            826,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Performance under Limited Computation Resource ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            781,
+            571,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In practical scenarios, the defender usually has limited clean data and computation resources, bringing more difficulty to repair backdoored models. While Section 4.2 has discussed the effectiveness of the proposed ANP on the extremely small amount of data, this part focuses on the performance with limited computation resources in defense. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In particular, we optimize all masks for a Badnets ResNet-18 with varying number of iterations (20, 100, 400, and 2000) on $1 \\%$ of clean data (500 images) and prune the model from neurons with the small mask to neurons with the large mask. Figure 5 shows the ACC and ASR with varying pruning fractions based on different numbers of iterations. We find that some backdoor-related neurons have already been distinguished just after 20 iterations. For example, after removing $4 \\%$ of neurons with the smallest masks, the pruned model has $6 . 2 8 \\%$ of ASR and $8 6 . 6 5 \\%$ of ACC. As the pruning fraction increases, ASR falls significantly first and raises again after $1 0 \\%$ of neurons are pruned. This is because ANP has not yet separated them completely due to extremely limited computation (only 20 iterations). With more than 100 iterations, this phenomenon disappears. And ANP based on 100 iterations already has comparable performance to ANP on 2000 iterations, especially when we have not pruned too many neurons $( < 8 \\%$ ). ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/93472c8a66980e364dd261efb96c5ac684e0055908acf754d698dfc147542165.jpg",
+        "image_caption": [
+            "Figure 4: Performance ( $\\pm$ std over 5 random runs) of the pruned model by a threshold 0.2 with different hyper-parameters (Left: trade-off coefficient $\\alpha$ ; Right: perturbation budget $\\dot { \\epsilon }$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            92,
+            472,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/b26378fa2b0246eadadac2f1c4a88e337567f18989a4f533b8eb7e774663c072.jpg",
+        "image_caption": [
+            "Figure 5: Performance ( $\\pm$ std over 5 random runs) of the proposed ANP with varying pruning fractions based on different numbers of iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            92,
+            818,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            825,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also find that ANP with 2000 iterations should prune more $( + 1 \\% )$ neurons to degrade ASR than ones with fewer iterations. We conjecture this is because there also exist some sensitive neurons that are unrelated to the injected backdoor9, which are assigned with small masks at the late optimization stage. Besides, for ACC, we can see that more iterations maintain a higher ACC than fewer iterations, especially when more neurons are pruned, as the left neurons are almost the discriminant and robust ones. In conclusion, even with extremely small number of iterations (e.g., 20 iterations), ANP is able to distinguish the backdoor-related neurons from other neurons and obtains satisfactory robustness against backdoor attacks. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            532
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            299,
+            578
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we identified a sensitivity of backdoored DNNs to adversarial neuron perturbations, which induces them to present backdoor behaviours even without the presence of the trigger patterns. Based on these findings, we proposed Adversarial Neuron Pruning (ANP) to prune the sensitive neurons under adversarial neuron perturbations. Comprehensive experiments show that ANP consistently removes the injected backdoor and provides the highest robustness against several state-of-the-art backdoor attacks even with a limited amount of clean data and computation resources. Finally, our work also reminds researchers that pruning (without fine-tuning) is still a promising defense against backdoor attacks. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            310,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The backdoor attack has become a threat to outsourcing training and open-sourcing models. We propose ANP to improve the robustness against these backdoor attacks, which may help to build a more secure model even trained in an untrustworthy third-party platform. Further, we do not want this paper to bring overoptimism about AI safety to the society. Since the backdoor attack is only a part of potential risks ( e.g., adversarial attacks, privacy leakage, and model extraction), there is still a long way towards secure AI and trustworthy AI. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            328,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yisen Wang is partially supported by the National Natural Science Foundation of China under Grant 62006153, and Project 2020BD006 supported by PKU-Baidu Fund. ",
+        "bbox": [
+            174,
+            121,
+            823,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            169,
+            266,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Mauro Barni, Kassem Kallas, and Benedetta Tondi. A new backdoor attack in cnns by training set corruption without label poisoning. In ICIP, 2019.   \n[2] Battista Biggio, Blaine Nelson, and Pavel Laskov. Support vector machines under adversarial label noise. In ACML, 2011.   \n[3] Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, ´ Giorgio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In ECML/PKDD, 2013.   \n[4] Eitan Borgnia, Valeriia Cherepanova, Liam Fowl, Amin Ghiasi, Jonas Geiping, Micah Goldblum, Tom Goldstein, and Arjun Gupta. Strong data augmentation sanitizes poisoning and backdoor attacks without an accuracy tradeoff. In ICASSP, 2021.   \n[5] Huili Chen, Cheng Fu, Jishen Zhao, and Farinaz Koushanfar. Deepinspect: A black-box trojan detection and mitigation framework for deep neural networks. In IJCAI, 2019.   \n[6] Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017.   \n[7] Xinyun Chen, Wenxiao Wang, Chris Bender, Yiming Ding, Ruoxi Jia, Bo Li, and Dawn Song. Refit: a unified watermark removal framework for deep learning systems with limited data. arXiv preprint arXiv:1911.07205, 2019.   \n[8] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Jacob Steinhardt, and Alistair Stewart. Sever: A robust meta-algorithm for stochastic optimization. In ICML, 2019.   \n[9] Chao Gao, Yuan Yao, and Weizhi Zhu. Generative adversarial nets for robust scatter estimation: A proper scoring rule perspective. Journal of Machine Learning Research, 21(160):1–48, 2020.   \n[10] Yansong Gao, Change Xu, Derui Wang, Shiping Chen, Damith C Ranasinghe, and Surya Nepal. Strip: A defence against trojan attacks on deep neural networks. In ACSAC, 2019.   \n[11] Amirata Ghorbani and James Zou. Neuron shapley: Discovering the responsible neurons. In NeurIPS, 2021.   \n[12] Micah Goldblum, Dimitris Tsipras, Chulin Xie, Xinyun Chen, Avi Schwarzschild, Dawn Song, Aleksander Madry, Bo Li, and Tom Goldstein. Data security for machine learning: Data poisoning, backdoor attacks, and defenses. arXiv preprint arXiv:2012.10544, 2020.   \n[13] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.   \n[14] Tianyu Gu, Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Badnets: Evaluating backdooring attacks on deep neural networks. IEEE Access, 7:47230–47244, 2019.   \n[15] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[16] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   \n[17] Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In ICML, 2017.   \n[18] Pang Wei Koh, Jacob Steinhardt, and Percy Liang. Stronger data poisoning attacks break data sanitization defenses. arXiv preprint arXiv:1811.00741, 2018.   \n[19] Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical Report, University of Toronto, 2009.   \n[20] Alexander Levine and Soheil Feizi. Deep partition aggregation: Provable defense against general poisoning attacks. arXiv preprint arXiv:2006.14768, 2020.   \n[21] Alexander Levine and Soheil Feizi. Deep partition aggregation: Provable defense against general poisoning attacks. In ICLR, 2021.   \n[22] Yige Li, Nodens Koren, Lingjuan Lyu, Xixiang Lyu, Bo Li, and Xingjun Ma. Neural attention distillation: Erasing backdoor triggers from deep neural networks. In ICLR, 2021.   \n[23] Yige Li, Xixiang Lyu, Nodens Koren, Lingjuan Lyu, Bo Li, and Xingjun Ma. Anti-backdoor learning: Training clean models on poisoned data. In NeurIPS, 2021.   \n[24] Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Fine-pruning: Defending against backdooring attacks on deep neural networks. In RAID, 2018.   \n[25] Yingqi Liu, Shiqing Ma, Yousra Aafer, Wen-Chuan Lee, Juan Zhai, Weihang Wang, and Xiangyu Zhang. Trojaning attack on neural networks. In NDSS, 2018.   \n[26] Yunfei Liu, Xingjun Ma, James Bailey, and Feng Lu. Reflection backdoor: A natural backdoor attack on deep neural networks. In ECCV, 2020.   \n[27] Yuntao Liu, Yang Xie, and Ankur Srivastava. Neural trojans. In ICCD, 2017.   \n[28] Shiqing Ma and Yingqi Liu. Nic: Detecting adversarial samples with neural network invariant checking. In NDSS, 2019.   \n[29] Yuzhe Ma, Xiaojin Zhu Zhu, and Justin Hsu. Data poisoning against differentially-private learners: Attacks and defenses. In IJCAI, 2019.   \n[30] Anh Nguyen and Anh Tran. Input-aware dynamic backdoor attack. In NeurIPS, 2020.   \n[31] Anh Nguyen and Anh Tran. Wanet–imperceptible warping-based backdoor attack. In ICLR, 2021.   \n[32] Ren Pang, Hua Shen, Xinyang Zhang, Shouling Ji, Yevgeniy Vorobeychik, Xiapu Luo, Alex Liu, and Ting Wang. A tale of evil twins: Adversarial inputs versus poisoned models. In CCS, 2020.   \n[33] Ximing Qiao, Yukun Yang, and Hai Li. Defending neural backdoors via generative distribution modeling. In NeurIPS, 2019.   \n[34] Elan Rosenfeld, Ezra Winston, Pradeep Ravikumar, and Zico Kolter. Certified robustness to label-flipping attacks via randomized smoothing. In ICML, 2020.   \n[35] Ali Shafahi, W Ronny Huang, Mahyar Najibi, Octavian Suciu, Christoph Studer, Tudor Dumitras, and Tom Goldstein. Poison frogs! targeted clean-label poisoning attacks on neural networks. In NeurIPS, 2018.   \n[36] David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.   \n[37] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[38] Jacob Steinhardt, Pang Wei Koh, and Percy Liang. Certified defenses for data poisoning attacks. In NeurIPS, 2017.   \n[39] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.   \n[40] Lue Tao, Lei Feng, Jinfeng Yi, Sheng-Jun Huang, and Songcan Chen. Better safe than sorry: Preventing delusive adversaries with adversarial training. In NeurIPS, 2021.   \n[41] Brandon Tran, Jerry Li, and Aleksander Madry. Spectral signatures in backdoor attacks. In NeurIPS, 2018.   \n[42] Alexander Turner, Dimitris Tsipras, and Aleksander Madry. Label-consistent backdoor attacks. arXiv preprint arXiv:1912.02771, 2019.   \n[43] Bolun Wang, Yuanshun Yao, Shawn Shan, Huiying Li, Bimal Viswanath, Haitao Zheng, and Ben Y Zhao. Neural cleanse: Identifying and mitigating backdoor attacks in neural networks. In S&P, 2019.   \n[44] Ren Wang, Gaoyuan Zhang, Sijia Liu, Pin-Yu Chen, Jinjun Xiong, and Meng Wang. Practical detection of trojan neural networks: Data-limited and data-free cases. In ECCV, 2020.   \n[45] Yisen Wang, Xuejiao Deng, Songbai Pu, and Zhiheng Huang. Residual convolutional ctc networks for automatic speech recognition. arXiv preprint arXiv:1702.07793, 2017.   \n[46] Maurice Weber, Xiaojun Xu, Bojan Karlas, Ce Zhang, and Bo Li. Rab: Provable robustness against backdoor attacks. arXiv preprint arXiv:2003.08904, 2020.   \n[47] Dongxian Wu, Shu-Tao Xia, and Yisen Wang. Adversarial weight perturbation helps robust generalization. In NeurIPS, 2020.   \n[48] Pu Zhao, Pin-Yu Chen, Payel Das, Karthikeyan Natesan Ramamurthy, and Xue Lin. Bridging mode connectivity in loss landscapes and adversarial robustness. In ICLR, 2019.   \n[49] Haoti Zhong, Cong Liao, Anna Cinzia Squicciarini, Sencun Zhu, and David Miller. Backdoor embedding in convolutional neural network models via invisible perturbation. In CODASPY, 2020.   \n[50] Liuwan Zhu, Rui Ning, Cong Wang, Chunsheng Xin, and Hongyi Wu. Gangsweep: Sweep out neural backdoors by gan. In MM, 2020. ",
+        "bbox": [
+            174,
+            195,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            49,
+            830,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            525
+        ],
+        "page_idx": 12
+    }
+]

parse/train/B1p461b0W/B1p461b0W.md

@@ -0,0 +1,216 @@
+# DEEP LEARNING IS ROBUST TOMASSIVE LABEL NOISE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep neural networks trained on large supervised datasets have led to impressive results in recent years. However, since well-annotated datasets can be prohibitively expensive and time-consuming to collect, recent work has explored the use of larger but noisy datasets that can be more easily obtained. In this paper, we investigate the behavior of deep neural networks on training sets with massively noisy labels. We show on multiple datasets such as MINST, CIFAR-10 and ImageNet that successful learning is possible even with an essentially arbitrary amount of noise. For example, on MNIST we find that accuracy of above 90 percent is still attainable even when the dataset has been diluted with 100 noisy examples for each clean example. Such behavior holds across multiple patterns of label noise, even when noisy labels are biased towards confusing classes. Further, we show how the required dataset size for successful training increases with higher label noise. Finally, we present simple actionable techniques for improving learning in the regime of high label noise.
+
+# 1 INTRODUCTION
+
+Deep learning has proven to be powerful for a wide range of problems, from image classification to machine translation. Typically, deep neural networks are trained using supervised learning on large, carefully annotated datasets. However, the need for such datasets restricts the space of problems that can be addressed. This has led to a proliferation of deep learning results on the same tasks using the same well-known datasets. Carefully annotated data is difficult to obtain, especially for classification tasks with large numbers of classes (requiring extensive annotation) or with fine-grained classes (requiring skilled annotation). Thus, annotation can be expensive and, for tasks requiring expert knowledge, may simply be unattainable at scale.
+
+To address this limitation, other training paradigms have been investigated to alleviate the need for expensive annotations, such as unsupervised learning (Le, 2013), self-supervised learning (Pinto et al., 2016; Wang & Gupta, 2015) and learning from noisy annotations (Joulin et al., 2016; Natarajan et al., 2013; Veit et al., 2017). Very large datasets (e.g., Krasin et al. (2016); Thomee et al. (2016)) can often be attained, for example from web sources, with partial or unreliable annotation. This can allow neural networks to be trained on a much wider variety of tasks or classes and with less manual effort. The good performance obtained from these large noisy datasets indicates that deep learning approaches can tolerate modest amounts of noise in the training set.
+
+In this work, we take this trend to an extreme, and consider the performance of deep neural networks under extremely low label reliability, only slightly above chance. We envision a future in which arbitrarily large amounts of data will easily be obtained, but in which labels come without any guarantee of validity and may merely be biased towards the correct distribution.
+
+The key takeaways from this paper may be summarized as follows:
+
+• Deep neural networks are able to learn from data that has been diluted by an arbitrary amount of noise. We demonstrate that standard deep neural networks still perform well even on training sets in which label accuracy is as low as 1 percent above chance. On MNIST, for example, performance still exceeds 90 percent even with this level of label noise (see Figure 1). This behavior holds, to varying extents, across datasets as well as patterns of label noise, including when noisy labels are biased towards confused classes.
+
+• A sufficiently large training set can accommodate a wide range of noise levels. We find that the minimum dataset size required for effective training increases with the noise level. A large enough training set can accommodate a wide range of noise levels. Increasing the dataset size further, however, does not appreciably increase accuracy.
+
+• Adjusting batch size and learning rate can allow conventional neural networks to operate in the regime of very high label noise. We find that label noise reduces the effective batch size, as noisy labels roughly cancel out and only a small learning signal remains. We show that dataset noise can be partly compensated for by larger batch sizes and by scaling the learning rate with the effective batch size.
+
+# 2 RELATED WORK
+
+Learning from noisy data. Several studies have investigated the impact of noisy datasets on machine classifiers. Approaches to learn from noisy data can generally be categorized into two groups: In the first group, approaches aim to learn directly from noisy labels and focus on noise-robust algorithms, e.g., Beigman & Klebanov (2009); Guan et al. (2017); Joulin et al. (2016); Krause et al. (2016); Manwani & Sastry (2013); Misra et al. (2016); Van Horn et al. (2015). The second group comprises mostly label-cleansing methods that aim to remove or correct mislabeled data, e.g., Brodley & Friedl (1999). Methods in this group frequently face the challenge of disambiguating between mislabeled and hard training examples. To address this challenge, they often use semi-supervised approaches by combining noisy data with a small set of clean labels (Zhu, 2005). Some approaches model the label noise as conditionally independent from the input image (Natarajan et al., 2013; Sukhbaatar et al., 2014) and some propose image-conditional noise models (Veit et al., 2017; Xiao et al., 2015). Our work differs from these approaches in that we do not aim to clean the training dataset or propose new noise-robust training algorithms. Instead, we study the behavior of standard neural network training procedures in settings with massive label noise. We show that even without explicit cleaning or noise-robust algorithms, neural networks can learn from data that has been diluted by an arbitrary amount of label noise.
+
+Analyzing the robustness of neural networks. Several investigative studies aim to improve our understanding of convolutional neural networks. One particular stream of research in this space seeks to investigate neural networks by analyzing their robustness. For example, Veit et al. (2016) show that network architectures with residual connections have a high redundancy in terms of parameters and are robust to the deletion of multiple complete layers during test time. Further, Szegedy et al. (2014) investigate the robustness of neural networks to adversarial examples. They show that even for fully trained networks, small changes in the input can lead to large changes in the output and thus misclassification. In contrast, we are focusing on non-adversarial noise during training time. Within this stream of research, closest to our work are studies that focus on the impact of noisy training datasets on classification performance (e.g., Sukhbaatar et al. (2014); Van Horn et al. (2015); Zhang et al. (2017)). In these studies an increase in noise is assumed to decrease not only the proportion of correct examples, but also their absolute number. In contrast to these studies, we separate the effects and show in $\ S 4$ that a decrease in the number of correct examples is more destructive to learning than an increase in the number of noisy labels.
+
+# 3 LEARNING WITH MASSIVE LABEL NOISE
+
+In this work, we are concerned with scenarios of abundant data of very poor label quality, i.e., the regime in which falsely labeled training examples vastly outnumber correctly labeled examples. In particular, our experiments involve observing the performance of deep neural networks on multiclass classification tasks as label noise is increased.
+
+To formalize the problem, we denote the number of original training examples by $n$ . To model the amount of noise, we dilute the dataset by adding $\alpha$ noisy examples to the training set for each original training example. Thus, the total number of noisy labels in the training set is αn. Note that by varying the noise level $\alpha$ , we do not change the available number of original examples. Thus, even in the presence of high noise, there is still appreciable data to learn from, if we are able to pick it out. This is in contrast to previous work (e.g., Sukhbaatar et al. (2014); Van Horn et al. (2015); Zhang et al. (2017)), in which an increase in noise also implies a decrease in the absolute number of correct examples. In the following experiments we investigate three different types of noise: uniform label-swapping, structured label-swapping, and out-of-vocabulary examples.
+
+![](images/f9c133111a2234ff5fd59247babd2c15f1298502c70a3f8cfbe2d33f50745d89.jpg)
+
+![](images/78e2b59393d4882edaaed93c66ab902845a045efd4a4cb2301e175d57533b2b3.jpg)  
+Figure 1: Performance on Figure 2: Performance on MNIST as different amounts of CIFAR-10 as different amounts noisy labels are added to a fixed of noisy labels are added to a training set of clean labels. We fixed training set of clean lacompare a perceptron, MLPs bels. We tested ConvNets with with 1, 2, and 4 hidden layers, 4 and 6 layers, and a ResNet and a 4-layer ConvNet. Even with 101 layers. Even with 10 with 100 noisy labels for every noisy labels for every clean laclean label the ConvNet still at- bel the ResNet still attains a pertains a performance of $91 \%$ . formance of $85 \%$ .
+
+![](images/9dd4bc5738563f214ee2d67f43b7bac997d30529a5f2edbe58cc0bbdca6ce3f7.jpg)  
+Figure 3: Performance on ImageNet as different amounts of noisy labels are added to a fixed training set of clean labels. Even with 5 noisy labels for every clean label, the 18- layer ResNet still attains a performance of $70 \%$ .
+
+A key assumption in this paper is that unreliable labels are better modeled by an unknown stochastic process rather than by the output of an adversary. This is a natural assumption for data that is pulled from the environment, in which antagonism is not to be expected in the noisy annotation process. Deep neural networks have been shown to be exceedingly brittle to adversarial noise patterns (Szegedy et al., 2014). In this work, we demonstrate that even massive amounts of non-adversarial noise present far less of an impediment to learning.
+
+# 3.1 EXPERIMENT 1: TRAINING WITH UNIFORM LABEL NOISE
+
+As a first experiment, we will show that common training procedures for neural networks are resilient even to settings where correct labels are outnumbered by labels sampled uniformly at random at a ratio of 100 to 1. For this experiment we focus on the task of image classification and work with three commonly used datasets, MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and ImageNet (Deng et al., 2009).
+
+In Figures 1 and 2 we show the classification performance with varying levels of label noise. For MNIST, we vary the ratio $\alpha$ of randomly labeled examples to cleanly labeled examples from 0 (no noise) to 100 (only 11 out of 101 labels are correct, as compared with 10.1 for pure chance). For the more challenging dataset CIFAR-10, we vary $\alpha$ from 0 to 10. For the most challenging dataset ImageNet, we let $\alpha$ range from 0 to 5. We compare various architectures of neural networks: multilayer perceptrons with different numbers of hidden layers, convolutional networks (ConvNets) with different numbers of convolutional layers, and residual networks (ResNets) with different numbers of layers (He et al., 2016). We evaluate performance after training on a test dataset that is free from noisy labels. Full details of our experimental setup are provided in $\ S 3 . 4$ .
+
+Our results show that, remarkably, it is possible to attain over 90 percent accuracy on MNIST, even when there are 100 randomly labeled images for every cleanly labeled example, to attain over 85 percent accuracy on CIFAR-10 with 10 random labels for every clean label, and to attain over 70 percent top-5 accuracy on ImageNet with 5 random labels for every clean label. Thus, in this highnoise regime, deep networks are able not merely to perform above chance, but to attain accuracies that would be respectable even without noise.
+
+Further, we observe from Figures 1 and 2 that larger neural network architectures tend also to be more robust to label noise. On MNIST, the performance of a perceptron decays rapidly with increasing noise (though it still attains 40 percent accuracy, well above chance, at $\alpha = 1 0 0$ ). The performance of a multilayer perceptron drops off more slowly, and the ConvNet is even more robust. Likewise, for CIFAR-10, the accuracy of the residual network drops more slowly than that of the smaller ConvNets. This observation provides further support for the effectiveness of ConvNets and ResNets in particular for applications where noise tolerance may be important.
+
+![](images/a40a9a284ee6fd7dda9b80e4d4f3fca2f337a8782ed7c386d90983f93f7e6a09.jpg)  
+Figure 4: Illustration of uniform and structured noise models. In the case of structured noise, the order of false labels is important; we tested decreasing order of confusion, increasing order of confusion, and random order. The parameter $\delta$ parameterizes the degree of structure in the noise. It defines how much more likely the second most likely class is over chance.
+
+# 3.2 EXPERIMENT 2: TRAINING WITH STRUCTURED LABEL NOISE
+
+We have seen that neural networks are extremely robust to uniform label noise. However, label noise in datasets gathered from a natural environment is unlikely to follow a perfectly uniform distribution. In this experiment, we investigate the effects of various forms of structured noise on the performance of neural networks. Figure 4 illustrates the procedure used to model noise structure.
+
+In the uniform noise setting, as illustrated on the left side of Figure 4, correct labels are more likely than any individual false label. However, overall false labels vastly outnumber correct labels. We denote the likelihood over chance for a label to be correct as $\epsilon$ . Note that $\epsilon = 1 / ( 1 + \alpha )$ , where $\alpha$ is the ratio of noisy labels to certainly correct labels. To induce structure in the noise, we bias noisy labels to certain classes. We introduce the parameter $\delta$ to parameterize the degree of structure in the noise. It defines how much more likely the second most likely class is over chance. With $\delta = 0$ the noise is uniform, whereas for $\delta = 1$ the second most likely class is equally likely as the correct class. The likelihood for the remaining classes is scaled linearly, as illustrated in Figure 4 on the right. We investigate three different setups for structured noise: labels biased towards easily confused classes, towards hardly confused classes and towards random classes.
+
+Figure 5 shows the results on MNIST for the three different types of structured noise, as $\delta$ varies from 0 to 1. In this experiment, we train 4-layer ConvNets on a dataset that is diluted with 20 noisy labels for each clean label. We vary the order of false labels so that, besides the correct class, labels are assigned most frequently to (1) those most often confused with the correct class, (2) those least often confused with it, and (3) in a random order. We determine commonly confused labels by training the network repeatedly on a small subset of MNIST and observing the errors it makes on a test set.
+
+The results show that deep neural nets are robust even to structured noise, as long as the correct label remains the most likely by at least a small margin. Generally, we do not observe large differences between the different models of noise structure, only that bias towards random classes seems to hurt the performance a little more than bias towards confused classes. This result might help explain why we often observe quite good results from real world noisy datasets, where label noise is more likely to be biased towards related and confusing classes.
+
+# 3.3 EXPERIMENT 3: SOURCE OF NOISY LABELS
+
+In the preceding experiments, we diluted the training sets with noisy examples drawn from the same dataset; i.e., falsely labeled examples were images from within other categories of the dataset. In natural scenarios, however, noisy examples likely also include categories not included in the dataset that have erroneously been assigned labels within the dataset.
+
+![](images/39e1b367b8f1cfe0c62387b7a9f5848b19b58283aacd07d334c5f26174a4d483.jpg)  
+Figure 5: Performance on MNIST with fixed $\alpha = 2 0$ noisy labels per clean label. Noise is drawn from three types of structured distribution: (1) “confusing order” (highest probability for the most confusing label), (2) “reverse confusing order”, and (3) random order. We interpolate between uniform noise, $\delta = 0$ , and noise so highly skewed that the most common false label is as likely as the correct label, $\delta \ = \ 1$ Except for $\delta \approx 1$ , performance is similar to uniform noise.   
+Figure 6: Performance on CIFAR-10 for varying amounts of noisy labels. Noisy training examples are drawn from (1) CIFAR-10 itself, but mislabeled uniformly at random, (2) CIFAR100, with uniformly random labels, and (3) white noise with mean and variance chosen to match those of CIFAR-10. Noise drawn from CIFAR-100 resulted in only half the drop in performance observed with noise from CIFAR-10 itself, while white noise examples did not appreciable affect performance.
+
+Thus, we now consider two alternative sources for noisy training examples. First, we dilute the training set with examples that are drawn from a similar but different dataset. In particular, we use CIFAR-10 as our training dataset and dilute it with examples from CIFAR-100, assigning each image a category from CIFAR-10 at random. Second, we also consider a dilution of the training set with “examples” that are simply white noise; in this case, we match the mean and variance of pixels within CIFAR-10 and again assign labels uniformly at random.
+
+Figure 6 shows the results obtained by a six-layer ConvNet on the different noise sources for varying levels of noise. We observe that both alternative sources of noise lead to better performance than the noise originating from the same dataset. For noisy examples drawn from CIFAR-100, performance drops only about half as much as when noise originates from CIFAR-10 itself. This trend is consistent across noise levels. For white noise, performance does not drop regardless of noise level; this is in line with prior work that has shown that neural networks are able to fit random input (Zhang et al., 2017). This indicates the scenarios considered in Experiments 1 and 2 represent in some sense a worst case.
+
+In natural scenarios, we may expect massively noisy datasets to fall somewhere in between the cases exemplified by CIFAR-10 and CIFAR-100. That is, some examples will be relevant but mislabeled. However, it is likely that many examples will not be from any classes under consideration and therefore will influence training less negatively. In fact, it is possible that such examples might increase accuracy, if the erroneous labels reflect underlying similarity between the examples in question.
+
+# 3.4 EXPERIMENTAL SETUP
+
+All models are trained with AdaDelta (Zeiler, 2012) as optimizer and a batch size of 128. For each level of label noise we train separate models with different learning rates ranging from 0.01 to 1 and pick the learning rate that results in the best performance. Generally, we observe that the higher the label noise, the lower the optimal learning rate. We investigate this trend in detail in §5.
+
+![](images/c21857a56a07b66737e2dc89fac883ddfa7637fbd412b8852778adb42a2d2904.jpg)  
+Figure 7: Comparison of the effect of reusing images vs. using novel images as noisy examples. Essentially no difference is observed between the two types of noisy examples, supporting the use of repeated examples in our experiments.
+
+![](images/188024bc06883009c65ceb60641d43e949b8968342b6ec41f0de7af7dee4a316.jpg)  
+Figure 8: Performance on MNIST at various noise levels, as a function of the number of clean labels. There seems to be a critical amount of clean training data required to successfully train the networks. This threshold increases as the noise level rises. For example, at $\alpha = 1 0$ , 2,000 clean labels are needed to attain $90 \%$ performance, while at $\alpha = 5 0$ , 10,000 clean labels are needed.
+
+In Experiments 1 and 2, noisy labels are drawn from the same dataset as the labels guaranteed to be correct. This involves drawing the same example many times from the dataset, giving it the correct label once, and in every other instance picking a random label according to the noise distribution in question. We show in Figure 7 that performance would have been comparable had we been able to draw noisy labels from an extended dataset, instead of repeating images. Specifically, we train a convolutional network on a subset of MNIST, with 2,500 certainly correct labels and with noisy labels drawn either with repetition from this set of 2,500 or without repetition from the remaining examples in the MNIST dataset. The results are essentially identical between repeated and unique examples, supporting our setup in the preceding experiments.
+
+# 4 THE IMPORTANCE OF LARGER DATASETS
+
+Underlying the ability of deep networks to learn from massively noisy data is the size of the data in question. It is well-established, see e.g., Deng et al. (2009), that traditional deep learning relies upon large datasets. We will now see how this is particularly true of noisy datasets.
+
+In Figure 8, we compare the performance of a ConvNet on MNIST as the size of the training set varies. We also show the performance of the same ConvNet trained on MNIST diluted with noisy labels sampled uniformly. We show how the performance of the ConvNet varies with the number of cleanly labeled training examples. For example, for the blue curve of $\alpha = 1 0$ and 1,000 clean labels, the network is trained on 11,000 examples: 1,000 cleanly labeled examples and 10,000 with random labels.
+
+Generally, we observe that independent of the noise level the networks benefit from more data and that, given sufficient data, the networks reach similar results. Further, the results indicate that there seems to be a critical amount of clean training data that is required to successfully train the networks. This critical amount of clean data depends on the noise level; in particular, it increases as the noise level rises. Since performance rapidly levels off past the critical threshold the main requirement for the clean training set is to be of sufficient size.
+
+It is because of the critical amount of required clean data that we have not attempted to train networks for $\alpha \gg 1 0 0$ . The number of correct examples needed to train such a network might rise above the 60,000 provided in the MNIST dataset. In a real-world dataset, the amount of (noisy) data available for training is likely not to be the limiting factor. Rather, considerations such as training time and learning rate may play a more important role, as we discuss in the following section.
+
+![](images/a1590b2c0e7c28dcefe6239ed9d9264e2b853c999e75f71c9ce77e8aabbae055.jpg)  
+Figure 9: Performance on MNIST for varying batch size as a function of noise level. Higher batch size gives better performance. We approximate the limit of infinite batch size by training without noisy labels, but using the noisy loss function $H _ { \alpha }$ .
+
+![](images/75e753a6581173fda8d01a6a18351eca675a2a2366feea4d91de9c2fc98173fe.jpg)  
+Figure 10: Performance on CIFAR-10 for varying learning rate as a function of noise level. Lower learning rates are generally optimal as the noise level increases.
+
+# 5 TRAINING ON NOISY DATASETS
+
+In the preceding sections, our results were obtained by training neural networks with fixed batch size and running a parameter search to pick the optimal learning rate. We now look in more detail into how the choice of hyperparameters affects learning on noisy datasets.
+
+# 5.1 BATCH SIZE
+
+First, we investigate the effect of the batch size on the noise robustness of neural network training. In Figure 9, we compare the performance of a simple 2-layer ConvNet on MNIST with increasing noise, as batch size varies from 32 to 256. We observe that increasing the batch size provides greater robustness to noisy labels. One reason for this behavior could be that, within a batch, gradient updates from randomly sampled noisy labels cancel out, while gradients from correct examples that are marginally more frequent sum together and contribute to learning. By this logic, large batch sizes would be more robust to noise since the mean gradient over a larger batch is closer to the gradient for correct labels. All other experiments in this paper are performed with a fixed batch size of 128.
+
+We may also consider the theoretical case of infinite batch size, in which gradients are averaged over the entire space of possible inputs at each training step. While this is often impossible to perform in practice, we can simulate such behavior by an auxiliary loss function.
+
+In classification tasks, we are given an input $\mathbf { x }$ and aim to predict the class $f ( \mathbf { x } ) \in \{ 1 , 2 , \dots , m \}$ . The value $f ( \mathbf { x } )$ is encoded within a neural network by the 1-hot vector $\mathbf { y } ( \mathbf { x } )$ such that
+
+$$
+y _ { k } ( \mathbf x ) = { \left\{ \begin{array} { l l } { 1 } & { { \mathrm { ~ i f ~ } } k = f ( \mathbf x ) } \\ { 0 } & { { \mathrm { ~ o t h e r w i s e ~ } } } \end{array} \right. }
+$$
+
+for $1 \leq k \leq m$ . Then, the standard cross-entropy loss over a batch $X$ is given by:
+
+$$
+H ( X ) = - \langle \log \hat { y } _ { f ( \mathbf { x } ) } \rangle _ { X } ,
+$$
+
+where $\hat { \mathbf { y } }$ is the predicted vector and $\langle \cdot \rangle _ { X }$ denotes the expected value over the batch $X$ . We assume that $\hat { \mathbf { y } }$ is normalized (e.g. by the softmax function) so that the entries sum to 1.
+
+For a training set with noisy labels, we may consider the label $f ( \mathbf { x } )$ given in the training set to be merely an approximation to the true label $f _ { 0 } ( x )$ . Consider the case of $n$ training examples, and $\alpha n$ noisy labels that are sampled uniformly at random from the set $\{ 1 , 2 , \ldots , m \}$ . Then, $f ( \mathbf { x } ) = f _ { 0 } ( \mathbf { x } )$ with probability $\frac { 1 } { 1 + \alpha }$ , and otherwise it is $1 , 2 , \ldots , m$ , each with probability $\frac { \alpha } { m ( 1 + \alpha ) }$ . As batch size increases, the expected value over the batch $X$ is approximated more closely by these probabilities. In the limit of infinite batch size, equation (2) takes the form of a noisy loss function $H _ { \alpha }$ :
+
+$$
+\begin{array} { l } { { \displaystyle { \cal H } _ { \alpha } ( X ) : = - \frac { 1 } { 1 + \alpha } \langle \log \hat { y } _ { f _ { 0 } ( { \bf x } ) } \rangle _ { X } - \frac { \alpha } { m ( 1 + \alpha ) } \sum _ { k = 1 } ^ { m } \langle \log \hat { y } _ { k } \rangle _ { X } } } \\ { { \displaystyle \propto - \langle \log \hat { y } _ { f _ { 0 } ( { \bf x } ) } \rangle _ { X } - \alpha \left. \log \prod _ { k = 1 } ^ { m } \hat { y } _ { k } ^ { 1 / m } \right. _ { X } } } \end{array}
+$$
+
+We can therefore compare training using the cross-entropy loss with $\alpha n$ noisy labels to training using the noisy loss function $H _ { \alpha }$ without noisy labels. The term on the right-hand side of (3) represents the noise contribution, and is clearly minimized where $\hat { y } _ { k }$ are all equal. As $\alpha$ increases, this contribution is weighted more heavily against $- \left. \log \hat { y } _ { f _ { 0 } ( \mathbf { x } ) } \right. _ { X }$ , which is minimized at $\hat { \mathbf { y } } ( \mathbf x ) = \mathbf { y } ( \mathbf x )$ .
+
+We show in Figure 9 the results of training our 2-layer ConvNet on MNIST with the noisy loss function $H _ { \alpha }$ , simulating $\alpha n$ noisy labels with infinite batch size. We can observe that the network’s accuracy does not decrease as $\alpha$ increases. This can be explained by the observation that an increasing $\alpha$ is merely decreasing the magnitude of the true gradient, rather than altering its direction.
+
+Our observations indicate that increasing noise in the training set reduces the effective batch size, as noisy signals roughly cancel out and only small learning signal remains. We show that increasing the batch size is a simple practical means to mitigate the effect of noisy training labels.
+
+# 5.2 LEARNING RATE
+
+It has become common practice in training deep neural networks to scale the learning rate with the batch size. In particular, it has been shown that the smaller the batch size, the lower the optimal learning rate (Krizhevsky, 2014). In our experiments, we have observed that noisy labels reduce the effective batch size. As such, we would expect that lower learning rates perform better than large learning rates as noise increases. Figure 10 shows the performance of a 4-layer ConvNet trained with different learning rates on CIFAR-10 for varying label noise. As expected, we observe that the optimal learning rate decreases as noise increases. For example, the optimal learning rate for the clean dataset is 1, while, with the introduction of noise, this learning rate becomes unstable.
+
+To sum up, we observe that increasing label noise reduces the effective batch size. We have shown that the effect of label noise can be partly counterbalanced for by a larger training batch size. Now, we see that one can additionally scale the learning rate to compensate for any remaining change in effective batch size induced by noisy labels.
+
+# 6 CONCLUSION
+
+In this paper, we have considered the behavior of deep neural networks on training sets with very noisy labels. In a series of experiments, we have demonstrated that learning is robust to an essentially arbitrary amount of label noise, provided that the number of clean labels is sufficiently large. We have further shown that the threshold required for clean labels increases as the noise level does. Finally, we have observed that noisy labels reduce the effective batch size, an effect that can be mitigated by larger batch sizes and downscaling the learning rate.
+
+It is worthy of note that although deep networks appear robust to even high degrees of label noise, clean labels still always perform better than noisy labels, given the same quantity of training data. Further, one still requires expert-vetted test sets for evaluation. Lastly, it is important to reiterate that our studies focus on non-adversarial noise.
+
+Our work suggests numerous directions for future investigation. For example, we are interested in how label-cleaning and semi-supervised methods affect the performance of networks in a high-noise regime. Are such approaches able to lower the threshold for training set size? Finally, it remains to translate the results we present into an actionable trade-off between data annotation and acquisition costs, which can be utilized in real world training pipelines for deep networks on massive noisy data.
+
+# REFERENCES
+
+Eyal Beigman and Beata Beigman Klebanov. Learning with annotation noise. In Proceedings of the Joint Conference of the 47th Annual Meeting of the ACL and the 4th International Joint Conference on Natural Language Processing of the AFNLP. Association for Computational Linguistics, 2009.
+
+Carla E Brodley and Mark A Friedl. Identifying mislabeled training data. Journal of artificial intelligence research (JAIR), 11:131–167, 1999.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, (CVPR), 2009.
+
+Melody Y Guan, Varun Gulshan, Andrew M Dai, and Geoffrey E Hinton. Who said what: Modeling individual labelers improves classification. arXiv:1703.08774, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, (CVPR), 2016.
+
+Armand Joulin, Laurens van der Maaten, Allan Jabri, and Nicolas Vasilache. Learning visual features from large weakly supervised data. In European Conference on Computer Vision, (ECCV). Springer, 2016.
+
+I Krasin, T Duerig, N Alldrin, A Veit, S Abu-El-Haija, S Belongie, D Cai, Z Feng, V Ferrari, V Gomes, et al. Openimages: A public dataset for large-scale multi-label and multiclass image classification. Dataset available from https://github. com/openimages, 2(6):7, 2016.
+
+Jonathan Krause, Benjamin Sapp, Andrew Howard, Howard Zhou, Alexander Toshev, Tom Duerig, James Philbin, and Li Fei-Fei. The unreasonable effectiveness of noisy data for fine-grained recognition. In European Conference on Computer Vision, (ECCV). Springer, 2016.
+
+Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv preprint arXiv:1404.5997, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images, 2009.
+
+Quoc V Le. Building high-level features using large scale unsupervised learning. In International Conference on Acoustics, Speech and Signal Processing, (ICASSP). IEEE, 2013.
+
+Yann LeCun, Corinna Cortes, and Christopher JC Burges. The MNIST database of handwritten digits, 1998.
+
+Naresh Manwani and PS Sastry. Noise tolerance under risk minimization. IEEE Transactions on cybernetics, 43(3):1146–1151, 2013.
+
+Ishan Misra, C Lawrence Zitnick, Margaret Mitchell, and Ross Girshick. Seeing through the human reporting bias: Visual classifiers from noisy human-centric labels. In Computer Vision and Pattern Recognition, (CVPR), 2016.
+
+Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with noisy labels. In Advances in neural information processing systems, (NIPS), 2013.
+
+Lerrel Pinto, Dhiraj Gandhi, Yuanfeng Han, Yong-Lae Park, and Abhinav Gupta. The curious robot: Learning visual representations via physical interactions. In European Conference on Computer Vision, (ECCV). Springer, 2016.
+
+Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. arXiv preprint arXiv:1406.2080, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, (ICLR), 2014.
+
+Bart Thomee, David A Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland, Damian Borth, and Li-Jia Li. YFCC100M: The new data in multimedia research. Communications of the ACM, 59(2):64–73, 2016.
+
+Grant Van Horn, Steve Branson, Ryan Farrell, Scott Haber, Jessie Barry, Panos Ipeirotis, Pietro Perona, and Serge Belongie. Building a bird recognition app and large scale dataset with citizen scientists: The fine print in fine-grained dataset collection. In Computer Vision and Pattern Recognition, (CVPR), 2015.
+
+Andreas Veit, Michael Wilber, and Serge Belongie. Residual networks behave like ensembles of relatively shallow networks. In Neural Information Processing Systems, (NIPS), 2016.
+
+Andreas Veit, Neil Alldrin, Gal Chechik, Ivan Krasin, Abhinav Gupta, and Serge Belongie. Learning from noisy large-scale datasets with minimal supervision. In Computer Vision and Pattern Recognition, (CVPR), 2017. URL https://vision.cornell.edu/se3/ wp-content/uploads/2017/04/DeepLabelCleaning_CVPR.pdf.
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In International Conference on Computer Vision, (ICCV), 2015.
+
+Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2691–2699, 2015.
+
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, (ICLR), 2017.
+
+Xiaojin Zhu. Semi-supervised learning literature survey. Computer Science, University of Wisconsin-Madison, 2(3):4, 2005.

parse/train/B1p461b0W/B1p461b0W_content_list.json

@@ -0,0 +1,1224 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP LEARNING IS ROBUST TOMASSIVE LABEL NOISE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            553,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks trained on large supervised datasets have led to impressive results in recent years. However, since well-annotated datasets can be prohibitively expensive and time-consuming to collect, recent work has explored the use of larger but noisy datasets that can be more easily obtained. In this paper, we investigate the behavior of deep neural networks on training sets with massively noisy labels. We show on multiple datasets such as MINST, CIFAR-10 and ImageNet that successful learning is possible even with an essentially arbitrary amount of noise. For example, on MNIST we find that accuracy of above 90 percent is still attainable even when the dataset has been diluted with 100 noisy examples for each clean example. Such behavior holds across multiple patterns of label noise, even when noisy labels are biased towards confusing classes. Further, we show how the required dataset size for successful training increases with higher label noise. Finally, we present simple actionable techniques for improving learning in the regime of high label noise. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            336,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has proven to be powerful for a wide range of problems, from image classification to machine translation. Typically, deep neural networks are trained using supervised learning on large, carefully annotated datasets. However, the need for such datasets restricts the space of problems that can be addressed. This has led to a proliferation of deep learning results on the same tasks using the same well-known datasets. Carefully annotated data is difficult to obtain, especially for classification tasks with large numbers of classes (requiring extensive annotation) or with fine-grained classes (requiring skilled annotation). Thus, annotation can be expensive and, for tasks requiring expert knowledge, may simply be unattainable at scale. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this limitation, other training paradigms have been investigated to alleviate the need for expensive annotations, such as unsupervised learning (Le, 2013), self-supervised learning (Pinto et al., 2016; Wang & Gupta, 2015) and learning from noisy annotations (Joulin et al., 2016; Natarajan et al., 2013; Veit et al., 2017). Very large datasets (e.g., Krasin et al. (2016); Thomee et al. (2016)) can often be attained, for example from web sources, with partial or unreliable annotation. This can allow neural networks to be trained on a much wider variety of tasks or classes and with less manual effort. The good performance obtained from these large noisy datasets indicates that deep learning approaches can tolerate modest amounts of noise in the training set. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            744
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we take this trend to an extreme, and consider the performance of deep neural networks under extremely low label reliability, only slightly above chance. We envision a future in which arbitrarily large amounts of data will easily be obtained, but in which labels come without any guarantee of validity and may merely be biased towards the correct distribution. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The key takeaways from this paper may be summarized as follows: ",
+        "bbox": [
+            174,
+            814,
+            612,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Deep neural networks are able to learn from data that has been diluted by an arbitrary amount of noise. We demonstrate that standard deep neural networks still perform well even on training sets in which label accuracy is as low as 1 percent above chance. On MNIST, for example, performance still exceeds 90 percent even with this level of label noise (see Figure 1). This behavior holds, to varying extents, across datasets as well as patterns of label noise, including when noisy labels are biased towards confused classes. ",
+        "bbox": [
+            217,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• A sufficiently large training set can accommodate a wide range of noise levels. We find that the minimum dataset size required for effective training increases with the noise level. A large enough training set can accommodate a wide range of noise levels. Increasing the dataset size further, however, does not appreciably increase accuracy. ",
+        "bbox": [
+            215,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Adjusting batch size and learning rate can allow conventional neural networks to operate in the regime of very high label noise. We find that label noise reduces the effective batch size, as noisy labels roughly cancel out and only a small learning signal remains. We show that dataset noise can be partly compensated for by larger batch sizes and by scaling the learning rate with the effective batch size. ",
+        "bbox": [
+            217,
+            165,
+            825,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            255,
+            344,
+            271
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning from noisy data. Several studies have investigated the impact of noisy datasets on machine classifiers. Approaches to learn from noisy data can generally be categorized into two groups: In the first group, approaches aim to learn directly from noisy labels and focus on noise-robust algorithms, e.g., Beigman & Klebanov (2009); Guan et al. (2017); Joulin et al. (2016); Krause et al. (2016); Manwani & Sastry (2013); Misra et al. (2016); Van Horn et al. (2015). The second group comprises mostly label-cleansing methods that aim to remove or correct mislabeled data, e.g., Brodley & Friedl (1999). Methods in this group frequently face the challenge of disambiguating between mislabeled and hard training examples. To address this challenge, they often use semi-supervised approaches by combining noisy data with a small set of clean labels (Zhu, 2005). Some approaches model the label noise as conditionally independent from the input image (Natarajan et al., 2013; Sukhbaatar et al., 2014) and some propose image-conditional noise models (Veit et al., 2017; Xiao et al., 2015). Our work differs from these approaches in that we do not aim to clean the training dataset or propose new noise-robust training algorithms. Instead, we study the behavior of standard neural network training procedures in settings with massive label noise. We show that even without explicit cleaning or noise-robust algorithms, neural networks can learn from data that has been diluted by an arbitrary amount of label noise. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Analyzing the robustness of neural networks. Several investigative studies aim to improve our understanding of convolutional neural networks. One particular stream of research in this space seeks to investigate neural networks by analyzing their robustness. For example, Veit et al. (2016) show that network architectures with residual connections have a high redundancy in terms of parameters and are robust to the deletion of multiple complete layers during test time. Further, Szegedy et al. (2014) investigate the robustness of neural networks to adversarial examples. They show that even for fully trained networks, small changes in the input can lead to large changes in the output and thus misclassification. In contrast, we are focusing on non-adversarial noise during training time. Within this stream of research, closest to our work are studies that focus on the impact of noisy training datasets on classification performance (e.g., Sukhbaatar et al. (2014); Van Horn et al. (2015); Zhang et al. (2017)). In these studies an increase in noise is assumed to decrease not only the proportion of correct examples, but also their absolute number. In contrast to these studies, we separate the effects and show in $\\ S 4$ that a decrease in the number of correct examples is more destructive to learning than an increase in the number of noisy labels. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 LEARNING WITH MASSIVE LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            542,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are concerned with scenarios of abundant data of very poor label quality, i.e., the regime in which falsely labeled training examples vastly outnumber correctly labeled examples. In particular, our experiments involve observing the performance of deep neural networks on multiclass classification tasks as label noise is increased. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To formalize the problem, we denote the number of original training examples by $n$ . To model the amount of noise, we dilute the dataset by adding $\\alpha$ noisy examples to the training set for each original training example. Thus, the total number of noisy labels in the training set is αn. Note that by varying the noise level $\\alpha$ , we do not change the available number of original examples. Thus, even in the presence of high noise, there is still appreciable data to learn from, if we are able to pick it out. This is in contrast to previous work (e.g., Sukhbaatar et al. (2014); Van Horn et al. (2015); Zhang et al. (2017)), in which an increase in noise also implies a decrease in the absolute number of correct examples. In the following experiments we investigate three different types of noise: uniform label-swapping, structured label-swapping, and out-of-vocabulary examples. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9c133111a2234ff5fd59247babd2c15f1298502c70a3f8cfbe2d33f50745d89.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            614,
+            101,
+            821,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/78e2b59393d4882edaaed93c66ab902845a045efd4a4cb2301e175d57533b2b3.jpg",
+        "image_caption": [
+            "Figure 1: Performance on Figure 2: Performance on MNIST as different amounts of CIFAR-10 as different amounts noisy labels are added to a fixed of noisy labels are added to a training set of clean labels. We fixed training set of clean lacompare a perceptron, MLPs bels. We tested ConvNets with with 1, 2, and 4 hidden layers, 4 and 6 layers, and a ResNet and a 4-layer ConvNet. Even with 101 layers. Even with 10 with 100 noisy labels for every noisy labels for every clean laclean label the ConvNet still at- bel the ResNet still attains a pertains a performance of $91 \\%$ . formance of $85 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            104,
+            383,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dd4bc5738563f214ee2d67f43b7bac997d30529a5f2edbe58cc0bbdca6ce3f7.jpg",
+        "image_caption": [
+            "Figure 3: Performance on ImageNet as different amounts of noisy labels are added to a fixed training set of clean labels. Even with 5 noisy labels for every clean label, the 18- layer ResNet still attains a performance of $70 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            393,
+            102,
+            599,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            428,
+            821,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A key assumption in this paper is that unreliable labels are better modeled by an unknown stochastic process rather than by the output of an adversary. This is a natural assumption for data that is pulled from the environment, in which antagonism is not to be expected in the noisy annotation process. Deep neural networks have been shown to be exceedingly brittle to adversarial noise patterns (Szegedy et al., 2014). In this work, we demonstrate that even massive amounts of non-adversarial noise present far less of an impediment to learning. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENT 1: TRAINING WITH UNIFORM LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            609,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As a first experiment, we will show that common training procedures for neural networks are resilient even to settings where correct labels are outnumbered by labels sampled uniformly at random at a ratio of 100 to 1. For this experiment we focus on the task of image classification and work with three commonly used datasets, MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and ImageNet (Deng et al., 2009). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Figures 1 and 2 we show the classification performance with varying levels of label noise. For MNIST, we vary the ratio $\\alpha$ of randomly labeled examples to cleanly labeled examples from 0 (no noise) to 100 (only 11 out of 101 labels are correct, as compared with 10.1 for pure chance). For the more challenging dataset CIFAR-10, we vary $\\alpha$ from 0 to 10. For the most challenging dataset ImageNet, we let $\\alpha$ range from 0 to 5. We compare various architectures of neural networks: multilayer perceptrons with different numbers of hidden layers, convolutional networks (ConvNets) with different numbers of convolutional layers, and residual networks (ResNets) with different numbers of layers (He et al., 2016). We evaluate performance after training on a test dataset that is free from noisy labels. Full details of our experimental setup are provided in $\\ S 3 . 4$ . ",
+        "bbox": [
+            174,
+            672,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our results show that, remarkably, it is possible to attain over 90 percent accuracy on MNIST, even when there are 100 randomly labeled images for every cleanly labeled example, to attain over 85 percent accuracy on CIFAR-10 with 10 random labels for every clean label, and to attain over 70 percent top-5 accuracy on ImageNet with 5 random labels for every clean label. Thus, in this highnoise regime, deep networks are able not merely to perform above chance, but to attain accuracies that would be respectable even without noise. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Further, we observe from Figures 1 and 2 that larger neural network architectures tend also to be more robust to label noise. On MNIST, the performance of a perceptron decays rapidly with increasing noise (though it still attains 40 percent accuracy, well above chance, at $\\alpha = 1 0 0$ ). The performance of a multilayer perceptron drops off more slowly, and the ConvNet is even more robust. Likewise, for CIFAR-10, the accuracy of the residual network drops more slowly than that of the smaller ConvNets. This observation provides further support for the effectiveness of ConvNets and ResNets in particular for applications where noise tolerance may be important. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a40a9a284ee6fd7dda9b80e4d4f3fca2f337a8782ed7c386d90983f93f7e6a09.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of uniform and structured noise models. In the case of structured noise, the order of false labels is important; we tested decreasing order of confusion, increasing order of confusion, and random order. The parameter $\\delta$ parameterizes the degree of structure in the noise. It defines how much more likely the second most likely class is over chance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            99,
+            728,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            325,
+            825,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXPERIMENT 2: TRAINING WITH STRUCTURED LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            637,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We have seen that neural networks are extremely robust to uniform label noise. However, label noise in datasets gathered from a natural environment is unlikely to follow a perfectly uniform distribution. In this experiment, we investigate the effects of various forms of structured noise on the performance of neural networks. Figure 4 illustrates the procedure used to model noise structure. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the uniform noise setting, as illustrated on the left side of Figure 4, correct labels are more likely than any individual false label. However, overall false labels vastly outnumber correct labels. We denote the likelihood over chance for a label to be correct as $\\epsilon$ . Note that $\\epsilon = 1 / ( 1 + \\alpha )$ , where $\\alpha$ is the ratio of noisy labels to certainly correct labels. To induce structure in the noise, we bias noisy labels to certain classes. We introduce the parameter $\\delta$ to parameterize the degree of structure in the noise. It defines how much more likely the second most likely class is over chance. With $\\delta = 0$ the noise is uniform, whereas for $\\delta = 1$ the second most likely class is equally likely as the correct class. The likelihood for the remaining classes is scaled linearly, as illustrated in Figure 4 on the right. We investigate three different setups for structured noise: labels biased towards easily confused classes, towards hardly confused classes and towards random classes. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows the results on MNIST for the three different types of structured noise, as $\\delta$ varies from 0 to 1. In this experiment, we train 4-layer ConvNets on a dataset that is diluted with 20 noisy labels for each clean label. We vary the order of false labels so that, besides the correct class, labels are assigned most frequently to (1) those most often confused with the correct class, (2) those least often confused with it, and (3) in a random order. We determine commonly confused labels by training the network repeatedly on a small subset of MNIST and observing the errors it makes on a test set. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results show that deep neural nets are robust even to structured noise, as long as the correct label remains the most likely by at least a small margin. Generally, we do not observe large differences between the different models of noise structure, only that bias towards random classes seems to hurt the performance a little more than bias towards confused classes. This result might help explain why we often observe quite good results from real world noisy datasets, where label noise is more likely to be biased towards related and confusing classes. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 EXPERIMENT 3: SOURCE OF NOISY LABELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            867,
+            514,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the preceding experiments, we diluted the training sets with noisy examples drawn from the same dataset; i.e., falsely labeled examples were images from within other categories of the dataset. In natural scenarios, however, noisy examples likely also include categories not included in the dataset that have erroneously been assigned labels within the dataset. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/39e1b367b8f1cfe0c62387b7a9f5848b19b58283aacd07d334c5f26174a4d483.jpg",
+        "image_caption": [
+            "Figure 5: Performance on MNIST with fixed $\\alpha = 2 0$ noisy labels per clean label. Noise is drawn from three types of structured distribution: (1) “confusing order” (highest probability for the most confusing label), (2) “reverse confusing order”, and (3) random order. We interpolate between uniform noise, $\\delta = 0$ , and noise so highly skewed that the most common false label is as likely as the correct label, $\\delta \\ = \\ 1$ Except for $\\delta \\approx 1$ , performance is similar to uniform noise. ",
+            "Figure 6: Performance on CIFAR-10 for varying amounts of noisy labels. Noisy training examples are drawn from (1) CIFAR-10 itself, but mislabeled uniformly at random, (2) CIFAR100, with uniformly random labels, and (3) white noise with mean and variance chosen to match those of CIFAR-10. Noise drawn from CIFAR-100 resulted in only half the drop in performance observed with noise from CIFAR-10 itself, while white noise examples did not appreciable affect performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            812,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            494,
+            821,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, we now consider two alternative sources for noisy training examples. First, we dilute the training set with examples that are drawn from a similar but different dataset. In particular, we use CIFAR-10 as our training dataset and dilute it with examples from CIFAR-100, assigning each image a category from CIFAR-10 at random. Second, we also consider a dilution of the training set with “examples” that are simply white noise; in this case, we match the mean and variance of pixels within CIFAR-10 and again assign labels uniformly at random. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the results obtained by a six-layer ConvNet on the different noise sources for varying levels of noise. We observe that both alternative sources of noise lead to better performance than the noise originating from the same dataset. For noisy examples drawn from CIFAR-100, performance drops only about half as much as when noise originates from CIFAR-10 itself. This trend is consistent across noise levels. For white noise, performance does not drop regardless of noise level; this is in line with prior work that has shown that neural networks are able to fit random input (Zhang et al., 2017). This indicates the scenarios considered in Experiments 1 and 2 represent in some sense a worst case. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In natural scenarios, we may expect massively noisy datasets to fall somewhere in between the cases exemplified by CIFAR-10 and CIFAR-100. That is, some examples will be relevant but mislabeled. However, it is likely that many examples will not be from any classes under consideration and therefore will influence training less negatively. In fact, it is possible that such examples might increase accuracy, if the erroneous labels reflect underlying similarity between the examples in question. ",
+        "bbox": [
+            174,
+            738,
+            823,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            372,
+            851
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All models are trained with AdaDelta (Zeiler, 2012) as optimizer and a batch size of 128. For each level of label noise we train separate models with different learning rates ranging from 0.01 to 1 and pick the learning rate that results in the best performance. Generally, we observe that the higher the label noise, the lower the optimal learning rate. We investigate this trend in detail in §5. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c21857a56a07b66737e2dc89fac883ddfa7637fbd412b8852778adb42a2d2904.jpg",
+        "image_caption": [
+            "Figure 7: Comparison of the effect of reusing images vs. using novel images as noisy examples. Essentially no difference is observed between the two types of noisy examples, supporting the use of repeated examples in our experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            486,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/188024bc06883009c65ceb60641d43e949b8968342b6ec41f0de7af7dee4a316.jpg",
+        "image_caption": [
+            "Figure 8: Performance on MNIST at various noise levels, as a function of the number of clean labels. There seems to be a critical amount of clean training data required to successfully train the networks. This threshold increases as the noise level rises. For example, at $\\alpha = 1 0$ , 2,000 clean labels are needed to attain $90 \\%$ performance, while at $\\alpha = 5 0$ , 10,000 clean labels are needed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            104,
+            807,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Experiments 1 and 2, noisy labels are drawn from the same dataset as the labels guaranteed to be correct. This involves drawing the same example many times from the dataset, giving it the correct label once, and in every other instance picking a random label according to the noise distribution in question. We show in Figure 7 that performance would have been comparable had we been able to draw noisy labels from an extended dataset, instead of repeating images. Specifically, we train a convolutional network on a subset of MNIST, with 2,500 certainly correct labels and with noisy labels drawn either with repetition from this set of 2,500 or without repetition from the remaining examples in the MNIST dataset. The results are essentially identical between repeated and unique examples, supporting our setup in the preceding experiments. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 THE IMPORTANCE OF LARGER DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            616,
+            544,
+            631
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Underlying the ability of deep networks to learn from massively noisy data is the size of the data in question. It is well-established, see e.g., Deng et al. (2009), that traditional deep learning relies upon large datasets. We will now see how this is particularly true of noisy datasets. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8, we compare the performance of a ConvNet on MNIST as the size of the training set varies. We also show the performance of the same ConvNet trained on MNIST diluted with noisy labels sampled uniformly. We show how the performance of the ConvNet varies with the number of cleanly labeled training examples. For example, for the blue curve of $\\alpha = 1 0$ and 1,000 clean labels, the network is trained on 11,000 examples: 1,000 cleanly labeled examples and 10,000 with random labels. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Generally, we observe that independent of the noise level the networks benefit from more data and that, given sufficient data, the networks reach similar results. Further, the results indicate that there seems to be a critical amount of clean training data that is required to successfully train the networks. This critical amount of clean data depends on the noise level; in particular, it increases as the noise level rises. Since performance rapidly levels off past the critical threshold the main requirement for the clean training set is to be of sufficient size. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is because of the critical amount of required clean data that we have not attempted to train networks for $\\alpha \\gg 1 0 0$ . The number of correct examples needed to train such a network might rise above the 60,000 provided in the MNIST dataset. In a real-world dataset, the amount of (noisy) data available for training is likely not to be the limiting factor. Rather, considerations such as training time and learning rate may play a more important role, as we discuss in the following section. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a1590b2c0e7c28dcefe6239ed9d9264e2b853c999e75f71c9ce77e8aabbae055.jpg",
+        "image_caption": [
+            "Figure 9: Performance on MNIST for varying batch size as a function of noise level. Higher batch size gives better performance. We approximate the limit of infinite batch size by training without noisy labels, but using the noisy loss function $H _ { \\alpha }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            488,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/75e753a6581173fda8d01a6a18351eca675a2a2366feea4d91de9c2fc98173fe.jpg",
+        "image_caption": [
+            "Figure 10: Performance on CIFAR-10 for varying learning rate as a function of noise level. Lower learning rates are generally optimal as the noise level increases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            102,
+            810,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            416,
+            823,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 TRAINING ON NOISY DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            467,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the preceding sections, our results were obtained by training neural networks with fixed batch size and running a parameter search to pick the optimal learning rate. We now look in more detail into how the choice of hyperparameters affects learning on noisy datasets. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 BATCH SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            299,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we investigate the effect of the batch size on the noise robustness of neural network training. In Figure 9, we compare the performance of a simple 2-layer ConvNet on MNIST with increasing noise, as batch size varies from 32 to 256. We observe that increasing the batch size provides greater robustness to noisy labels. One reason for this behavior could be that, within a batch, gradient updates from randomly sampled noisy labels cancel out, while gradients from correct examples that are marginally more frequent sum together and contribute to learning. By this logic, large batch sizes would be more robust to noise since the mean gradient over a larger batch is closer to the gradient for correct labels. All other experiments in this paper are performed with a fixed batch size of 128. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            691
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We may also consider the theoretical case of infinite batch size, in which gradients are averaged over the entire space of possible inputs at each training step. While this is often impossible to perform in practice, we can simulate such behavior by an auxiliary loss function. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In classification tasks, we are given an input $\\mathbf { x }$ and aim to predict the class $f ( \\mathbf { x } ) \\in \\{ 1 , 2 , \\dots , m \\}$ . The value $f ( \\mathbf { x } )$ is encoded within a neural network by the 1-hot vector $\\mathbf { y } ( \\mathbf { x } )$ such that ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18d4f9d5c1dfa98b60aec3c6950849a98b78fdc33043eb25c49a692c61f1c9a5.jpg",
+        "text": "$$\ny _ { k } ( \\mathbf x ) = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { ~ i f ~ } } k = f ( \\mathbf x ) } \\\\ { 0 } & { { \\mathrm { ~ o t h e r w i s e ~ } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            780,
+            589,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "for $1 \\leq k \\leq m$ . Then, the standard cross-entropy loss over a batch $X$ is given by: ",
+        "bbox": [
+            173,
+            819,
+            705,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4c189d95322892db05fd567f9d3a08c9dc0f8fd00f879c4840f716556e4e4d40.jpg",
+        "text": "$$\nH ( X ) = - \\langle \\log \\hat { y } _ { f ( \\mathbf { x } ) } \\rangle _ { X } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            838,
+            581,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\mathbf { y } }$ is the predicted vector and $\\langle \\cdot \\rangle _ { X }$ denotes the expected value over the batch $X$ . We assume that $\\hat { \\mathbf { y } }$ is normalized (e.g. by the softmax function) so that the entries sum to 1. ",
+        "bbox": [
+            174,
+            859,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For a training set with noisy labels, we may consider the label $f ( \\mathbf { x } )$ given in the training set to be merely an approximation to the true label $f _ { 0 } ( x )$ . Consider the case of $n$ training examples, and $\\alpha n$ noisy labels that are sampled uniformly at random from the set $\\{ 1 , 2 , \\ldots , m \\}$ . Then, $f ( \\mathbf { x } ) = f _ { 0 } ( \\mathbf { x } )$ with probability $\\frac { 1 } { 1 + \\alpha }$ , and otherwise it is $1 , 2 , \\ldots , m$ , each with probability $\\frac { \\alpha } { m ( 1 + \\alpha ) }$ . As batch size increases, the expected value over the batch $X$ is approximated more closely by these probabilities. In the limit of infinite batch size, equation (2) takes the form of a noisy loss function $H _ { \\alpha }$ : ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            102,
+            821,
+            162
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6aae83939a8d4dfab8c8ed2207f1be86c162f385fe38ec2f94cf942e35130348.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\cal H } _ { \\alpha } ( X ) : = - \\frac { 1 } { 1 + \\alpha } \\langle \\log \\hat { y } _ { f _ { 0 } ( { \\bf x } ) } \\rangle _ { X } - \\frac { \\alpha } { m ( 1 + \\alpha ) } \\sum _ { k = 1 } ^ { m } \\langle \\log \\hat { y } _ { k } \\rangle _ { X } } } \\\\ { { \\displaystyle \\propto - \\langle \\log \\hat { y } _ { f _ { 0 } ( { \\bf x } ) } \\rangle _ { X } - \\alpha \\left. \\log \\prod _ { k = 1 } ^ { m } \\hat { y } _ { k } ^ { 1 / m } \\right. _ { X } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            166,
+            700,
+            255
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We can therefore compare training using the cross-entropy loss with $\\alpha n$ noisy labels to training using the noisy loss function $H _ { \\alpha }$ without noisy labels. The term on the right-hand side of (3) represents the noise contribution, and is clearly minimized where $\\hat { y } _ { k }$ are all equal. As $\\alpha$ increases, this contribution is weighted more heavily against $- \\left. \\log \\hat { y } _ { f _ { 0 } ( \\mathbf { x } ) } \\right. _ { X }$ , which is minimized at $\\hat { \\mathbf { y } } ( \\mathbf x ) = \\mathbf { y } ( \\mathbf x )$ . ",
+        "bbox": [
+            174,
+            263,
+            825,
+            321
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show in Figure 9 the results of training our 2-layer ConvNet on MNIST with the noisy loss function $H _ { \\alpha }$ , simulating $\\alpha n$ noisy labels with infinite batch size. We can observe that the network’s accuracy does not decrease as $\\alpha$ increases. This can be explained by the observation that an increasing $\\alpha$ is merely decreasing the magnitude of the true gradient, rather than altering its direction. ",
+        "bbox": [
+            174,
+            327,
+            823,
+            383
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our observations indicate that increasing noise in the training set reduces the effective batch size, as noisy signals roughly cancel out and only small learning signal remains. We show that increasing the batch size is a simple practical means to mitigate the effect of noisy training labels. ",
+        "bbox": [
+            176,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 LEARNING RATE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            449,
+            330,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It has become common practice in training deep neural networks to scale the learning rate with the batch size. In particular, it has been shown that the smaller the batch size, the lower the optimal learning rate (Krizhevsky, 2014). In our experiments, we have observed that noisy labels reduce the effective batch size. As such, we would expect that lower learning rates perform better than large learning rates as noise increases. Figure 10 shows the performance of a 4-layer ConvNet trained with different learning rates on CIFAR-10 for varying label noise. As expected, we observe that the optimal learning rate decreases as noise increases. For example, the optimal learning rate for the clean dataset is 1, while, with the introduction of noise, this learning rate becomes unstable. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To sum up, we observe that increasing label noise reduces the effective batch size. We have shown that the effect of label noise can be partly counterbalanced for by a larger training batch size. Now, we see that one can additionally scale the learning rate to compensate for any remaining change in effective batch size induced by noisy labels. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            669,
+            318,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have considered the behavior of deep neural networks on training sets with very noisy labels. In a series of experiments, we have demonstrated that learning is robust to an essentially arbitrary amount of label noise, provided that the number of clean labels is sufficiently large. We have further shown that the threshold required for clean labels increases as the noise level does. Finally, we have observed that noisy labels reduce the effective batch size, an effect that can be mitigated by larger batch sizes and downscaling the learning rate. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is worthy of note that although deep networks appear robust to even high degrees of label noise, clean labels still always perform better than noisy labels, given the same quantity of training data. Further, one still requires expert-vetted test sets for evaluation. Lastly, it is important to reiterate that our studies focus on non-adversarial noise. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our work suggests numerous directions for future investigation. For example, we are interested in how label-cleaning and semi-supervised methods affect the performance of networks in a high-noise regime. Are such approaches able to lower the threshold for training set size? Finally, it remains to translate the results we present into an actionable trade-off between data annotation and acquisition costs, which can be utilized in real world training pipelines for deep networks on massive noisy data. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eyal Beigman and Beata Beigman Klebanov. Learning with annotation noise. In Proceedings of the Joint Conference of the 47th Annual Meeting of the ACL and the 4th International Joint Conference on Natural Language Processing of the AFNLP. Association for Computational Linguistics, 2009. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            183
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carla E Brodley and Mark A Friedl. Identifying mislabeled training data. Journal of artificial intelligence research (JAIR), 11:131–167, 1999. ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, (CVPR), 2009. ",
+        "bbox": [
+            173,
+            232,
+            821,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Melody Y Guan, Varun Gulshan, Andrew M Dai, and Geoffrey E Hinton. Who said what: Modeling individual labelers improves classification. arXiv:1703.08774, 2017. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, (CVPR), 2016. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Laurens van der Maaten, Allan Jabri, and Nicolas Vasilache. Learning visual features from large weakly supervised data. In European Conference on Computer Vision, (ECCV). Springer, 2016. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "I Krasin, T Duerig, N Alldrin, A Veit, S Abu-El-Haija, S Belongie, D Cai, Z Feng, V Ferrari, V Gomes, et al. Openimages: A public dataset for large-scale multi-label and multiclass image classification. Dataset available from https://github. com/openimages, 2(6):7, 2016. ",
+        "bbox": [
+            176,
+            405,
+            821,
+            448
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Krause, Benjamin Sapp, Andrew Howard, Howard Zhou, Alexander Toshev, Tom Duerig, James Philbin, and Li Fei-Fei. The unreasonable effectiveness of noisy data for fine-grained recognition. In European Conference on Computer Vision, (ECCV). Springer, 2016. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv preprint arXiv:1404.5997, 2014. ",
+        "bbox": [
+            174,
+            511,
+            823,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images, 2009. ",
+        "bbox": [
+            173,
+            550,
+            821,
+            566
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le. Building high-level features using large scale unsupervised learning. In International Conference on Acoustics, Speech and Signal Processing, (ICASSP). IEEE, 2013. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Corinna Cortes, and Christopher JC Burges. The MNIST database of handwritten digits, 1998. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Naresh Manwani and PS Sastry. Noise tolerance under risk minimization. IEEE Transactions on cybernetics, 43(3):1146–1151, 2013. ",
+        "bbox": [
+            169,
+            656,
+            823,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra, C Lawrence Zitnick, Margaret Mitchell, and Ross Girshick. Seeing through the human reporting bias: Visual classifiers from noisy human-centric labels. In Computer Vision and Pattern Recognition, (CVPR), 2016. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with noisy labels. In Advances in neural information processing systems, (NIPS), 2013. ",
+        "bbox": [
+            171,
+            748,
+            823,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto, Dhiraj Gandhi, Yuanfeng Han, Yong-Lae Park, and Abhinav Gupta. The curious robot: Learning visual representations via physical interactions. In European Conference on Computer Vision, (ECCV). Springer, 2016. ",
+        "bbox": [
+            176,
+            787,
+            823,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. arXiv preprint arXiv:1406.2080, 2014. ",
+        "bbox": [
+            169,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, (ICLR), 2014. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bart Thomee, David A Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland, Damian Borth, and Li-Jia Li. YFCC100M: The new data in multimedia research. Communications of the ACM, 59(2):64–73, 2016. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Grant Van Horn, Steve Branson, Ryan Farrell, Scott Haber, Jessie Barry, Panos Ipeirotis, Pietro Perona, and Serge Belongie. Building a bird recognition app and large scale dataset with citizen scientists: The fine print in fine-grained dataset collection. In Computer Vision and Pattern Recognition, (CVPR), 2015. ",
+        "bbox": [
+            174,
+            155,
+            825,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Veit, Michael Wilber, and Serge Belongie. Residual networks behave like ensembles of relatively shallow networks. In Neural Information Processing Systems, (NIPS), 2016. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Veit, Neil Alldrin, Gal Chechik, Ivan Krasin, Abhinav Gupta, and Serge Belongie. Learning from noisy large-scale datasets with minimal supervision. In Computer Vision and Pattern Recognition, (CVPR), 2017. URL https://vision.cornell.edu/se3/ wp-content/uploads/2017/04/DeepLabelCleaning_CVPR.pdf. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In International Conference on Computer Vision, (ICCV), 2015. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2691–2699, 2015. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012. ",
+        "bbox": [
+            173,
+            412,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, (ICLR), 2017. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu. Semi-supervised learning literature survey. Computer Science, University of Wisconsin-Madison, 2(3):4, 2005. ",
+        "bbox": [
+            169,
+            502,
+            825,
+            531
+        ],
+        "page_idx": 9
+    }
+]

parse/train/JWOiYxMG92s/JWOiYxMG92s.md

@@ -0,0 +1,316 @@
+# FREE LUNCH FOR FEW-SHOT LEARNING: DISTRIBUTION CALIBRATION
+
+Shuo $\mathbf { Y a n g ^ { 1 } }$ , Lu $\mathbf { L i u ^ { 2 } }$ , Min $\mathbf { X } \mathbf { u } ^ { 1 * }$ 1School of Electrical and Data Engineering, University of Technology Sydney, 2Australian Artificial Intelligence Institute, University of Technology Sydney {shuo.yang, lu.liu-10}@student.uts.edu.au, min.xu@uts.edu.au,
+
+# ABSTRACT
+
+Learning from a limited number of samples is challenging since the learned model can easily become overfitted based on the biased distribution formed by only a few training examples. In this paper, we calibrate the distribution of these fewsample classes by transferring statistics from the classes with sufficient examples. Then an adequate number of examples can be sampled from the calibrated distribution to expand the inputs to the classifier. We assume every dimension in the feature representation follows a Gaussian distribution so that the mean and the variance of the distribution can borrow from that of similar classes whose statistics are better estimated with an adequate number of samples. Our method can be built on top of off-the-shelf pretrained feature extractors and classification models without extra parameters. We show that a simple logistic regression classifier trained using the features sampled from our calibrated distribution can outperform the state-of-the-art accuracy on three datasets $5 \%$ improvement on miniImageNet compared to the next best). The visualization of these generated features demonstrates that our calibrated distribution is an accurate estimation. The code is available at: https://github.com/ShuoYang-1998/Few_ Shot_Distribution_Calibration
+
+# 1 INTRODUCTION
+
+Learning from a limited number of training samples has drawn increasing attention due to the high cost of collecting and annotating a large amount of data. Researchers have developed algorithms to improve the performance of models that have been trained with very few data. Finn et al. (2017); Snell et al. (2017) train models in a meta-learning fashion so that the model can adapt quickly on tasks with only a few training samples available. Hariharan & Girshick (2017); Wang et al. (2018) try to synthesize data or features by learning a generative model to alleviate the data insufficiency problem. Ren et al. (2018) propose to leverage unlabeled data and predict pseudo labels to improve the performance of fewshot learning.
+
+Table 1: The class mean similarity (“mean sim”) and class variance similarity (“var sim”) between Arctic fox and different classes.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Arctic fox</td></tr><tr><td>mean sim</td><td>var sim</td></tr><tr><td>white wolf</td><td>97%</td><td>97%</td></tr><tr><td>malamute</td><td>85%</td><td>78%</td></tr><tr><td>lion</td><td>81%</td><td>70%</td></tr><tr><td>meerkat</td><td>78%</td><td>70%</td></tr><tr><td> jellyfish</td><td>46%</td><td>26%</td></tr><tr><td>orange</td><td>40%</td><td>19%</td></tr><tr><td>beer bottle</td><td>34%</td><td>11%</td></tr></table>
+
+While most previous works focus on developing stronger models, scant attention has been paid to the property of the data itself. It is natural that when the number of data grows, the ground truth distribution can be more accurately uncovered. Models trained with a wide coverage of data can generalize well during evaluation. On the other hand, when training a model with only a few training data, the model tends to overfit on these few samples by minimizing the training loss over these samples. These phenomena are illustrated in Figure 1. This biased distribution based on a few examples can damage the generalization ability of the model since it is far from mirroring the ground truth distribution from which test cases are sampled during evaluation.
+
+![](images/f4ca58d351dd312c05898a42b7dc7690158afa432c5ba49f7761c4aa20e3bb2e.jpg)  
+Figure 1: Training a classifier from few-shot features makes the classifier overfit to the few examples (Left). Classifier trained with features sampled from calibrated distribution has better generalization ability (Right).
+
+Here, we consider calibrating this biased distribution into a more accurate approximation of the ground truth distribution. In this way, a model trained with inputs sampled from the calibrated distribution can generalize over a broader range of data from a more accurate distribution rather than only fitting itself to those few samples. Instead of calibrating the distribution of the original data space, we try to calibrate the distribution in the feature space, which has much lower dimensions and is easier to calibrate (Xian et al. (2018)). We assume every dimension in the feature vectors follows a Gaussian distribution and observe that similar classes usually have similar mean and variance of the feature representations, as shown in Table 1. Thus, the mean and variance of the Gaussian distribution can be transferred across similar classes (Salakhutdinov et al. (2012)). Meanwhile, the statistics can be estimated more accurately when there are adequate samples for this class. Based on these observations, we reuse the statistics from many-shot classes and transfer them to better estimate the distribution of the few-shot classes according to their class similarity. More samples can be generated according to the estimated distribution which provides sufficient supervision for training the classification model.
+
+In the experiments, we show that a simple logistic regression classifier trained with our strategy can achieve state-of-the-art accuracy on three datasets. Our distribution calibration strategy can be paired with any classifier and feature extractor with no extra learnable parameters. Training with samples selected from the calibrated distribution can achieve $12 \%$ accuracy gain compared to the baseline which is only trained with the few samples given in a 5way1shot task. We also visualize the calibrated distribution and show that it is an accurate approximation of the ground truth that can better cover the test cases.
+
+# 2 RELATED WORKS
+
+Few-shot classification is a challenging machine learning problem and researchers have explored the idea of learning to learn or meta-learning to improve the quick adaptation ability to alleviate the few-shot challenge. One of the most general algorithms for meta-learning is the optimizationbased algorithm. Finn et al. (2017) and Li et al. (2017) proposed to learn how to optimize the gradient descent procedure so that the learner can have a good initialization, update direction, and learning rate. For the classification problem, researchers proposed simple but effective algorithms based on metric learning. MatchingNet (Vinyals et al., 2016) and ProtoNet (Snell et al., 2017) learned to classify samples by comparing the distance to the representatives of each class. Our distribution calibration and feature sampling procedure does not include any learnable parameters and the classifier is trained in a traditional supervised learning way.
+
+Another line of algorithms is to compensate for the insufficient number of available samples by generation. Most methods use the idea of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) or autoencoder (Rumelhart et al., 1986) to generate samples (Zhang et al. (2018); Chen et al. (2019b); Schwartz et al. (2018); Gao et al. (2018)) or features (Xian et al. (2018); Zhang et al. (2019)) to augment the training set. Specifically, Zhang et al. (2018) and Xian et al. (2018) proposed to synthesize data by introducing an adversarial generator conditioned on tasks. Zhang et al. (2019) tried to learn a variational autoencoder to approximate the distribution and predict labels based on the estimated statistics. The autoencoder can also augment samples by projecting between the visual space and the semantic space (Chen et al., 2019b) or encoding the intra-class deformations (Schwartz et al., 2018). Liu et al. (2019b) and Liu et al. (2019a) propose to generate features through the class hierarchy. While these methods can generate extra samples or features for training, they require the design of a complex model and loss function to learn how to generate. However, our distribution calibration strategy is simple and does not need extra learnable parameters.
+
+Data augmentation is a traditional and effective way of increasing the number of training samples. Qin et al. (2020) and Antoniou & Storkey (2019) proposed the used of the traditional data augmentation technique to construct pretext tasks for unsupervised few-shot learning. Wang et al. (2018) and Hariharan & Girshick (2017) leveraged the general idea of data augmentation, they designed a hallucination model to generate the augmented version of the image with different choices for the model’s input, i.e., an image and a noise (Wang et al., 2018) or the concatenation of multiple features (Hariharan & Girshick, 2017). Park et al. (2020); Wang et al. (2019); Liu et al. (2020b) tried to augment feature representations by leveraging intra-class variance. These methods learn to augment from the original samples or their feature representation while we try to estimate the classlevel distribution and thus can eliminate the inductive bias from a single sample and provide more diverse generations from the calibrated distribution.
+
+# 3 MAIN APPROACH
+
+In this section, we introduce the few-shot classification problem definition in Section 3.1 and details of our proposed approach in Section 3.2.
+
+# 3.1 PROBLEM DEFINITION
+
+We follow a typical few-shot classification setting. Given a dataset with data-label pairs $\mathcal { D } =$ $\{ ( x _ { i } , y _ { i } ) \}$ where $\pmb { x } _ { i } \in \mathbb { R } ^ { d }$ is the feature vector of a sample and $y _ { i } \in C$ , where $C$ denotes the set of   
+classes. This set of classes is divided into base classes $C _ { b }$ and novel classes $C _ { n }$ , where $C _ { b } \cap C _ { n } = \emptyset$   
+and $C _ { b } \cup C _ { n } = C$ . The goal is to train a model on the data from the base classes so that the model   
+can generalize well on tasks sampled from the novel classes. In order to evaluate the fast adaptation   
+ability or the generalization ability of the model, there are only a few available labeled samples for   
+each task $\tau$ . The most common way to build a task is called an N-way-K-shot task (Vinyals et al.   
+(2016)), where $\mathbf { N }$ classes are sampled from the novel set and only $\mathbf { K }$ (e.g., 1 or 5) labeled samples are   
+provideand the for each class. The few available labeodel is evaluated on another query set set , wh $\boldsymbol { S } = \{ ( \boldsymbol { x } _ { i } , y _ { i } ) \} _ { i = 1 } ^ { N \times K }$ $\mathcal { Q } = \{ ( \pmb { x } _ { i } , y _ { i } ) \} _ { i = N \times K + 1 } ^ { N \times K + N \times q }$ $q$   
+query set of) multiple tasks sampled from the novel classes.
+
+# 3.2 DISTRIBUTION CALIBRATION
+
+As introduced in Section 3.1, the base classes have a sufficient amount of data while the evaluation tasks sampled from the novel classes only have a limited number of labeled samples. The statistics of the distribution for the base class can be estimated more accurately compared to the estimation based on few-shot samples, which is an ill-posed problem. As shown in Table 1, we observe that if we assume the feature distribution is Gaussian, the mean and variance with respect to each class are correlated to the semantic similarity of each class. With this in mind, the statistics can be transferred from the base classes to the novel classes if we learn how similar the two classes are. In the following sections, we discuss how we calibrate the distribution estimation of the classes with only a few samples (Section 3.2.2) with the help of the statistics of the base classes (Section 3.2.1). We will also elaborate on how do we leverage the calibrated distribution to improve the performance of few-shot learning (Section 3.2.3).
+
+Note that our distribution calibration strategy is over the feature-level and is agnostic to any feature extractor. Thus, it can be built on top of any pretrained feature extractors without further costly finetuning. In our experiments, we use the pretrained WideResNet Zagoruyko & Komodakis (2016) following previous work (Mangla et al. (2020)). The WideResNet is trained to classify the base classes, along with a self-supervised pretext task to learn the general-purpose representations suitable for image understanding tasks. Please refer to their paper for more details on training the feature extractor.
+
+# Algorithm 1 Training procedure for an N-way-K-shot task
+
+$\pmb { S } = ( \pmb { x } _ { i } , y ) _ { i = 1 } ^ { N \times K }$ $\{ \pmb { \mu } _ { i } \} _ { i = 1 } ^ { | C _ { b } | } , \{ \pmb { \Sigma } _ { i } \} _ { i = 1 } ^ { | C _ { b } | }$
+
+1: Transform $\left( \pmb { x } _ { i } \right) _ { i = 1 } ^ { N \times K }$ i=1 i=1with Tukey’s Ladder of Powers as Equation 3   
+2: for $( x _ { i } , y _ { i } ) \in S$ do   
+3: Calibrate the mean $\mu ^ { \prime }$ and the covariance $\pmb { \Sigma } ^ { \prime }$ for class $y _ { i }$ using $\mathbf { \Delta } \mathbf { x } _ { i }$ with Equation 6   
+4: Sample features for class $y _ { i }$ from the calibrated distribution as Equation 7   
+5: end for   
+6: Train a classifier using both support set features and all sampled features as Equation 8
+
+# 3.2.1 STATISTICS OF THE BASE CLASSES
+
+We assume the feature distribution of base classes is Gaussian. The mean of the feature vector from a base class $i$ is calculated as the mean of every single dimension in the vector:
+
+$$
+\mu _ { i } = \frac { \sum _ { j = 1 } ^ { n _ { i } } { \pmb x } _ { j } } { n _ { i } } ,
+$$
+
+where $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { j } }$ is a feature vector of the $j$ -th sample from the base class $i$ and $n _ { i }$ is the total number of samples in class $i$ . As the feature vector $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { j } }$ is multi-dimensional, we use covariance for a better representation of the variance between any pair of elements in the feature vector. The covariance matrix $\Sigma _ { i }$ for the features from class $i$ is calculated as:
+
+$$
+\pmb { \Sigma } _ { i } = \frac { 1 } { n _ { i } - 1 } \sum _ { j = 1 } ^ { n _ { i } } \left( \pmb { x } _ { j } - \pmb { \mu } _ { i } \right) \left( \pmb { x } _ { j } - \pmb { \mu } _ { i } \right) ^ { T } .
+$$
+
+# 3.2.2 CALIBRATING STATISTICS OF THE NOVEL CLASSES
+
+Here, we consider an N-way-K-shot task sampled from the novel classes.
+
+# Tukey’s Ladder of Powers Transformation
+
+To make the feature distribution more Gaussian-like, we first transform the features of the support set and query set in the target task using Tukey’s Ladder of Powers transformation (Tukey (1977)). Tukey’s Ladder of Powers transformation is a family of power transformations which can reduce the skewness of distributions and make distributions more Gaussian-like. Tukey’s Ladder of Powers transformation is formulated as:
+
+$$
+\tilde { \mathbf { x } } = \left\{ \begin{array} { l l } { x ^ { \lambda } } & { \mathrm { ~ i f ~ } \lambda \neq 0 } \\ { \log ( \pmb { x } ) } & { \mathrm { ~ i f ~ } \lambda = 0 } \end{array} \right.
+$$
+
+where $\lambda$ is a hyper-parameter to adjust how to correct the distribution. The original feature can be recovered by setting $\lambda$ as 1. Decreasing $\lambda$ makes the distribution less positively skewed and vice versa.
+
+# Calibration through statistics transfer
+
+Using the statistics from the base classes introduced in Section 3.2.1, we transfer the statistics from the base classes which are estimated more accurately on sufficient data to the novel classes. The transfer is based on the Euclidean distance between the feature space of the novel classes and the mean of the features from the base classes $\pmb { \mu _ { i } }$ as computed in Equation 1. Specifically, we select the top $k$ base classes with the closest distance to the feature of a sample $\tilde { \pmb x }$ from the support set:
+
+$$
+\begin{array} { r } { \mathbb { S } _ { d } = \{ - \| \pmb { \mu } _ { i } - \tilde { \pmb { x } } \| ^ { 2 } | i \in C _ { b } \} , } \\ { \mathbb { S } _ { N } = \{ i | - \| \pmb { \mu } _ { i } - \tilde { \pmb { x } } \| ^ { 2 } \in t o p k ( \mathbb { S } _ { d } ) \} , } \end{array}
+$$
+
+where $t o p k ( \cdot )$ is an operator to select the top elements from the input distance set $\mathbb { S } _ { d }$ . $\mathbb { S } _ { N }$ stores the $k$ nearest base classes with respect to a feature vector $\tilde { \pmb x }$ . Then, the mean and covariance of the distribution is calibrated by the statistics from the nearest base classes:
+
+$$
+\pmb { \mu } ^ { \prime } = \frac { \sum _ { i \in \mathbb { S } _ { N } } \pmb { \mu } _ { i } + \tilde { \pmb { x } } } { k + 1 } , \pmb { \Sigma } ^ { \prime } = \frac { \sum _ { i \in \mathbb { S } _ { N } } \pmb { \Sigma } _ { i } } { k } + \alpha ,
+$$
+
+Table 2: 5way1shot and 5way5shot classification accuracy $( \% )$ on miniImageNet and CUB with $9 5 \%$ confidence intervals. The numbers in bold have intersecting confidence intervals with the most accurate method.   
+
+<table><tr><td rowspan="2">Methods</td><td colspan="2">miniImageNet</td><td colspan="2">CUB</td></tr><tr><td>5way1shot</td><td>5way5shot</td><td>5way1shot</td><td>5way5shot</td></tr><tr><td>Optimization-based</td><td></td><td></td><td></td><td></td></tr><tr><td>MAML (Finn et al. (2017))</td><td>48.70 ±1.84</td><td>63.10 ± 0.92</td><td>50.45 ±0.97 59.60 ± 0.84</td><td></td></tr><tr><td>Meta-SGD (Li et al. (2017))</td><td>50.47 ± 1.87</td><td>64.03 ±0.94</td><td>53.34± 0.97</td><td>67.59 ±0.82</td></tr><tr><td>LEO (Rusu et al. (2019))</td><td>61.76 ± 0.08</td><td>77.59 ± 0.12</td><td></td><td></td></tr><tr><td>E3BM (Liu et al. (2020c))</td><td>63.80 ±0.40</td><td>80.29 ±0.25</td><td></td><td></td></tr><tr><td>Metric-based</td><td></td><td></td><td></td><td></td></tr><tr><td>Matching Net (Vinyals et al. (2016))</td><td>43.56 ± 0.84</td><td>55.31 ± 0.73</td><td>56.53 ± 0.99</td><td>63.54 ± 0.85</td></tr><tr><td>Prototypical Net (Snell et al. (2017))</td><td>54.16 ± 0.82</td><td>73.68 ±0.65</td><td>72.99±0.88</td><td>86.64± 0.51</td></tr><tr><td>Baseline++ (Chen et al. (2019a))</td><td>51.87 ± 0.77</td><td>75.68 ± 0.63</td><td>67.02 ±0.90</td><td>83.58 ± 0.54</td></tr><tr><td>Variational Few-shot(Zhang et al. (2019))</td><td>61.23 ±0.26</td><td>77.69 ± 0.17</td><td></td><td></td></tr><tr><td>Negative-Cosine(Liu et al. (2020a))</td><td>62.33 ±0.82</td><td>80.94± 0.59</td><td>72.66 ± 0.85</td><td>89.40 ± 0.43</td></tr><tr><td>Generation-based</td><td></td><td></td><td></td><td></td></tr><tr><td>MetaGAN (Zhang et al. (2018))</td><td>52.71 ± 0.64</td><td>68.63±0.67</td><td></td><td></td></tr><tr><td>Delta-Encoder (Schwartz et al. (2018))</td><td>59.9</td><td>69.7</td><td>69.8</td><td>82.6</td></tr><tr><td>TriNet (Chen et al. (2019b))</td><td>58.12 ± 1.37</td><td>76.92 ±0.69</td><td>69.61± 0.46</td><td>84.10 ± 0.35</td></tr><tr><td>Meta Variance Transfer (Park etal. (2020))</td><td>-</td><td>67.67 ± 0.70</td><td>1</td><td>80.33 ±0.61</td></tr><tr><td>Maximum Likelihood with DC (Ours)</td><td>66.91± 0.17</td><td>80.74±0.48</td><td>77.22± 0.14</td><td>89.58±0.27</td></tr><tr><td>SVM with DC (Ours)</td><td>67.31 ± 0.83</td><td>82.30 ± 0.34</td><td>79.49 ± 0.33</td><td>90.26 ± 0.98</td></tr><tr><td>Logistic Regression with DC (Ours)</td><td>68.57 ± 0.55</td><td>82.88 ± 0.42</td><td>79.56 ± 0.87</td><td>90.67 ± 0.35</td></tr></table>
+
+where $\alpha$ is a hyper-parameter that determines the degree of dispersion of features sampled from the calibrated distribution.
+
+For few-shot learning with more than one shot, the aforementioned procedure of the distribution calibration should be undertaken multiple times with each time using one feature vector from the support set. This avoids the bias provided by one specific sample and potentially achieves more diverse and accurate distribution estimation. Thus, for simplicity, we denote the calibrated distribution as a set of statistics. For a class $y \in C _ { n }$ , we denote the set of statistics as $\mathbb { S } _ { y } = \{ ( \boldsymbol { \mu } _ { 1 } ^ { \prime } , \boldsymbol { \Sigma } _ { 1 } ^ { \prime } ) , . . . , ( \boldsymbol { \mu } _ { K } ^ { \prime } , \boldsymbol { \Sigma } _ { K } ^ { \prime } ) \}$ , where $\mu _ { i } ^ { ' } , \Sigma _ { i } ^ { ' }$ are the calibrated mean and covariance, respectively, computed based on the $i$ -th feature in the support set of class $y$ . Here, the size of the set is the value of $K$ for an $\mathbf { N } .$ -way-K-shot task.
+
+# 3.2.3 HOW TO LEVERAGE THE CALIBRATED DISTRIBUTION?
+
+With a set of calibrated statistics $\mathbb { S } _ { y }$ for class $y$ in a target task, we generate a set of feature vectors with label $y$ by sampling from the calibrated Gaussian distributions:
+
+$$
+\mathbb { D } _ { y } = \{ ( \boldsymbol { x } , y ) | \boldsymbol { x } \sim \mathcal { N } ( \boldsymbol { \mu } , \boldsymbol { \Sigma } ) , \forall ( \boldsymbol { \mu } , \boldsymbol { \Sigma } ) \in \mathbb { S } ^ { y } \} .
+$$
+
+Here, the total number of generated features per class is set as a hyperparameter and they are equally distributed for every calibrated distribution in $\mathbb { S } _ { y }$ . The generated features along with the original support set features for a few-shot task is then served as the training data for a task-specific classifier. We train the classifier for a task by minimizing the cross-entropy loss over both the features of its support set $s$ and the generated features $\mathbb { D } _ { y }$ :
+
+$$
+\ell = \sum _ { ( \pmb { x } , y ) \sim \tilde { S } \cup \mathbb { D } _ { y , y \in \mathcal { V } } \mathcal { T } } - \log \operatorname* { P r } ( y | \pmb { x } ; \theta ) ,
+$$
+
+where $y ^ { \tau }$ is the set of classes for the task $\tau$ . $\tilde { \cal S }$ denotes the support set with features transformed by Turkey’s Ladder of Powers transformation and the classifier model is parameterized by $\theta$ .
+
+# 4 EXPERIMENTS
+
+In this section, we answer the following questions:
+
+• How does our distribution calibration strategy perform compared to the state-of-the-art methods?
+
+Table 3: 5way1shot and 5way5shot classification accuracy $( \% )$ on tieredImageNet (Ren et al., 2018). The numbers in bold have intersecting confidence intervals with the most accurate method.   
+
+<table><tr><td>Methods</td><td colspan="2">tieredImageNet</td></tr><tr><td></td><td>5way1shot</td><td>5way5shot</td></tr><tr><td>Matching Net (Vinyals et al. (2016))</td><td>68.50 ± 0.92</td><td>80.60±0.71</td></tr><tr><td>Prototypical Net (Snell et al. (2017))</td><td>65.65 ± 0.92</td><td>83.40 ± 0.65</td></tr><tr><td>LEO (Rusu et al. (2019))</td><td>66.33± ( 0.05</td><td>82.06 ±0.08</td></tr><tr><td>E3BM (Liu et al. (2020c))</td><td>71.20 士 0.40</td><td>85.30 ± 0.30</td></tr><tr><td>DeepEMD (Zhang et al., 2020)</td><td>71.16 ± 0.87</td><td>86.03 ± 0.58</td></tr><tr><td rowspan="2">MaximumLikelihood with DC (Ours) SVM with DC (Ours)</td><td>75.92 士 0.60</td><td>87.84 ± 0.65</td></tr><tr><td>77.93 ± ( 0.12</td><td>89.72 ± 0.37</td></tr><tr><td rowspan="2">Logistic Regression with DC (Ours)</td><td>78.19 ± 0.25</td><td>89.90 ± 0.41</td></tr><tr><td></td><td></td></tr></table>
+
+• What does calibrated distribution look like? Is it an accurate approximation for this class? • How does Tukey’s Ladder of Power transformation interact with the feature generations? How important is each in relation to performance?
+
+# 4.1 EXPERIMENTAL SETUP
+
+# 4.1.1 DATASETS
+
+We evaluate our distribution calibration strategy on miniImageNet (Ravi & Larochelle (2017)), tieredImageNet (Ren et al. (2018)) and CUB (Welinder et al. (2010)). miniImageNet and tieredImageNet have a brand range of classes including various animals and objects while CUB is a more fine-grained dataset that includes various species of birds. Datasets with different levels of granularity may have different distributions for their feature space. We want to show the effectiveness and generality of our strategy on all three datasets.
+
+miniImageNet is derived from ILSVRC-12 dataset (Russakovsky et al., 2014). It contains 100 diverse classes with 600 samples per class. The image size is $8 4 \times 8 4 \times 3$ . We follow the splits used in previous works (Ravi & Larochelle, 2017), which split the dataset into 64 base classes, 16 validation classes, and 20 novel classes.
+
+tieredImageNet is a larger subset of ILSVRC-12 dataset (Russakovsky et al., 2014), which contains 608 classes sampled from hierarchical category structure. Each class belongs to one of 34 higherlevel categories sampled from the high-level nodes in the ImageNet. The average number of images in each class is 1281. We use 351, 97, and 160 classes for training, validation, and test, respectively.
+
+CUB is a fine-grained few-shot classification benchmark. It contains 200 different classes of birds with a total of 11,788 images of size $8 4 \times 8 4 \times 3$ . Following previous works (Chen et al., 2019a), we split the dataset into 100 base classes, 50 validation classes, and 50 novel classes.
+
+# 4.1.2 EVALUATION METRIC
+
+We use the top-1 accuracy as the evaluation metric to measure the performance of our method. We report the accuracy on 5way1shot and 5way5shot settings for miniImageNet, tieredImageNet and CUB. The reported results are the averaged classification accuracy over 10,000 tasks.
+
+# 4.1.3 IMPLEMENTATION DETAILS
+
+For feature extractor, we use the WideResNet (Zagoruyko & Komodakis, 2016) trained following previous work (Mangla et al. (2020)). For each dataset, we train the feature extractor with base classes and test the performance using novel classes. Note that the feature representation is extracted from the penultimate layer (with a ReLU activation function) from the feature extractor, thus the values are all non-negative so that the inputs to Tukey’s Ladder of Powers transformation in Equation 3 are valid. At the distribution calibration stage, we compute the base class statistics and transfer them to calibrate novel class distribution for each dataset. We use the LR and SVM implementation of scikit-learn (Pedregosa et al. (2011)) with the default settings. We use the same hyperparameter value for all datasets except for $\alpha$ . Specifically, the number of generated features is 750; $k = 2$ and $\lambda = 0 . 5$ . $\alpha$ is 0.21, 0.21 and 0.3 for miniImageNet, tieredImageNet and CUB, respectively.
+
+![](images/deecfda56372ac9b0994653778df74588488d220e75ca612d156efd4b51701da.jpg)  
+Figure 2: t-SNE visualization of our distribution estimation. Different colors represent different classes. ‘F’ represents support set features, $\mathbf { \dot { x } } _ { } ,$ in figure (d) represents query set features, $\mathbf { \check { \Psi } } _ { \mathbf { A } } \mathbf { \Psi } ^ { * }$ in figure (b)(c) represents generated features.
+
+![](images/225124df96764e8072f5bdd807a6440c9593e2d01102fc20827feba072ac1a98.jpg)  
+Figure 3: Left: Accuracy when increasing the power in Tukey’s transformation when training with (red) or without (blue) the generated features. Right: Accuracy when increasing the number of generated features with the features are transformed by Tukey’s transformation (red) and without Tukey’s transformation (blue).
+
+# 4.2 COMPARISION TO STATE-OF-THE-ART
+
+Table 2 and Table 3 presents the 5way1shot and 5way5shot classification results of our method on miniImageNet, tieredImageNet and CUB. We compare our method with the three groups of the fewshot learning method, optimization-based, metric-based, and generation-based. Our method can be built on top of any classifier, and we use two popular and simple classifiers, namely SVM and LR to prove the effectiveness of our method. Simple linear classifiers equipped with our method perform better than the state-of-the-art few-shot classification method and achieve the best performance on 1-shot and 5-shot settings of miniImageNet, tieredImageNet and CUB. The performance of our distribution calibration surpasses the state-of-the-art generation-based method by $10 \%$ for the 5way1shot setting, which proves that our method can handle extremely low-shot classification tasks better. Compared to other generation-based methods, which require the design of a generative model with extra training costs on the learnable parameters, simple machine learning classifier with DC is much more simple, effective and flexible and can be equipped with any feature extractors and classifier model structures. Specifically, we show three variants, i.e, Maximum likelihood with DC, SVM with DC, Logistic Regression with DC in Table 2 and Table 3. A simple maximum likelihood classifier based on the calibrated distribution can outperform previous baselines and training a SVM classifier or Logistic Regression classifier using the samples from the calibrated distribution can further improve the performance.
+
+# 4.3 VISUALIZATION OF GENERATED SAMPLES
+
+We show what the calibrated distribution looks like by visualizing the generated features sampled from the distribution. In Figure 2, we show the t-SNE representation (van der Maaten & Hinton (2008)) of the original support set (a), the generated features (b,c) as well as the query set (d). Based on the calibrated distribution, the sampled features form a Gaussian distribution and more samples (c) can have a more comprehensive representation of the distribution. Due to the limited number of examples in the support set, only 1 in this case, the samples from the query set usually cover a greater area and are a mismatch with the support set. This mismatch can be fixed to some extent by the generated features, i.e., the generated features in (c) can overlap areas of the query set. Thus, training with these generated features can alleviate the mismatch between the distribution estimated only from the few-shot samples and the ground truth distribution.
+
+Table 4: Ablation study on miniImageNet 5way1shot and 5way5shot showing accuracy $( \% )$ with $9 5 \%$ confidence intervals.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Tukey transformationTraining with generated features</td><td colspan="2">miniImageNet</td></tr><tr><td>5way1shot</td><td>5way5shot</td></tr><tr><td>X</td><td>X</td><td>56.37± 0.68</td><td>79.03 ± 0.51</td></tr><tr><td></td><td>X</td><td>64.30 ± 0.53</td><td>81.33 ± 0.35</td></tr><tr><td>X</td><td>√</td><td>63.70 ± 0.38</td><td>82.26 ± 0.73</td></tr><tr><td>√</td><td>~</td><td>68.57 ± 0.55</td><td>82.88 ± 0.42</td></tr></table>
+
+Table 5: 5way1shot classification accuracy $( \% )$ on miniImageNet with different backbones.   
+
+<table><tr><td>Backbones</td><td>without DC</td><td>with DC</td></tr><tr><td>conv4 (Chen et al., 2019a)</td><td>42.11 ± 0.71</td><td>54.62± 0.64 (个12.51)</td></tr><tr><td>conv6 (Chen et al., 2019a)</td><td>46.07 ± 0.26</td><td>57.14 ± 0.45 (个 11.07)</td></tr><tr><td>resnet18 (Chen et al., 2019a)</td><td>52.32 土 0.82</td><td>61.50 士 0.47 （个 9.180)</td></tr><tr><td>WRN28 (Mangla etal., 2020)</td><td>54.53± 0.56</td><td>64.38 士 0.63 （个 9.850)</td></tr><tr><td>WRN28 + Rotation Loss (Mangla et al., 2020)</td><td>56.37 ± 0.68</td><td>68.57 士 0.55 5(个12.20)</td></tr></table>
+
+# 4.4 APPLICABILITY OF DISTRIBUTION CALIBRATION
+
+# Applying distribution calibration on different backbones
+
+Our distribution calibration strategy is agnostic to backbones $/$ feature extractors. Table 5 shows the consistent performance boost when applying distribution calibration on different feature extractors, i.e, four convolutional layers (conv4), six convolutional layers (conv6), resnet18, WRN28 and WRN28 trained with rotation loss. Distribution calibration achieves around $10 \%$ accuracy improvement compared to the backbones trained with different baselines.
+
+# Applying distribution calibration on other baselines
+
+A variety of works can benefit from training with the features generated by our distribution calibration strategy. We apply our distribution calibration strategy on two simple few-shot classification algorithms, Baseline (Chen et al., 2019a) and Baseline $^ { + + }$ (Chen et al., 2019a). Table 6 shows that our distribution calibration brings over $10 \%$ of accuracy improvement on both.
+
+# 4.5 EFFECTS OF FEATURE TRANSFORMATION AND TRAINING WITH GENERATED FEATURES
+
+# Ablation Study
+
+Table 4 shows the performance when our model is trained without Tukey’s Ladder of Powers transformation for the features as in Equation 3 and when it is trained without the generated features as in Equation 7. It is clear that there is a severe decline in performance of over $10 \%$ if both are not used in the 5way1shot setting. The ablation of either one results in a performance drop of around $5 \%$ in the 5way1shot setting.
+
+# Choices of Power for Tukey’s Ladder of Powers Transformation
+
+The left side of Figure 3 shows the 5way1shot accuracy when choosing different powers for the Tukey’s transformation in Equation 3 when training the classifier with the generated features (red) and without (blue). Note that when the power $\lambda$ equals 1, the transformation keeps the original feature representations. There is a consistent general tendency for training with and without the generated features and in both cases, we found $\lambda = 0 . 5$ is the optimum choice. With the Tukey’s transformation, the distribution of query set features in target tasks become more aligned to the calibrated Gaussian distribution, thus benefits the classifier which is trained on features sampled from the calibrated distribution.
+
+Table 6: 5way1shot classification accuracy $( \% )$ on miniImageNet with different baselines using distribution calibration.   
+
+<table><tr><td>Method</td><td>without DC</td><td>with DC</td></tr><tr><td>Baseline (Chen et al.,2019a) Baseline++ (Chen et al.,2019a)</td><td>42.11±0.71 48.24 ± 0.75</td><td>54.62 ± 0.64 (个 12.51) 61.24 ± 0.37 (个13.00)</td></tr></table>
+
+# Number of generated features
+
+The right side of Figure 3 analyzes whether more generated features results in consistent improvement in both cases, namely when the features of support and query set are transformed by Tukey’s transformation (red) and when they are not (blue). We found that when the number of generated features is below 500, both cases can benefit from more generated features. However, when more features are sampled, the performance of the classifier tested on untransformed features begins to decline. By training with the generated samples, the simple logistic regression classifier has a $12 \%$ relative performance improvement in a 1-shot classification setting.
+
+# 4.6 OTHER HYPER-PARAMETERS
+
+We select the hyperparameters based on the performance of the validation set. The $k$ base class statistics to calibrate the novel class distribution in Equation 5 is set to 2. Figure 4 shows the effect of different values of $k$ . The $\alpha$ in Equation 6 is a constant added on each element of the estimated covariance matrix, which can determine the degree of dispersion of features sampled from the calibrated distributions. An appropriate value of $\alpha$ can ensure a good decision boundary for the classifier. Different datasets have different statistics and an appropriate value of $\alpha$ may vary for different datasets. Figure 5 explores the effect of $\alpha$ on all three datasets, i.e. miniImageNet, tieredImageNet and CUB. We observe that in each dataset, the performance of the validation set and the novel (testing) set generally has the same tendency, which indicates that the variance is dataset-dependent and is not overfitting to a specific set.
+
+![](images/6c98d8c600fda1cf93a0bef20bb528be60e2ba30644285b61ad6f647f5bae774.jpg)  
+Figure 4: The effect of different values of $k$ .
+
+![](images/99d76257658bffe4a53b0ccea91b4619d0c3d8a51aeb9a45d4da77130bf715b8.jpg)  
+Figure 5: The effect of different values of $\alpha$
+
+# 5 CONCLUSION AND FUTURE WORKS
+
+We propose a simple but effective distribution calibration strategy for few-shot classification. Without complex generative models, training loss and extra parameters to learn, a simple logistic regression trained with features generated by our strategy outperforms the current state-of-the-art methods by $\sim 5 \%$ on miniImageNet. The calibrated distribution is visualized and demonstrates an accurate estimation of the feature distribution. Future works will explore the applicability of distribution calibration on more problem settings, such as multi-domain few-shot classification, and more methods, such as metric-based meta-learning algorithms.
+
+# REFERENCES
+
+Antreas Antoniou and Amos J. Storkey. Assume, augment and learn: Unsupervised few-shot metalearning via random labels and data augmentation. CoRR, 2019.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. In ICLR, 2019a.
+
+Zitian Chen, Yanwei Fu, Yinda Zhang, Yu-Gang Jiang, Xiangyang Xue, and Leonid Sigal. Multilevel semantic feature augmentation for one-shot learning. TIP, 28(9):4594–4605, 2019b.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, 2017.
+
+Hang Gao, Zheng Shou, Alireza Zareian, Hanwang Zhang, and Shih-Fu Chang. Low-shot learning via covariance-preserving adversarial augmentation networks. In NeurIPS, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NeurIPS, 2014.
+
+Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In ICCV, 2017.
+
+Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. CoRR, 2017.
+
+Bin Liu, Yue Cao, Yutong Lin, Qi Li, Zheng Zhang, Mingsheng Long, and Han Hu. Negative margin matters: Understanding margin in few-shot classification. In ECCV, 2020a.
+
+Jialun Liu, Yifan Sun, Chuchu Han, Zhaopeng Dou, and Wenhui Li. Deep representation learning on long-tailed data: A learnable embedding augmentation perspective. In CVPR, June 2020b.
+
+Lu Liu, Tianyi Zhou, Guodong Long, Jing Jiang, Lina Yao, and Chengqi Zhang. Prototype propagation networks (PPN) for weakly-supervised few-shot learning on category graph. In IJCAI, 2019a.
+
+Lu Liu, Tianyi Zhou, Guodong Long, Jing Jiang, and Chengqi Zhang. Learning to propagate for graph meta-learning. In NeurIPS, 2019b.
+
+Yaoyao Liu, Bernt Schiele, and Qianru Sun. An ensemble of epoch-wise empirical bayes for fewshot learning. In ECCV, 2020c.
+
+Puneet Mangla, Nupur Kumari, Abhishek Sinha, Mayank Singh, Balaji Krishnamurthy, and Vineeth N Balasubramanian. Charting the right manifold: Manifold mixup for few-shot learning. In WACV, 2020.
+
+Seong-Jin Park, Seungju Han, Ji-won Baek, Insoo Kim, Juhwan Song, Hae Beom Lee, Jae-Joon Han, and Sung Ju Hwang. Meta variance transfer: Learning to augment from the others. In ICML, 2020.
+
+F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011.
+
+Tiexin Qin, Wenbin Li, Yinghuan Shi, and Yang Gao. Diversity helps: Unsupervised few-shot learning via distribution shift-based data augmentation, 2020.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018.
+
+David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning Representations by Back-propagating Errors. Nature, 323:533–536, 1986.   
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. CoRR, abs/1409.0575, 2014.   
+Andrei A. Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. In ICLR, 2019.   
+Ruslan Salakhutdinov, Joshua Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In ICML workshop, 2012.   
+Eli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Abhishek Kumar, Rogerio Feris, Raja Giryes, and Alex Bronstein. Delta-encoder: an effective sample synthesis method for few-shot object recognition. In NeurIPS, 2018.   
+Jake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017.   
+John W Tukey. Exploratory data analysis. Addison-Wesley Series in Behavioral Science. AddisonWesley, Reading, MA, 1977. URL https://cds.cern.ch/record/107005.   
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE. Journal of Machine Learning Research, 2008.   
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. In NeurIPS, 2016.   
+Yu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In CVPR, 2018.   
+Yulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In NeurIPS, 2019.   
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.   
+Yongqin Xian, Tobias Lorenz, Bernt Schiele, and Zeynep Akata. Feature generating networks for zero-shot learning. In CVPR, 2018.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   
+Chi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Few-shot image classification with differentiable earth mover’s distance and structured classifiers. In CVPR, 2020.   
+Jian Zhang, Chenglong Zhao, Bingbing Ni, Minghao Xu, and Xiaokang Yang. Variational few-shot learning. In ICCV, 2019.   
+Ruixiang Zhang, Tong Che, Zoubin Ghahramani, Yoshua Bengio, and Yangqiu Song. Metagan: An adversarial approach to few-shot learning. In NeurIPS, 2018.
+
+![](images/0a660f4a0195daaa4161ed37a66854e795c54db5921767dfa35670ef13d69928.jpg)  
+Figure 6: We show the feature distribution of 5 base classes, and the feature distribution of 5 novel classes before/after Tukey’s Transformation.
+
+Table 7: The comparison with nearest class feature augmentation.   
+
+<table><tr><td>Training data</td><td>miniImageNet 5way1shot</td></tr><tr><td>Support set only</td><td>56.37±0.68</td></tr><tr><td>Support set + 1 feature from the nearest class</td><td>62.39 ± 0.49</td></tr><tr><td>Support set + 5 features from the nearest class</td><td>59.73 ± 0.42</td></tr><tr><td>Support set + 1O features from the nearest class</td><td>58.93 ± 0.49</td></tr><tr><td>Support set+1OO features from the nearest class</td><td>57.33 ± 0.48</td></tr><tr><td>Support set + 1OO features sampled from calibrated distribution</td><td>68.53 ± 0.32</td></tr></table>
+
+# A AUGMENTATION WITH NEAREST CLASS FEATURES
+
+Instead of sampling from the calibrated distribution, we can simply retrieve examples from the nearest class to augment the support set. Table 7 shows the comparison of training using samples from the calibrated distribution, the different number of retrieved features from the nearest class, and only using the support set. We found the retrieved features can improve the performance compared to only using the support set but can damage the performance when increasing the number of retrieved features, where the retrieved samples probably serve as noisy data for tasks targeting different classes.
+
+# B DISTRIBUTION CALIBRATION WITHOUT NOVEL FEATURE
+
+We calibrate the novel class mean by averaging the novel class mean and the retrieved base class means in Equation 6. Table 8 shows the distribution calibration without averaging novel feature, in which the calibrated mean is calculated as $\begin{array} { r } { \pmb { \mu } ^ { \prime } = \frac { \Sigma _ { i \in \mathbb { S } _ { N } } \pmb { \mu } _ { i } } { k } } \end{array}$ .
+
+# C THE EFFECTS OF TUKEY’S TRANSFORMATION
+
+Figure 6 shows the distribution of 5 base classes and 5 novel classes before/after Tukey’s transformation. It is observed that the base class distribution satisfies Gaussian assumption well (left) while the novel class distribution is more skew (middle). The novel class distribution after Tukey’s transformation (right) is more aligned with the Gaussian-like base class distribution.
+
+Table 8: The comparison between distribution calibration with and without novel feature $\tilde { \pmb x }$ .   
+
+<table><tr><td></td><td>miniImageNet 5way1shot</td></tr><tr><td>Distribution Calibration w/o novel feature x</td><td>59.38 ± 0.73</td></tr><tr><td>Distribution Calibration w/ novel feature x</td><td>68.57 ± 0.55</td></tr></table>
+
+<table><tr><td>Novel class</td><td>Top-1 base class similarity</td><td>Top-2 base class similarity</td><td>DC improvement</td></tr><tr><td>malamute</td><td>93%</td><td>85%</td><td>↑21.30%</td></tr><tr><td>golden retriever</td><td>85%</td><td>74%</td><td>个 18.37%</td></tr><tr><td>ant</td><td>71%</td><td>67%</td><td>↑9.77%</td></tr></table>
+
+Table 9: Performance improvement with respect to the similarity level between a query novel class and the most similar base classes.
+
+# D THE SIMILARITY LEVEL ANALYSIS
+
+We found that the higher similarities between the retrieved base class distribution and the novel class ground-truth distribution, the higher the performance improvement our method will bring as shown in Table 9. The results in the table are under 5-way-1-shot setting.

parse/train/JWOiYxMG92s/JWOiYxMG92s_content_list.json

@@ -0,0 +1,1560 @@
+[
+    {
+        "type": "text",
+        "text": "FREE LUNCH FOR FEW-SHOT LEARNING: DISTRIBUTION CALIBRATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            669,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shuo $\\mathbf { Y a n g ^ { 1 } }$ , Lu $\\mathbf { L i u ^ { 2 } }$ , Min $\\mathbf { X } \\mathbf { u } ^ { 1 * }$ 1School of Electrical and Data Engineering, University of Technology Sydney, 2Australian Artificial Intelligence Institute, University of Technology Sydney {shuo.yang, lu.liu-10}@student.uts.edu.au, min.xu@uts.edu.au, ",
+        "bbox": [
+            186,
+            169,
+            763,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning from a limited number of samples is challenging since the learned model can easily become overfitted based on the biased distribution formed by only a few training examples. In this paper, we calibrate the distribution of these fewsample classes by transferring statistics from the classes with sufficient examples. Then an adequate number of examples can be sampled from the calibrated distribution to expand the inputs to the classifier. We assume every dimension in the feature representation follows a Gaussian distribution so that the mean and the variance of the distribution can borrow from that of similar classes whose statistics are better estimated with an adequate number of samples. Our method can be built on top of off-the-shelf pretrained feature extractors and classification models without extra parameters. We show that a simple logistic regression classifier trained using the features sampled from our calibrated distribution can outperform the state-of-the-art accuracy on three datasets $5 \\%$ improvement on miniImageNet compared to the next best). The visualization of these generated features demonstrates that our calibrated distribution is an accurate estimation. The code is available at: https://github.com/ShuoYang-1998/Few_ Shot_Distribution_Calibration ",
+        "bbox": [
+            232,
+            297,
+            766,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            336,
+            580
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning from a limited number of training samples has drawn increasing attention due to the high cost of collecting and annotating a large amount of data. Researchers have developed algorithms to improve the performance of models that have been trained with very few data. Finn et al. (2017); Snell et al. (2017) train models in a meta-learning fashion so that the model can adapt quickly on tasks with only a few training samples available. Hariharan & Girshick (2017); Wang et al. (2018) try to synthesize data or features by learning a generative model to alleviate the data insufficiency problem. Ren et al. (2018) propose to leverage unlabeled data and predict pseudo labels to improve the performance of fewshot learning. ",
+        "bbox": [
+            174,
+            598,
+            607,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/729640e0c5cebe352c754de3283eba5aab89eb8e4d37dda0bd3487455079d830.jpg",
+        "table_caption": [
+            "Table 1: The class mean similarity (“mean sim”) and class variance similarity (“var sim”) between Arctic fox and different classes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Arctic fox</td></tr><tr><td>mean sim</td><td>var sim</td></tr><tr><td>white wolf</td><td>97%</td><td>97%</td></tr><tr><td>malamute</td><td>85%</td><td>78%</td></tr><tr><td>lion</td><td>81%</td><td>70%</td></tr><tr><td>meerkat</td><td>78%</td><td>70%</td></tr><tr><td> jellyfish</td><td>46%</td><td>26%</td></tr><tr><td>orange</td><td>40%</td><td>19%</td></tr><tr><td>beer bottle</td><td>34%</td><td>11%</td></tr></table>",
+        "bbox": [
+            627,
+            675,
+            816,
+            792
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While most previous works focus on developing stronger models, scant attention has been paid to the property of the data itself. It is natural that when the number of data grows, the ground truth distribution can be more accurately uncovered. Models trained with a wide coverage of data can generalize well during evaluation. On the other hand, when training a model with only a few training data, the model tends to overfit on these few samples by minimizing the training loss over these samples. These phenomena are illustrated in Figure 1. This biased distribution based on a few examples can damage the generalization ability of the model since it is far from mirroring the ground truth distribution from which test cases are sampled during evaluation. ",
+        "bbox": [
+            173,
+            771,
+            607,
+            813
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            813,
+            825,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4ca58d351dd312c05898a42b7dc7690158afa432c5ba49f7761c4aa20e3bb2e.jpg",
+        "image_caption": [
+            "Figure 1: Training a classifier from few-shot features makes the classifier overfit to the few examples (Left). Classifier trained with features sampled from calibrated distribution has better generalization ability (Right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            823,
+            241
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we consider calibrating this biased distribution into a more accurate approximation of the ground truth distribution. In this way, a model trained with inputs sampled from the calibrated distribution can generalize over a broader range of data from a more accurate distribution rather than only fitting itself to those few samples. Instead of calibrating the distribution of the original data space, we try to calibrate the distribution in the feature space, which has much lower dimensions and is easier to calibrate (Xian et al. (2018)). We assume every dimension in the feature vectors follows a Gaussian distribution and observe that similar classes usually have similar mean and variance of the feature representations, as shown in Table 1. Thus, the mean and variance of the Gaussian distribution can be transferred across similar classes (Salakhutdinov et al. (2012)). Meanwhile, the statistics can be estimated more accurately when there are adequate samples for this class. Based on these observations, we reuse the statistics from many-shot classes and transfer them to better estimate the distribution of the few-shot classes according to their class similarity. More samples can be generated according to the estimated distribution which provides sufficient supervision for training the classification model. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            502
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the experiments, we show that a simple logistic regression classifier trained with our strategy can achieve state-of-the-art accuracy on three datasets. Our distribution calibration strategy can be paired with any classifier and feature extractor with no extra learnable parameters. Training with samples selected from the calibrated distribution can achieve $12 \\%$ accuracy gain compared to the baseline which is only trained with the few samples given in a 5way1shot task. We also visualize the calibrated distribution and show that it is an accurate approximation of the ground truth that can better cover the test cases. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            607
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            354,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Few-shot classification is a challenging machine learning problem and researchers have explored the idea of learning to learn or meta-learning to improve the quick adaptation ability to alleviate the few-shot challenge. One of the most general algorithms for meta-learning is the optimizationbased algorithm. Finn et al. (2017) and Li et al. (2017) proposed to learn how to optimize the gradient descent procedure so that the learner can have a good initialization, update direction, and learning rate. For the classification problem, researchers proposed simple but effective algorithms based on metric learning. MatchingNet (Vinyals et al., 2016) and ProtoNet (Snell et al., 2017) learned to classify samples by comparing the distance to the representatives of each class. Our distribution calibration and feature sampling procedure does not include any learnable parameters and the classifier is trained in a traditional supervised learning way. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another line of algorithms is to compensate for the insufficient number of available samples by generation. Most methods use the idea of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) or autoencoder (Rumelhart et al., 1986) to generate samples (Zhang et al. (2018); Chen et al. (2019b); Schwartz et al. (2018); Gao et al. (2018)) or features (Xian et al. (2018); Zhang et al. (2019)) to augment the training set. Specifically, Zhang et al. (2018) and Xian et al. (2018) proposed to synthesize data by introducing an adversarial generator conditioned on tasks. Zhang et al. (2019) tried to learn a variational autoencoder to approximate the distribution and predict labels based on the estimated statistics. The autoencoder can also augment samples by projecting between the visual space and the semantic space (Chen et al., 2019b) or encoding the intra-class deformations (Schwartz et al., 2018). Liu et al. (2019b) and Liu et al. (2019a) propose to generate features through the class hierarchy. While these methods can generate extra samples or features for training, they require the design of a complex model and loss function to learn how to generate. However, our distribution calibration strategy is simple and does not need extra learnable parameters. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation is a traditional and effective way of increasing the number of training samples. Qin et al. (2020) and Antoniou & Storkey (2019) proposed the used of the traditional data augmentation technique to construct pretext tasks for unsupervised few-shot learning. Wang et al. (2018) and Hariharan & Girshick (2017) leveraged the general idea of data augmentation, they designed a hallucination model to generate the augmented version of the image with different choices for the model’s input, i.e., an image and a noise (Wang et al., 2018) or the concatenation of multiple features (Hariharan & Girshick, 2017). Park et al. (2020); Wang et al. (2019); Liu et al. (2020b) tried to augment feature representations by leveraging intra-class variance. These methods learn to augment from the original samples or their feature representation while we try to estimate the classlevel distribution and thus can eliminate the inductive bias from a single sample and provide more diverse generations from the calibrated distribution. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MAIN APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            352,
+            352,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the few-shot classification problem definition in Section 3.1 and details of our proposed approach in Section 3.2. ",
+        "bbox": [
+            174,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            370,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We follow a typical few-shot classification setting. Given a dataset with data-label pairs $\\mathcal { D } =$ $\\{ ( x _ { i } , y _ { i } ) \\}$ where $\\pmb { x } _ { i } \\in \\mathbb { R } ^ { d }$ is the feature vector of a sample and $y _ { i } \\in C$ , where $C$ denotes the set of   \nclasses. This set of classes is divided into base classes $C _ { b }$ and novel classes $C _ { n }$ , where $C _ { b } \\cap C _ { n } = \\emptyset$   \nand $C _ { b } \\cup C _ { n } = C$ . The goal is to train a model on the data from the base classes so that the model   \ncan generalize well on tasks sampled from the novel classes. In order to evaluate the fast adaptation   \nability or the generalization ability of the model, there are only a few available labeled samples for   \neach task $\\tau$ . The most common way to build a task is called an N-way-K-shot task (Vinyals et al.   \n(2016)), where $\\mathbf { N }$ classes are sampled from the novel set and only $\\mathbf { K }$ (e.g., 1 or 5) labeled samples are   \nprovideand the for each class. The few available labeodel is evaluated on another query set set , wh $\\boldsymbol { S } = \\{ ( \\boldsymbol { x } _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { N \\times K }$ $\\mathcal { Q } = \\{ ( \\pmb { x } _ { i } , y _ { i } ) \\} _ { i = N \\times K + 1 } ^ { N \\times K + N \\times q }$ $q$   \nquery set of) multiple tasks sampled from the novel classes. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DISTRIBUTION CALIBRATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            419,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As introduced in Section 3.1, the base classes have a sufficient amount of data while the evaluation tasks sampled from the novel classes only have a limited number of labeled samples. The statistics of the distribution for the base class can be estimated more accurately compared to the estimation based on few-shot samples, which is an ill-posed problem. As shown in Table 1, we observe that if we assume the feature distribution is Gaussian, the mean and variance with respect to each class are correlated to the semantic similarity of each class. With this in mind, the statistics can be transferred from the base classes to the novel classes if we learn how similar the two classes are. In the following sections, we discuss how we calibrate the distribution estimation of the classes with only a few samples (Section 3.2.2) with the help of the statistics of the base classes (Section 3.2.1). We will also elaborate on how do we leverage the calibrated distribution to improve the performance of few-shot learning (Section 3.2.3). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that our distribution calibration strategy is over the feature-level and is agnostic to any feature extractor. Thus, it can be built on top of any pretrained feature extractors without further costly finetuning. In our experiments, we use the pretrained WideResNet Zagoruyko & Komodakis (2016) following previous work (Mangla et al. (2020)). The WideResNet is trained to classify the base classes, along with a self-supervised pretext task to learn the general-purpose representations suitable for image understanding tasks. Please refer to their paper for more details on training the feature extractor. ",
+        "bbox": [
+            173,
+            827,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Training procedure for an N-way-K-shot task ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            560,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\pmb { S } = ( \\pmb { x } _ { i } , y ) _ { i = 1 } ^ { N \\times K }$ $\\{ \\pmb { \\mu } _ { i } \\} _ { i = 1 } ^ { | C _ { b } | } , \\{ \\pmb { \\Sigma } _ { i } \\} _ { i = 1 } ^ { | C _ { b } | }$ ",
+        "bbox": [
+            176,
+            125,
+            460,
+            138
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            141,
+            490,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Transform $\\left( \\pmb { x } _ { i } \\right) _ { i = 1 } ^ { N \\times K }$ i=1 i=1with Tukey’s Ladder of Powers as Equation 3   \n2: for $( x _ { i } , y _ { i } ) \\in S$ do   \n3: Calibrate the mean $\\mu ^ { \\prime }$ and the covariance $\\pmb { \\Sigma } ^ { \\prime }$ for class $y _ { i }$ using $\\mathbf { \\Delta } \\mathbf { x } _ { i }$ with Equation 6   \n4: Sample features for class $y _ { i }$ from the calibrated distribution as Equation 7   \n5: end for   \n6: Train a classifier using both support set features and all sampled features as Equation 8 ",
+        "bbox": [
+            179,
+            155,
+            710,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 STATISTICS OF THE BASE CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            468,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We assume the feature distribution of base classes is Gaussian. The mean of the feature vector from a base class $i$ is calculated as the mean of every single dimension in the vector: ",
+        "bbox": [
+            171,
+            287,
+            823,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/298c1e0652e4d470640e61c9f2900dfc8ff2cdad3fe60b2d2ed9aa32be5d13a0.jpg",
+        "text": "$$\n\\mu _ { i } = \\frac { \\sum _ { j = 1 } ^ { n _ { i } } { \\pmb x } _ { j } } { n _ { i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            320,
+            553,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { j } }$ is a feature vector of the $j$ -th sample from the base class $i$ and $n _ { i }$ is the total number of samples in class $i$ . As the feature vector $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { j } }$ is multi-dimensional, we use covariance for a better representation of the variance between any pair of elements in the feature vector. The covariance matrix $\\Sigma _ { i }$ for the features from class $i$ is calculated as: ",
+        "bbox": [
+            174,
+            362,
+            825,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/297eab7cfd165ab965607a507a4f84db0d001d81e04c02a5ca15cc9ece11c7c8.jpg",
+        "text": "$$\n\\pmb { \\Sigma } _ { i } = \\frac { 1 } { n _ { i } - 1 } \\sum _ { j = 1 } ^ { n _ { i } } \\left( \\pmb { x } _ { j } - \\pmb { \\mu } _ { i } \\right) \\left( \\pmb { x } _ { j } - \\pmb { \\mu } _ { i } \\right) ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            422,
+            637,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 CALIBRATING STATISTICS OF THE NOVEL CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            478,
+            583,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we consider an N-way-K-shot task sampled from the novel classes. ",
+        "bbox": [
+            176,
+            502,
+            653,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tukey’s Ladder of Powers Transformation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            472,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make the feature distribution more Gaussian-like, we first transform the features of the support set and query set in the target task using Tukey’s Ladder of Powers transformation (Tukey (1977)). Tukey’s Ladder of Powers transformation is a family of power transformations which can reduce the skewness of distributions and make distributions more Gaussian-like. Tukey’s Ladder of Powers transformation is formulated as: ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ec8c825328536e635434f148cb10d0bdf4d0b5439e07a8a5d281462caaff3fe.jpg",
+        "text": "$$\n\\tilde { \\mathbf { x } } = \\left\\{ \\begin{array} { l l } { x ^ { \\lambda } } & { \\mathrm { ~ i f ~ } \\lambda \\neq 0 } \\\\ { \\log ( \\pmb { x } ) } & { \\mathrm { ~ i f ~ } \\lambda = 0 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            617,
+            584,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a hyper-parameter to adjust how to correct the distribution. The original feature can be recovered by setting $\\lambda$ as 1. Decreasing $\\lambda$ makes the distribution less positively skewed and vice versa. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Calibration through statistics transfer ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            707,
+            441,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using the statistics from the base classes introduced in Section 3.2.1, we transfer the statistics from the base classes which are estimated more accurately on sufficient data to the novel classes. The transfer is based on the Euclidean distance between the feature space of the novel classes and the mean of the features from the base classes $\\pmb { \\mu _ { i } }$ as computed in Equation 1. Specifically, we select the top $k$ base classes with the closest distance to the feature of a sample $\\tilde { \\pmb x }$ from the support set: ",
+        "bbox": [
+            173,
+            728,
+            825,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59d97707c1272a00da2a6e8cc19017ea60e5b0d6ad6fd3e33601ca3beeff2506.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { S } _ { d } = \\{ - \\| \\pmb { \\mu } _ { i } - \\tilde { \\pmb { x } } \\| ^ { 2 } | i \\in C _ { b } \\} , } \\\\ { \\mathbb { S } _ { N } = \\{ i | - \\| \\pmb { \\mu } _ { i } - \\tilde { \\pmb { x } } \\| ^ { 2 } \\in t o p k ( \\mathbb { S } _ { d } ) \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            801,
+            625,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t o p k ( \\cdot )$ is an operator to select the top elements from the input distance set $\\mathbb { S } _ { d }$ . $\\mathbb { S } _ { N }$ stores the $k$ nearest base classes with respect to a feature vector $\\tilde { \\pmb x }$ . Then, the mean and covariance of the distribution is calibrated by the statistics from the nearest base classes: ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ce25a499ae02fd026afcbfd1ea4026ef73782c79e790ab4f08553917a609657.jpg",
+        "text": "$$\n\\pmb { \\mu } ^ { \\prime } = \\frac { \\sum _ { i \\in \\mathbb { S } _ { N } } \\pmb { \\mu } _ { i } + \\tilde { \\pmb { x } } } { k + 1 } , \\pmb { \\Sigma } ^ { \\prime } = \\frac { \\sum _ { i \\in \\mathbb { S } _ { N } } \\pmb { \\Sigma } _ { i } } { k } + \\alpha ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            893,
+            648,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/11ad467cb85ab8e79b861d18690e5eef31d74bee53d821d1d91b753a15452d15.jpg",
+        "table_caption": [
+            "Table 2: 5way1shot and 5way5shot classification accuracy $( \\% )$ on miniImageNet and CUB with $9 5 \\%$ confidence intervals. The numbers in bold have intersecting confidence intervals with the most accurate method. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td colspan=\"2\">miniImageNet</td><td colspan=\"2\">CUB</td></tr><tr><td>5way1shot</td><td>5way5shot</td><td>5way1shot</td><td>5way5shot</td></tr><tr><td>Optimization-based</td><td></td><td></td><td></td><td></td></tr><tr><td>MAML (Finn et al. (2017))</td><td>48.70 ±1.84</td><td>63.10 ± 0.92</td><td>50.45 ±0.97 59.60 ± 0.84</td><td></td></tr><tr><td>Meta-SGD (Li et al. (2017))</td><td>50.47 ± 1.87</td><td>64.03 ±0.94</td><td>53.34± 0.97</td><td>67.59 ±0.82</td></tr><tr><td>LEO (Rusu et al. (2019))</td><td>61.76 ± 0.08</td><td>77.59 ± 0.12</td><td></td><td></td></tr><tr><td>E3BM (Liu et al. (2020c))</td><td>63.80 ±0.40</td><td>80.29 ±0.25</td><td></td><td></td></tr><tr><td>Metric-based</td><td></td><td></td><td></td><td></td></tr><tr><td>Matching Net (Vinyals et al. (2016))</td><td>43.56 ± 0.84</td><td>55.31 ± 0.73</td><td>56.53 ± 0.99</td><td>63.54 ± 0.85</td></tr><tr><td>Prototypical Net (Snell et al. (2017))</td><td>54.16 ± 0.82</td><td>73.68 ±0.65</td><td>72.99±0.88</td><td>86.64± 0.51</td></tr><tr><td>Baseline++ (Chen et al. (2019a))</td><td>51.87 ± 0.77</td><td>75.68 ± 0.63</td><td>67.02 ±0.90</td><td>83.58 ± 0.54</td></tr><tr><td>Variational Few-shot(Zhang et al. (2019))</td><td>61.23 ±0.26</td><td>77.69 ± 0.17</td><td></td><td></td></tr><tr><td>Negative-Cosine(Liu et al. (2020a))</td><td>62.33 ±0.82</td><td>80.94± 0.59</td><td>72.66 ± 0.85</td><td>89.40 ± 0.43</td></tr><tr><td>Generation-based</td><td></td><td></td><td></td><td></td></tr><tr><td>MetaGAN (Zhang et al. (2018))</td><td>52.71 ± 0.64</td><td>68.63±0.67</td><td></td><td></td></tr><tr><td>Delta-Encoder (Schwartz et al. (2018))</td><td>59.9</td><td>69.7</td><td>69.8</td><td>82.6</td></tr><tr><td>TriNet (Chen et al. (2019b))</td><td>58.12 ± 1.37</td><td>76.92 ±0.69</td><td>69.61± 0.46</td><td>84.10 ± 0.35</td></tr><tr><td>Meta Variance Transfer (Park etal. (2020))</td><td>-</td><td>67.67 ± 0.70</td><td>1</td><td>80.33 ±0.61</td></tr><tr><td>Maximum Likelihood with DC (Ours)</td><td>66.91± 0.17</td><td>80.74±0.48</td><td>77.22± 0.14</td><td>89.58±0.27</td></tr><tr><td>SVM with DC (Ours)</td><td>67.31 ± 0.83</td><td>82.30 ± 0.34</td><td>79.49 ± 0.33</td><td>90.26 ± 0.98</td></tr><tr><td>Logistic Regression with DC (Ours)</td><td>68.57 ± 0.55</td><td>82.88 ± 0.42</td><td>79.56 ± 0.87</td><td>90.67 ± 0.35</td></tr></table>",
+        "bbox": [
+            179,
+            137,
+            818,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is a hyper-parameter that determines the degree of dispersion of features sampled from the calibrated distribution. ",
+        "bbox": [
+            174,
+            431,
+            823,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For few-shot learning with more than one shot, the aforementioned procedure of the distribution calibration should be undertaken multiple times with each time using one feature vector from the support set. This avoids the bias provided by one specific sample and potentially achieves more diverse and accurate distribution estimation. Thus, for simplicity, we denote the calibrated distribution as a set of statistics. For a class $y \\in C _ { n }$ , we denote the set of statistics as $\\mathbb { S } _ { y } = \\{ ( \\boldsymbol { \\mu } _ { 1 } ^ { \\prime } , \\boldsymbol { \\Sigma } _ { 1 } ^ { \\prime } ) , . . . , ( \\boldsymbol { \\mu } _ { K } ^ { \\prime } , \\boldsymbol { \\Sigma } _ { K } ^ { \\prime } ) \\}$ , where $\\mu _ { i } ^ { ' } , \\Sigma _ { i } ^ { ' }$ are the calibrated mean and covariance, respectively, computed based on the $i$ -th feature in the support set of class $y$ . Here, the size of the set is the value of $K$ for an $\\mathbf { N } .$ -way-K-shot task. ",
+        "bbox": [
+            173,
+            465,
+            826,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 HOW TO LEVERAGE THE CALIBRATED DISTRIBUTION? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            597,
+            604,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With a set of calibrated statistics $\\mathbb { S } _ { y }$ for class $y$ in a target task, we generate a set of feature vectors with label $y$ by sampling from the calibrated Gaussian distributions: ",
+        "bbox": [
+            173,
+            621,
+            820,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77713cd24fecbab7d209f19a561ba84822628074bf420a6fbf7482c4dcf53b20.jpg",
+        "text": "$$\n\\mathbb { D } _ { y } = \\{ ( \\boldsymbol { x } , y ) | \\boldsymbol { x } \\sim \\mathcal { N } ( \\boldsymbol { \\mu } , \\boldsymbol { \\Sigma } ) , \\forall ( \\boldsymbol { \\mu } , \\boldsymbol { \\Sigma } ) \\in \\mathbb { S } ^ { y } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            652,
+            648,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, the total number of generated features per class is set as a hyperparameter and they are equally distributed for every calibrated distribution in $\\mathbb { S } _ { y }$ . The generated features along with the original support set features for a few-shot task is then served as the training data for a task-specific classifier. We train the classifier for a task by minimizing the cross-entropy loss over both the features of its support set $s$ and the generated features $\\mathbb { D } _ { y }$ : ",
+        "bbox": [
+            173,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e01653938acccc253d7761e7b2976f4c72b273d7dd9e6800450d7bc8b2ba681.jpg",
+        "text": "$$\n\\ell = \\sum _ { ( \\pmb { x } , y ) \\sim \\tilde { S } \\cup \\mathbb { D } _ { y , y \\in \\mathcal { V } } \\mathcal { T } } - \\log \\operatorname* { P r } ( y | \\pmb { x } ; \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            746,
+            627,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y ^ { \\tau }$ is the set of classes for the task $\\tau$ . $\\tilde { \\cal S }$ denotes the support set with features transformed by Turkey’s Ladder of Powers transformation and the classifier model is parameterized by $\\theta$ . ",
+        "bbox": [
+            171,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            839,
+            328,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we answer the following questions: ",
+        "bbox": [
+            173,
+            869,
+            504,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• How does our distribution calibration strategy perform compared to the state-of-the-art methods? ",
+        "bbox": [
+            212,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/8f25a110b59b2faf4dd832ccf5f222edc3ac26dbe5959bca90660d9ce0c8dc8c.jpg",
+        "table_caption": [
+            "Table 3: 5way1shot and 5way5shot classification accuracy $( \\% )$ on tieredImageNet (Ren et al., 2018). The numbers in bold have intersecting confidence intervals with the most accurate method. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td colspan=\"2\">tieredImageNet</td></tr><tr><td></td><td>5way1shot</td><td>5way5shot</td></tr><tr><td>Matching Net (Vinyals et al. (2016))</td><td>68.50 ± 0.92</td><td>80.60±0.71</td></tr><tr><td>Prototypical Net (Snell et al. (2017))</td><td>65.65 ± 0.92</td><td>83.40 ± 0.65</td></tr><tr><td>LEO (Rusu et al. (2019))</td><td>66.33± ( 0.05</td><td>82.06 ±0.08</td></tr><tr><td>E3BM (Liu et al. (2020c))</td><td>71.20 士 0.40</td><td>85.30 ± 0.30</td></tr><tr><td>DeepEMD (Zhang et al., 2020)</td><td>71.16 ± 0.87</td><td>86.03 ± 0.58</td></tr><tr><td rowspan=\"2\">MaximumLikelihood with DC (Ours) SVM with DC (Ours)</td><td>75.92 士 0.60</td><td>87.84 ± 0.65</td></tr><tr><td>77.93 ± ( 0.12</td><td>89.72 ± 0.37</td></tr><tr><td rowspan=\"2\">Logistic Regression with DC (Ours)</td><td>78.19 ± 0.25</td><td>89.90 ± 0.41</td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            264,
+            138,
+            732,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• What does calibrated distribution look like? Is it an accurate approximation for this class? • How does Tukey’s Ladder of Power transformation interact with the feature generations? How important is each in relation to performance? ",
+        "bbox": [
+            215,
+            305,
+            825,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            368,
+            375,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            395,
+            302,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our distribution calibration strategy on miniImageNet (Ravi & Larochelle (2017)), tieredImageNet (Ren et al. (2018)) and CUB (Welinder et al. (2010)). miniImageNet and tieredImageNet have a brand range of classes including various animals and objects while CUB is a more fine-grained dataset that includes various species of birds. Datasets with different levels of granularity may have different distributions for their feature space. We want to show the effectiveness and generality of our strategy on all three datasets. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            502
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "miniImageNet is derived from ILSVRC-12 dataset (Russakovsky et al., 2014). It contains 100 diverse classes with 600 samples per class. The image size is $8 4 \\times 8 4 \\times 3$ . We follow the splits used in previous works (Ravi & Larochelle, 2017), which split the dataset into 64 base classes, 16 validation classes, and 20 novel classes. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "tieredImageNet is a larger subset of ILSVRC-12 dataset (Russakovsky et al., 2014), which contains 608 classes sampled from hierarchical category structure. Each class belongs to one of 34 higherlevel categories sampled from the high-level nodes in the ImageNet. The average number of images in each class is 1281. We use 351, 97, and 160 classes for training, validation, and test, respectively. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CUB is a fine-grained few-shot classification benchmark. It contains 200 different classes of birds with a total of 11,788 images of size $8 4 \\times 8 4 \\times 3$ . Following previous works (Chen et al., 2019a), we split the dataset into 100 base classes, 50 validation classes, and 50 novel classes. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            678
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 EVALUATION METRIC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            693,
+            382,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use the top-1 accuracy as the evaluation metric to measure the performance of our method. We report the accuracy on 5way1shot and 5way5shot settings for miniImageNet, tieredImageNet and CUB. The reported results are the averaged classification accuracy over 10,000 tasks. ",
+        "bbox": [
+            176,
+            717,
+            823,
+            760
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            773,
+            419,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For feature extractor, we use the WideResNet (Zagoruyko & Komodakis, 2016) trained following previous work (Mangla et al. (2020)). For each dataset, we train the feature extractor with base classes and test the performance using novel classes. Note that the feature representation is extracted from the penultimate layer (with a ReLU activation function) from the feature extractor, thus the values are all non-negative so that the inputs to Tukey’s Ladder of Powers transformation in Equation 3 are valid. At the distribution calibration stage, we compute the base class statistics and transfer them to calibrate novel class distribution for each dataset. We use the LR and SVM implementation of scikit-learn (Pedregosa et al. (2011)) with the default settings. We use the same hyperparameter value for all datasets except for $\\alpha$ . Specifically, the number of generated features is 750; $k = 2$ and $\\lambda = 0 . 5$ . $\\alpha$ is 0.21, 0.21 and 0.3 for miniImageNet, tieredImageNet and CUB, respectively. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/deecfda56372ac9b0994653778df74588488d220e75ca612d156efd4b51701da.jpg",
+        "image_caption": [
+            "Figure 2: t-SNE visualization of our distribution estimation. Different colors represent different classes. ‘F’ represents support set features, $\\mathbf { \\dot { x } } _ { } ,$ in figure (d) represents query set features, $\\mathbf { \\check { \\Psi } } _ { \\mathbf { A } } \\mathbf { \\Psi } ^ { * }$ in figure (b)(c) represents generated features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            823,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/225124df96764e8072f5bdd807a6440c9593e2d01102fc20827feba072ac1a98.jpg",
+        "image_caption": [
+            "Figure 3: Left: Accuracy when increasing the power in Tukey’s transformation when training with (red) or without (blue) the generated features. Right: Accuracy when increasing the number of generated features with the features are transformed by Tukey’s transformation (red) and without Tukey’s transformation (blue). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            303,
+            792,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            540,
+            825,
+            570
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPARISION TO STATE-OF-THE-ART ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            477,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 and Table 3 presents the 5way1shot and 5way5shot classification results of our method on miniImageNet, tieredImageNet and CUB. We compare our method with the three groups of the fewshot learning method, optimization-based, metric-based, and generation-based. Our method can be built on top of any classifier, and we use two popular and simple classifiers, namely SVM and LR to prove the effectiveness of our method. Simple linear classifiers equipped with our method perform better than the state-of-the-art few-shot classification method and achieve the best performance on 1-shot and 5-shot settings of miniImageNet, tieredImageNet and CUB. The performance of our distribution calibration surpasses the state-of-the-art generation-based method by $10 \\%$ for the 5way1shot setting, which proves that our method can handle extremely low-shot classification tasks better. Compared to other generation-based methods, which require the design of a generative model with extra training costs on the learnable parameters, simple machine learning classifier with DC is much more simple, effective and flexible and can be equipped with any feature extractors and classifier model structures. Specifically, we show three variants, i.e, Maximum likelihood with DC, SVM with DC, Logistic Regression with DC in Table 2 and Table 3. A simple maximum likelihood classifier based on the calibrated distribution can outperform previous baselines and training a SVM classifier or Logistic Regression classifier using the samples from the calibrated distribution can further improve the performance. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            851
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 VISUALIZATION OF GENERATED SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            509,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show what the calibrated distribution looks like by visualizing the generated features sampled from the distribution. In Figure 2, we show the t-SNE representation (van der Maaten & Hinton (2008)) of the original support set (a), the generated features (b,c) as well as the query set (d). Based on the calibrated distribution, the sampled features form a Gaussian distribution and more samples (c) can have a more comprehensive representation of the distribution. Due to the limited number of examples in the support set, only 1 in this case, the samples from the query set usually cover a greater area and are a mismatch with the support set. This mismatch can be fixed to some extent by the generated features, i.e., the generated features in (c) can overlap areas of the query set. Thus, training with these generated features can alleviate the mismatch between the distribution estimated only from the few-shot samples and the ground truth distribution. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/495800d492a5909be5c38c856e3eb02e222275b3e92ee3c159e4ba62484336bf.jpg",
+        "table_caption": [
+            "Table 4: Ablation study on miniImageNet 5way1shot and 5way5shot showing accuracy $( \\% )$ with $9 5 \\%$ confidence intervals. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Tukey transformationTraining with generated features</td><td colspan=\"2\">miniImageNet</td></tr><tr><td>5way1shot</td><td>5way5shot</td></tr><tr><td>X</td><td>X</td><td>56.37± 0.68</td><td>79.03 ± 0.51</td></tr><tr><td></td><td>X</td><td>64.30 ± 0.53</td><td>81.33 ± 0.35</td></tr><tr><td>X</td><td>√</td><td>63.70 ± 0.38</td><td>82.26 ± 0.73</td></tr><tr><td>√</td><td>~</td><td>68.57 ± 0.55</td><td>82.88 ± 0.42</td></tr></table>",
+        "bbox": [
+            196,
+            137,
+            803,
+            226
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b6d7116be072f066fab11c8d3844461b9a80e995d051819d9b360c696eb93ae.jpg",
+        "table_caption": [
+            "Table 5: 5way1shot classification accuracy $( \\% )$ on miniImageNet with different backbones. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbones</td><td>without DC</td><td>with DC</td></tr><tr><td>conv4 (Chen et al., 2019a)</td><td>42.11 ± 0.71</td><td>54.62± 0.64 (个12.51)</td></tr><tr><td>conv6 (Chen et al., 2019a)</td><td>46.07 ± 0.26</td><td>57.14 ± 0.45 (个 11.07)</td></tr><tr><td>resnet18 (Chen et al., 2019a)</td><td>52.32 土 0.82</td><td>61.50 士 0.47 （个 9.180)</td></tr><tr><td>WRN28 (Mangla etal., 2020)</td><td>54.53± 0.56</td><td>64.38 士 0.63 （个 9.850)</td></tr><tr><td>WRN28 + Rotation Loss (Mangla et al., 2020)</td><td>56.37 ± 0.68</td><td>68.57 士 0.55 5(个12.20)</td></tr></table>",
+        "bbox": [
+            210,
+            263,
+            789,
+            351
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            375,
+            825,
+            487
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 APPLICABILITY OF DISTRIBUTION CALIBRATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            549,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Applying distribution calibration on different backbones ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            570,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our distribution calibration strategy is agnostic to backbones $/$ feature extractors. Table 5 shows the consistent performance boost when applying distribution calibration on different feature extractors, i.e, four convolutional layers (conv4), six convolutional layers (conv6), resnet18, WRN28 and WRN28 trained with rotation loss. Distribution calibration achieves around $10 \\%$ accuracy improvement compared to the backbones trained with different baselines. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Applying distribution calibration on other baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            535,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A variety of works can benefit from training with the features generated by our distribution calibration strategy. We apply our distribution calibration strategy on two simple few-shot classification algorithms, Baseline (Chen et al., 2019a) and Baseline $^ { + + }$ (Chen et al., 2019a). Table 6 shows that our distribution calibration brings over $10 \\%$ of accuracy improvement on both. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            705
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 EFFECTS OF FEATURE TRANSFORMATION AND TRAINING WITH GENERATED FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            723,
+            810,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            748,
+            281,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the performance when our model is trained without Tukey’s Ladder of Powers transformation for the features as in Equation 3 and when it is trained without the generated features as in Equation 7. It is clear that there is a severe decline in performance of over $10 \\%$ if both are not used in the 5way1shot setting. The ablation of either one results in a performance drop of around $5 \\%$ in the 5way1shot setting. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Choices of Power for Tukey’s Ladder of Powers Transformation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            845,
+            620,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The left side of Figure 3 shows the 5way1shot accuracy when choosing different powers for the Tukey’s transformation in Equation 3 when training the classifier with the generated features (red) and without (blue). Note that when the power $\\lambda$ equals 1, the transformation keeps the original feature representations. There is a consistent general tendency for training with and without the generated features and in both cases, we found $\\lambda = 0 . 5$ is the optimum choice. With the Tukey’s transformation, the distribution of query set features in target tasks become more aligned to the calibrated Gaussian distribution, thus benefits the classifier which is trained on features sampled from the calibrated distribution. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a89032156b55e27bd72e23b3ac5152b30ec74af1be7c4612d2136e36853077a8.jpg",
+        "table_caption": [
+            "Table 6: 5way1shot classification accuracy $( \\% )$ on miniImageNet with different baselines using distribution calibration. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>without DC</td><td>with DC</td></tr><tr><td>Baseline (Chen et al.,2019a) Baseline++ (Chen et al.,2019a)</td><td>42.11±0.71 48.24 ± 0.75</td><td>54.62 ± 0.64 (个 12.51) 61.24 ± 0.37 (个13.00)</td></tr></table>",
+        "bbox": [
+            254,
+            138,
+            738,
+            184
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            207,
+            823,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Number of generated features ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            385,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The right side of Figure 3 analyzes whether more generated features results in consistent improvement in both cases, namely when the features of support and query set are transformed by Tukey’s transformation (red) and when they are not (blue). We found that when the number of generated features is below 500, both cases can benefit from more generated features. However, when more features are sampled, the performance of the classifier tested on untransformed features begins to decline. By training with the generated samples, the simple logistic regression classifier has a $12 \\%$ relative performance improvement in a 1-shot classification setting. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.6 OTHER HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            405,
+            416,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We select the hyperparameters based on the performance of the validation set. The $k$ base class statistics to calibrate the novel class distribution in Equation 5 is set to 2. Figure 4 shows the effect of different values of $k$ . The $\\alpha$ in Equation 6 is a constant added on each element of the estimated covariance matrix, which can determine the degree of dispersion of features sampled from the calibrated distributions. An appropriate value of $\\alpha$ can ensure a good decision boundary for the classifier. Different datasets have different statistics and an appropriate value of $\\alpha$ may vary for different datasets. Figure 5 explores the effect of $\\alpha$ on all three datasets, i.e. miniImageNet, tieredImageNet and CUB. We observe that in each dataset, the performance of the validation set and the novel (testing) set generally has the same tendency, which indicates that the variance is dataset-dependent and is not overfitting to a specific set. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c98d8c600fda1cf93a0bef20bb528be60e2ba30644285b61ad6f647f5bae774.jpg",
+        "image_caption": [
+            "Figure 4: The effect of different values of $k$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            583,
+            475,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/99d76257658bffe4a53b0ccea91b4619d0c3d8a51aeb9a45d4da77130bf715b8.jpg",
+        "image_caption": [
+            "Figure 5: The effect of different values of $\\alpha$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            582,
+            803,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            498,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose a simple but effective distribution calibration strategy for few-shot classification. Without complex generative models, training loss and extra parameters to learn, a simple logistic regression trained with features generated by our strategy outperforms the current state-of-the-art methods by $\\sim 5 \\%$ on miniImageNet. The calibrated distribution is visualized and demonstrates an accurate estimation of the feature distribution. Future works will explore the applicability of distribution calibration on more problem settings, such as multi-domain few-shot classification, and more methods, such as metric-based meta-learning algorithms. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antreas Antoniou and Amos J. Storkey. Assume, augment and learn: Unsupervised few-shot metalearning via random labels and data augmentation. CoRR, 2019. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. In ICLR, 2019a. ",
+        "bbox": [
+            171,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zitian Chen, Yanwei Fu, Yinda Zhang, Yu-Gang Jiang, Xiangyang Xue, and Leonid Sigal. Multilevel semantic feature augmentation for one-shot learning. TIP, 28(9):4594–4605, 2019b. ",
+        "bbox": [
+            173,
+            203,
+            823,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, 2017. ",
+        "bbox": [
+            171,
+            242,
+            823,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hang Gao, Zheng Shou, Alireza Zareian, Hanwang Zhang, and Shih-Fu Chang. Low-shot learning via covariance-preserving adversarial augmentation networks. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 NeurIPS, 2014. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. CoRR, 2017. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bin Liu, Yue Cao, Yutong Lin, Qi Li, Zheng Zhang, Mingsheng Long, and Han Hu. Negative margin matters: Understanding margin in few-shot classification. In ECCV, 2020a. ",
+        "bbox": [
+            173,
+            436,
+            823,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jialun Liu, Yifan Sun, Chuchu Han, Zhaopeng Dou, and Wenhui Li. Deep representation learning on long-tailed data: A learnable embedding augmentation perspective. In CVPR, June 2020b. ",
+        "bbox": [
+            173,
+            476,
+            823,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lu Liu, Tianyi Zhou, Guodong Long, Jing Jiang, Lina Yao, and Chengqi Zhang. Prototype propagation networks (PPN) for weakly-supervised few-shot learning on category graph. In IJCAI, 2019a. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lu Liu, Tianyi Zhou, Guodong Long, Jing Jiang, and Chengqi Zhang. Learning to propagate for graph meta-learning. In NeurIPS, 2019b. ",
+        "bbox": [
+            171,
+            566,
+            823,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaoyao Liu, Bernt Schiele, and Qianru Sun. An ensemble of epoch-wise empirical bayes for fewshot learning. In ECCV, 2020c. ",
+        "bbox": [
+            171,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Puneet Mangla, Nupur Kumari, Abhishek Sinha, Mayank Singh, Balaji Krishnamurthy, and Vineeth N Balasubramanian. Charting the right manifold: Manifold mixup for few-shot learning. In WACV, 2020. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seong-Jin Park, Seungju Han, Ji-won Baek, Insoo Kim, Juhwan Song, Hae Beom Lee, Jae-Joon Han, and Sung Ju Hwang. Meta variance transfer: Learning to augment from the others. In ICML, 2020. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tiexin Qin, Wenbin Li, Yinghuan Shi, and Yang Gao. Diversity helps: Unsupervised few-shot learning via distribution shift-based data augmentation, 2020. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            856,
+            813,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning Representations by Back-propagating Errors. Nature, 323:533–536, 1986.   \nOlga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. CoRR, abs/1409.0575, 2014.   \nAndrei A. Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. In ICLR, 2019.   \nRuslan Salakhutdinov, Joshua Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In ICML workshop, 2012.   \nEli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Abhishek Kumar, Rogerio Feris, Raja Giryes, and Alex Bronstein. Delta-encoder: an effective sample synthesis method for few-shot object recognition. In NeurIPS, 2018.   \nJake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017.   \nJohn W Tukey. Exploratory data analysis. Addison-Wesley Series in Behavioral Science. AddisonWesley, Reading, MA, 1977. URL https://cds.cern.ch/record/107005.   \nLaurens van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE. Journal of Machine Learning Research, 2008.   \nOriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. In NeurIPS, 2016.   \nYu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In CVPR, 2018.   \nYulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In NeurIPS, 2019.   \nP. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.   \nYongqin Xian, Tobias Lorenz, Bernt Schiele, and Zeynep Akata. Feature generating networks for zero-shot learning. In CVPR, 2018.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   \nChi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Few-shot image classification with differentiable earth mover’s distance and structured classifiers. In CVPR, 2020.   \nJian Zhang, Chenglong Zhao, Bingbing Ni, Minghao Xu, and Xiaokang Yang. Variational few-shot learning. In ICCV, 2019.   \nRuixiang Zhang, Tong Che, Zoubin Ghahramani, Yoshua Bengio, and Yangqiu Song. Metagan: An adversarial approach to few-shot learning. In NeurIPS, 2018. ",
+        "bbox": [
+            171,
+            97,
+            826,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a660f4a0195daaa4161ed37a66854e795c54db5921767dfa35670ef13d69928.jpg",
+        "image_caption": [
+            "Figure 6: We show the feature distribution of 5 base classes, and the feature distribution of 5 novel classes before/after Tukey’s Transformation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            101,
+            807,
+            257
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/6329281b2ec553ea23700d925efbd023ffb292b91f31d48a87dcdc4a394bb89a.jpg",
+        "table_caption": [
+            "Table 7: The comparison with nearest class feature augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training data</td><td>miniImageNet 5way1shot</td></tr><tr><td>Support set only</td><td>56.37±0.68</td></tr><tr><td>Support set + 1 feature from the nearest class</td><td>62.39 ± 0.49</td></tr><tr><td>Support set + 5 features from the nearest class</td><td>59.73 ± 0.42</td></tr><tr><td>Support set + 1O features from the nearest class</td><td>58.93 ± 0.49</td></tr><tr><td>Support set+1OO features from the nearest class</td><td>57.33 ± 0.48</td></tr><tr><td>Support set + 1OO features sampled from calibrated distribution</td><td>68.53 ± 0.32</td></tr></table>",
+        "bbox": [
+            186,
+            313,
+            810,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A AUGMENTATION WITH NEAREST CLASS FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            468,
+            625,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Instead of sampling from the calibrated distribution, we can simply retrieve examples from the nearest class to augment the support set. Table 7 shows the comparison of training using samples from the calibrated distribution, the different number of retrieved features from the nearest class, and only using the support set. We found the retrieved features can improve the performance compared to only using the support set but can damage the performance when increasing the number of retrieved features, where the retrieved samples probably serve as noisy data for tasks targeting different classes. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B DISTRIBUTION CALIBRATION WITHOUT NOVEL FEATURE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            626,
+            683,
+            641
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We calibrate the novel class mean by averaging the novel class mean and the retrieved base class means in Equation 6. Table 8 shows the distribution calibration without averaging novel feature, in which the calibrated mean is calculated as $\\begin{array} { r } { \\pmb { \\mu } ^ { \\prime } = \\frac { \\Sigma _ { i \\in \\mathbb { S } _ { N } } \\pmb { \\mu } _ { i } } { k } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            660,
+            825,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C THE EFFECTS OF TUKEY’S TRANSFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            732,
+            591,
+            748
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the distribution of 5 base classes and 5 novel classes before/after Tukey’s transformation. It is observed that the base class distribution satisfies Gaussian assumption well (left) while the novel class distribution is more skew (middle). The novel class distribution after Tukey’s transformation (right) is more aligned with the Gaussian-like base class distribution. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/a8016ee8cf85e6290eb91a0e95ef88c08d70efcd66587e70e40baa467bb7ecdb.jpg",
+        "table_caption": [
+            "Table 8: The comparison between distribution calibration with and without novel feature $\\tilde { \\pmb x }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>miniImageNet 5way1shot</td></tr><tr><td>Distribution Calibration w/o novel feature x</td><td>59.38 ± 0.73</td></tr><tr><td>Distribution Calibration w/ novel feature x</td><td>68.57 ± 0.55</td></tr></table>",
+        "bbox": [
+            248,
+            851,
+            748,
+            897
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff6e8034d2f5de641d2d926d1800a7565d2f2f3c6641c0fc50ec9c8504308c57.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 9: Performance improvement with respect to the similarity level between a query novel class and the most similar base classes. "
+        ],
+        "table_body": "<table><tr><td>Novel class</td><td>Top-1 base class similarity</td><td>Top-2 base class similarity</td><td>DC improvement</td></tr><tr><td>malamute</td><td>93%</td><td>85%</td><td>↑21.30%</td></tr><tr><td>golden retriever</td><td>85%</td><td>74%</td><td>个 18.37%</td></tr><tr><td>ant</td><td>71%</td><td>67%</td><td>↑9.77%</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            821,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D THE SIMILARITY LEVEL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            223,
+            498,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We found that the higher similarities between the retrieved base class distribution and the novel class ground-truth distribution, the higher the performance improvement our method will bring as shown in Table 9. The results in the table are under 5-way-1-shot setting. ",
+        "bbox": [
+            174,
+            252,
+            823,
+            296
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SJCPLLpaW/SJCPLLpaW.md

@@ -0,0 +1,313 @@
+# EXPLORING THE HIDDEN DIMENSION IN ACCELERATING CONVOLUTIONAL NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+DeePa is a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training process of convolutional neural networks. DeePa optimizes parallelism at the granularity of each individual layer in the network. We present an elimination-based algorithm that finds an optimal parallelism configuration for every layer. Our evaluation shows that DeePa achieves up to $6 . 5 \times$ speedup compared to state-of-the-art deep learning frameworks and reduces data transfers by up to $2 3 \times$ .
+
+# 1 INTRODUCTION
+
+Training convolutional neural networks (CNNs) is increasingly compute-intensive and timeconsuming. It takes days or even weeks to train deep CNNs from scratch (Szegedy et al., 2014; Zeiler & Fergus, 2014; Simonyan & Zisserman, 2014; Szegedy et al., 2016). Existing deep learning frameworks such as TensorFlow, PyTorch, and Caffe2 parallelize the training process onto multiple processors (usually GPUs) using image parallelism1 dividing the entire image dataset into batches with the same number of images and assigning each batch to a dedicated processor.
+
+The standard parallelization of CNN training only exploits image parallelism. However, other dimensions can also parallelize the training process. For example, in CNNs for 2D images, data is commonly organized as 4-dimensional tensors (i.e., image, height, width, channel). The image dimension includes an index for each image in the input dataset. The height and width dimensions specify a position in an image. For a particular position, the channel dimension2 indexes different neurons for that position. Exploring these other parallelizable dimensions can potentially reduce the compute time and data transfer cost when training CNNs (see Section 2). Moreover, different layers in a CNN may prefer different parallelism configurations for achieving optimal performance.
+
+We propose DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs. To the best of our knowledge, DeePa is the first system that models and exploits the parallelism of neural networks at the granularity of each individual layer. To generate a parallelism configuration for each layer, DeePa uses an elimination-based algorithm that automatically finds the configuration with the best estimated performance.
+
+The main contributions of this paper are:
+
+• We present DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs.   
+• The parallelization strategy is selected at the granularity of each individual layer.   
+• We present an elimination-based algorithm for finding the parallelism configuration with optimal estimated performance for each layer.   
+• Our evaluation shows that, compared to state-of-the-art deep learning frameworks (e.g., TensorFlow and PyTorch), DeePa achieves $6 . 5 \times$ , $1 . 9 \times$ , and $1 . 5 \times$ speedup for AlexNet,
+
+Table 1: Detailed information for the example convolutional layers used in Figure 1 and 2.   
+
+<table><tr><td>Name</td><td>Input Channels</td><td>Output Channels</td><td>Height</td><td>Width</td><td>Kernel</td><td>Stride</td><td>Description</td></tr><tr><td>C1</td><td>128</td><td>128</td><td>112</td><td>112</td><td>3x3</td><td>1x1</td><td>Conv4 in VGG-16</td></tr><tr><td>C2</td><td>512</td><td>512</td><td>28</td><td>28</td><td>3x3</td><td>1x1</td><td>Conv8,Conv9,and Conv10 in VGG-16</td></tr><tr><td>C3</td><td>192</td><td>64</td><td>35</td><td>35</td><td>1x1</td><td>1x1</td><td>Conv1x1 in an Inception-v3 module</td></tr><tr><td>C4</td><td>48</td><td>64</td><td>35</td><td>35</td><td>5x5</td><td>1x1</td><td>Conv5x5 in an Inception-v3 module</td></tr><tr><td>C5</td><td>64</td><td>192</td><td>27</td><td>27</td><td>5x5</td><td>1x1</td><td>Conv2 in AlexNet</td></tr><tr><td>C6</td><td>256</td><td>256</td><td>13</td><td>13</td><td>3x3</td><td>1x1</td><td>Conv5 in AlexNet</td></tr><tr><td>C7</td><td>32</td><td>64</td><td>147</td><td>147</td><td>3x3</td><td>1x1</td><td>Conv3 in Inception-v3</td></tr><tr><td>C8</td><td>448</td><td>384</td><td>8</td><td>8</td><td>3x3</td><td>1x1</td><td>Conv3x3 in an Inception-v3 module</td></tr></table>
+
+VGG-16, and Inception-v3, respectively. The performance improvement comes from reducing overall data transfers, automatically overlapping computation with data movement, and accelerating computation throughput.
+
+# 2 MOTIVATION
+
+This work is motivated by the following observations.
+
+# 2.1 ACCELERATING COMPUTATION THROUGHPUT
+
+![](images/20ab3eaf0d3e2ade09d05eae1955907088f1ca0e086505fac32f7f4307ee3b86.jpg)  
+Figure 1: Relative performance for training different convolutional layers. Computation throughput is calculated by dividing the batch size with computation time (both forward processing and back propagation) and is normalized by the worst case.
+
+![](images/d2511e9fd175b0a8fcefd5e352fb34b1abd24d077f8f81f5254a1be85aa5735c.jpg)  
+Figure 2: Computation and data transfer time to process a batch of 512 images using image parallelism for the third layer, an intermediate layer, and the last layer of Inception-v3.
+
+Convolutional layers generally consume the bulk of the training time in CNNs, and parallelizing training in different data dimensions results in significantly different performance. Figure 1 shows the relative speed of training six different convolutional layers from AlexNet, VGG-16, and Inception-v3. The properties of the convolutional layers are shown in Table 1. For each convolutional layer, we tried parallelizing the computation in each individual parallelizable dimension as well as combinations of different parallelizable dimensions, and we report the performance of the standard parallelization over images along with the worst and best parallelization strategies we discovered. Figure 1 shows that different parallelism configurations result in very different performance, and image parallelism generally achieves suboptimal performance. Therefore, exploring parallelism in other dimensions can potentially accelerate the training of convolutional layers.
+
+# 2.2 REDUCING DATA TRANSFER COST
+
+Different parallelization strategies can also result in significantly different amounts of data movement. Figure 3 shows an example of parallelizing the first fully-connected layer of VGG-16 on two GPUs in different dimensions. In image parallelism (Figure 3a), each GPU processes a batch of images and computes the gradient for the entire fully-connected layer. This requires each GPU to synchronize the gradients for the entire fully-connected layer (shown as the shadow rectangles) after each step. An alternative approach (Figure 3b) parallelizes in the channel dimension by assigning a subset of the output channels to each GPU. As a result, different GPUs compute the gradients for disjoint subsets of the fully-connected layer, which eliminates transferring the fully-connected layer but introduces additional data transfers for input tensors (shown as the shadow rectangles). For this particular case, using parallelism in the channel dimension reduces data transfer costs by $1 2 \times$ .
+
+![](images/087082065dd2852e1aabf15f08fb37a71a5eb1ca792911dba8159579f380fdec.jpg)  
+(a) Parallelism in the image dimension. (b) Parallelism in the channel dimension.   
+Figure 3: Different configurations for parallelizing the first fully-connected layer of VGG-16. Rectangles with solid lines indicate tensors managed by the local GPU, while rectangles with dot lines are tensors managed by a remote GPU. The shadow rectangles indicate data transfers for each step.
+
+# 2.3 OPTIMIZING PER-LAYER PERFORMANCE
+
+When processing a batch of images, increasing the number of workers does not always improve overall execution time, due to the data transfer overhead to synchronize gradients across different workers. Figure 2 shows the per-step training time for three different layers in Inception-v3 for a batch size of 512 images on up to 16 GPUs. The training time includes forward processing, backward propagation, and gradient aggregation. The figure shows that different layers in a neural network may prefer different hardware configurations, and there is no single configuration that is optimal for all layers. For example, the third layer performs best on 16 GPUs while the last layer performs best on 4 GPUs. Thus, a parallelism configuration includes both selecting the data dimensions to be parallelized and the number of parallel workers (or, equivalently, the number of subsets into which the data is partitioned).
+
+# 3 DEEPA
+
+![](images/d0339f1478608f95400a49f9cc1d88ec5ec106b9fc53a5614d8c8e826fa5c6ad.jpg)  
+Figure 4: Example configurations that parallelize an operation in a single dimension or combinations of multiple dimensions. The figure shows how each image is partitioned in different configurations. Each configuration needs a total of 4 workers.
+
+Similar to TensorFlow and PyTorch, DeePa uses computation graphs to describe dependencies between operations. In a computation graph $G = ( V , E )$ , each node $n \in V$ is an operation (e.g., a convolution or matrix-multiply), and each directed edge $( u , v ) \in E$ is a tensor that is an output of $u$ and an input of $v$ .
+
+One key difference between DeePa and TensorFlow or PyTorch is that each node in the DeePa computation graph also includes a configuration that describes how the corresponding operation is parallelized across different workers. For each parallelizable dimension (i.e., image, height, width, and channel), the configuration includes an integer that describes the degree of parallelism in that dimension. For a configuration, the product of the integers over all dimensions is the number of workers needed to process the operation in that configuration. Figure 4 demonstrates some example configurations that explore parallelism in a single dimension as well as combinations of different dimensions. DeePa assumes equal partitioning in each dimension. As a result, each worker receives the same size input, which provides well-balanced workload distribution in our experiments.
+
+For each node in the computation graph, its configuration describes how the output tensor is divided onto multiple workers. Each worker computes a disjoint subset of the output tensor, and thus each worker can process the operation in parallel without data dependencies. Given a node’s configuration, DeePa calculates the input sets for each worker and automatically schedules proper data transfers between operations.
+
+DeePa also provides three additional functions:
+
+• For each node $v$ and configuration $c$ , v.compute $( c )$ estimates the time to process the corresponding operation under the parallelism configuration $c$ . This includes both the forward processing and back propagation time and is estimated by running the operation in that configuration multiple times on the device and measuring the average execution time.   
+• For each edge $\boldsymbol { e } ~ = ~ ( u , v )$ , $e . x f e r ( c _ { u } , c _ { v } )$ estimates the time to transfer the input tensor $e$ to each worker, using the size of the data to be moved and the known communication bandwidth. Note that $e . x f e r ( c _ { u } , c _ { v } )$ is zero if $u$ and $v$ have the same configuration (i.e., $c _ { u } = c _ { v } ,$ , in which case no data is transferred. As with compute(), we precompute the $x f e r ( )$ function for each edge in the graph by calculating the overall data transfer size for all possible source and destination configurations.   
+• For each node $v$ and configuration $c$ , v.update $( c )$ estimates the time to update parameters for the corresponding operation. We use the data transfer time to approximate the update time, since the data transfer time is much longer than the compute time for updating parameters. Note that different configurations can have significantly different update time, as described in Section 2.2.
+
+A global configuration $g$ includes a parallelism configuration for each node in a computation graph: $g ( v )$ describes the parallelism configuration for node $v$ . Using the functions defined above, we can model the per-step execution time for a computation graph:
+
+$$
+C o s t ( g , ( V , E ) ) = \sum _ { v \in V } \{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \} + \sum _ { e = ( u , v ) \in E } e . x f e r ( g ( u ) , g ( v ) )
+$$
+
+$C o s t ( g , ( V , E ) )$ estimates the per-step execution time if the computation graph $( V , E )$ is parallelized using global configuration $g$ . This execution time includes forwarding processing, backward propagation, and gradient aggregation. Equation 1 expresses the problem of finding the configuration for each individual node as a global optimization problem.
+
+# 4 FINDING OPTIMAL GLOBAL CONFIGURATIONS
+
+![](images/c82e48e9ee621289587ff7e0281f5657624601010588e74df4e479f713a5683c.jpg)  
+Figure 5: Performing a node/edge elimination on a computation graph.
+
+We now describe our algorithm for finding a global configuration that minimizes Equation 1. In DeePa, each node can select any of a fixed (but large) set of parallelism configurations. Therefore the number of potential global configurations is exponential in the number of nodes in a computation graph, which makes it impractical to enumerate all global configurations for deep CNNs such as VGG-16 and Inception-v3.
+
+However, the CNNs we have seen in practice exhibit strong locality: each node is only connected to a few nodes with similar depth in a computation graph. Based on this observation, we use the following two elimination strategies to iteratively simplify the computation graph while preserving the globally optimal configuration.
+
+Node elimination. For each node $w$ with a single in-edge $\boldsymbol { e } _ { 1 } ~ = ~ ( u , w )$ and a single out-edge $e _ { 2 } = \left( w , v \right)$ , we remove node $w$ and the two edges $e _ { 1 }$ and $e _ { 2 }$ from the graph and insert a new edge $\boldsymbol { e } ^ { \prime } = \left( \boldsymbol { u } , \boldsymbol { v } \right)$ (shown in Figure 5a). The xfer() function for node $e ^ { \prime }$ is
+
+$$
+e ^ { \prime } . x f e r ( c _ { u } , c _ { v } ) = \operatorname* { m i n } _ { c _ { w } } \{ e _ { 1 } . x f e r ( c _ { u } , c _ { w } ) + w . c o m p u t e ( c _ { w } ) + w . u p d a t e ( c _ { w } ) + e _ { 2 } . x f e r ( c _ { w } , c _ { v } ) \}
+$$
+
+Note that because we have precomputed the $x f e r ( )$ function for edges in the original graph, we can similarly compute the $x f e r ( )$ function for the transitive edge added by a node elimination; i.e., we use dynamic programming to compute the optimal configuration for node $w$ for every possible choice of configurations for nodes $u$ and $v$ . For CNNs with a linear computation graph (e.g., AlexNet and VGG-16), node elimination is sufficient to reduce the original graph to a graph with only 2 nodes.
+
+Edge elimination. For two edges with the same source and destination node (i.e., $\boldsymbol { e } _ { 1 } = ( u , v )$ and $e _ { 2 } = ( u , v ) )$ , we can remove $e _ { 1 }$ and $e _ { 2 }$ from the graph and insert a new edge $\boldsymbol { e } ^ { \prime } = \left( u , v \right)$ (shown in Figure 5b). The $x f e r ( )$ function for node $e ^ { \prime }$ is
+
+$$
+e ^ { \prime } . x f e r ( c _ { u } , c _ { v } ) = e _ { 1 } . x f e r ( c _ { u } , c _ { v } ) + e _ { 2 } . x f e r ( c _ { u } , c _ { v } )
+$$
+
+![](images/dda15850056babc26c99b6228694861bbb715df2bba3cd953aaee45bc92c0dab.jpg)  
+Figure 6: Iteratively performing node/edge eliminations on an Inception module.
+
+As with node elimination, we compute the $x f e r ( )$ function for $e ^ { \prime }$ using the already computed xfer() functions for $e _ { 1 }$ and $e _ { 2 }$ . Figure 6 shows how DeePa iteratively eliminates nodes and edges for an
+
+Inception-v3 module. The full Inception-v3 computation graph has 120 nodes, which DeePa reduces to a 2-node graph.
+
+DeePa iteratively uses node and edge eliminations to simplify a computation graph until neither elimination can be applied. DeePa then enumerates all global configurations for the final graph and chooses the one that minimizes the Cost function in Equation 1.
+
+After deciding the configuration for each node in the final graph, DeePa then decides the configuration for the eliminated nodes by undoing the node and edge eliminations in reverse order. When undoing a node elimination for node $w$ , DeePa selects the configuration that minimizes Equation 2 for node $w$ . After undoing all eliminations, DeePa has a configuration for every node in the original graph. In Appendix A.1, we prove that our algorithm finds an optimal global configuration. In our experiments, DeePa finds an optimal configuration for parallelizing the largest CNN we have worked with, Inception-v3, on 16 GPUs in about $1 0 0 \mathrm { m s }$ .
+
+# 5 IMPLEMENTATION
+
+We found that it is non-trivial to parallelize the training of CNNs in the height, width, and channel dimensions in existing frameworks (e.g., TensorFlow, PyTorch, and Caffe2), and none provides an interface for controlling per-operation parallelism. We implemented DeePa in Legion (Bauer et al., 2012), a high-performance parallel runtime for distributed heterogeneous architectures, and use cuDNN (Chetlur et al., 2014) and cuBLAS (cub, 2016) as the underlying libraries for processing neural network operations. The following Legion features significantly simplify our implementation for DeePa. First, Legion supports high-dimensional partitioning that allows us to parallelize any operation in any combination of the dimensions. Second, Legion allows DeePa to control parallelism at the granularity of each operation. Third, Legion allows fine-grain control over the placement of data in memory. Fourth, Legion’s asynchronous tasking model makes it easy to exploit task as well as image parallelism. We also include two critical optimizations that help achieve good performance.
+
+Overlapping computation with data transfers. DeePa manages the gradients of each operation separately and transfers an operation’s gradients as long as its back propagation is completed. We have found that this can effectively hide the data transfer overhead for gradient synchronization. As a result, the synchronous training performance matches asynchronous training in DeePa, which allows users to use synchronous training with its better algorithmic efficiency.
+
+Distributing parameter servers. Existing frameworks use parameter servers to store and update variables for a CNN model. Parameter servers are located in CPU memory in TensorFlow and PyTorch. Because DeePa manages the parameters for each operation separately, DeePa can opportunistically distribute the parameter server onto the GPU memories whenever possible. This eliminates data transfers for operations whose gradients and parameter server are located on the same GPU and transforms all GPU to CPU copies into faster GPU to GPU copies.
+
+# 6 RELATED WORK
+
+To the best of our knowledge, DeePa is the first deep learning framework that controls and optimizes the parallelism of neural networks in all dimensions at the granularity of each operation.
+
+Existing frameworks such as TensorFlow (Abadi et al., 2016), Caffe2 (Caf, 2016), and PyTorch (Pyt, 2017) use image parallelism to distribute the training of CNNs and only explore parallelism in the image dimension. The standard image parallelism configuration keeps a replica of the entire network on each worker, which results in large data transfers for synchronizing the gradients in each step.
+
+Mirhoseini et al. (2017) uses model parallelism that assigns each operation to a dedicated processor for training Inception-v3. It uses a reinforcement learning algorithm to optimize the placement of each operation on a GPU device. The learned device placement on 4 GPUs achieves $19 \%$ speedup compared to single GPU performance. However, parallelism in each operation is not explored.
+
+Krizhevsky (2014) introduces “one weird trick” (OWT) that combines image parallelism with model parallelism to accelerate the distributed training of AlexNet, which efficiently reduces the data transfer cost compared to the standard image parallelism configuration. In Section 7.1.2, we show that
+
+DeePa further reduces the overall data transfers for AlexNet by $3 \times$ and the per-step training time by $2 . 3 \times$ compared to OWT.
+
+Goyal et al. (2017) empirically shows no loss of accuracy for training ResNet-50 on the ImageNet dataset with a large minibatch size of 8192 images3. It uses the standard image parallelism configuration to distribute the training onto 256 GPUs and includes a number of optimizations for reducing communication overhead. As communication is a bottleneck in distributed deep learning, we believe our techniques for reducing data transfers can substantially benefit training on large numbers of GPUs.
+
+# 7 EVALUATION
+
+![](images/6a8603f4feaccae978b2b90aca2c6b48a954047e9d30946644ba57eefa039cca.jpg)  
+Figure 7: Training throughput (images/second) for AlexNet, VGG-16, and Inception-v3 on 16 GPUs. The purple and green bar shows the DeePa performance by restricting DeePa to use image and OWT parallelism, respectively.
+
+![](images/88771cf8f78487d7c8ae7da1c16f6db428cc51628e774ad66dc7dd7ecc60e9da.jpg)  
+Figure 8: Total amount of data transferred in each step for training AlexNet, VGG-16, and Inception-v3 on 16 GPUs with a minibatch size of 512.
+
+We use AlexNet (Krizhevsky, 2014), VGG-16 (Simonyan & Zisserman, 2014), and Inceptionv3 (Szegedy et al., 2016) as benchmark CNNs and use the ImageNet dataset (Russakovsky et al., 2015) as the input. For each CNN, we compare the performance of DeePa against TensorFlow, PyTorch, and OWT. We implement OWT in DeePa by restricting all convolutional and pooling layers to use image parallelism and all fully-connected layers to use model parallelism.
+
+# 7.1 CASE STUDY ON A 16-GPU MACHINE
+
+We conduct a detailed case study for training the three CNNs on a 16-GPU machine, with two Intel 10-core E5-2680 Xeon processors, 256 GB main memory, and 16 NVIDIA Tesla K80 GPUs4. We use all 16 GPUs for training each CNN model with a minibatch size of 512 images. As a result, each GPU processes a batch of 32 images in the image parallelism configuration. DeePa uses the search algorithm in Section 4 to find the optimal parallelism configurations, which requires 0.7, 1.1, and 4.8 seconds for AlexNet, VGG-16, and Inception-v3, respectively.
+
+Figure 7 shows the synchronous training throughput for a minibatch size of 512 images on 16 GPUs. When DeePa uses image parallelism for all operations, DeePa achieves competitive performance compared to the best of TensorFlow and PyTorch. The OWT approach that uses model parallelism for fully-connected layers speeds up the training throughput by $1 . 4 \times , 1 . 2 \times$ , and $1 . 0 7 \times$ compared to image parallelism using DeePa. The best configurations found by DeePa achieve $6 . 5 \times$ , $1 . 9 \times$ , and $1 . 5 \times$ speedup compared to TensorFlow and PyTorch.
+
+Three main optimizations in DeePa achieve most of the performance benefit over the other frameworks. First, DeePa significantly reduces data transfers in each step, as shown in Figure 8. Compared to image parallelism, the OWT approach reduces data transfers by $1 . 0 5 { - } 8 . 4 \times$ . However, the best configuration used by DeePa further reduces data transfers by $1 . 2 \mathrm { - } 2 . 7 \mathrm { \times }$ compared to OWT. Second, the optimization for overlapping computation with data transfers (described in Section 5) effectively hides data transfer latency and achieves better GPU utilization. The grey bars in Figure 7 illustrate DeePa’s performance when the overlap optimization is disabled, which shows that overlapping computation with data transfers can improve the training throughput by $10 \% { - } 3 0 \%$ . Third, DeePa also improves performance by exploring parallelism in the height and width dimensions (see Section 7.1.3).
+
+Table 2: The cost for different configurations for the first fully-connected of AlexNet.   
+
+<table><tr><td>Configuration</td><td>#GPU Workers</td><td>Transfer Cost</td><td>Compute Cost</td><td>Update Cost</td><td>Total Cost</td><td>Parallelism Configurations</td></tr><tr><td>{n=16,c=1}</td><td>16</td><td>0</td><td>+1.28</td><td>+1075</td><td>= 1076</td><td>ImageParallelism</td></tr><tr><td>{n=1,c=16}</td><td>16</td><td>134.4</td><td>+1.28</td><td>+0</td><td>= 135.7</td><td>OWT</td></tr><tr><td>{n=1,c=4}</td><td>4</td><td>33.6</td><td>+5.1</td><td>+0</td><td>=38.7</td><td></td></tr><tr><td>{n=1,c=2}</td><td>2</td><td>16.8</td><td>+10.2</td><td>+0</td><td>= 27.0</td><td>DeePa</td></tr><tr><td>{n=1,c=1}</td><td>1</td><td>8.4</td><td>+20.4</td><td>+0</td><td>=28.8</td><td></td></tr></table>
+
+# 7.1.1 THE BEST CONFIGURATIONS
+
+We describe the best configurations discovered for AlexNet, VGG-16, and Inception-v3 in Sections 7.1.2 to 7.1.4. The best configurations have several similarities.
+
+First, for the beginning layers with large height/width dimensions and small channel dimensions, DeePa uses image parallelism on all available GPUs, since the data transfers for synchronizing gradients are much smaller than the data transfers for moving tensors between operations.
+
+Second, deeper layers in CNNs tend to have smaller height/width dimensions and larger channel dimensions. As a result, the cost for moving tensors between different operations decreases, while the cost for synchronizing gradients increases. DeePa adaptively reduces the number of GPU workers for these layers to reduce the expensive data transfers for synchronizing gradients at the cost of introducing cheaper data transfers for moving tensors.
+
+Third, DeePa uses model parallelism on a small number of GPU workers for fully-connected layers, because synchronizing gradients and moving tensors are both much more expensive than the compute time for fully-connected layers. DeePa reduces the data transfers for synchronizing gradients and moving tensors at the cost of using fewer GPUs.
+
+# 7.1.2 ALEXNET
+
+![](images/1fdc606e91795c844913b613431e568e584b2d6b849313aba4b291b077c06bbb.jpg)  
+Figure 9: The global configuration for parallelizing AlexNet on 16 GPU workers.
+
+Figure 9 shows the global configuration for AlexNet on 16 GPU workers. Note that DeePa selects the parallelism configuration that optimizes the performance for each layer. Table 2 lists the cost for different configurations of the first fully-connected layer. The standard image parallelism configuration eliminates the cost for transferring the input tensors but introduces additional data transfers for synchronizing gradients. The OWT approach completely eliminates gradient synchronization at the cost of replicating the input tensors on every GPU worker. The configuration chosen by DeePa only uses 2 GPU workers for training the first fully-connected layer, which prolongs the compute time but significantly reduces the cost for both transferring input tensors and synchronizing gradients. As a result, DeePa reduces the total cost by $5 \times$ compared to other approaches.
+
+DeePa uses image parallelism for all convolutional and pooling layers, because the additional data transfer cost introduced by transforming configurations outweighs any performance benefits.
+
+# 7.1.3 VGG-16
+
+![](images/95df748900bc84eba803cc88fd5a97ef3361566c57dcdd7501747e30ff8bc4d5.jpg)  
+Figure 10: The global configuration for parallelizing VGG-16 on 16 GPU workers.
+
+Table 3: The cost for different configurations for the last three convolutional layers of VGG-16.   
+
+<table><tr><td>Configuration</td><td># GPU Workers</td><td>Transfer Cost</td><td>Compute Cost</td><td>Update Cost</td><td>Total Cost</td><td>Parallelism Configurations</td></tr><tr><td>{n=16,c=1,h=1,w=1}</td><td>16</td><td>0</td><td>+15.9</td><td>+134.4</td><td>=150.3</td><td>ImageParallelism&amp;OWT</td></tr><tr><td>{n=8,c=1,h=1,w=1}</td><td>8</td><td>39.2</td><td>+31.8</td><td>+67.2</td><td>=138.2</td><td></td></tr><tr><td>{n=4,c=1,h=1,w=1}</td><td>4</td><td>39.2</td><td>+63.7</td><td>+33.6</td><td>=136.5</td><td></td></tr><tr><td>n=1,c=1,h=2,w=2}</td><td>4</td><td>39.2</td><td>+54.7</td><td>+33.6</td><td>= 127.5</td><td>DeePa</td></tr><tr><td>{n=2,c=1,h=1,w=1}</td><td>2</td><td>39.2</td><td>+127.4</td><td>+16.8</td><td>= 183.4</td><td></td></tr></table>
+
+DeePa uses similar configurations for parallelizing the fully-connected layers in VGG-16 (Figure 10). In addition, DeePa also uses a different configuration to cooperatively accelerate the last three convolutional layers (the yellow node in Figure 10). Table 3 lists the cost for different parallelism configurations for the last three convolutional layers. The configuration with optimal total cost uses only four GPU workers for the last three convolutional layers to reduce data transfers for synchronizing gradients. DeePa also exploits parallelism in the height and width dimensions to further reduce the compute time.
+
+# 7.1.4 INCEPTION-V3
+
+![](images/24622793c7d9a18be1849cfbf2f27bf3f3b7217458333dcd812989ffb48a683f.jpg)  
+Figure 11: The global configuration for parallelizing Inception-v3 on 16 GPU workers. Each module is shown as a single node for simplicity.
+
+![](images/a90e2a59301a873254383b009ff421c72d65c2019d8ddc83463f23f0cfa9dbb8.jpg)  
+Figure 12: The configurations for parallelizing the InceptionE1 module.
+
+The Inception-v3 model has multiple Inception modules (Szegedy et al., 2016). Each module has several branches of convolutional and pooling layers, which are then concatenated as the output tensor of the module. Figure 11 shows the global configuration for Inception-v3. DeePa uses different configurations to parallelize different branches for the InceptionE1 module, as shown in Figure 12. We found that this configuration reduces data transfers by $30 \%$ in InceptionE1 and InceptionE2 and reduces overall data transfers by $20 \%$ .
+
+# 7.2 MINIBATCH SIZE
+
+The minibatch size plays an important rule on the performance of CNNs. Figure 13 compares DeePa, PyTorch, and TensorFlow with different minibatch sizes. All three networks were trained on 16 Tesla K80 GPUs on a single node, as described in Section 7.1. We were not able to train VGG-16 and Inception-v3 with a minibatch size of 2048 images, because the required metadata size exceeds the aggregate memory capacity of the 16 GPUs.
+
+Figure 13 shows that, DeePa achieves constant speedups compared to PyTorch and TensorFlow for various minibatch sizes. In particular, DeePa achieves $4 . 6 { - } 6 . 5 \times$ , $1 . 6 \mathrm { - } 1 . 9 \times$ , and $1 . 2 \mathrm { - } 1 . 5 \times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively.
+
+# 7.3 MULTI-NODE RESULTS
+
+We evaluate the scalability of different frameworks by comparing their training throughput with different number of GPUs and compute nodes. The experiments were performed on a GPU cluster with 4 nodes, each of which is equipped with two Intel 10-core E5-2600 Xeon processors, 256G main memory, and four NVIDIA Tesla P100 GPUs. GPUs on the same node are connected by NVLink, and nodes are connected over 100Gb/s EDR Infiniband.
+
+![](images/93d7458c30e952d22471ba797bc25194e958c53604a5bbb842f5261434b76644.jpg)  
+Figure 13: Performance comparisons among DeePa, PyTorch, and TensorFlow with different minibatch sizes.
+
+![](images/bb0caedab1734e4586484851a263b00c77853d7a82ca74ef5d38bc970f581d94.jpg)  
+Figure 14: Performance results for DeePa, PyTorch, and TensorFlow on up to 4 nodes. We perform weak-scaling, where each GPU worker processes a batch of 32 images in every iteration. We use all 4 GPUs on each node in the last two subfigures.
+
+Figure 14 shows the performance comparison among DeePa, PyTorch, and TensorFlow for weakscaling. DeePa achieves competitive performance compared to PyTorch and TensorFlow for training on a single GPU, in which all three frameworks place all operations on a single GPU. For training on 4 GPUs on a single node, DeePa achieves $3 . 1 \times$ , $1 . 6 \times$ , and $1 . 3 \times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively. DeePa achieves even better performance speedups for trainings on multiple nodes, where the data transfer time becomes a larger component of the per-iteration training time. For training on 4 nodes, DeePa achieves $8 . 1 \times$ , $3 . 2 \times$ , and $1 . 8 \times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively.
+
+# 8 CONCLUSION
+
+We have presented DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs. DeePa optimizes the parallelism configuration chosen at the granularity of individual layers. DeePa achieves up to $6 . 5 \times$ for training CNNs and reduces overall data transfers by up to $2 3 \times$ compared to state-of-the-art deep learning frameworks.
+
+# REFERENCES
+
+A New Lightweight, Modular, and Scalable Deep Learning Framework. https://caffe2.ai, 2016.
+
+Dense Linear Algebra on GPUs. https://developer.nvidia.com/cublas, 2016.
+
+Tensors and Dynamic neural networks in Python with strong GPU acceleration. https:// pytorch.org, 2017.
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for largescale machine learning. In OSDI, volume 16, pp. 265–283, 2016.
+
+Michael Bauer, Sean Treichler, Elliott Slaughter, and Alex Aiken. Legion: Expressing locality and independence with logical regions. In Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis, 2012.
+
+Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. CoRR, abs/1410.0759, 2014. URL http://arxiv.org/abs/1410.0759.
+
+Priya Goyal, Piotr Dollar, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, ´ Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL http://arxiv.org/abs/1706. 02677.
+
+Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. CoRR, abs/1404.5997, 2014. URL http://arxiv.org/abs/1404.5997.
+
+Azalia Mirhoseini, Hieu Pham, Quoc V Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean. Device placement optimization with reinforcement learning. CoRR, abs/1706.04972, 2017. URL http://arxiv.org/abs/ 1706.04972.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, 2014.
+
+# A APPENDIX
+
+# A.1 NODE AND EDGE ELIMINATION
+
+We prove the correctness of the node and edge eliminations in Section 4. In particular, we prove that after applying node and edge eliminations, the modified graph has the same optimal configuration as the original graph.
+
+# A.1.1 NODE ELIMINATION
+
+For a given computation graph $G = ( V , E )$ , applying a node elimination on $w$ requires $w$ having a single in-edge $\boldsymbol { e } _ { 1 } = ( u , w )$ and a single out-edge $e _ { 2 } = ( w , v )$ . The node elimination results in a modified graph $G ^ { \prime } = ( V ^ { \prime } , E ^ { \prime } )$ , where $V ^ { \prime } = V - \{ w \}$ , $E ^ { \prime } = E - e _ { 1 } - e _ { 2 } + e ^ { \prime }$ , and $\boldsymbol { e } ^ { \prime } = \left( \boldsymbol { u } , \boldsymbol { v } \right)$ .
+
+Theorem 1. Consider graphs $( V , E )$ and the result of a single node elimination $( V ^ { \prime } , E ^ { \prime } )$ . Then an optimal configuration of $V , E )$ ) is also an optimal configuration of $( V ^ { \prime } , E ^ { \prime } )$ , and an optimal configuration of $( V ^ { \prime } , E ^ { \prime } )$ is extensible to a an optimal configuration of $( V , E )$ .
+
+Proof. The Cost function is defined in Equation 1. Let $g$ be any configuration. We first compute the difference between $C o s t ( g , ( V , E ) )$ and $C o s t ( g , ( V ^ { \prime } , E ^ { \prime } ) )$ .
+
+$$
+\begin{array} { l } { { \displaystyle C o s t ( g , ( V , E ) ) - C o s t ( g , ( V ^ { \prime } , E ^ { \prime } ) ) } } \\ { { \displaystyle = \sum _ { v \in V } \{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \} + \sum _ { e = ( u , v ) \in E } e . x f e r ( g ( u ) , g ( v ) ) } } \\ { { \displaystyle ~ - \sum _ { v \in V ^ { \prime } } \{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \} + \sum _ { e = ( u , v ) \in E ^ { \prime } } e . x f e r ( g ( u ) , g ( v ) ) } } \\ { { \displaystyle = w . c o m p u t e ( g ( w ) ) + w . u p d a t e ( g ( w ) ) } } \\ { { \displaystyle ~ + e . \cdot x f e r ( g ( u ) , g ( w ) ) + e . \cdot x f e r ( g ( w ) , g ( v ) ) - e ^ { \prime } . x f e r ( g ( u ) , g ( v ) ) } } \end{array}
+$$
+
+Now assume $g$ is an optimal configuration for $( V , E )$ . Then we have
+
+$$
+\begin{array} { r l } & { \quad w . c o m p u t e ( g ( w ) ) + w . u p d a t e ( g ( w ) ) + e _ { 1 } . x f e r ( g ( u ) , g ( w ) ) + e _ { 2 } . x f e r ( g ( w ) , g ( v ) ) } \\ & { = \underset { c _ { w } } { \operatorname* { m i n } } \{ w . c o m p u t e ( c _ { w } ) + w . u p d a t e ( c _ { w } ) + e _ { 1 } . x f e r ( g ( u ) , c _ { w } ) + e _ { 2 } . x f e r ( c _ { w } , g ( v ) ) \} } \end{array}
+$$
+
+Therefore, $g$ is an optimal configuration of $( V ^ { \prime } , E ^ { \prime } )$ . For the other direction, note that if $g$ is an optimal configuration of $( V ^ { \prime } , E ^ { \prime } )$ , then it can be extended to an optimal configuration of $( V , E )$ by adding the node $w$ with the same minimal assignment. □
+
+# A.1.2 EDGE ELIMINATION
+
+For a computation graph $G ( V , E )$ , applying an edge elimination on $\boldsymbol { e } _ { 1 } = ( u , v )$ and $\boldsymbol { e } _ { 2 } = ( u , v )$ results in a modified graph $G ^ { \prime } = ( V , E ^ { \prime } )$ , where $E ^ { \prime } = E - e _ { 1 } - e _ { 2 } + e ^ { \prime }$ and $\boldsymbol { e } ^ { \prime } = \left( \boldsymbol { u } , \boldsymbol { v } \right)$ . We prove that $C o s t ( g , ( V , E ) ) = C o s t ( g , ( V , E ^ { \prime } ) )$ for any global configuration $g$ of $( V , E )$ .
+
+Theorem 2. For any global configuration $g$ of graph $\begin{array} { r c l } { G } & { = } & { ( V , E ) } \end{array}$ , $C o s t ( g , ( V , E ) ) \quad = \quad$ $C o s t ( g , ( V , E ^ { \prime } ) )$ , where $( V , E ^ { \prime } )$ is the modified graph of $( V , E )$ after an edge elimination.
+
+Proof. We compute the difference between $C o s t ( g , ( V , E ) )$ and $C o s t ( g , ( V , E ^ { \prime } ) )$ .
+
+$$
+\begin{array} { r l } & { \quad C o s t ( g , ( V , E ) ) - C o s t ( g , ( V , E ^ { \prime } ) ) } \\ & { = e _ { 1 } . x f e r ( g ( u ) , g ( v ) ) - e _ { 2 } . x f e r ( g ( u ) , g ( v ) ) + e ^ { \prime } . x f e r ( g ( u ) , g ( v ) ) } \\ & { = 0 } \end{array}
+$$
+
+The last equation uses Equation 3.
+
+# A.2 RELATED WORK ON OVERLAPPING COMMUNICATION WITH DATA TRANSFER
+
+The overlap optimization in Section 5 is motivated by Goyal et al. (2017), which performs gradient aggregation in parallel with back propagation to scale synchronous training to large number of GPUs. We extend their design and implementation by also enabling the optimization for asynchronous training in DeePa.
+
+# A.3 PROFILING RESULTS
+
+We show profiling results for visualizing the performance bottlenecks in different parallelism approaches. The experiment was performed on a single node with four Tesla P100 GPUs (as described in Section 7.3). We enable overlapping computation with data transfers (described in Section 5) in this experiment.
+
+Figure 15 shows the profiling results for training VGG-16 on 4 GPUs with different parallelism configurations. Note that DeePa with image parallelism achieves $10 \%$ higher training throughput compared to PyTorch and TensorFlow, as shown in Figure 14. Figure 15a shows that all GPUs are highly utilized during forward and backward passes, as indicated by the tight packing of tasks in the timeline. However, the image parallelism approach requires moving 4GB of metadata in every iteration, which cannot be fully overlapped with back propagation, therefore the image parallelism approach has a performance gap between iterations (shown as the white space on the GPU timelines).
+
+![](images/dfe354450aec70902555e21661a7d63eaf3b55d3bdfe2b63f4ce187cb4786c07.jpg)  
+Figure 15: Timelines for training VGG-16 with a minibatch size of 128 images on 4 GPUs. The first horizontal line in each figure shows the overall GPU utilization at different timesteps, and each of the following lines shows the run times for individual operations on each GPU.
+
+Figure 15b shows the profiling of the optimal parallelism configuration chosen by DeePa, which uses image parallelism on 4 GPUs for all convolutional layers and pooling layers and uses model parallelism on 2 GPUs for the fully connected layers. Therefore, the training with the optimal configuration includes data transfers for each fully connected layers, which adds small performance gaps at the end of the forward pass and the beginning of the backward pass (shown as the small white space on the GPU timelines). However, the optimal configuration reduces the per-iteration data transfers from 4GB to 490MB, which effectively hides data transfer overhead and achieves better GPU utilization. As a result, the optimal configuration reduces the per-iteration training time from 0.34 seconds to 0.24 seconds.
+
+# A.4 IMANGENET-22K
+
+We compare the performance of DeePa, PyTorch, and TensorFlow on the ImageNet-22K dataset (Russakovsky et al., 2015) that contains 21,841 different categories (the ImageNet dataset used in Section 7 contains 1,000 catagories). The last fully-connected layer in AlexNet, VGG-16, and Inception-v3 originally have 1,000 neurons followed by a 1,000-way softmax layer. To train the three networks on the ImageNet-22K dataset, we change the last fully-connected layer to have 21,841 neurons and use a 21,841-way softmax layer at the end. The modified networks were trained on 16 Tesla K80 GPUs on a single node with a minibatch size of 512 images.
+
+Figure 16 compares the training throughput and per-iteration data transfers among DeePa, PyTorch, and TensorFlow on the ImageNet and ImageNet-22K datasets. Figure 16a shows that, on the ImageNet-22K dataset, the training throughput of PyTorch and TensorFlow is reduced by $20 \%$ - $45 \%$ , while DeePa’s throughput falls off by $3 \%$ , compared to training on the original ImageNet dataset. Figure 16b compares the per-iteration data transfers between image parallelism and the global configurations used by DeePa. Using image parallelism increases the data transfers in each iteration by 5-10GB, while DeePa only increases the per-iteration data transfers by 40MB. As a result, for training on the ImageNet-22K dataset, DeePa reduces the per-iteration data transfers by $3 . 7 – 4 4 . 5 \times$ compared to image parallelism.
+
+![](images/77258f4c33113381b171df167a6b62265e6737ee838ead9a1aa8de95aa53aa34.jpg)  
+Figure 16: Performance comparisons among DeePa, PyTorch, and TensorFlow on the ImageNet-22k dataset.

parse/train/SJCPLLpaW/SJCPLLpaW_content_list.json

@@ -0,0 +1,1684 @@
+[
+    {
+        "type": "text",
+        "text": "EXPLORING THE HIDDEN DIMENSION IN ACCELERATING CONVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "DeePa is a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training process of convolutional neural networks. DeePa optimizes parallelism at the granularity of each individual layer in the network. We present an elimination-based algorithm that finds an optimal parallelism configuration for every layer. Our evaluation shows that DeePa achieves up to $6 . 5 \\times$ speedup compared to state-of-the-art deep learning frameworks and reduces data transfers by up to $2 3 \\times$ . ",
+        "bbox": [
+            232,
+            267,
+            764,
+            364
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            391,
+            336,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training convolutional neural networks (CNNs) is increasingly compute-intensive and timeconsuming. It takes days or even weeks to train deep CNNs from scratch (Szegedy et al., 2014; Zeiler & Fergus, 2014; Simonyan & Zisserman, 2014; Szegedy et al., 2016). Existing deep learning frameworks such as TensorFlow, PyTorch, and Caffe2 parallelize the training process onto multiple processors (usually GPUs) using image parallelism1 dividing the entire image dataset into batches with the same number of images and assigning each batch to a dedicated processor. ",
+        "bbox": [
+            174,
+            422,
+            823,
+            506
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The standard parallelization of CNN training only exploits image parallelism. However, other dimensions can also parallelize the training process. For example, in CNNs for 2D images, data is commonly organized as 4-dimensional tensors (i.e., image, height, width, channel). The image dimension includes an index for each image in the input dataset. The height and width dimensions specify a position in an image. For a particular position, the channel dimension2 indexes different neurons for that position. Exploring these other parallelizable dimensions can potentially reduce the compute time and data transfer cost when training CNNs (see Section 2). Moreover, different layers in a CNN may prefer different parallelism configurations for achieving optimal performance. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs. To the best of our knowledge, DeePa is the first system that models and exploits the parallelism of neural networks at the granularity of each individual layer. To generate a parallelism configuration for each layer, DeePa uses an elimination-based algorithm that automatically finds the configuration with the best estimated performance. ",
+        "bbox": [
+            176,
+            632,
+            823,
+            702
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of this paper are: ",
+        "bbox": [
+            176,
+            708,
+            441,
+            723
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• We present DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs.   \n• The parallelization strategy is selected at the granularity of each individual layer.   \n• We present an elimination-based algorithm for finding the parallelism configuration with optimal estimated performance for each layer.   \n• Our evaluation shows that, compared to state-of-the-art deep learning frameworks (e.g., TensorFlow and PyTorch), DeePa achieves $6 . 5 \\times$ , $1 . 9 \\times$ , and $1 . 5 \\times$ speedup for AlexNet, ",
+        "bbox": [
+            215,
+            734,
+            825,
+            848
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/88e879f366f247facb2b422db75f569491000c1d650872608042d54d61544ea8.jpg",
+        "table_caption": [
+            "Table 1: Detailed information for the example convolutional layers used in Figure 1 and 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>Input Channels</td><td>Output Channels</td><td>Height</td><td>Width</td><td>Kernel</td><td>Stride</td><td>Description</td></tr><tr><td>C1</td><td>128</td><td>128</td><td>112</td><td>112</td><td>3x3</td><td>1x1</td><td>Conv4 in VGG-16</td></tr><tr><td>C2</td><td>512</td><td>512</td><td>28</td><td>28</td><td>3x3</td><td>1x1</td><td>Conv8,Conv9,and Conv10 in VGG-16</td></tr><tr><td>C3</td><td>192</td><td>64</td><td>35</td><td>35</td><td>1x1</td><td>1x1</td><td>Conv1x1 in an Inception-v3 module</td></tr><tr><td>C4</td><td>48</td><td>64</td><td>35</td><td>35</td><td>5x5</td><td>1x1</td><td>Conv5x5 in an Inception-v3 module</td></tr><tr><td>C5</td><td>64</td><td>192</td><td>27</td><td>27</td><td>5x5</td><td>1x1</td><td>Conv2 in AlexNet</td></tr><tr><td>C6</td><td>256</td><td>256</td><td>13</td><td>13</td><td>3x3</td><td>1x1</td><td>Conv5 in AlexNet</td></tr><tr><td>C7</td><td>32</td><td>64</td><td>147</td><td>147</td><td>3x3</td><td>1x1</td><td>Conv3 in Inception-v3</td></tr><tr><td>C8</td><td>448</td><td>384</td><td>8</td><td>8</td><td>3x3</td><td>1x1</td><td>Conv3x3 in an Inception-v3 module</td></tr></table>",
+        "bbox": [
+            178,
+            109,
+            820,
+            228
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "VGG-16, and Inception-v3, respectively. The performance improvement comes from reducing overall data transfers, automatically overlapping computation with data movement, and accelerating computation throughput. ",
+        "bbox": [
+            230,
+            244,
+            823,
+            286
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            313,
+            323
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This work is motivated by the following observations. ",
+        "bbox": [
+            176,
+            338,
+            527,
+            353
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ACCELERATING COMPUTATION THROUGHPUT",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            534,
+            385
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/20ab3eaf0d3e2ade09d05eae1955907088f1ca0e086505fac32f7f4307ee3b86.jpg",
+        "image_caption": [
+            "Figure 1: Relative performance for training different convolutional layers. Computation throughput is calculated by dividing the batch size with computation time (both forward processing and back propagation) and is normalized by the worst case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            404,
+            452,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2511e9fd175b0a8fcefd5e352fb34b1abd24d077f8f81f5254a1be85aa5735c.jpg",
+        "image_caption": [
+            "Figure 2: Computation and data transfer time to process a batch of 512 images using image parallelism for the third layer, an intermediate layer, and the last layer of Inception-v3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            539,
+            411,
+            792,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Convolutional layers generally consume the bulk of the training time in CNNs, and parallelizing training in different data dimensions results in significantly different performance. Figure 1 shows the relative speed of training six different convolutional layers from AlexNet, VGG-16, and Inception-v3. The properties of the convolutional layers are shown in Table 1. For each convolutional layer, we tried parallelizing the computation in each individual parallelizable dimension as well as combinations of different parallelizable dimensions, and we report the performance of the standard parallelization over images along with the worst and best parallelization strategies we discovered. Figure 1 shows that different parallelism configurations result in very different performance, and image parallelism generally achieves suboptimal performance. Therefore, exploring parallelism in other dimensions can potentially accelerate the training of convolutional layers. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            796
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 REDUCING DATA TRANSFER COST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            447,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Different parallelization strategies can also result in significantly different amounts of data movement. Figure 3 shows an example of parallelizing the first fully-connected layer of VGG-16 on two GPUs in different dimensions. In image parallelism (Figure 3a), each GPU processes a batch of images and computes the gradient for the entire fully-connected layer. This requires each GPU to synchronize the gradients for the entire fully-connected layer (shown as the shadow rectangles) after each step. An alternative approach (Figure 3b) parallelizes in the channel dimension by assigning a subset of the output channels to each GPU. As a result, different GPUs compute the gradients for disjoint subsets of the fully-connected layer, which eliminates transferring the fully-connected layer but introduces additional data transfers for input tensors (shown as the shadow rectangles). For this particular case, using parallelism in the channel dimension reduces data transfer costs by $1 2 \\times$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/087082065dd2852e1aabf15f08fb37a71a5eb1ca792911dba8159579f380fdec.jpg",
+        "image_caption": [
+            "(a) Parallelism in the image dimension. (b) Parallelism in the channel dimension. ",
+            "Figure 3: Different configurations for parallelizing the first fully-connected layer of VGG-16. Rectangles with solid lines indicate tensors managed by the local GPU, while rectangles with dot lines are tensors managed by a remote GPU. The shadow rectangles indicate data transfers for each step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            94,
+            753,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            338,
+            825,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 OPTIMIZING PER-LAYER PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            414,
+            493,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When processing a batch of images, increasing the number of workers does not always improve overall execution time, due to the data transfer overhead to synchronize gradients across different workers. Figure 2 shows the per-step training time for three different layers in Inception-v3 for a batch size of 512 images on up to 16 GPUs. The training time includes forward processing, backward propagation, and gradient aggregation. The figure shows that different layers in a neural network may prefer different hardware configurations, and there is no single configuration that is optimal for all layers. For example, the third layer performs best on 16 GPUs while the last layer performs best on 4 GPUs. Thus, a parallelism configuration includes both selecting the data dimensions to be parallelized and the number of parallel workers (or, equivalently, the number of subsets into which the data is partitioned). ",
+        "bbox": [
+            173,
+            439,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DEEPA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            264,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0339f1478608f95400a49f9cc1d88ec5ec106b9fc53a5614d8c8e826fa5c6ad.jpg",
+        "image_caption": [
+            "Figure 4: Example configurations that parallelize an operation in a single dimension or combinations of multiple dimensions. The figure shows how each image is partitioned in different configurations. Each configuration needs a total of 4 workers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            631,
+            815,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similar to TensorFlow and PyTorch, DeePa uses computation graphs to describe dependencies between operations. In a computation graph $G = ( V , E )$ , each node $n \\in V$ is an operation (e.g., a convolution or matrix-multiply), and each directed edge $( u , v ) \\in E$ is a tensor that is an output of $u$ and an input of $v$ . ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One key difference between DeePa and TensorFlow or PyTorch is that each node in the DeePa computation graph also includes a configuration that describes how the corresponding operation is parallelized across different workers. For each parallelizable dimension (i.e., image, height, width, and channel), the configuration includes an integer that describes the degree of parallelism in that dimension. For a configuration, the product of the integers over all dimensions is the number of workers needed to process the operation in that configuration. Figure 4 demonstrates some example configurations that explore parallelism in a single dimension as well as combinations of different dimensions. DeePa assumes equal partitioning in each dimension. As a result, each worker receives the same size input, which provides well-balanced workload distribution in our experiments. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each node in the computation graph, its configuration describes how the output tensor is divided onto multiple workers. Each worker computes a disjoint subset of the output tensor, and thus each worker can process the operation in parallel without data dependencies. Given a node’s configuration, DeePa calculates the input sets for each worker and automatically schedules proper data transfers between operations. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DeePa also provides three additional functions: ",
+        "bbox": [
+            174,
+            285,
+            483,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• For each node $v$ and configuration $c$ , v.compute $( c )$ estimates the time to process the corresponding operation under the parallelism configuration $c$ . This includes both the forward processing and back propagation time and is estimated by running the operation in that configuration multiple times on the device and measuring the average execution time.   \n• For each edge $\\boldsymbol { e } ~ = ~ ( u , v )$ , $e . x f e r ( c _ { u } , c _ { v } )$ estimates the time to transfer the input tensor $e$ to each worker, using the size of the data to be moved and the known communication bandwidth. Note that $e . x f e r ( c _ { u } , c _ { v } )$ is zero if $u$ and $v$ have the same configuration (i.e., $c _ { u } = c _ { v } ,$ , in which case no data is transferred. As with compute(), we precompute the $x f e r ( )$ function for each edge in the graph by calculating the overall data transfer size for all possible source and destination configurations.   \n• For each node $v$ and configuration $c$ , v.update $( c )$ estimates the time to update parameters for the corresponding operation. We use the data transfer time to approximate the update time, since the data transfer time is much longer than the compute time for updating parameters. Note that different configurations can have significantly different update time, as described in Section 2.2. ",
+        "bbox": [
+            215,
+            311,
+            825,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A global configuration $g$ includes a parallelism configuration for each node in a computation graph: $g ( v )$ describes the parallelism configuration for node $v$ . Using the functions defined above, we can model the per-step execution time for a computation graph: ",
+        "bbox": [
+            176,
+            544,
+            825,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e722f2d81f67fef5e1ca9fa1e8bacc7477641004404efa4f3b656f71e7c6db6d.jpg",
+        "text": "$$\nC o s t ( g , ( V , E ) ) = \\sum _ { v \\in V } \\{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \\} + \\sum _ { e = ( u , v ) \\in E } e . x f e r ( g ( u ) , g ( v ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            611,
+            790,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$C o s t ( g , ( V , E ) )$ estimates the per-step execution time if the computation graph $( V , E )$ is parallelized using global configuration $g$ . This execution time includes forwarding processing, backward propagation, and gradient aggregation. Equation 1 expresses the problem of finding the configuration for each individual node as a global optimization problem. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 FINDING OPTIMAL GLOBAL CONFIGURATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            741,
+            596,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c82e48e9ee621289587ff7e0281f5657624601010588e74df4e479f713a5683c.jpg",
+        "image_caption": [
+            "Figure 5: Performing a node/edge elimination on a computation graph. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            356,
+            768,
+            635,
+            898
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe our algorithm for finding a global configuration that minimizes Equation 1. In DeePa, each node can select any of a fixed (but large) set of parallelism configurations. Therefore the number of potential global configurations is exponential in the number of nodes in a computation graph, which makes it impractical to enumerate all global configurations for deep CNNs such as VGG-16 and Inception-v3. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, the CNNs we have seen in practice exhibit strong locality: each node is only connected to a few nodes with similar depth in a computation graph. Based on this observation, we use the following two elimination strategies to iteratively simplify the computation graph while preserving the globally optimal configuration. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Node elimination. For each node $w$ with a single in-edge $\\boldsymbol { e } _ { 1 } ~ = ~ ( u , w )$ and a single out-edge $e _ { 2 } = \\left( w , v \\right)$ , we remove node $w$ and the two edges $e _ { 1 }$ and $e _ { 2 }$ from the graph and insert a new edge $\\boldsymbol { e } ^ { \\prime } = \\left( \\boldsymbol { u } , \\boldsymbol { v } \\right)$ (shown in Figure 5a). The xfer() function for node $e ^ { \\prime }$ is ",
+        "bbox": [
+            173,
+            243,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b60f2bf2162eda225f3744b2ff87ccfaa3907b497d2a9cb4d0269097e8a7f792.jpg",
+        "text": "$$\ne ^ { \\prime } . x f e r ( c _ { u } , c _ { v } ) = \\operatorname* { m i n } _ { c _ { w } } \\{ e _ { 1 } . x f e r ( c _ { u } , c _ { w } ) + w . c o m p u t e ( c _ { w } ) + w . u p d a t e ( c _ { w } ) + e _ { 2 } . x f e r ( c _ { w } , c _ { v } ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            291,
+            794,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that because we have precomputed the $x f e r ( )$ function for edges in the original graph, we can similarly compute the $x f e r ( )$ function for the transitive edge added by a node elimination; i.e., we use dynamic programming to compute the optimal configuration for node $w$ for every possible choice of configurations for nodes $u$ and $v$ . For CNNs with a linear computation graph (e.g., AlexNet and VGG-16), node elimination is sufficient to reduce the original graph to a graph with only 2 nodes. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Edge elimination. For two edges with the same source and destination node (i.e., $\\boldsymbol { e } _ { 1 } = ( u , v )$ and $e _ { 2 } = ( u , v ) )$ , we can remove $e _ { 1 }$ and $e _ { 2 }$ from the graph and insert a new edge $\\boldsymbol { e } ^ { \\prime } = \\left( u , v \\right)$ (shown in Figure 5b). The $x f e r ( )$ function for node $e ^ { \\prime }$ is ",
+        "bbox": [
+            173,
+            401,
+            821,
+            443
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d87808698f88478d022087039d80a59658db128c107c75766fa5f3d09d07cd2.jpg",
+        "text": "$$\ne ^ { \\prime } . x f e r ( c _ { u } , c _ { v } ) = e _ { 1 } . x f e r ( c _ { u } , c _ { v } ) + e _ { 2 } . x f e r ( c _ { u } , c _ { v } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            450,
+            663,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/dda15850056babc26c99b6228694861bbb715df2bba3cd953aaee45bc92c0dab.jpg",
+        "image_caption": [
+            "Figure 6: Iteratively performing node/edge eliminations on an Inception module. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            491,
+            761,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As with node elimination, we compute the $x f e r ( )$ function for $e ^ { \\prime }$ using the already computed xfer() functions for $e _ { 1 }$ and $e _ { 2 }$ . Figure 6 shows how DeePa iteratively eliminates nodes and edges for an ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inception-v3 module. The full Inception-v3 computation graph has 120 nodes, which DeePa reduces to a 2-node graph. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DeePa iteratively uses node and edge eliminations to simplify a computation graph until neither elimination can be applied. DeePa then enumerates all global configurations for the final graph and chooses the one that minimizes the Cost function in Equation 1. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            180
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After deciding the configuration for each node in the final graph, DeePa then decides the configuration for the eliminated nodes by undoing the node and edge eliminations in reverse order. When undoing a node elimination for node $w$ , DeePa selects the configuration that minimizes Equation 2 for node $w$ . After undoing all eliminations, DeePa has a configuration for every node in the original graph. In Appendix A.1, we prove that our algorithm finds an optimal global configuration. In our experiments, DeePa finds an optimal configuration for parallelizing the largest CNN we have worked with, Inception-v3, on 16 GPUs in about $1 0 0 \\mathrm { m s }$ . ",
+        "bbox": [
+            174,
+            188,
+            825,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            309,
+            357,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We found that it is non-trivial to parallelize the training of CNNs in the height, width, and channel dimensions in existing frameworks (e.g., TensorFlow, PyTorch, and Caffe2), and none provides an interface for controlling per-operation parallelism. We implemented DeePa in Legion (Bauer et al., 2012), a high-performance parallel runtime for distributed heterogeneous architectures, and use cuDNN (Chetlur et al., 2014) and cuBLAS (cub, 2016) as the underlying libraries for processing neural network operations. The following Legion features significantly simplify our implementation for DeePa. First, Legion supports high-dimensional partitioning that allows us to parallelize any operation in any combination of the dimensions. Second, Legion allows DeePa to control parallelism at the granularity of each operation. Third, Legion allows fine-grain control over the placement of data in memory. Fourth, Legion’s asynchronous tasking model makes it easy to exploit task as well as image parallelism. We also include two critical optimizations that help achieve good performance. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Overlapping computation with data transfers. DeePa manages the gradients of each operation separately and transfers an operation’s gradients as long as its back propagation is completed. We have found that this can effectively hide the data transfer overhead for gradient synchronization. As a result, the synchronous training performance matches asynchronous training in DeePa, which allows users to use synchronous training with its better algorithmic efficiency. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Distributing parameter servers. Existing frameworks use parameter servers to store and update variables for a CNN model. Parameter servers are located in CPU memory in TensorFlow and PyTorch. Because DeePa manages the parameters for each operation separately, DeePa can opportunistically distribute the parameter server onto the GPU memories whenever possible. This eliminates data transfers for operations whose gradients and parameter server are located on the same GPU and transforms all GPU to CPU copies into faster GPU to GPU copies. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            344,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, DeePa is the first deep learning framework that controls and optimizes the parallelism of neural networks in all dimensions at the granularity of each operation. ",
+        "bbox": [
+            176,
+            719,
+            823,
+            748
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Existing frameworks such as TensorFlow (Abadi et al., 2016), Caffe2 (Caf, 2016), and PyTorch (Pyt, 2017) use image parallelism to distribute the training of CNNs and only explore parallelism in the image dimension. The standard image parallelism configuration keeps a replica of the entire network on each worker, which results in large data transfers for synchronizing the gradients in each step. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            811
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Mirhoseini et al. (2017) uses model parallelism that assigns each operation to a dedicated processor for training Inception-v3. It uses a reinforcement learning algorithm to optimize the placement of each operation on a GPU device. The learned device placement on 4 GPUs achieves $19 \\%$ speedup compared to single GPU performance. However, parallelism in each operation is not explored. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Krizhevsky (2014) introduces “one weird trick” (OWT) that combines image parallelism with model parallelism to accelerate the distributed training of AlexNet, which efficiently reduces the data transfer cost compared to the standard image parallelism configuration. In Section 7.1.2, we show that ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DeePa further reduces the overall data transfers for AlexNet by $3 \\times$ and the per-step training time by $2 . 3 \\times$ compared to OWT. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            131
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Goyal et al. (2017) empirically shows no loss of accuracy for training ResNet-50 on the ImageNet dataset with a large minibatch size of 8192 images3. It uses the standard image parallelism configuration to distribute the training onto 256 GPUs and includes a number of optimizations for reducing communication overhead. As communication is a bottleneck in distributed deep learning, we believe our techniques for reducing data transfers can substantially benefit training on large numbers of GPUs. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            243,
+            315,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a8603f4feaccae978b2b90aca2c6b48a954047e9d30946644ba57eefa039cca.jpg",
+        "image_caption": [
+            "Figure 7: Training throughput (images/second) for AlexNet, VGG-16, and Inception-v3 on 16 GPUs. The purple and green bar shows the DeePa performance by restricting DeePa to use image and OWT parallelism, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            263,
+            455,
+            407
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/88771cf8f78487d7c8ae7da1c16f6db428cc51628e774ad66dc7dd7ecc60e9da.jpg",
+        "image_caption": [
+            "Figure 8: Total amount of data transferred in each step for training AlexNet, VGG-16, and Inception-v3 on 16 GPUs with a minibatch size of 512. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            266,
+            784,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use AlexNet (Krizhevsky, 2014), VGG-16 (Simonyan & Zisserman, 2014), and Inceptionv3 (Szegedy et al., 2016) as benchmark CNNs and use the ImageNet dataset (Russakovsky et al., 2015) as the input. For each CNN, we compare the performance of DeePa against TensorFlow, PyTorch, and OWT. We implement OWT in DeePa by restricting all convolutional and pooling layers to use image parallelism and all fully-connected layers to use model parallelism. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.1 CASE STUDY ON A 16-GPU MACHINE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            478,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct a detailed case study for training the three CNNs on a 16-GPU machine, with two Intel 10-core E5-2680 Xeon processors, 256 GB main memory, and 16 NVIDIA Tesla K80 GPUs4. We use all 16 GPUs for training each CNN model with a minibatch size of 512 images. As a result, each GPU processes a batch of 32 images in the image parallelism configuration. DeePa uses the search algorithm in Section 4 to find the optimal parallelism configurations, which requires 0.7, 1.1, and 4.8 seconds for AlexNet, VGG-16, and Inception-v3, respectively. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows the synchronous training throughput for a minibatch size of 512 images on 16 GPUs. When DeePa uses image parallelism for all operations, DeePa achieves competitive performance compared to the best of TensorFlow and PyTorch. The OWT approach that uses model parallelism for fully-connected layers speeds up the training throughput by $1 . 4 \\times , 1 . 2 \\times$ , and $1 . 0 7 \\times$ compared to image parallelism using DeePa. The best configurations found by DeePa achieve $6 . 5 \\times$ , $1 . 9 \\times$ , and $1 . 5 \\times$ speedup compared to TensorFlow and PyTorch. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Three main optimizations in DeePa achieve most of the performance benefit over the other frameworks. First, DeePa significantly reduces data transfers in each step, as shown in Figure 8. Compared to image parallelism, the OWT approach reduces data transfers by $1 . 0 5 { - } 8 . 4 \\times$ . However, the best configuration used by DeePa further reduces data transfers by $1 . 2 \\mathrm { - } 2 . 7 \\mathrm { \\times }$ compared to OWT. Second, the optimization for overlapping computation with data transfers (described in Section 5) effectively hides data transfer latency and achieves better GPU utilization. The grey bars in Figure 7 illustrate DeePa’s performance when the overlap optimization is disabled, which shows that overlapping computation with data transfers can improve the training throughput by $10 \\% { - } 3 0 \\%$ . Third, DeePa also improves performance by exploring parallelism in the height and width dimensions (see Section 7.1.3). ",
+        "bbox": [
+            174,
+            803,
+            823,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/10f6abdaa2f9fe0fdab260bc1a7deda8ec803c449b147978a2d48f549e9e7116.jpg",
+        "table_caption": [
+            "Table 2: The cost for different configurations for the first fully-connected of AlexNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Configuration</td><td>#GPU Workers</td><td>Transfer Cost</td><td>Compute Cost</td><td>Update Cost</td><td>Total Cost</td><td>Parallelism Configurations</td></tr><tr><td>{n=16,c=1}</td><td>16</td><td>0</td><td>+1.28</td><td>+1075</td><td>= 1076</td><td>ImageParallelism</td></tr><tr><td>{n=1,c=16}</td><td>16</td><td>134.4</td><td>+1.28</td><td>+0</td><td>= 135.7</td><td>OWT</td></tr><tr><td>{n=1,c=4}</td><td>4</td><td>33.6</td><td>+5.1</td><td>+0</td><td>=38.7</td><td></td></tr><tr><td>{n=1,c=2}</td><td>2</td><td>16.8</td><td>+10.2</td><td>+0</td><td>= 27.0</td><td>DeePa</td></tr><tr><td>{n=1,c=1}</td><td>1</td><td>8.4</td><td>+20.4</td><td>+0</td><td>=28.8</td><td></td></tr></table>",
+        "bbox": [
+            227,
+            102,
+            766,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            200,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1.1 THE BEST CONFIGURATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            272,
+            424,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We describe the best configurations discovered for AlexNet, VGG-16, and Inception-v3 in Sections 7.1.2 to 7.1.4. The best configurations have several similarities. ",
+        "bbox": [
+            176,
+            296,
+            821,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, for the beginning layers with large height/width dimensions and small channel dimensions, DeePa uses image parallelism on all available GPUs, since the data transfers for synchronizing gradients are much smaller than the data transfers for moving tensors between operations. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            373
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Second, deeper layers in CNNs tend to have smaller height/width dimensions and larger channel dimensions. As a result, the cost for moving tensors between different operations decreases, while the cost for synchronizing gradients increases. DeePa adaptively reduces the number of GPU workers for these layers to reduce the expensive data transfers for synchronizing gradients at the cost of introducing cheaper data transfers for moving tensors. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Third, DeePa uses model parallelism on a small number of GPU workers for fully-connected layers, because synchronizing gradients and moving tensors are both much more expensive than the compute time for fully-connected layers. DeePa reduces the data transfers for synchronizing gradients and moving tensors at the cost of using fewer GPUs. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1.2 ALEXNET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            299,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1fdc606e91795c844913b613431e568e584b2d6b849313aba4b291b077c06bbb.jpg",
+        "image_caption": [
+            "Figure 9: The global configuration for parallelizing AlexNet on 16 GPU workers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            556,
+            807,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the global configuration for AlexNet on 16 GPU workers. Note that DeePa selects the parallelism configuration that optimizes the performance for each layer. Table 2 lists the cost for different configurations of the first fully-connected layer. The standard image parallelism configuration eliminates the cost for transferring the input tensors but introduces additional data transfers for synchronizing gradients. The OWT approach completely eliminates gradient synchronization at the cost of replicating the input tensors on every GPU worker. The configuration chosen by DeePa only uses 2 GPU workers for training the first fully-connected layer, which prolongs the compute time but significantly reduces the cost for both transferring input tensors and synchronizing gradients. As a result, DeePa reduces the total cost by $5 \\times$ compared to other approaches. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "DeePa uses image parallelism for all convolutional and pooling layers, because the additional data transfer cost introduced by transforming configurations outweighs any performance benefits. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1.3 VGG-16 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            819,
+            290,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/95df748900bc84eba803cc88fd5a97ef3361566c57dcdd7501747e30ff8bc4d5.jpg",
+        "image_caption": [
+            "Figure 10: The global configuration for parallelizing VGG-16 on 16 GPU workers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            848,
+            807,
+            896
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/86e71464cd56728964614dbc559679fa9d3180740c98a8befb9f7239eac39609.jpg",
+        "table_caption": [
+            "Table 3: The cost for different configurations for the last three convolutional layers of VGG-16. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Configuration</td><td># GPU Workers</td><td>Transfer Cost</td><td>Compute Cost</td><td>Update Cost</td><td>Total Cost</td><td>Parallelism Configurations</td></tr><tr><td>{n=16,c=1,h=1,w=1}</td><td>16</td><td>0</td><td>+15.9</td><td>+134.4</td><td>=150.3</td><td>ImageParallelism&amp;OWT</td></tr><tr><td>{n=8,c=1,h=1,w=1}</td><td>8</td><td>39.2</td><td>+31.8</td><td>+67.2</td><td>=138.2</td><td></td></tr><tr><td>{n=4,c=1,h=1,w=1}</td><td>4</td><td>39.2</td><td>+63.7</td><td>+33.6</td><td>=136.5</td><td></td></tr><tr><td>n=1,c=1,h=2,w=2}</td><td>4</td><td>39.2</td><td>+54.7</td><td>+33.6</td><td>= 127.5</td><td>DeePa</td></tr><tr><td>{n=2,c=1,h=1,w=1}</td><td>2</td><td>39.2</td><td>+127.4</td><td>+16.8</td><td>= 183.4</td><td></td></tr></table>",
+        "bbox": [
+            178,
+            119,
+            820,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "DeePa uses similar configurations for parallelizing the fully-connected layers in VGG-16 (Figure 10). In addition, DeePa also uses a different configuration to cooperatively accelerate the last three convolutional layers (the yellow node in Figure 10). Table 3 lists the cost for different parallelism configurations for the last three convolutional layers. The configuration with optimal total cost uses only four GPU workers for the last three convolutional layers to reduce data transfers for synchronizing gradients. DeePa also exploits parallelism in the height and width dimensions to further reduce the compute time. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.1.4 INCEPTION-V3",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            331,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/24622793c7d9a18be1849cfbf2f27bf3f3b7217458333dcd812989ffb48a683f.jpg",
+        "image_caption": [
+            "Figure 11: The global configuration for parallelizing Inception-v3 on 16 GPU workers. Each module is shown as a single node for simplicity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            366,
+            807,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a90e2a59301a873254383b009ff421c72d65c2019d8ddc83463f23f0cfa9dbb8.jpg",
+        "image_caption": [
+            "Figure 12: The configurations for parallelizing the InceptionE1 module. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            383,
+            467,
+            612,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Inception-v3 model has multiple Inception modules (Szegedy et al., 2016). Each module has several branches of convolutional and pooling layers, which are then concatenated as the output tensor of the module. Figure 11 shows the global configuration for Inception-v3. DeePa uses different configurations to parallelize different branches for the InceptionE1 module, as shown in Figure 12. We found that this configuration reduces data transfers by $30 \\%$ in InceptionE1 and InceptionE2 and reduces overall data transfers by $20 \\%$ . ",
+        "bbox": [
+            174,
+            604,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.2 MINIBATCH SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            334,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The minibatch size plays an important rule on the performance of CNNs. Figure 13 compares DeePa, PyTorch, and TensorFlow with different minibatch sizes. All three networks were trained on 16 Tesla K80 GPUs on a single node, as described in Section 7.1. We were not able to train VGG-16 and Inception-v3 with a minibatch size of 2048 images, because the required metadata size exceeds the aggregate memory capacity of the 16 GPUs. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 13 shows that, DeePa achieves constant speedups compared to PyTorch and TensorFlow for various minibatch sizes. In particular, DeePa achieves $4 . 6 { - } 6 . 5 \\times$ , $1 . 6 \\mathrm { - } 1 . 9 \\times$ , and $1 . 2 \\mathrm { - } 1 . 5 \\times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.3 MULTI-NODE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            375,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the scalability of different frameworks by comparing their training throughput with different number of GPUs and compute nodes. The experiments were performed on a GPU cluster with 4 nodes, each of which is equipped with two Intel 10-core E5-2600 Xeon processors, 256G main memory, and four NVIDIA Tesla P100 GPUs. GPUs on the same node are connected by NVLink, and nodes are connected over 100Gb/s EDR Infiniband. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/93d7458c30e952d22471ba797bc25194e958c53604a5bbb842f5261434b76644.jpg",
+        "image_caption": [
+            "Figure 13: Performance comparisons among DeePa, PyTorch, and TensorFlow with different minibatch sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            104,
+            818,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb0caedab1734e4586484851a263b00c77853d7a82ca74ef5d38bc970f581d94.jpg",
+        "image_caption": [
+            "Figure 14: Performance results for DeePa, PyTorch, and TensorFlow on up to 4 nodes. We perform weak-scaling, where each GPU worker processes a batch of 32 images in every iteration. We use all 4 GPUs on each node in the last two subfigures. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            310,
+            821,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            541,
+            823,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 14 shows the performance comparison among DeePa, PyTorch, and TensorFlow for weakscaling. DeePa achieves competitive performance compared to PyTorch and TensorFlow for training on a single GPU, in which all three frameworks place all operations on a single GPU. For training on 4 GPUs on a single node, DeePa achieves $3 . 1 \\times$ , $1 . 6 \\times$ , and $1 . 3 \\times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively. DeePa achieves even better performance speedups for trainings on multiple nodes, where the data transfer time becomes a larger component of the per-iteration training time. For training on 4 nodes, DeePa achieves $8 . 1 \\times$ , $3 . 2 \\times$ , and $1 . 8 \\times$ speedup for AlexNet, VGG-16, and Inception-v3, respectively. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            318,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented DeePa, a deep learning framework that explores parallelism in all parallelizable dimensions to accelerate the training of CNNs. DeePa optimizes the parallelism configuration chosen at the granularity of individual layers. DeePa achieves up to $6 . 5 \\times$ for training CNNs and reduces overall data transfers by up to $2 3 \\times$ compared to state-of-the-art deep learning frameworks. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            815
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            287,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A New Lightweight, Modular, and Scalable Deep Learning Framework. https://caffe2.ai, 2016. ",
+        "bbox": [
+            171,
+            866,
+            825,
+            895
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dense Linear Algebra on GPUs. https://developer.nvidia.com/cublas, 2016. ",
+        "bbox": [
+            169,
+            910,
+            781,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tensors and Dynamic neural networks in Python with strong GPU acceleration. https:// pytorch.org, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for largescale machine learning. In OSDI, volume 16, pp. 265–283, 2016. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Bauer, Sean Treichler, Elliott Slaughter, and Alex Aiken. Legion: Expressing locality and independence with logical regions. In Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis, 2012. ",
+        "bbox": [
+            174,
+            190,
+            823,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. CoRR, abs/1410.0759, 2014. URL http://arxiv.org/abs/1410.0759. ",
+        "bbox": [
+            174,
+            241,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, ´ Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL http://arxiv.org/abs/1706. 02677. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            347
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. CoRR, abs/1404.5997, 2014. URL http://arxiv.org/abs/1404.5997. ",
+        "bbox": [
+            171,
+            356,
+            823,
+            385
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Azalia Mirhoseini, Hieu Pham, Quoc V Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean. Device placement optimization with reinforcement learning. CoRR, abs/1706.04972, 2017. URL http://arxiv.org/abs/ 1706.04972. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 2015. ",
+        "bbox": [
+            176,
+            457,
+            821,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            174,
+            507,
+            821,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842. ",
+        "bbox": [
+            176,
+            542,
+            823,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            594,
+            821,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, 2014. ",
+        "bbox": [
+            174,
+            645,
+            821,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            297,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 NODE AND EDGE ELIMINATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            436,
+            743
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We prove the correctness of the node and edge eliminations in Section 4. In particular, we prove that after applying node and edge eliminations, the modified graph has the same optimal configuration as the original graph. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 NODE ELIMINATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            370,
+            827
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For a given computation graph $G = ( V , E )$ , applying a node elimination on $w$ requires $w$ having a single in-edge $\\boldsymbol { e } _ { 1 } = ( u , w )$ and a single out-edge $e _ { 2 } = ( w , v )$ . The node elimination results in a modified graph $G ^ { \\prime } = ( V ^ { \\prime } , E ^ { \\prime } )$ , where $V ^ { \\prime } = V - \\{ w \\}$ , $E ^ { \\prime } = E - e _ { 1 } - e _ { 2 } + e ^ { \\prime }$ , and $\\boldsymbol { e } ^ { \\prime } = \\left( \\boldsymbol { u } , \\boldsymbol { v } \\right)$ . ",
+        "bbox": [
+            174,
+            835,
+            825,
+            878
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Consider graphs $( V , E )$ and the result of a single node elimination $( V ^ { \\prime } , E ^ { \\prime } )$ . Then an optimal configuration of $V , E )$ ) is also an optimal configuration of $( V ^ { \\prime } , E ^ { \\prime } )$ , and an optimal configuration of $( V ^ { \\prime } , E ^ { \\prime } )$ is extensible to a an optimal configuration of $( V , E )$ . ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof. The Cost function is defined in Equation 1. Let $g$ be any configuration. We first compute the difference between $C o s t ( g , ( V , E ) )$ and $C o s t ( g , ( V ^ { \\prime } , E ^ { \\prime } ) )$ . ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc9da573458996f841e41630daab0f17d1b184f20d104f564fac4d2ae22b20e2.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle C o s t ( g , ( V , E ) ) - C o s t ( g , ( V ^ { \\prime } , E ^ { \\prime } ) ) } } \\\\ { { \\displaystyle = \\sum _ { v \\in V } \\{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \\} + \\sum _ { e = ( u , v ) \\in E } e . x f e r ( g ( u ) , g ( v ) ) } } \\\\ { { \\displaystyle ~ - \\sum _ { v \\in V ^ { \\prime } } \\{ v . c o m p u t e ( g ( v ) ) + v . u p d a t e ( g ( v ) ) \\} + \\sum _ { e = ( u , v ) \\in E ^ { \\prime } } e . x f e r ( g ( u ) , g ( v ) ) } } \\\\ { { \\displaystyle = w . c o m p u t e ( g ( w ) ) + w . u p d a t e ( g ( w ) ) } } \\\\ { { \\displaystyle ~ + e . \\cdot x f e r ( g ( u ) , g ( w ) ) + e . \\cdot x f e r ( g ( w ) , g ( v ) ) - e ^ { \\prime } . x f e r ( g ( u ) , g ( v ) ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            138,
+            761,
+            271
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Now assume $g$ is an optimal configuration for $( V , E )$ . Then we have ",
+        "bbox": [
+            171,
+            276,
+            622,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe52b82e9a33b3fcb590b7db357367479f25567c3fcb6515a1d88acca45629b1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad w . c o m p u t e ( g ( w ) ) + w . u p d a t e ( g ( w ) ) + e _ { 1 } . x f e r ( g ( u ) , g ( w ) ) + e _ { 2 } . x f e r ( g ( w ) , g ( v ) ) } \\\\ & { = \\underset { c _ { w } } { \\operatorname* { m i n } } \\{ w . c o m p u t e ( c _ { w } ) + w . u p d a t e ( c _ { w } ) + e _ { 1 } . x f e r ( g ( u ) , c _ { w } ) + e _ { 2 } . x f e r ( c _ { w } , g ( v ) ) \\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            297,
+            777,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore, $g$ is an optimal configuration of $( V ^ { \\prime } , E ^ { \\prime } )$ . For the other direction, note that if $g$ is an optimal configuration of $( V ^ { \\prime } , E ^ { \\prime } )$ , then it can be extended to an optimal configuration of $( V , E )$ by adding the node $w$ with the same minimal assignment. □ ",
+        "bbox": [
+            174,
+            347,
+            823,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.2 EDGE ELIMINATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            406,
+            369,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For a computation graph $G ( V , E )$ , applying an edge elimination on $\\boldsymbol { e } _ { 1 } = ( u , v )$ and $\\boldsymbol { e } _ { 2 } = ( u , v )$ results in a modified graph $G ^ { \\prime } = ( V , E ^ { \\prime } )$ , where $E ^ { \\prime } = E - e _ { 1 } - e _ { 2 } + e ^ { \\prime }$ and $\\boldsymbol { e } ^ { \\prime } = \\left( \\boldsymbol { u } , \\boldsymbol { v } \\right)$ . We prove that $C o s t ( g , ( V , E ) ) = C o s t ( g , ( V , E ^ { \\prime } ) )$ for any global configuration $g$ of $( V , E )$ . ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. For any global configuration $g$ of graph $\\begin{array} { r c l } { G } & { = } & { ( V , E ) } \\end{array}$ , $C o s t ( g , ( V , E ) ) \\quad = \\quad$ $C o s t ( g , ( V , E ^ { \\prime } ) )$ , where $( V , E ^ { \\prime } )$ is the modified graph of $( V , E )$ after an edge elimination. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof. We compute the difference between $C o s t ( g , ( V , E ) )$ and $C o s t ( g , ( V , E ^ { \\prime } ) )$ . ",
+        "bbox": [
+            173,
+            521,
+            705,
+            537
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cb2ac2c05098a998553c8bac7b597e68aaf6f2f455a8e0f28b7d17a8a0d3432.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad C o s t ( g , ( V , E ) ) - C o s t ( g , ( V , E ^ { \\prime } ) ) } \\\\ & { = e _ { 1 } . x f e r ( g ( u ) , g ( v ) ) - e _ { 2 } . x f e r ( g ( u ) , g ( v ) ) + e ^ { \\prime } . x f e r ( g ( u ) , g ( v ) ) } \\\\ & { = 0 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            544,
+            714,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The last equation uses Equation 3. ",
+        "bbox": [
+            174,
+            606,
+            398,
+            621
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 RELATED WORK ON OVERLAPPING COMMUNICATION WITH DATA TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            743,
+            652
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The overlap optimization in Section 5 is motivated by Goyal et al. (2017), which performs gradient aggregation in parallel with back propagation to scale synchronous training to large number of GPUs. We extend their design and implementation by also enabling the optimization for asynchronous training in DeePa. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            719
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 PROFILING RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            362,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show profiling results for visualizing the performance bottlenecks in different parallelism approaches. The experiment was performed on a single node with four Tesla P100 GPUs (as described in Section 7.3). We enable overlapping computation with data transfers (described in Section 5) in this experiment. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            819
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 15 shows the profiling results for training VGG-16 on 4 GPUs with different parallelism configurations. Note that DeePa with image parallelism achieves $10 \\%$ higher training throughput compared to PyTorch and TensorFlow, as shown in Figure 14. Figure 15a shows that all GPUs are highly utilized during forward and backward passes, as indicated by the tight packing of tasks in the timeline. However, the image parallelism approach requires moving 4GB of metadata in every iteration, which cannot be fully overlapped with back propagation, therefore the image parallelism approach has a performance gap between iterations (shown as the white space on the GPU timelines). ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfe354450aec70902555e21661a7d63eaf3b55d3bdfe2b63f4ce187cb4786c07.jpg",
+        "image_caption": [
+            "Figure 15: Timelines for training VGG-16 with a minibatch size of 128 images on 4 GPUs. The first horizontal line in each figure shows the overall GPU utilization at different timesteps, and each of the following lines shows the run times for individual operations on each GPU. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            102,
+            764,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 15b shows the profiling of the optimal parallelism configuration chosen by DeePa, which uses image parallelism on 4 GPUs for all convolutional layers and pooling layers and uses model parallelism on 2 GPUs for the fully connected layers. Therefore, the training with the optimal configuration includes data transfers for each fully connected layers, which adds small performance gaps at the end of the forward pass and the beginning of the backward pass (shown as the small white space on the GPU timelines). However, the optimal configuration reduces the per-iteration data transfers from 4GB to 490MB, which effectively hides data transfer overhead and achieves better GPU utilization. As a result, the optimal configuration reduces the per-iteration training time from 0.34 seconds to 0.24 seconds. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            715
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 IMANGENET-22K ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            341,
+            751
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of DeePa, PyTorch, and TensorFlow on the ImageNet-22K dataset (Russakovsky et al., 2015) that contains 21,841 different categories (the ImageNet dataset used in Section 7 contains 1,000 catagories). The last fully-connected layer in AlexNet, VGG-16, and Inception-v3 originally have 1,000 neurons followed by a 1,000-way softmax layer. To train the three networks on the ImageNet-22K dataset, we change the last fully-connected layer to have 21,841 neurons and use a 21,841-way softmax layer at the end. The modified networks were trained on 16 Tesla K80 GPUs on a single node with a minibatch size of 512 images. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 16 compares the training throughput and per-iteration data transfers among DeePa, PyTorch, and TensorFlow on the ImageNet and ImageNet-22K datasets. Figure 16a shows that, on the ImageNet-22K dataset, the training throughput of PyTorch and TensorFlow is reduced by $20 \\%$ - $45 \\%$ , while DeePa’s throughput falls off by $3 \\%$ , compared to training on the original ImageNet dataset. Figure 16b compares the per-iteration data transfers between image parallelism and the global configurations used by DeePa. Using image parallelism increases the data transfers in each iteration by 5-10GB, while DeePa only increases the per-iteration data transfers by 40MB. As a result, for training on the ImageNet-22K dataset, DeePa reduces the per-iteration data transfers by $3 . 7 – 4 4 . 5 \\times$ compared to image parallelism. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/77258f4c33113381b171df167a6b62265e6737ee838ead9a1aa8de95aa53aa34.jpg",
+        "image_caption": [
+            "Figure 16: Performance comparisons among DeePa, PyTorch, and TensorFlow on the ImageNet-22k dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            130,
+            816,
+            324
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            397,
+            825,
+            468
+        ],
+        "page_idx": 13
+    }
+]

parse/train/Ske6wiAcKQ/Ske6wiAcKQ.md

@@ -0,0 +1,214 @@
+# REAL-TIME NEURAL-BASED INPUT METHOD
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The input method is an essential service on every mobile and desktop devices that provides text suggestions. It converts sequential keyboard inputs to the characters in its target language, which is indispensable for Japanese and Chinese users. Due to critical resource constraints and limited network bandwidth of the target devices, applying neural models to input method is not well explored. In this work, we apply a LSTM-based language model to input method and evaluate its performance for both prediction and conversion tasks with Japanese BCCWJ corpus. We articulate the bottleneck to be the slow softmax computation during conversion. To solve the issue, we propose incremental softmax approximation approach, which computes softmax with a selected subset vocabulary and fix the stale probabilities when the vocabulary is updated in future steps. We refer to this method as incremental selective softmax. The results show a two order speedup for the softmax computation when converting Japanese input sequences with a large vocabulary, reaching real-time speed on commodity CPU. We also exploit the model compressing potential to achieve a $92 \%$ model size reduction without losing accuracy.
+
+# 1 INTRODUCTION
+
+Typing is one of the core activities users interact with devices. The input method is an intelligent service in operating systems that provides text suggestions to boost typing efficiency. With a large user base, commercial input products have helped users save trillions of key presses. Being able to provide an input method service in high quality makes a huge business impact.
+
+Among various features an input method provides, we consider two essential text suggestion tasks in this work: next word prediction task and conversion task. Next word prediction task relies on a language model, which gives the probability of the next word $p \big ( w _ { t } | w _ { 1 : t - 1 } \big )$ . Usually, top 3 or 5 candidates are shown to users. Conversion task, however, is not a common scenario for Latin users. Latin users can type directly with a keyboard, but there are thousands of characters in the Chinese and Japanese language. Conversion task takes a key sequence and converts it to target word sequence that best matches users’ original intentions. It is a sequence decoding task similar to machine translation.
+
+Conventionally, an n-gram language model is used to solve these two tasks (Stolcke, 2002). However, due to the exponential increase in model size , the $\mathbf { n }$ -gram model can only support up to tri-gram. The decoding results often fail to have global consistency as the tri-gram language model is not capable of considering distant context. Also, n-gram models are often pruned to meet model size requirement with a loss in accuracy. In contrast, neural-based language models are proven to solve such issues more efficiently(Bengio et al., 2003; Mikolov et al., 2010; Jozefowicz et al., 2016).
+
+Although neural-based language model has achieved enormous success, conventionally, it is not considered feasible for input method task. One major reason is that the input method has to run interactively at user devices with critical constraints of resources and run-time speed. This is different from speech recognition or machine translation services that are normally served from online servers. Input applications have to sacrifice accuracy for execution speed and model size.
+
+In this work, we enhance a neural language model tailored for input method task to meet both runtime speed and model size requirement. Our baseline model is composed of a LSTM-based language model (Hochreiter & Schmidhuber, 1997) with a Viterbi decoder (Forney, 1973) as Figure 1 shows.
+
+![](images/0bfa12a95181689e0155dd0c85df34a7db7d0491abb46b1baf290a433572667b.jpg)  
+Figure 1: Illustration of the proposed neural-based input method. (a) Input context. (b) Conversion with LSTM LM and Viterbi decoder. (c) Word prediction.
+
+It improves the performance for both conversion and next word prediction task and is capable of capturing distant context.
+
+For languages like Japanese and Chinese, a large vocabulary is required in the conversion task. we articulate the bottleneck of run-time speed as the vocabulary size matrix operation before softmax. We propose an incremental selective softmax approach that builds a subset vocabulary $V _ { t }$ at each decoding step $t$ . By only computing softmax over $V _ { t }$ , the cost of softmax significantly drops since $| V _ { t } |$ is usually a small number that is less than $1 \%$ of the original vocabulary size. We evaluate the speedup comparing to other softmax optimization. To further handle the model disk size and memory size, we apply $\mathbf { k }$ -means based quantization algorithm and analyze its performance with various compression ratio.
+
+We summarize the main contributions of this paper as follows:
+
+1) We empirically evaluate using a LSTM-based language model to address input method challenges and demonstrate its performance for a complex language with large vocabulary size.
+
+2) We propose an effective approach to accelerate the inference time with incremental selective softmax. By avoiding computing the full softmax, our approach achieves two orders inference speed boost without negatively impact the accuracy of conversion.
+
+3) To let the neural language model with a large vocabulary fit into the execution environment on consumer devices, we compress the model with quantization techniques, achieving a $92 \%$ reduction on model size.
+
+# 2 NEURAL-BASED INPUT METHOD
+
+The neural-based approach we propose for input method is illustrated in Figure 1. We use LSTM language model for both the conversion and prediction tasks. A noticeable difference from the ngram approach is the use of a latent vector to capture input context. It is the hidden vector from the last recurrent unit of the previous sequence. In a real scenario, users don’t type the full sentence in one effort. Instead, they type and convert in fragments, where each fragment contains a few words. It is important to carry the context of the previously determined results to current conversion task.
+
+Conversion task is described in Figure 1(b). As the user starts to type in an editor control, the input method first converts the alphabet user typed into syllables. Take Japanese as an example, Japanese Kana, also called “fifty sounds”, can be converted from the alphabet with fixed rules. In lexicon, Japanese words are indexed by Kana characters with an efficient structure such as Trie. A word lattice is then built with all possible words from a Kana sequence by lexicon lookup. To find the best combination of words aligned with the Kana sequence, we use a Viterbi decoder to decode with a beam size $S$ . LSTM language model is used here to evaluate path probabilities. The best path is then shown to the user as the conversion candidate.
+
+Once the user selects the conversion candidate, last hidden vector of the best path becomes the new context vector. We compute the softmax based on the context vector and provides a probability distribution of the next words as shown in Figure 1(c).
+
+Although several commercial input products have already tried to apply neural models1, they mainly aim to solve the prediction task for Latin languages. Conversion task has a different scale of computational cost and is not yet tackled.
+
+# 3 MODEL ACCELERATION
+
+# 3.1 BACKGROUND
+
+Comparing to a prediction task, the conversion task is even more costly to compute. We further articulate three issues that make the conversion task difficult to solve: 1) For Japanese or Chinese input method, a much larger vocabulary size is required, which is usually several times larger than English. 2) During decoding, we have to evaluate probabilities for all paths with a beam size $S$ . 3) Most importantly, there are no natural word boundaries in Chinese or Japanese, such as a space character. The path evaluation has to run each time a new key input arrives, instead of when space is inserted. With all above constraints, the conversion task has to compute $S \times | V | \times | X |$ steps of LSTM computation for one input sequence, where $| V |$ is the vocabulary size, $| X |$ is the sequence length.
+
+Heavy computation cost of LSTM model comes from two operations: the matrix operations inside LSTM cell and the matrix projection at softmax. In the case of a LSTM model with a vocabulary size of 100K, a hidden size of 512, and an embedding size of 256, estimated by simple matrix multiplication, the number of multiplication operations for LSTM cell is about $1 . 5 \mathbf { M }$ , while the softmax has 50M operations. In practice, the softmax occupies $9 7 \%$ of the total computation cost, which is the bottleneck for the conversion task with a large vocabulary size.
+
+# 3.2 INCREMENTAL SELECTIVE SOFTMAX
+
+To solve the challenges, we propose an incremental selective softmax approach to obtain correct probabilities for paths in the lattice. Given a partial observed character input sequence $( x _ { 1 } , . . . , x _ { t } )$ , we search for a set of words in the dictionary that match any suffix of the observation:
+
+$$
+D _ { t } = \bigcup _ { i = 1 } ^ { t } { \mathrm { m a t c h } } ( x _ { i } , . . . , x _ { t } ) ,
+$$
+
+where the function $\mathrm { { m a t c h } ( \cdot ) }$ returns all lexicon items matching the partial sequence. For example, given the observation “ha ru ka”, the lexicon set $D _ { t }$ contains all words matching “ha ru $\mathbf { k } \mathbf { a } ^ { \prime \prime }$ or “ru ka” or “ka”. With the lexicon set in each step, we can construct a subset vocabulary $V _ { t }$ that covers all possible output words until step $t$ as:
+
+$$
+V _ { t } = \bigcup _ { i = 1 } ^ { t } D _ { i } .
+$$
+
+In this work, we refer to $V _ { t }$ as the lattice vocabulary. In contrast to the beam search in machine translation, we have to rank paths that contain different number of words. If we directly compute path probabilities on $V _ { t }$ with a language model, as the denominator of the softmax becomes smaller, all words will have higher probabilities. Therefore, the paths containing more words will have advantage due to the incorrect probabilities. As a result, the paths can be ranked wrongly.
+
+To circumvent the probability issue, we also sample a subset vocabulary from the full vocabulary, denoted by $\tilde { V }$ . We use $V _ { t }$ jointly with $\tilde { V }$ to make the word probabilities closer to their original probabilities, thus minimizing the impact of exposure bias.
+
+![](images/3d562e15cb3e0776b6f6525eadd76ad810f72b2a4af90e6045eff1b1b9a53610.jpg)  
+Figure 2: Illustration of incremental selective softmax: (a) Vocabulary sampling strategies (b) Incrementally correct path probabilities with new lattice vocabulary.
+
+As shown in Figure 2(a), we experiment two sampling methods. The first one samples mostly frequent words from the vocabulary, whereas the second one uniformly samples from the full vocabulary. We found the first sampling method (top sampling) delivers the best performance. In practice, both $V _ { t }$ and $\tilde { V }$ have less than $1 \%$ of the words in the original vocabulary.
+
+Our proposed softmax approximation technique has two passes. When a new input character $x _ { t + 1 }$ arrives, we merge the current vocabulary $V _ { t }$ with new words from the lexicon set $D _ { t + 1 }$ , forming a new vocabulary $V _ { t + 1 }$ . Then for each path in the lattice, we compute the language model probability at step $t + 1$ with the joint vocabulary $V _ { t + 1 } \cup \tilde { V }$ as:
+
+$$
+P ( y _ { t } = i | h _ { t } ) = \frac { \exp ( h _ { t } ^ { \top } W _ { i } ) } { \sum _ { j \in V _ { t + 1 } \cup \tilde { V } } \exp ( h _ { t } ^ { \top } W _ { j } ) } ,
+$$
+
+where $h _ { t }$ is the LSTM hidden state in step $t$ . In this pass, we only compute the word probabilities for top paths in batch with a beam size $S$ .
+
+Now we computed the latest word probabilities using the lattice vocabulary $V _ { t + 1 }$ . Unfortunately, as previous word probabilities are computed on old vocabularies, they are not comparable with the new ones. Therefore, in the second pass, we correct the stale word probabilities to let them have the same denominator as the ones computed on the latest lattice vocabulary.
+
+In principle, we can correct an old probability in step $k$ by adding the logits of missing vocabulary to the denominator as:
+
+$$
+P ( y _ { k } = i | h _ { k } ) = \frac { \exp ( h _ { k } ^ { \top } W _ { i } ) } { \displaystyle \sum _ { j \in V _ { k + 1 } \cup { \tilde { V } } } \exp ( h _ { k } ^ { \top } W _ { j } ) + \sum _ { j \in V _ { t + 1 } , j \notin V _ { k + 1 } \cup { \tilde { V } } } \exp ( h _ { k } ^ { \top } W _ { j } ) } .
+$$
+
+However, in practice, as each path has different missing vocabularies, we compute a union of all missing vocabularies, and then recompute the logits of them in batch. Experiments show that our proposed incremental selective softmax strategy achieves a 76x speedup comparing to the baseline.
+
+# 4 EXPERIMENTS
+
+In this section, we compare the performance of the neural-based approach with conventional approaches. Then, we report the results of applying model acceleration and compression techniques.
+
+# 4.1 DATASET
+
+We use BCCWJ (Balanced Corpus of Contemporary Written Japanese) corpus (Maekawa et al., 2014) for evaluating our model. The corpus is well balanced with various sources of text representing contemporary written Japanese. This corpus contains 5.8M sentences, which are segmented into 127M tokens. In our experiments, all words are further segmented into short unit words. Each word has a format of ”display/reading/POS”. The reading and POS attributes are attached to tell different usages of the same word. Among the 611K unique words, we choose top 50K frequent ones that cover $9 7 . 3 \%$ of token appearances as an appropriate vocabulary size for the input method task. The words in the vocabulary are ranked with frequency. Most frequent words are at the top.
+
+# 4.2 EXPERIMENT SETTINGS
+
+The BCCWJ dataset is split into training, valid, and test set. The ratio is $70 \%$ , $20 \%$ , and $10 \%$ respectively. We randomly sample 2000 sentences from the test set for evaluating conversion accuracy. For input method task, we evaluate the conversion accuracy using a Viterbi decoder with a beam size of 10. In Japanese, there are often more than one correct conversion results. For instance, a verb may have two acceptable styles, one in original Japanese Kana, the other in Chinese characters. To better evaluate the model performance, we also report the top-10 accuracy in addition to top-1 accuracy.
+
+We implement the model using TensorFlow2. We use a batch size of 384, and dropout with a drop rate of 0.9. Adam optimizer is used with a fixed learning rate of 0.001. The hyper-parameters are shared for all experiments.
+
+A replica of the same model is written in numpy to work with a Viterbi decoder in python. It uses the weights learned with TensorFlow model. The inference performance is measure with numpy on a single Intel E5 CPU. We also apply the underline BLAS library to accelerate matrix operation.
+
+# 4.3 EVALUATION OF NEURAL-BASED INPUT METHOD
+
+We first compared the neural model performance with a conventional n-gram model. We calculate the perplexity of the n-gram model with SRILM package (Stolcke, 2002). We choose modified Kneser Ney (Kneser & Ney, 1995; James, 2000) as the smoothing algorithm when learning the ngram model. The learned language model is plugged into our input method pipeline for evaluating the sentence conversation accuracy. The prediction accuracy is not provided as it is directly reflected by model perplexity.
+
+The LSTM baseline model has a standard architecture. The embedding size is 256, and the hidden size is 256. The size of LSTM cells is selected empirically on a validation dataset. In practice, using a network size bigger than 256 cannot gain significant improvement on perplexity. In all following experiments, we bind the input embedding and output embedding according to Press & Wolf (2017). The idea is proven to save space and almost loss-less. We treat it as the baseline model in following experiments.
+
+<table><tr><td>Models</td><td>pp</td><td>top1 hit %</td><td>top10 hit %</td></tr><tr><td>uni-gram</td><td>833.55</td><td>26.95</td><td>45.85</td></tr><tr><td>bi-gram KN</td><td>99.30</td><td>51.15</td><td>78.10</td></tr><tr><td>tri-gram KN</td><td>68.11</td><td>55.60</td><td>79.65</td></tr><tr><td>LSTMbaseline</td><td>41.39</td><td>61.20</td><td>88.30</td></tr></table>
+
+Table 1: Performance comparison of baseline LSTM model with conventional n-gram model.
+
+As shown in Table 1, the LSTM baseline achieved a significant improvement on perplexity, comparing to conventional n-gram based models. The top-1 and top-10 path conversion accuracy were increased by $5 . 6 \%$ and $8 . 6 5 \%$ respectively comparing to tri-gram KN. In real products, bi-gram is often used for decoding while tri-gram is only used for re-ranking the best paths. Please note that in this evaluation, we didn’t apply any pruning for n-gram. The n-gram model takes over 1GB storage size.
+
+# 4.4 EVALUATION OF RUN-TIME SPEED
+
+In this section, we compare the inference speed of various softmax acceleration approaches. We measure the execution speed only for the component that computes the language model probabilities. For neural-based methods, the component includes the LSTM and softmax layer. For the n-gram model, the computation of probability is only a lookup in the hash tables. Other components such as lattice construction are not included as they heavily depend on implementation.
+
+Here, we report the decoding time in each step receiving a key input, because the per-step latency is critical for the real-time requirement. The computation cost for decoding the whole sequence is linear to the number of steps. For comparison, we also report the computation time of the softmax alone.
+
+Table 2: Model acceleration among different methods with accuracy.   
+
+<table><tr><td>Models</td><td>Total Time (ms)</td><td>Softmax Time (ms)</td><td>Top-1 Hit (%)</td><td>Top-10 Hit (%)</td></tr><tr><td>tri-gram Kneser-Ney</td><td>0.0025</td><td>1</td><td>55.6</td><td>79.6</td></tr><tr><td>LSTMbaselinew/obatch</td><td>526</td><td>513</td><td>61.2</td><td>88.3</td></tr><tr><td>LSTMbaselinew/batch</td><td>87</td><td>84</td><td>61.2</td><td>88.3</td></tr><tr><td>Char LSTM</td><td>63</td><td>21</td><td>53.2</td><td>79.8</td></tr><tr><td>Char LSTM w/ large beam3</td><td>152</td><td>55</td><td>54.4</td><td>85.2</td></tr><tr><td>D-Softmax</td><td>38</td><td>35</td><td>60.8</td><td>86.8</td></tr><tr><td>D-Softmax*</td><td>37</td><td>35</td><td>60.9</td><td>87.5</td></tr><tr><td>IS-Softmax</td><td>3</td><td>1</td><td>58.8</td><td>86.9</td></tr><tr><td>w/ top sampling</td><td>4</td><td>2</td><td>60.1</td><td>88.2</td></tr><tr><td>w/uniform sampling</td><td>4</td><td>2</td><td>58.9</td><td>87.2</td></tr><tr><td>non-incremental S-Softmax</td><td>11</td><td>2</td><td>58.8</td><td>86.9</td></tr></table>
+
+As Table 2 shows, our proposed incremental selective softmax (IS-Softmax) achieves a 76x speedup comparing to the LSTM baseline. The lattice vocabulary in our experiments contains only a few hundred words, while the full vocabulary has 50k words. IS-Softmax only takes $3 ~ \mathrm { m s }$ to handle a new coming key. Such a high processing speed meets the real-time latency requirement.
+
+As a comparison, the non-incremental selective softmax is less efficient since it recalculates from the beginning in each step. Therefore, the majority of its cost comes from computing LSTM cells. We also evaluate various sampling methods with IS-Softmax. We find top sampling help close the accuracy gap between the baseline and softmax approximations. In our experiments, the number of samples used in top sampling and uniform sampling methods are both 400.
+
+Differentiated softmax (D-Softmax) (Chen et al., 2016) and its variation (D-softmax∗) (Joulin et al., 2017) can also reduce the amount of softmax computation by over a half depends on the segmentation strategy. However, since the vocabulary size is still large, the room for speedup is limited. For character-based LSTM models, we use a hidden size of 1024 and embedding size of 512. Since there is no direct mapping between a single Kana and a single Chinese character, we use the word lattice and evaluate the path probability by character-based LSTM. It reduces the vocabulary size from 50K to 3717 in this experiment. However, the amount of vocabulary is still non-trivial. Furthermore, the integration of character-based models is not as efficient as word-based models in this task. Consequently, we have to use a large beam size to improve accuracy.
+
+We also confirmed that batching is critical for acceleration matrix operations even on CPU. The LSTM computation without batching is almost $7 \mathbf { x }$ slower with a beam size 10. Therefore, we batch all the softmax computations when fixing the vocabulary in the second pass of IS-Softmax to achieve the best speed.
+
+# 4.5 EVALUATION OF MODEL COMPRESSION
+
+Due to the limited resource on user devices, the model for the input method has to be extremely compact for both storage and memory footprint. For the mobile platforms, the distribution package that contains the neural model shall have a size small than $1 0 \mathrm { { M B } }$ in order to handle various network environments. For commercial products, a large model size directly hinders the adoption of neural models even a higher accuracy is achieved.
+
+![](images/5b4504a3b3ce8f35b3119fff7dd45853970f1f6946637df7b70e6ea79c4bbbb4.jpg)  
+Figure 3: Model compression with k-means clusters from $2 ^ { 1 }$ to $2 ^ { 8 }$ .
+
+In our experiments, we implement a $\mathbf { k }$ -means clustering algorithm (Han et al., 2016) to compress our neural language model. Instead of applying clustering method to all the weights of the LSTM model, we generate code and codebook for each trained matrix. As Figure 3 shows, the quantization method using codes of 8 bits works well without degrading the conversion accuracy. Even with very low bits such as 3 and 4, the conversion accuracy is still higher than the n-gram baseline. The model size for n-gram has over than 1GB storage footprint. In practice, pruning the n-gram model inevitably causes a loss in accuracy. The neural language model shows a big advantage over n-gram in terms of model compression. By applying 5-bit quantization, together with the tie embedding approach, we reduce $92 \%$ of model size without noticeable accuracy loss.
+
+# 5 QUALITATIVE ANALYSIS
+
+Among the sentences that n-gram cannot simply decode, we select a few examples to perform a qualitative study from the user experience point of view. Figure 4 shows the decoded results from the n-gram and LSTM-based language models. The text in red shows the wrong conversion results, and the text in blue is the correct results. According to human judgment, the most important hint words for a correct conversion are set to bold font. To better align with the Japanese text, the English translation is not in its original order.
+
+We observe that the LSTM-based language model is capable of capturing distant context and producing correct results that are difficult for a statistical language model to predict. In case 1, the writer uses parallel structure to describe the core difference between two famous universities in Japan. Such long tail sentence is very creative and doesn’t appear twice in the corpus. Also, the middle word is separated by parenthesis, which causes trouble for the n-gram model. As word embedding can easily identify the antonyms, the LSTM-based model successfully predicts the correct output in such cases. Case 2 and 3 show that distant trigger can be captured by the neural model. Even when the trigger word is in a distant context, the LSTM-based model still understands the topic and selects the correct candidate as case 4 and 5 demonstrate.
+
+We also found that when two correct candidates exist, n-gram models tend to keep only one of them in the lattice. In contrast, the LSTM-based model keeps the variety in the lattice and thus resulting in a better top 10 hit rate. We argue that the word embeddings for such interchangeable words are very close in the vector space after training. As a result, they retain similar probabilities during the decoding process.
+
+Figure 4: Case study between conversion results of LSTM-based language model and n-gram model.   
+
+<table><tr><td rowspan="2"></td><td>n-gram</td><td>論理（具体）の東大、凳送（中小）の兄弟 Logical (concrete) University of Tokyo,delivery (medium small) brother</td></tr><tr><td>LSTM baseline</td><td>論理（具体）の東大、凳想（抽象）の京大 Logical (concrete) University of Tokyo, creative (abstract) University of Kyoto</td></tr><tr><td rowspan="3">2</td><td>n-gram</td><td>昔は駐車た抗生物質</td></tr><tr><td>LSTM baseline</td><td>In the past parking antibiotics 昔は注射だた抗生物質</td></tr><tr><td></td><td>In the past injected antibiotics 自民党だけとな���と非常に偏体</td></tr><tr><td rowspan="2">3</td><td>n-gram LSTMbaseline</td><td>Liberal Democratic Party only about very biased experience 自民党けとなまと非常に偏た意見</td></tr><tr><td></td><td>Liberal Democratic Party only about very biased opinion 子供二人を幼くして亡くし、百二十二歳で妻も高い</td></tr><tr><td rowspan="2">4</td><td>n-gram</td><td>Children as child lost life,at the age of 122 wife also tall 子供2人を幼&lt;して亡&lt;し、百二十二歳妻も他界</td></tr><tr><td>LSTM baseline</td><td>Children as child lost life,at the age of 122 wife also died 飛行場行てみると、予約をれてあーたのに、何かの都合での日はに飛</td></tr><tr><td rowspan="2">5</td><td>n-gram</td><td>はずのものがー気しか飛ばなかたのである Airport went to,reservation had made,for some reason at the day Ki didn&#x27;t flew only one stroke flew. 飛行場行てみると、予約をれてあーたのに、何かの都合でその日は二機飛</td></tr><tr><td>LSTMbaseline</td><td>はのものがー機しか飛ばなかたのである Airport went to,reservation had made,for some reason at the day two aircraft didn&#x27;t flew only one aircraft flew.</td></tr></table>
+
+# 6 RELATED WORKS
+
+Applying a neural-based model for input method is studied in a few previous works. Chen et al. (2015) proposed a MLP architecture for Chinese Pinyin input method. Due to the huge computation cost of matrix operations, the neural model is only applied to rank the best paths decoded with n-gram language model. Though not in literature, we have found implementation of RNN-based input method4. The decoding results on BCCWJ corpus show promising accuracy improvement comparing to the n-gram model. Huang et al. (2018) treat the Chinese input conversion as machine translation and apply seq2seq with attention model. The conversion model and a few other features are served as cloud services. Our work focus on enabling neural-based models on devices especially with limited computation resources.
+
+While there are various choices for the neural-based model, we choose a single layer LSTM model (Hochreiter & Schmidhuber, 1997) primarily due to the run-time speed consideration. For other DNN models, we argue that seq2seq like models (Cho et al., 2014) are not feasible to input method task because in each step the decoder needs to compute from start with a new latent vector. Bi-directional architectures such as Bi-LSTM (Huang et al., 2015) normally requires full input sequence beforehand, it cannot compute incrementally. Character-based RNN (Mikolov et al., 2010) is a good alternative for word-based models. It has a smaller vocabulary size. However, for Chinese and Japanese, there are still thousands of characters. Also, it doesn’t predict the next word directly.
+
+To reduce the cost of softmax computation, Chen et al. (2016) proposed a differentiated softmax (D-Softmax), which computes the logits with weight matrices differ in size depending on word frequency. It argues that less frequent words require fewer softmax parameters compared to frequently used words. Joulin et al. (2017) is a variation of the D-softmax with more efficient weight segmentation. Together with the tie embedding approach (Press & Wolf, 2017), the cost of the differentiated softmax becomes $\scriptstyle \sum _ { i = 0 } ^ { n } | V _ { i } | \times E _ { i }$ , where each $E _ { i }$ is smaller value than its original size. Although the embedding optimization approach can reduce softmax cost, the amount of reduction is limited. It is still proportional to the reduced embedding size.
+
+Another direction of reducing softmax cost comes from vocabulary manipulation. In machine translation, given a source sentence, the vocabulary of target words can be limited before translation. It is possible to calculate the softmax on a subset of the full vocabulary (Jean et al., 2015; Mi et al., 2016). However, for the input method, the conversion task takes user input incrementally. Our proposed incremental selective softmax can work without knowing full vocabulary beforehand. It is generally applicable for incremental sequence decoding task with a large vocabulary.
+
+# 7 CONCLUSION
+
+Input method plays an important role in improving typing efficiency and user experiences. It has to work on various devices with minimized latency. We study the key challenges to apply neural-based input method to real commodity devices. The proposed incremental selective softmax significantly reduces cost in the softmax computation without losing accuracy. We also demonstrate that the neural-based models can be highly compressed comparing to the conventional n-gram language models. Our proposed method sets a strong baseline in real-time input method. More importantly, as the computation has a low latency, the model is production-ready to be used on real devices.
+
+# REFERENCES
+
+Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of machine learning research, 3(Feb):1137–1155, 2003.
+
+Shenyuan Chen, Hai Zhao, and Rui Wang. Neural network language model for chinese pinyin input method engine. In Proceedings of the 29th Pacific Asia Conference on Language, Information and Computation, pp. 455–461, 2015.
+
+Wenlin Chen, David Grangier, and Michael Auli. Strategies for training large vocabulary neural language models. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1975–1985, 2016.
+
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, 2014.
+
+G David Forney. The viterbi algorithm. Proceedings of the IEEE, 61(3):268–278, 1973.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In ICLR, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Yafang Huang, Zuchao Li, Zhuosheng Zhang, and Hai Zhao. Moon ime: Neural-based chinese pinyin aided input method with customizable association. In Proceedings of ACL 2018, System Demonstrations, pp. 140–145. Association for Computational Linguistics, 2018.
+
+Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. arXiv preprint arXiv:1508.01991, 2015.
+
+Frankie James. Modified kneser-ney smoothing of n-gram models. Technical report, 2000.
+
+Sebastien Jean, Kyunghyun Cho, Roland Memisevic, and Yoshua Bengio. On using very large target vocabulary for neural machine translation. In 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing of the Asian Federation of Natural Language Processing, ACL-IJCNLP 2015, pp. 1–10. Association for Computational Linguistics (ACL), 2015.
+
+Armand Joulin, Moustapha Cisse, David Grangier, Herv ´ e J ´ egou, et al. Efficient softmax approxi-´ mation for gpus. In International Conference on Machine Learning, pp. 1302–1310, 2017.
+
+Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410, 2016.
+
+Reinhard Kneser and Hermann Ney. Improved backing-off for m-gram language modeling. In icassp, volume 1, pp. 181e4, 1995.
+
+Kikuo Maekawa, Makoto Yamazaki, Toshinobu Ogiso, Takehiko Maruyama, Hideki Ogura, Wakako Kashino, Hanae Koiso, Masaya Yamaguchi, Makiro Tanaka, and Yasuharu Den. Balanced corpus of contemporary written japanese. Language resources and evaluation, 48(2):345–371, 2014.
+
+Haitao Mi, Zhiguo Wang, and Abe Ittycheriah. Vocabulary manipulation for neural machine translation. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), volume 2, pp. 124–129, 2016.
+
+Toma´s Mikolov, Martin Karafi ˇ at, Luk ´ a´s Burget, Jan ˇ Cernock ˇ y, and Sanjeev Khudanpur. Recurrent \` neural network based language model. In Eleventh Annual Conference of the International Speech Communication Association, 2010.
+
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, volume 2, pp. 157–163, 2017.
+
+Andreas Stolcke. Srilm-an extensible language modeling toolkit. In Seventh international conference on spoken language processing, 2002.

parse/train/Ske6wiAcKQ/Ske6wiAcKQ_content_list.json

@@ -0,0 +1,1163 @@
+[
+    {
+        "type": "text",
+        "text": "REAL-TIME NEURAL-BASED INPUT METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            714,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The input method is an essential service on every mobile and desktop devices that provides text suggestions. It converts sequential keyboard inputs to the characters in its target language, which is indispensable for Japanese and Chinese users. Due to critical resource constraints and limited network bandwidth of the target devices, applying neural models to input method is not well explored. In this work, we apply a LSTM-based language model to input method and evaluate its performance for both prediction and conversion tasks with Japanese BCCWJ corpus. We articulate the bottleneck to be the slow softmax computation during conversion. To solve the issue, we propose incremental softmax approximation approach, which computes softmax with a selected subset vocabulary and fix the stale probabilities when the vocabulary is updated in future steps. We refer to this method as incremental selective softmax. The results show a two order speedup for the softmax computation when converting Japanese input sequences with a large vocabulary, reaching real-time speed on commodity CPU. We also exploit the model compressing potential to achieve a $92 \\%$ model size reduction without losing accuracy. ",
+        "bbox": [
+            233,
+            244,
+            764,
+            467
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            336,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Typing is one of the core activities users interact with devices. The input method is an intelligent service in operating systems that provides text suggestions to boost typing efficiency. With a large user base, commercial input products have helped users save trillions of key presses. Being able to provide an input method service in high quality makes a huge business impact. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Among various features an input method provides, we consider two essential text suggestion tasks in this work: next word prediction task and conversion task. Next word prediction task relies on a language model, which gives the probability of the next word $p \\big ( w _ { t } | w _ { 1 : t - 1 } \\big )$ . Usually, top 3 or 5 candidates are shown to users. Conversion task, however, is not a common scenario for Latin users. Latin users can type directly with a keyboard, but there are thousands of characters in the Chinese and Japanese language. Conversion task takes a key sequence and converts it to target word sequence that best matches users’ original intentions. It is a sequence decoding task similar to machine translation. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conventionally, an n-gram language model is used to solve these two tasks (Stolcke, 2002). However, due to the exponential increase in model size , the $\\mathbf { n }$ -gram model can only support up to tri-gram. The decoding results often fail to have global consistency as the tri-gram language model is not capable of considering distant context. Also, n-gram models are often pruned to meet model size requirement with a loss in accuracy. In contrast, neural-based language models are proven to solve such issues more efficiently(Bengio et al., 2003; Mikolov et al., 2010; Jozefowicz et al., 2016). ",
+        "bbox": [
+            174,
+            714,
+            823,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although neural-based language model has achieved enormous success, conventionally, it is not considered feasible for input method task. One major reason is that the input method has to run interactively at user devices with critical constraints of resources and run-time speed. This is different from speech recognition or machine translation services that are normally served from online servers. Input applications have to sacrifice accuracy for execution speed and model size. ",
+        "bbox": [
+            176,
+            805,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we enhance a neural language model tailored for input method task to meet both runtime speed and model size requirement. Our baseline model is composed of a LSTM-based language model (Hochreiter & Schmidhuber, 1997) with a Viterbi decoder (Forney, 1973) as Figure 1 shows. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/0bfa12a95181689e0155dd0c85df34a7db7d0491abb46b1baf290a433572667b.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the proposed neural-based input method. (a) Input context. (b) Conversion with LSTM LM and Viterbi decoder. (c) Word prediction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            107,
+            815,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It improves the performance for both conversion and next word prediction task and is capable of capturing distant context. ",
+        "bbox": [
+            176,
+            395,
+            821,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For languages like Japanese and Chinese, a large vocabulary is required in the conversion task. we articulate the bottleneck of run-time speed as the vocabulary size matrix operation before softmax. We propose an incremental selective softmax approach that builds a subset vocabulary $V _ { t }$ at each decoding step $t$ . By only computing softmax over $V _ { t }$ , the cost of softmax significantly drops since $| V _ { t } |$ is usually a small number that is less than $1 \\%$ of the original vocabulary size. We evaluate the speedup comparing to other softmax optimization. To further handle the model disk size and memory size, we apply $\\mathbf { k }$ -means based quantization algorithm and analyze its performance with various compression ratio. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize the main contributions of this paper as follows: ",
+        "bbox": [
+            174,
+            549,
+            583,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1) We empirically evaluate using a LSTM-based language model to address input method challenges and demonstrate its performance for a complex language with large vocabulary size. ",
+        "bbox": [
+            173,
+            569,
+            821,
+            598
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2) We propose an effective approach to accelerate the inference time with incremental selective softmax. By avoiding computing the full softmax, our approach achieves two orders inference speed boost without negatively impact the accuracy of conversion. ",
+        "bbox": [
+            174,
+            606,
+            823,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3) To let the neural language model with a large vocabulary fit into the execution environment on consumer devices, we compress the model with quantization techniques, achieving a $92 \\%$ reduction on model size. ",
+        "bbox": [
+            176,
+            655,
+            821,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 NEURAL-BASED INPUT METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            478,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The neural-based approach we propose for input method is illustrated in Figure 1. We use LSTM language model for both the conversion and prediction tasks. A noticeable difference from the ngram approach is the use of a latent vector to capture input context. It is the hidden vector from the last recurrent unit of the previous sequence. In a real scenario, users don’t type the full sentence in one effort. Instead, they type and convert in fragments, where each fragment contains a few words. It is important to carry the context of the previously determined results to current conversion task. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Conversion task is described in Figure 1(b). As the user starts to type in an editor control, the input method first converts the alphabet user typed into syllables. Take Japanese as an example, Japanese Kana, also called “fifty sounds”, can be converted from the alphabet with fixed rules. In lexicon, Japanese words are indexed by Kana characters with an efficient structure such as Trie. A word lattice is then built with all possible words from a Kana sequence by lexicon lookup. To find the best combination of words aligned with the Kana sequence, we use a Viterbi decoder to decode with a beam size $S$ . LSTM language model is used here to evaluate path probabilities. The best path is then shown to the user as the conversion candidate. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Once the user selects the conversion candidate, last hidden vector of the best path becomes the new context vector. We compute the softmax based on the context vector and provides a probability distribution of the next words as shown in Figure 1(c). ",
+        "bbox": [
+            176,
+            138,
+            821,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although several commercial input products have already tried to apply neural models1, they mainly aim to solve the prediction task for Latin languages. Conversion task has a different scale of computational cost and is not yet tackled. ",
+        "bbox": [
+            176,
+            188,
+            823,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ACCELERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            250,
+            406,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            281,
+            315,
+            296
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Comparing to a prediction task, the conversion task is even more costly to compute. We further articulate three issues that make the conversion task difficult to solve: 1) For Japanese or Chinese input method, a much larger vocabulary size is required, which is usually several times larger than English. 2) During decoding, we have to evaluate probabilities for all paths with a beam size $S$ . 3) Most importantly, there are no natural word boundaries in Chinese or Japanese, such as a space character. The path evaluation has to run each time a new key input arrives, instead of when space is inserted. With all above constraints, the conversion task has to compute $S \\times | V | \\times | X |$ steps of LSTM computation for one input sequence, where $| V |$ is the vocabulary size, $| X |$ is the sequence length. ",
+        "bbox": [
+            173,
+            308,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Heavy computation cost of LSTM model comes from two operations: the matrix operations inside LSTM cell and the matrix projection at softmax. In the case of a LSTM model with a vocabulary size of 100K, a hidden size of 512, and an embedding size of 256, estimated by simple matrix multiplication, the number of multiplication operations for LSTM cell is about $1 . 5 \\mathbf { M }$ , while the softmax has 50M operations. In practice, the softmax occupies $9 7 \\%$ of the total computation cost, which is the bottleneck for the conversion task with a large vocabulary size. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 INCREMENTAL SELECTIVE SOFTMAX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            473,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To solve the challenges, we propose an incremental selective softmax approach to obtain correct probabilities for paths in the lattice. Given a partial observed character input sequence $( x _ { 1 } , . . . , x _ { t } )$ , we search for a set of words in the dictionary that match any suffix of the observation: ",
+        "bbox": [
+            173,
+            565,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4548308e32a38b9911aa4ae1c0f1f49cd1fee2e749cc4a5374bd9d01b1b1939.jpg",
+        "text": "$$\nD _ { t } = \\bigcup _ { i = 1 } ^ { t } { \\mathrm { m a t c h } } ( x _ { i } , . . . , x _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            614,
+            591,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the function $\\mathrm { { m a t c h } ( \\cdot ) }$ returns all lexicon items matching the partial sequence. For example, given the observation “ha ru ka”, the lexicon set $D _ { t }$ contains all words matching “ha ru $\\mathbf { k } \\mathbf { a } ^ { \\prime \\prime }$ or “ru ka” or “ka”. With the lexicon set in each step, we can construct a subset vocabulary $V _ { t }$ that covers all possible output words until step $t$ as: ",
+        "bbox": [
+            173,
+            662,
+            823,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f0448fd8c4a07e391d516f19ad5e008f126f58305f2873921a8f5f552f0dc52.jpg",
+        "text": "$$\nV _ { t } = \\bigcup _ { i = 1 } ^ { t } D _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            724,
+            544,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we refer to $V _ { t }$ as the lattice vocabulary. In contrast to the beam search in machine translation, we have to rank paths that contain different number of words. If we directly compute path probabilities on $V _ { t }$ with a language model, as the denominator of the softmax becomes smaller, all words will have higher probabilities. Therefore, the paths containing more words will have advantage due to the incorrect probabilities. As a result, the paths can be ranked wrongly. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To circumvent the probability issue, we also sample a subset vocabulary from the full vocabulary, denoted by $\\tilde { V }$ . We use $V _ { t }$ jointly with $\\tilde { V }$ to make the word probabilities closer to their original probabilities, thus minimizing the impact of exposure bias. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d562e15cb3e0776b6f6525eadd76ad810f72b2a4af90e6045eff1b1b9a53610.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of incremental selective softmax: (a) Vocabulary sampling strategies (b) Incrementally correct path probabilities with new lattice vocabulary. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            108,
+            816,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2(a), we experiment two sampling methods. The first one samples mostly frequent words from the vocabulary, whereas the second one uniformly samples from the full vocabulary. We found the first sampling method (top sampling) delivers the best performance. In practice, both $V _ { t }$ and $\\tilde { V }$ have less than $1 \\%$ of the words in the original vocabulary. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our proposed softmax approximation technique has two passes. When a new input character $x _ { t + 1 }$ arrives, we merge the current vocabulary $V _ { t }$ with new words from the lexicon set $D _ { t + 1 }$ , forming a new vocabulary $V _ { t + 1 }$ . Then for each path in the lattice, we compute the language model probability at step $t + 1$ with the joint vocabulary $V _ { t + 1 } \\cup \\tilde { V }$ as: ",
+        "bbox": [
+            173,
+            448,
+            825,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f49cc1069d4d5fb5cd72b5f43e3f57b84d8da225b27615e1765da9a9421af81b.jpg",
+        "text": "$$\nP ( y _ { t } = i | h _ { t } ) = \\frac { \\exp ( h _ { t } ^ { \\top } W _ { i } ) } { \\sum _ { j \\in V _ { t + 1 } \\cup \\tilde { V } } \\exp ( h _ { t } ^ { \\top } W _ { j } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            531,
+            645,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { t }$ is the LSTM hidden state in step $t$ . In this pass, we only compute the word probabilities for top paths in batch with a beam size $S$ . ",
+        "bbox": [
+            173,
+            599,
+            823,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Now we computed the latest word probabilities using the lattice vocabulary $V _ { t + 1 }$ . Unfortunately, as previous word probabilities are computed on old vocabularies, they are not comparable with the new ones. Therefore, in the second pass, we correct the stale word probabilities to let them have the same denominator as the ones computed on the latest lattice vocabulary. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In principle, we can correct an old probability in step $k$ by adding the logits of missing vocabulary to the denominator as: ",
+        "bbox": [
+            173,
+            698,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02b54ea9089458bdc6880db54fe9b54487e38c4a7dc1795138df603d502930cc.jpg",
+        "text": "$$\nP ( y _ { k } = i | h _ { k } ) = \\frac { \\exp ( h _ { k } ^ { \\top } W _ { i } ) } { \\displaystyle \\sum _ { j \\in V _ { k + 1 } \\cup { \\tilde { V } } } \\exp ( h _ { k } ^ { \\top } W _ { j } ) + \\sum _ { j \\in V _ { t + 1 } , j \\notin V _ { k + 1 } \\cup { \\tilde { V } } } \\exp ( h _ { k } ^ { \\top } W _ { j } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            731,
+            781,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, in practice, as each path has different missing vocabularies, we compute a union of all missing vocabularies, and then recompute the logits of them in batch. Experiments show that our proposed incremental selective softmax strategy achieves a 76x speedup comparing to the baseline. ",
+        "bbox": [
+            176,
+            799,
+            825,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            326,
+            880
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare the performance of the neural-based approach with conventional approaches. Then, we report the results of applying model acceleration and compression techniques. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            279,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use BCCWJ (Balanced Corpus of Contemporary Written Japanese) corpus (Maekawa et al., 2014) for evaluating our model. The corpus is well balanced with various sources of text representing contemporary written Japanese. This corpus contains 5.8M sentences, which are segmented into 127M tokens. In our experiments, all words are further segmented into short unit words. Each word has a format of ”display/reading/POS”. The reading and POS attributes are attached to tell different usages of the same word. Among the 611K unique words, we choose top 50K frequent ones that cover $9 7 . 3 \\%$ of token appearances as an appropriate vocabulary size for the input method task. The words in the vocabulary are ranked with frequency. Most frequent words are at the top. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            382,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The BCCWJ dataset is split into training, valid, and test set. The ratio is $70 \\%$ , $20 \\%$ , and $10 \\%$ respectively. We randomly sample 2000 sentences from the test set for evaluating conversion accuracy. For input method task, we evaluate the conversion accuracy using a Viterbi decoder with a beam size of 10. In Japanese, there are often more than one correct conversion results. For instance, a verb may have two acceptable styles, one in original Japanese Kana, the other in Chinese characters. To better evaluate the model performance, we also report the top-10 accuracy in addition to top-1 accuracy. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We implement the model using TensorFlow2. We use a batch size of 384, and dropout with a drop rate of 0.9. Adam optimizer is used with a fixed learning rate of 0.001. The hyper-parameters are shared for all experiments. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A replica of the same model is written in numpy to work with a Viterbi decoder in python. It uses the weights learned with TensorFlow model. The inference performance is measure with numpy on a single Intel E5 CPU. We also apply the underline BLAS library to accelerate matrix operation. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION OF NEURAL-BASED INPUT METHOD ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            482,
+            560,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first compared the neural model performance with a conventional n-gram model. We calculate the perplexity of the n-gram model with SRILM package (Stolcke, 2002). We choose modified Kneser Ney (Kneser & Ney, 1995; James, 2000) as the smoothing algorithm when learning the ngram model. The learned language model is plugged into our input method pipeline for evaluating the sentence conversation accuracy. The prediction accuracy is not provided as it is directly reflected by model perplexity. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The LSTM baseline model has a standard architecture. The embedding size is 256, and the hidden size is 256. The size of LSTM cells is selected empirically on a validation dataset. In practice, using a network size bigger than 256 cannot gain significant improvement on perplexity. In all following experiments, we bind the input embedding and output embedding according to Press & Wolf (2017). The idea is proven to save space and almost loss-less. We treat it as the baseline model in following experiments. ",
+        "bbox": [
+            173,
+            598,
+            826,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/242a3f7a7e2592dde537d04ee10516d20906be197a1a49b7428618cbb0faf08d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>pp</td><td>top1 hit %</td><td>top10 hit %</td></tr><tr><td>uni-gram</td><td>833.55</td><td>26.95</td><td>45.85</td></tr><tr><td>bi-gram KN</td><td>99.30</td><td>51.15</td><td>78.10</td></tr><tr><td>tri-gram KN</td><td>68.11</td><td>55.60</td><td>79.65</td></tr><tr><td>LSTMbaseline</td><td>41.39</td><td>61.20</td><td>88.30</td></tr></table>",
+        "bbox": [
+            307,
+            695,
+            691,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Performance comparison of baseline LSTM model with conventional n-gram model. ",
+        "bbox": [
+            186,
+            784,
+            803,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, the LSTM baseline achieved a significant improvement on perplexity, comparing to conventional n-gram based models. The top-1 and top-10 path conversion accuracy were increased by $5 . 6 \\%$ and $8 . 6 5 \\%$ respectively comparing to tri-gram KN. In real products, bi-gram is often used for decoding while tri-gram is only used for re-ranking the best paths. Please note that in this evaluation, we didn’t apply any pruning for n-gram. The n-gram model takes over 1GB storage size. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 EVALUATION OF RUN-TIME SPEED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            454,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare the inference speed of various softmax acceleration approaches. We measure the execution speed only for the component that computes the language model probabilities. For neural-based methods, the component includes the LSTM and softmax layer. For the n-gram model, the computation of probability is only a lookup in the hash tables. Other components such as lattice construction are not included as they heavily depend on implementation. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we report the decoding time in each step receiving a key input, because the per-step latency is critical for the real-time requirement. The computation cost for decoding the whole sequence is linear to the number of steps. For comparison, we also report the computation time of the softmax alone. ",
+        "bbox": [
+            174,
+            212,
+            823,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9651b44fd383e8f322caa04ff6cc78ca8282cb0152535f13e93265ad2f526260.jpg",
+        "table_caption": [
+            "Table 2: Model acceleration among different methods with accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Total Time (ms)</td><td>Softmax Time (ms)</td><td>Top-1 Hit (%)</td><td>Top-10 Hit (%)</td></tr><tr><td>tri-gram Kneser-Ney</td><td>0.0025</td><td>1</td><td>55.6</td><td>79.6</td></tr><tr><td>LSTMbaselinew/obatch</td><td>526</td><td>513</td><td>61.2</td><td>88.3</td></tr><tr><td>LSTMbaselinew/batch</td><td>87</td><td>84</td><td>61.2</td><td>88.3</td></tr><tr><td>Char LSTM</td><td>63</td><td>21</td><td>53.2</td><td>79.8</td></tr><tr><td>Char LSTM w/ large beam3</td><td>152</td><td>55</td><td>54.4</td><td>85.2</td></tr><tr><td>D-Softmax</td><td>38</td><td>35</td><td>60.8</td><td>86.8</td></tr><tr><td>D-Softmax*</td><td>37</td><td>35</td><td>60.9</td><td>87.5</td></tr><tr><td>IS-Softmax</td><td>3</td><td>1</td><td>58.8</td><td>86.9</td></tr><tr><td>w/ top sampling</td><td>4</td><td>2</td><td>60.1</td><td>88.2</td></tr><tr><td>w/uniform sampling</td><td>4</td><td>2</td><td>58.9</td><td>87.2</td></tr><tr><td>non-incremental S-Softmax</td><td>11</td><td>2</td><td>58.8</td><td>86.9</td></tr></table>",
+        "bbox": [
+            199,
+            292,
+            797,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As Table 2 shows, our proposed incremental selective softmax (IS-Softmax) achieves a 76x speedup comparing to the LSTM baseline. The lattice vocabulary in our experiments contains only a few hundred words, while the full vocabulary has 50k words. IS-Softmax only takes $3 ~ \\mathrm { m s }$ to handle a new coming key. Such a high processing speed meets the real-time latency requirement. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a comparison, the non-incremental selective softmax is less efficient since it recalculates from the beginning in each step. Therefore, the majority of its cost comes from computing LSTM cells. We also evaluate various sampling methods with IS-Softmax. We find top sampling help close the accuracy gap between the baseline and softmax approximations. In our experiments, the number of samples used in top sampling and uniform sampling methods are both 400. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Differentiated softmax (D-Softmax) (Chen et al., 2016) and its variation (D-softmax∗) (Joulin et al., 2017) can also reduce the amount of softmax computation by over a half depends on the segmentation strategy. However, since the vocabulary size is still large, the room for speedup is limited. For character-based LSTM models, we use a hidden size of 1024 and embedding size of 512. Since there is no direct mapping between a single Kana and a single Chinese character, we use the word lattice and evaluate the path probability by character-based LSTM. It reduces the vocabulary size from 50K to 3717 in this experiment. However, the amount of vocabulary is still non-trivial. Furthermore, the integration of character-based models is not as efficient as word-based models in this task. Consequently, we have to use a large beam size to improve accuracy. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also confirmed that batching is critical for acceleration matrix operations even on CPU. The LSTM computation without batching is almost $7 \\mathbf { x }$ slower with a beam size 10. Therefore, we batch all the softmax computations when fixing the vocabulary in the second pass of IS-Softmax to achieve the best speed. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 EVALUATION OF MODEL COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            490,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Due to the limited resource on user devices, the model for the input method has to be extremely compact for both storage and memory footprint. For the mobile platforms, the distribution package that contains the neural model shall have a size small than $1 0 \\mathrm { { M B } }$ in order to handle various network environments. For commercial products, a large model size directly hinders the adoption of neural models even a higher accuracy is achieved. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b4504a3b3ce8f35b3119fff7dd45853970f1f6946637df7b70e6ea79c4bbbb4.jpg",
+        "image_caption": [
+            "Figure 3: Model compression with k-means clusters from $2 ^ { 1 }$ to $2 ^ { 8 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            229,
+            753,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we implement a $\\mathbf { k }$ -means clustering algorithm (Han et al., 2016) to compress our neural language model. Instead of applying clustering method to all the weights of the LSTM model, we generate code and codebook for each trained matrix. As Figure 3 shows, the quantization method using codes of 8 bits works well without degrading the conversion accuracy. Even with very low bits such as 3 and 4, the conversion accuracy is still higher than the n-gram baseline. The model size for n-gram has over than 1GB storage footprint. In practice, pruning the n-gram model inevitably causes a loss in accuracy. The neural language model shows a big advantage over n-gram in terms of model compression. By applying 5-bit quantization, together with the tie embedding approach, we reduce $92 \\%$ of model size without noticeable accuracy loss. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            411,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Among the sentences that n-gram cannot simply decode, we select a few examples to perform a qualitative study from the user experience point of view. Figure 4 shows the decoded results from the n-gram and LSTM-based language models. The text in red shows the wrong conversion results, and the text in blue is the correct results. According to human judgment, the most important hint words for a correct conversion are set to bold font. To better align with the Japanese text, the English translation is not in its original order. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We observe that the LSTM-based language model is capable of capturing distant context and producing correct results that are difficult for a statistical language model to predict. In case 1, the writer uses parallel structure to describe the core difference between two famous universities in Japan. Such long tail sentence is very creative and doesn’t appear twice in the corpus. Also, the middle word is separated by parenthesis, which causes trouble for the n-gram model. As word embedding can easily identify the antonyms, the LSTM-based model successfully predicts the correct output in such cases. Case 2 and 3 show that distant trigger can be captured by the neural model. Even when the trigger word is in a distant context, the LSTM-based model still understands the topic and selects the correct candidate as case 4 and 5 demonstrate. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also found that when two correct candidates exist, n-gram models tend to keep only one of them in the lattice. In contrast, the LSTM-based model keeps the variety in the lattice and thus resulting in a better top 10 hit rate. We argue that the word embeddings for such interchangeable words are very close in the vector space after training. As a result, they retain similar probabilities during the decoding process. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ad645d6a69e07549366611d576e7d40d8205039c24783ce64d2b9a0fe69b8468.jpg",
+        "table_caption": [
+            "Figure 4: Case study between conversion results of LSTM-based language model and n-gram model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td>n-gram</td><td>論理（具体）の東大、凳送（中小）の兄弟 Logical (concrete) University of Tokyo,delivery (medium small) brother</td></tr><tr><td>LSTM baseline</td><td>論理（具体）の東大、凳想（抽象）の京大 Logical (concrete) University of Tokyo, creative (abstract) University of Kyoto</td></tr><tr><td rowspan=\"3\">2</td><td>n-gram</td><td>昔は駐車た抗生物質</td></tr><tr><td>LSTM baseline</td><td>In the past parking antibiotics 昔は注射だた抗生物質</td></tr><tr><td></td><td>In the past injected antibiotics 自民党だけとなまと非常に偏体</td></tr><tr><td rowspan=\"2\">3</td><td>n-gram LSTMbaseline</td><td>Liberal Democratic Party only about very biased experience 自民党けとなまと非常に偏た意見</td></tr><tr><td></td><td>Liberal Democratic Party only about very biased opinion 子供二人を幼くして亡くし、百二十二歳で妻も高い</td></tr><tr><td rowspan=\"2\">4</td><td>n-gram</td><td>Children as child lost life,at the age of 122 wife also tall 子供2人を幼&lt;して亡&lt;し、百二十二歳妻も他界</td></tr><tr><td>LSTM baseline</td><td>Children as child lost life,at the age of 122 wife also died 飛行場行てみると、予約をれてあーたのに、何かの都合での日はに飛</td></tr><tr><td rowspan=\"2\">5</td><td>n-gram</td><td>はずのものがー気しか飛ばなかたのである Airport went to,reservation had made,for some reason at the day Ki didn&#x27;t flew only one stroke flew. 飛行場行てみると、予約をれてあーたのに、何かの都合でその日は二機飛</td></tr><tr><td>LSTMbaseline</td><td>はのものがー機しか飛ばなかたのである Airport went to,reservation had made,for some reason at the day two aircraft didn&#x27;t flew only one aircraft flew.</td></tr></table>",
+        "bbox": [
+            181,
+            107,
+            816,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            498,
+            354,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Applying a neural-based model for input method is studied in a few previous works. Chen et al. (2015) proposed a MLP architecture for Chinese Pinyin input method. Due to the huge computation cost of matrix operations, the neural model is only applied to rank the best paths decoded with n-gram language model. Though not in literature, we have found implementation of RNN-based input method4. The decoding results on BCCWJ corpus show promising accuracy improvement comparing to the n-gram model. Huang et al. (2018) treat the Chinese input conversion as machine translation and apply seq2seq with attention model. The conversion model and a few other features are served as cloud services. Our work focus on enabling neural-based models on devices especially with limited computation resources. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While there are various choices for the neural-based model, we choose a single layer LSTM model (Hochreiter & Schmidhuber, 1997) primarily due to the run-time speed consideration. For other DNN models, we argue that seq2seq like models (Cho et al., 2014) are not feasible to input method task because in each step the decoder needs to compute from start with a new latent vector. Bi-directional architectures such as Bi-LSTM (Huang et al., 2015) normally requires full input sequence beforehand, it cannot compute incrementally. Character-based RNN (Mikolov et al., 2010) is a good alternative for word-based models. It has a smaller vocabulary size. However, for Chinese and Japanese, there are still thousands of characters. Also, it doesn’t predict the next word directly. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To reduce the cost of softmax computation, Chen et al. (2016) proposed a differentiated softmax (D-Softmax), which computes the logits with weight matrices differ in size depending on word frequency. It argues that less frequent words require fewer softmax parameters compared to frequently used words. Joulin et al. (2017) is a variation of the D-softmax with more efficient weight segmentation. Together with the tie embedding approach (Press & Wolf, 2017), the cost of the differentiated softmax becomes $\\scriptstyle \\sum _ { i = 0 } ^ { n } | V _ { i } | \\times E _ { i }$ , where each $E _ { i }$ is smaller value than its original size. Although the embedding optimization approach can reduce softmax cost, the amount of reduction is limited. It is still proportional to the reduced embedding size. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            893
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another direction of reducing softmax cost comes from vocabulary manipulation. In machine translation, given a source sentence, the vocabulary of target words can be limited before translation. It is possible to calculate the softmax on a subset of the full vocabulary (Jean et al., 2015; Mi et al., 2016). However, for the input method, the conversion task takes user input incrementally. Our proposed incremental selective softmax can work without knowing full vocabulary beforehand. It is generally applicable for incremental sequence decoding task with a large vocabulary. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            208,
+            318,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Input method plays an important role in improving typing efficiency and user experiences. It has to work on various devices with minimized latency. We study the key challenges to apply neural-based input method to real commodity devices. The proposed incremental selective softmax significantly reduces cost in the softmax computation without losing accuracy. We also demonstrate that the neural-based models can be highly compressed comparing to the conventional n-gram language models. Our proposed method sets a strong baseline in real-time input method. More importantly, as the computation has a low latency, the model is production-ready to be used on real devices. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            338
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            285,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of machine learning research, 3(Feb):1137–1155, 2003. ",
+        "bbox": [
+            173,
+            382,
+            823,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shenyuan Chen, Hai Zhao, and Rui Wang. Neural network language model for chinese pinyin input method engine. In Proceedings of the 29th Pacific Asia Conference on Language, Information and Computation, pp. 455–461, 2015. ",
+        "bbox": [
+            174,
+            421,
+            823,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenlin Chen, David Grangier, and Michael Auli. Strategies for training large vocabulary neural language models. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1975–1985, 2016. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, 2014. ",
+        "bbox": [
+            173,
+            527,
+            825,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "G David Forney. The viterbi algorithm. Proceedings of the IEEE, 61(3):268–278, 1973. ",
+        "bbox": [
+            173,
+            593,
+            751,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "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 ICLR, 2016. ",
+        "bbox": [
+            174,
+            619,
+            823,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            659,
+            821,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yafang Huang, Zuchao Li, Zhuosheng Zhang, and Hai Zhao. Moon ime: Neural-based chinese pinyin aided input method with customizable association. In Proceedings of ACL 2018, System Demonstrations, pp. 140–145. Association for Computational Linguistics, 2018. ",
+        "bbox": [
+            174,
+            696,
+            826,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. arXiv preprint arXiv:1508.01991, 2015. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frankie James. Modified kneser-ney smoothing of n-gram models. Technical report, 2000. ",
+        "bbox": [
+            174,
+            789,
+            769,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sebastien Jean, Kyunghyun Cho, Roland Memisevic, and Yoshua Bengio. On using very large target vocabulary for neural machine translation. In 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing of the Asian Federation of Natural Language Processing, ACL-IJCNLP 2015, pp. 1–10. Association for Computational Linguistics (ACL), 2015. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Moustapha Cisse, David Grangier, Herv ´ e J ´ egou, et al. Efficient softmax approxi-´ mation for gpus. In International Conference on Machine Learning, pp. 1302–1310, 2017. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410, 2016. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reinhard Kneser and Hermann Ney. Improved backing-off for m-gram language modeling. In icassp, volume 1, pp. 181e4, 1995. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kikuo Maekawa, Makoto Yamazaki, Toshinobu Ogiso, Takehiko Maruyama, Hideki Ogura, Wakako Kashino, Hanae Koiso, Masaya Yamaguchi, Makiro Tanaka, and Yasuharu Den. Balanced corpus of contemporary written japanese. Language resources and evaluation, 48(2):345–371, 2014. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haitao Mi, Zhiguo Wang, and Abe Ittycheriah. Vocabulary manipulation for neural machine translation. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), volume 2, pp. 124–129, 2016. ",
+        "bbox": [
+            176,
+            229,
+            821,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Toma´s Mikolov, Martin Karafi ˇ at, Luk ´ a´s Burget, Jan ˇ Cernock ˇ y, and Sanjeev Khudanpur. Recurrent \\` neural network based language model. In Eleventh Annual Conference of the International Speech Communication Association, 2010. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ofir Press and Lior Wolf. Using the output embedding to improve language models. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, volume 2, pp. 157–163, 2017. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Stolcke. Srilm-an extensible language modeling toolkit. In Seventh international conference on spoken language processing, 2002. ",
+        "bbox": [
+            173,
+            386,
+            823,
+            416
+        ],
+        "page_idx": 9
+    }
+]