Add files using upload-large-folder tool

parse/train/Hkemdj09YQ/Hkemdj09YQ.md

@@ -0,0 +1,433 @@
+# RECTIFIED GRADIENT: LAYER-WISE THRESHOLDING FOR SHARP AND COHERENT ATTRIBUTION MAPS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Saliency map, or the gradient of the score function with respect to the input, is the most basic means of interpreting deep neural network decisions. However, saliency maps are often visually noisy. Although several hypotheses were proposed to account for this phenomenon, there is no work that provides a rigorous analysis of noisy saliency maps. This may be a problem as numerous advanced attribution methods were proposed under the assumption that the existing hypotheses are true. In this paper, we identify the cause of noisy saliency maps. Then, we propose Rectified Gradient, a simple method that significantly improves saliency maps by alleviating that cause. Experiments showed effectiveness of our method and its superiority to other attribution methods. Codes and examples for the experiments will be released in public.
+
+# 1 INTRODUCTION
+
+The gradient of the score function with respect to the input, also called the saliency map (Erhan et al., 2009; Baehrens et al., 2010; Simonyan et al., 2014), is the most basic means of interpreting deep neural networks (DNNs). It is also a baseline method for other advanced attribution-based methods. However, our understanding of saliency maps is still poor.
+
+Previous studies such as Springenberg et al. (2015) and Selvaraju et al. (2017) have noted that saliency maps tend to be visually noisy. To explain this phenomenon, Sundararajan et al. (2016) and Smilkov et al. (2017) suggested saturation and discontinuous gradients as the causes (see Section 2.1 for further explanation). There were several studies attempting to improve saliency maps by tackling these hypothesized causes (Bach et al., 2015; Montavon et al., 2017; Sundararajan et al., 2016; Shrikumar et al., 2017; Smilkov et al., 2017; Sundararajan et al., 2017).
+
+Even though such attribution methods generally produce better visualizations, we find troubling that the hypotheses regarding noisy saliency maps have not been rigorously verified (see Section 2.2 for more detail on attribution methods). In other words, numerous attribution methods were built upon unproven claims that gradient discontinuity or saturation truly causes saliency maps to be noisy. This situation gives rise to two major problems. First, if the hypotheses regarding noisy saliency maps are incorrect, current and future works based on those hypotheses will also be erroneous. Second, as we do not know precisely why saliency maps are noisy, we have to rely on heuristics and guessworks to develop better attribution methods.
+
+In this paper, we address these problems by identifying saliency maps are noisy because DNNs do not filter out irrelevant features during forward propagation. We then introduce Rectified Gradient, or RectGrad in short, a simple technique that significantly improves the quality of saliency maps by alleviating the cause through layer-wise thresholding during backpropagation. Finally, we demonstrate that RectGrad produces attributions qualitatively superior and quantitatively comparable to other attribution methods. Specifically, we have the following key contributions:
+
+• We explain why saliency maps are noisy. Noise occurs in saliency maps when irrelevant features have positive pre-activation values and consequently pass through ReLU activation functions. This causes gradients to be nonzero at unimportant regions. We perform experiments with networks trained on CIFAR-10 to justify our claims (Section 3).
+
+![](images/66ea85f99fe2f850dc4fb81bc964d16d6dcaf32b1b8cd556b679b4242651c1a0.jpg)  
+Figure 1: Comparison of attribution methods. See Section 5 for details on the visualization.
+
+• We introduce Rectified Gradient, a method that removes noise from saliency maps by thresholding irrelevant units at ReLU binary gates during backpropagation (Section 4). We first explain the rationale behind Rectified Gradient (Section 4.1). We then prove that Rectified Gradient generalizes Deconvolution and Guided Backpropagation (Section 4.2). In addition, we discuss two techniques that enhance the visual quality of Rectified Gradient attribution maps (Appendix C). We first investigate the effect of threshold level on attribution maps produced by Rectified Gradient (Section 5.1). Then, we apply Rectified Gradient to networks trained on CIFAR10 and ImageNet to demonstrate that it produces qualitatively superior attribution maps (Section 5.2). We also compare Rectified Gradient with other attribution methods using several quantitative metrics (Section 5.3).
+
+# 2 BACKGROUND OVERVIEW
+
+Let $S : \mathbb { R } ^ { d } \mapsto \mathbb { R } ^ { | C | }$ be an image classification network, where $x \in \mathbb { R } ^ { d }$ is a single image instance and $C$ is the set of image classes. Then, we can define a score function $S _ { c } : \mathbb { R } ^ { d } \stackrel { - } { \mapsto } \mathbb { R }$ for each class $c \in C$ and the final class of the image $x$ is given by $c l a s s ( x ) = \arg \operatorname* { m a x } _ { c \in C } S _ { c } ( x )$ . A typical score function is constructed by alternately composing affine transformations and nonlinear activation functions. A squashing function such as softmax is applied to the final layer.
+
+Since functions comprising $S _ { c }$ are differentiable or piecewise linear, the score function is also piecewise differentiable. Using this fact, Erhan et al. (2009), Baehrens et al. (2010) and Simonyan et al. (2014) proposed the saliency map, or the gradient of $S _ { c }$ with respect to $x$ , to highlight features within $x$ that the network associates with the given class. In an ideal case, saliency maps highlight objects of interest. However, previous studies such as Springenberg et al. (2015) and Selvaraju et al. (2017) have pointed out that saliency maps tend to be visually noisy, as verified by Figure 1. Three hypotheses were proposed to account for this phenomenon. We describe them in the next section.
+
+# 2.1 PREVIOUS HYPOTHESES
+
+Saliency Maps are Truthful. Smilkov et al. (2017) suggested that noisy saliency maps are faithful descriptions of what the network is doing. That is, pixels scattered seemingly at random are actually crucial to how the network makes a decision. In short, this hypothesis claims that noise is actually informative.
+
+Discontinuous Gradients. Smilkov et al. (2017) and Shrikumar et al. (2017) proposed that saliency maps are noisy due to the piece-wise linearity of the score function. Specifically, since typical DNNs use ReLU activation functions and max pooling, the derivative of the score function with respect to the input will not be continuously differentiable. Under this hypothesis, noise is caused by meaningless local variations in the gradient.
+
+Saturating Score Function. Shrikumar et al. (2017) and Sundararajan et al. (2017) suggested that important features may have small gradient due to saturation. In other words, the score function can flatten in the proximity of the input and have a small derivative. This hypothesis explains why informative features may not be highlighted in the saliency map even though they contributed significantly to the decision of the DNN.
+
+# 2.2 PREVIOUS WORKS ON IMPROVING SALIENCY MAPS
+
+DNN interpretation methods that assign a signed attribution value to each input feature are collectively called attribution methods. Attributions are usually visualized as a heatmap by arranging them to have the same shape as the input sample. Such heatmaps are called attribution maps. We now describe attribution methods that have been proposed to improve saliency maps.
+
+Attribution Methods Addressing Discontinuity. SmoothGrad (Smilkov et al., 2017) attempts to smooth discontinuous gradient with a Gaussian kernel. Since calculating the local average in a high dimensional space is intractable, the authors proposed a stochastic approximation which takes random samples in a neighborhood of the input $x$ and then averages their gradients.
+
+Attribution Methods Addressing Saturation. Since saliency maps estimate the local importance of each input feature, they are vulnerable to saturation. Therefore, attribution methods such as Gradient \* Input (Shrikumar et al., 2017), Layer-wise Relevance Propagation (LRP) (Bach et al., 2015), DeepLIFT (Shrikumar et al., 2017) and Integrated Gradient (Sundararajan et al., 2017) attempt to alleviate saturation by estimating the global importance of each pixel (Ancona et al., 2018). Ancona et al. (2018) has also shown that several global attribution methods are closely related under certain conditions.
+
+Other Attribution Methods. Some attribution methods take a different approach to improving saliency maps. Deconvolution (Zeiler & Fergus, 2014) and Guided Backpropagation (Springenberg et al., 2015) remove negative gradient during backpropagation. Due to this imputation procedure, Deconvolution and Guided Backpropagation yield attribution maps sharper than those of other methods. However, Nie et al. (2018) has recently proven that these methods are actually doing partial image recovery which is unrelated to DNN decisions.
+
+# 3 OUR EXPLANATION FOR NOISY SALIENCY MAPS
+
+For brevity, we refer to pixels on the background as background features and pixels on the object as object features. Then, noise in a saliency map corresponds to background gradient, or gradient that highlights background features. We assume the DNN uses ReLU activation functions. Under this condition, nonzero background gradient indicates the presence of at least one positive pre-activation in each network layer corresponding to background features.
+
+To verify this, we visualized intermediate layer activations of a convolutional neural network (CNN) trained on CIFAR-10. Figure 2b shows convolutional layer feature maps for an image that produced a noisy saliency map. Since CNN filters act as feature extractors, we expected the CNN to remove most background feature activations through convolutions. However, we found significant amounts of background feature activations in all convolution layers. As the last convolution layer is connected to fully connected layers, the majority of activations in the last convolution layer will have nonzero gradient. Hence, the gradient flowed through background feature activations up to the input. This gradient flow caused background gradient, as shown in Figure 2a. From our perspective, the answer to “why are saliency maps noisy?” is trivial. Saliency maps are noisy because background features pass through ReLU activation functions.
+
+Therefore, rather than asking why saliency maps are noisy, we ask “do activations of background features highlighted by background gradient have nontrivial influence on the decision?” If the answer is yes, noise in saliency maps is informative as suggested by Smilkov et al. (2017), and saliency maps do not need any major improvement. However, if the answer is no, we should find a way to remove background gradient. We investigated this question through two experiments.
+
+Feature Map Occlusion. We evaluated the significance of background features by occluding activations at intermediate layers. Then, we analyzed the effect of this perturbation on the final decision. Note that this is different from the Sensitivity metric (Bach et al., 2015; Samek et al., 2017). Sensitivity measures the impact of occlusion in the data space (e.g. pixel occlusion) while we measured the impact of occlusion in each feature space.
+
+![](images/da762375abf069a3095a2d0368d4fb3ae062d1e54c20d86dc2e005c7188bf91b.jpg)  
+Figure 2: Feature map visualization for an image with a noisy saliency map.
+
+We first created a background mask that covers background features in the images. We then plotted the average class logits as we incrementally occluded intermediate layer activations that fell on the background mask. We carried out occlusion following a random ordering and took the average over 50 trials. Figures 3a and 3b give an example of a background mask and a completely occluded feature map respectively. Figure 3c shows that the final decision did not change throughout the occlusion process for all convolution layers. Moreover, the difference between the top label logit and the next largest logit remained constant. Therefore, background feature activations are irrelevant to the classification task. To further support this claim, we conducted a larger-scale version of this experiment, and we describe the procedure and results in Appendix A.1.
+
+Training Dataset Occlusion. Next, we show that gradient can be nonzero for completely uninformative features. We occluded the upper left corner of all images in the training dataset with a $1 0 \times 1 0$ random patch and trained a randomly initialized CNN on the modified dataset. We used the same patch for all images. Since the test accuracy did not change significantly $( 7 9 . 4 \%$ to $7 9 . 3 \%$ ), we expected the CNN to have learned to extract important features and ignore irrelevant ones. However, Figure 4 shows that gradient is nonzero for the patch although it is completely irrelevant to the classification task.
+
+We can draw three conclusions from these experiments:
+
+1. DNNs do not filter out irrelevant features during forward propagation.   
+2. DNNs are capable of making correct decisions even if we occlude the majority of background feature activations in intermediate layers. This implies that most background feature activations are irrelevant to the classification task.   
+3. Since DNNs do not remove irrelevant features through ReLU activation functions, zero threshold at ReLU binary gates during backpropagation also allow irrelevant information to flow through the gradient.
+
+With the conclusions above, we can refute the first of three previous hypotheses. As for the second hypothesis, we can interpret meaningless local variation in the gradient as a side effect of irrelevant features contaminating the gradient. Why the network does not learn to filter out irrelevant features is (c) Average class logits as background feature activations are incrementally occluded in a random order. The average is taken over 50 trials. Image class is illustrated by a solid line and other classes by dotted lines.
+
+![](images/4de9ce5e9d8a6c774f0f287af3d00e83cd4f06aa88b490817e5fb309d29fc15e.jpg)  
+Figure 3: Impact of background feature activation occlusion on the final decision.
+
+![](images/b4577a2f7227618e63fdfc31ac6940785d28ab1f0b3f4858c45bd351233526d0.jpg)  
+Figure 4: Saliency maps produced from a CNN trained on occluded images. The upper left corner of all the images in the training dataset is replaced with a $1 0 \times 1 0$ random patch, as shown above. Readers should examine the $8 \times 8$ patch enclosed by the red square instead of the entire $1 0 \times 1 0$ patch due to the receptive field of filters in the first convolution layer $( 3 \times 3 )$ .
+
+a matter of optimization, which is out of scope of this paper. However, we believe it is a phenomenon worth investigating.
+
+# 4 RECTIFIED GRADIENT
+
+We now introduce our technique to improve saliency maps. As we have shown in Section 3, zero is a poor threshold at ReLU binary gates during backpropagation. This indicates that we need better thresholds at ReLU binary gates in order to remove uninformative gradient from saliency maps. To this end, we propose Rectified Gradient, or RectGrad in short, where the gradient propagates only through units whose importance scores exceed some threshold. Importance score for an unit is calculated by multiplying its activation with gradient propagated up to the unit. Formally, RectGrad is given as follows:
+
+ifuncti Suppose we have a $l$ as $\bar { z } _ { i } ^ { ( l ) }$ , its activation as ien, the relation between (L) $L$ -layer ReLU DNN. Denote input feature $a _ { i } ^ { ( l ) }$ and gradient propagated up to $a _ { i } ^ { ( l ) }$ and ) $z _ { i } ^ { ( l ) }$ iis given by $a _ { i } ^ { ( l ) }$ $i$ as $a _ { i } ^ { ( l ) } = R e L U ( z _ { i } ^ { ( l ) } ) = \operatorname* { m a x } ( z _ { i } ^ { ( l ) } , 0 )$ as $x _ { i }$ $R _ { i } ^ { \bar { ( l + 1 ) } }$ , pre-activation of unit . Let $\mathbb { I } ( \cdot )$ be the indicator $i$ in layer when $l < L$ and $a _ { i } ^ { ( L ) } = s o f t m a x ( z _ { i } ^ { ( L ) } )$ . By the chain rule, backward pass through the ReLU nonlinearity for vanilla gradient is achieved by $R _ { i } ^ { ( l ) } = \mathbb { I } ( a _ { i } ^ { ( l ) } > 0 ) \cdot R _ { i } ^ { ( l + 1 ) }$ .
+
+We modify this rule such that $R _ { i } ^ { ( l ) } = \mathbb { I } ( a _ { i } ^ { ( l ) } \cdot R _ { i } ^ { ( l + 1 ) } > \tau ) \cdot R _ { i } ^ { ( l + 1 ) }$ for some threshold $\tau$ . Backward pass through affine transformations and pooling operations is carried out in the same manner as backpropagation. Finally, importance scores for input features are calculated by multiplying gradient propagated up to input layer $l = 0$ ) with input features: $x _ { i } \cdot R _ { i } ^ { ( 1 ) }$ . Instead of setting $\tau$ to a constant value, we use the $q ^ { \mathrm { t h } }$ percentile of importance scores at each layer. This prevents the gradient from entirely dying out during the backward pass.
+
+Due to the simplicity of the propagation rule, RectGrad can easily be applied to DNNs in graph computation frameworks such as TensorFlow (Abadi et al., 2016) or PyTorch (Paszke et al., 2017). Listing 1 in Appendix D.1 shows how to implement RectGrad in TensorFlow. In Appendix C we also introduce two techniques, namely the padding trick and the proportional redistribution rule (PRR) that enhance the visual quality of RectGrad attribution maps.
+
+# 4.1 RATIONALE BEHIND THE PROPAGATION RULE FOR RECTIFIED GRADIENT
+
+This subsection explains the reason we have chosen $R _ { i } ^ { ( l ) } = \mathbb { I } ( a _ { i } ^ { ( l ) } \cdot R _ { i } ^ { ( l + 1 ) } > \tau ) \cdot R _ { i } ^ { ( l + 1 ) }$ and not $R _ { i } ^ { ( l ) } = \mathbb { I } ( a _ { i } ^ { ( l ) } > \tau ) \cdot R _ { i } ^ { ( l + 1 ) }$ or $R _ { i } ^ { ( l ) } = \mathbb { I } ( R _ { i } ^ { ( l + 1 ) } > \tau ) \cdot R _ { i } ^ { ( l + 1 ) }$ as the definition of RectGrad. The significance of multiplying an unit’s activation with gradient propagated up to the unit is that it estimates the marginal effect of that unit on the output (Ancona et al., 2018). For instance, consider the following linear model: $f ( a _ { 1 } , a _ { 2 } , a _ { 3 } ) = 2 \cdot \bar { a } _ { 1 } + 1 \cdot a _ { 2 } + 3 \cdot a _ { 3 }$ . We have $\partial f / \partial a _ { 1 } \ = \ 2$ , $\partial f / \partial a _ { 2 } = 1$ , and $\partial f / a _ { 3 } = 3$ . Suppose we are given inputs $a _ { 1 } = 2$ , $a _ { 2 } = 3$ , $a _ { 3 } = 1$ and we apply RectGrad with $q \ = \ 6 7$ , i.e., we propagate the gradient through the unit with the highest importance score. Clearly $a _ { 1 }$ has the largest contribution of $2 \cdot 2 = 4$ to the final output compared to $1 \cdot 3 = 3 \cdot 1 = 3$ of $a _ { 2 }$ and $a _ { 3 }$ . Only the first rule correctly propagates gradient through the most influential unit $a _ { 1 }$ while the latter two rules mistakenly choose $a _ { 2 }$ and $a _ { 3 }$ respectively. Since the latter two rules fail even for this simple example, it is highly likely that they will not work for DNNs which are constructed by composing multiple linear layers. On the other hand, the first rule propagates gradient through units with the largest marginal effect in a layer-wise manner. Hence, it makes sense to select the first propagation rule as the definition of RectGrad. Next, we show that RectGrad generalizes Deconvolution and Guided Backpropagation.
+
+4.2 RELATION TO DECONVOLUTION AND GUIDED BACKPROPAGATION
+
+Claim 1. Deconvolution \* Input is equivalent to Rectified Gradient with the propagation rule
+
+$$
+R _ { i } ^ { ( l ) } = \mathbb { I } \left[ \left( a _ { i } ^ { ( l ) } + \epsilon \right) \cdot R _ { i } ^ { ( l + 1 ) } > 0 \right] \cdot R _ { i } ^ { ( l + 1 ) }
+$$
+
+for some small $\epsilon > 0$
+
+Claim 2. Guided Backpropagation $^ *$ Input is equivalent to Rectified Gradient when $\tau = 0$ :
+
+$$
+R _ { i } ^ { ( l ) } = \mathbb { I } \left( a _ { i } ^ { ( l ) } \cdot R _ { i } ^ { ( l + 1 ) } > 0 \right) \cdot R _ { i } ^ { ( l + 1 ) } .
+$$
+
+The proofs for Claims 1 and 2 are provided in Appendix E.1 and E.2 respectively. These results indicate that RectGrad generalizes Deconvolution and Guided Backpropagation. Figure 1 illustrates the relation between the saliency map, Deconvolution, Guided Backpropagation and RectGrad.
+
+However, Nie et al. (2018) has recently proven that Deconvolution and Guided Backpropagation are actually doing partial image recovery which is unrelated to DNN decisions. RectGrad does not suffer from this problem as it does not satisfy the assumptions of the analyses of Nie et al. (2018) for two reasons. First, the threshold criterion is based on the product of activation and gradient which is not Gaussian distributed.1 Second, we set $\tau$ as the $q ^ { \mathrm { t h } }$ percentile of importance scores and therefore $\tau$ will vary layer by layer. We also show in Section 5.2 with adversarial attacks that attributions produced by RectGrad are class sensitive. Therefore, RectGrad inherits the sharp visualizations of Deconvolution and Guided Backpropagation while amending their disadvantages with layer-wise importance score thresholding.
+
+# 5 EXPERIMENTS
+
+To evaluate RectGrad, we performed a series of experiments using Inception V4 network (Szegedy et al., 2017) trained on ImageNet (Russakovsky et al., 2015) and CNNs trained on CIFAR-10 (Krizhevsky & Hinton, 2009). See Appendix F.1 for details on the attribution map visualization method.
+
+![](images/860840588f1f0c683182874049218e0e59f899bcd2140329aab288b369ba187f.jpg)  
+Figure 5: Effect of threshold $\tau$ (columns) on RectGrad for 3 images of the cabbage butterfly class in ImageNet (rows). The second column shows attribution maps with $\tau = 0$ , which is equivalent to Guided Backpropagation \* Input. For the following columns, $\tau$ is set to $q ^ { \mathrm { t h } }$ percentile of importance scores. The padding trick was used for all attribution maps above.
+
+# 5.1 EFFECT OF THRESHOLD PERCENTILE
+
+RectGrad has one hyper-parameter $\tau$ , which is set to $q ^ { \mathrm { t h } }$ percentile of importance scores for each layer. Figure 5 shows the effect of threshold percentile for several images from ImageNet. While the attribution maps were incomprehensible for $q = 0$ , the visual quality dramatically improved as we incremented $q$ up to 20. There was no significant change up to $q = 8 0$ . Then the attribution maps began to sparse out again as we incremented $q$ further. We also observed that regions of high attributions did not change from $q > 2 0$ .
+
+We speculate that the attributions stay constant between $q = 2 0$ and 80 because of zero activations. That is, since we use ReLU activation functions, the majority of activations and consequently importance scores will be zero. Hence, $\tau \approx 0$ for $2 0 \leq q \leq 8 0$ . This causes RectGrad attribution maps to resemble those produced by Guided Backpropagation \* Input. It indicates that we have to increment $q > 8 0$ in order to produce sparser attribution maps that highlight important regions instead of reconstruct input images.
+
+# 5.2 QUALITATIVE COMPARISON WITH BASELINE METHODS
+
+We used the saliency map, Gradient \* Input, Guided Backpropagation, SmoothGrad, Integrated Gradient, Epsilon-LRP and DeepLIFT as baseline methods. As for RectGrad, we used the padding trick and $q = 9 8$ for all attribution maps. We show attributions both with and without application of the proportional redistribution rule. In this subsection, we compare RectGrad with other attribution methods through three experiments that each focus on different aspect of qualitative evaluation.
+
+We also show applying simple final thresholding to baseline methods is not enough to replicate the benefits of RectGrad. To demonstrate this, we applied 95 percentile final threshold to baseline attribution methods such that RectGrad and baseline attribution maps have similar levels of sparsity.2
+
+Coherence. Following prior work (Simonyan et al., 2014; Zeiler & Fergus, 2014), we inspected two types of visual coherence. First, the attributions should fall on discriminative features (e.g. the object of interest), not the background. Second, the attributions should highlight similar features for images of the same class.
+
+For the first type of visual coherence, Figure 6 shows a side-by-side comparison between our method and baseline methods. It can clearly be seen that RectGrad produced attribution maps more visually coherent and focused than other methods—background noise was nearly nonexistent. This phenomenon may be due to noise accumulation. Specifically, irrelevant features may have trivial gradient near the output layer. However, since gradient is calculated by successive multiplication, the noise can grow exponentially as gradient is propagated towards the input layer. This can result in confusing attribution maps which assign high attribution to irrelevant regions (e.g. uniform background in “lighter”), especially for deep networks such as Inception. RectGrad does not suffer from this problem since it thresholds irrelevant features at every layer and hence stops noise accumulation. In this situation, final thresholding cannot replicate RectGrad’s ability to remove noise. In Appendix A.2, we corroborate this claim by comparing Saliency map and RectGrad attributions as they are propagated towards the input layer.
+
+![](images/c7ec0794a4ddbe7666531ef84d42c5d635c261364d619d42630ff37f04545976.jpg)  
+Figure 6: Evaluation of coherence across different classes without and with final thresholding.
+
+![](images/b636665359e93b22baf6e515237ab8db9ee075525f59e434a494103ad8a45467.jpg)  
+Figure 7: Comparison of attribution maps for images (left column) and their adversarial examples (right column) without and with final thresholding. This figure shows examples where attribution maps produced by RectGrad changed significantly.
+
+For the second type of visual coherence, Figure 11 in Appendix A.3 shows attribution maps for a pair of images belonging to the same class. Attribution maps generated by RectGrad consistently emphasized similar parts of the object of interest. On the contrary, Saliency map, Gradient \* Input and Epsilon-LRP emphasized different regions for each image instance. Attributions for Smooth
+
+![](images/31aaa66cea4f78c801a98553e95948e400bb218fbcafd378fe14aa02ab1d7cc2.jpg)  
+Figure 8: Comparison of amount of attribution on occluded patch. The left and right charts compare the amount of attribution inside occluded patch without and with final thresholding respectively. The numbers in parentheses show the custom threshold levels.
+
+Grad, Guided Backpropagation, Integrated Gradient and DeepLIFT were generally coherent across images of the same class. Nevertheless, they also highlighted background features and hence failed to satisfy the first type of visual coherence. This observation also holds for attribution maps with final thresholding.
+
+Adversarial Attack. We evaluated class sensitivity following prior work by Nie et al. (2018). Specifically, we compared the attributions for an image and its adversarial example. If the attribution method is class sensitive, attribution maps should change significantly since ReLU activations and consequently the predicted class have changed. On the other hand, if the attribution method merely does image reconstruction, attribution maps will not change much since we add an indistinguishable adversarial perturbation to the image. In this experiment, we used the fast gradient sign method (Goodfellow et al., 2015) with $\epsilon = 0 . 0 1$ to generate adversarial examples.
+
+Figure 7 shows large changes in attribution maps produced by RectGrad. We observed that only RectGrad attributions were coherent with the class labels. Figure 12 in Appendix A.3 shows some instances where there was no significant change in attribution maps produced by RectGrad. In those cases, attribution maps for other methods also showed little change. Hence, we can conclude that RectGrad is equally or more class sensitive than baseline attribution methods. We observed that this conclusion also holds with final thresholding. It is also possible that adversarial attacks only modified a tiny amount of ReLU activations (i.e. the images were near the decision boundary), causing little change in attribution maps.
+
+# 5.3 QUANTITATIVE COMPARISON WITH BASELINE METHODS
+
+In this section, we quantitatively compare RectGrad with baseline methods using DNNs trained on CIFAR-10. We did not include Epsilon-LRP since it is equivalent to Gradient \* Input for ReLU DNNs (Ancona et al., 2018). We divided baseline attribution methods into local and global methods following the criterion proposed by Ancona et al. (2018). We also repeated the same experiments with final thresholding to the baselines to compare them with RectGrad in similar sparsity setting.
+
+Training Dataset Occlusion. Just like the training dataset occlusion experiment in Section 3, we occluded the upper left corner of all images in CIFAR-10 training dataset with a $1 0 \times 1 0$ random patch and trained a randomly initialized CNN on the modified dataset. We then summed all absolute attribution within the patch and averaged across the test dataset. A reasonable attribution method should assign nearly zero attribution to the patch as it is completely irrelevant to the classification task. Figure 8 compares the amount of average attribution in the patch between attribution methods. We observed that without final thresholding, RectGrad assigned little or no attribution to the random patch. However, all other methods failed to do so. For this test, we found using $q \ = \ 9 5$ final threshold led to trivially different averages. Hence we used a custom threshold for each baseline method such that they had similar average attribution in the patch as RectGrad. We observed that RectGrad had smaller standard deviation than baseline methods. This indicates that RectGrad more consistently assigns near-zero attribution to the patch. Therefore RectGrad has advantages over baseline methods regardless of whether final threshold is used or not. Figures for the following quantitative experiment outcomes are in Appendix A.4.
+
+Noise Level. We evaluated whether RectGrad really reduces noise through two experiments. For the first test, we created segmentation masks for 10 correctly classified images of each class (total 100 images) and measured how much attribution falls on the background. Specifically, we compared the sum of absolute value of attribution on the background. For the second test, we measured the average total variation of attribution maps for each attribution method. The average was taken over the test dataset. Figure 13 shows that RectGrad assigned significantly less attribution to the background than baseline methods. Moreover, even with final thresholding, RectGrad outperformed baseline methods. In addition, Figure 14 shows that even though the total variation reduces for baseline methods after final thresholding, RectGrad outperforms baseline methods in both cases. The results imply that baselines with final thresholding cannot replicate RectGrad’s ability to reduce noise.
+
+Sensitivity. We evaluated RectGrad using the Sensitivity metric proposed by Bach et al. (2015) and Samek et al. (2017). Specifically, we measured how the logit for the initial class changed as features were occluded based on the ordering assigned by the attribution method. We split the image into non-overlapping patches of $2 \times 2$ pixels. Next, we computed attributions and summed all the values within each patch. We sorted the patches in decreasing order based on the aggregate attribution values. We then incrementally replaced the first 100 patches with per-channel mean computed using the entire training set and measured the change in class logit. We calculated the average across 500 randomly chosen test set images. An attribution method is better if it has a lower sensitivity AUC.
+
+The results are shown in Figure 15. All attribution methods outperformed the random baseline in which we randomly removed patches. We observed that RectGrad performed better than local attribution methods. In comparison with global attribution methods, RectGrad showed similar performance up to approximately 10 patches (red vertical line) but the performance dropped as more patches were removed. In Appendix B.1, we offer an explanation for this behavior. Figure 16 shows that after final thresholding, RectGrad still outperforms local attribution methods. For global attribution methods, RectGrad now shows similar performance.
+
+ROAR and KAR. We evaluated RectGrad using Remove and Retrain (ROAR) and Keep and Retrain (KAR) proposed by Hooker et al. (2018). Specifically, we measured how the performance of the classifier changed as features were occluded based on the ordering assigned by the attribution method. For ROAR, given an attribution method, we replaced a fraction of all CIFAR-10 pixels that were estimated to be most important with a constant value. We then retrained a CNN on the modified dataset and measured the change in test accuracy. For KAR, we replaced a fraction of all CIFAR-10 pixels that were estimated to be least important. We trained 3 CNNs per estimator for each fraction $\{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \}$ . We measured test accuracy as the average of theses 3 CNNs. An attribution method is better if it has a lower ROAR AUC and a higher KAR AUC.
+
+Figure 17 presents ROAR scores. All attribution methods outperformed the random baseline in which we randomly removed pixels. RectGrad showed similar performance to local attribution methods but performed worse than all global attribution methods. Next, Figure 18 shows KAR scores. Interestingly, all baseline attribution methods failed to exceed even the random baseline. Only RectGrad had similar or better performance than the random baseline. In Appendix B.2, we offer an explanation for why RectGrad performed poorly in ROAR.
+
+# 6 CONCLUSIONS
+
+Saliency map is the most basic means of interpreting deep neural network decisions. However, it is often visually noisy. Although several hypotheses were proposed to account for this phenomenon, there is no work that provides a thorough analysis of noisy saliency maps. Therefore, we first identified saliency maps are noisy because DNNs do not filter out irrelevant features during forward propagation. We then proposed RectGrad Gradient which significantly improves saliency maps by alleviating this problem through layer-wise thresholding during backpropagation. We showed that Rectified Gradient generalizes Deconvolution and Guided Backpropagation and moreover, overcomes the class-insensitivity problem. We also demonstrated through extensive experiments that Rectified Gradient outperforms previous attribution methods.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: A system for largescale machine learning. In Proceedings of the 12th USENIX Conference on Operating Systems Design and Implementation, OSDI’16, pp. 265–283, Berkeley, CA, USA, 2016. USENIX Association. ISBN 978-1-931971-33-1. URL http://dl.acm.org/citation.cfm?id $=$ 3026877.3026899.
+
+Marco Ancona, Enea Ceolini, Cengiz Oztireli, and Markus Gross. Towards better understanding ¨ of gradient-based attribution methods for deep neural networks. In International Conference on Learning Representations, 2018.
+
+Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PLoS ONE, 10(7):1–46, 2015. ISSN 19326203. doi: 10.1371/journal. pone.0130140.
+
+David Baehrens, Timon Schroeter, Stefan Harmeling, Motoaki Kawanabe, Katja Hansen, and KlausRobert Muller. How to explain individual classification decisions. ¨ Journal of Machine Learning Research, 11(Jun):1803–1831, 2010.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, and Pascal Vincent. Visualizing higher-layer features of a deep network. University of Montreal 1341.3, 2009.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Striving for simplicity: The all convolutional net. In International Conference on Learning Representations, 2015.
+
+Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. In ICML Workshop on Human Interpretability in Machine Learning, 2018.
+
+ALex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Gregoire Montavon, Sebastian Lapuschkin, Alexander Binder, Wojciech Samek, and Klaus-Robert ´ Muller. Explaining nonlinear classification decisions with deep taylor decomposition. ¨ Pattern Recognition, 65:211–222, 2017.
+
+Weili Nie, Yang Zhang, and Ankit Patel. A theoretical explanation for perplexing behaviors of backpropagation-based visualizations. In International Conference on Machine Learning, 2018.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS Workshop on Autodiff, 2017.
+
+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, 115(3):211–252, 2015.
+
+Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE transactions on neural networks and learning systems, 28(11):2660–2673, 2017.
+
+Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In The IEEE International Conference on Computer Vision, Oct 2017.
+
+Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In International Conference on Machine Learning, 2017.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In International Conference on Learning Representations Workshop, 2014.
+
+Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. In ICML Workshop on Visualization for Deep Learning, 2017.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. International Conference on Learning Representations Workshop, 2015.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Gradients of counterfactuals. arXiv preprint arXiv:1611.02639, 2016.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In International Conference on Machine Learning, 2017.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI Conference on Artificial Intelligence, 2017.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European Conference on Computer Vision, pp. 818–833. Springer, 2014.
+
+# A EXPERIMENT RESULTS
+
+A.1 SUPPLEMENTARY EXPERIMENT FOR FEATURE MAP OCCLUSION
+
+![](images/b95f58f6e2a7cc71a7978e187858c5a28d0e48b4ff1f123acbf2761b39bb7e8d.jpg)  
+(c) Average of (class logit) − (largest logit among the other 9 classes) as background feature activations are incrementally occluded in a random order (average is taken over 50 random trials). The average is taken over 100 images. The average is illustrated by a solid red line, standard deviation by the shaded blue region, and 10 randomly selected instances by green dotted lines.   
+Figure 9: Larger-scale study of the impact of background feature activation occlusion on the final decision.
+
+To further support our claim that background feature activations are irrelevant to the classification task, we conducted a larger-scale experiment. We created segmentation masks for 10 correctly classified images of each class (total 100 images) and repeated the feature map occlusion for each image. We then took the average of (class logit) − (largest logit among the other 9 classes) across all 100 images. Figures 9a and 9b give an example of a background segmentation mask and a completely occluded feature map. Figure 9c shows that the difference is generally positive throughout the occlusion process, that is, the class does not change for most images. From this, we can infer that background features are generally irrelevant to the classification task.
+
+# A.2 SUPPLEMENTARY EXPERIMENT FOR NOISE ACCUMULATION
+
+<table><tr><td>Tiger</td><td>Saliency Map</td><td>RectGrad</td></tr><tr><td></td><td></td><td></td></tr></table>
+
+![](images/a194f812e1a8ef3afe13341fcf68c50679c1103371b04cea7925afdf5401f5fb.jpg)
+
+![](images/ff67af697b9ad91520510f811d2f8cbafdc13def9c162fa47541ede8a07550b5.jpg)
+
+![](images/75ea27c621f7326742d3dc224beb3fda0cb820ebfb497c0565debbf5d2dffed1.jpg)
+
+![](images/81354b1debd40de14b70dc21a2adffb53146a6c27f7cfc26128ac280e0417c29.jpg)
+
+![](images/fce7c0cebeb30301fa1077474f275eb208adf1982e6895189ed796659bea6c67.jpg)
+
+![](images/668ed407e0bdf8931fd246f3f705f1f7b734da73196a02fc9dacb4c8c6db0b75.jpg)
+
+![](images/c9dad4ccc0210c47146d744e90dea044c4acaaaa0ade18b0340c01c9eafcb0d2.jpg)
+
+![](images/256fe7329d8707ec6bb6e65c9ef7af660275500c12484479bc0578c0187991c3.jpg)
+
+![](images/1af18a83b337877b4377e5505af12af08ce02142ed31245ec014e45fe4739971.jpg)
+
+![](images/1f807aaea7402260d6271801530637840d8a8e66d24a53dc4214f47aa8766017.jpg)
+
+<table><tr><td></td><td></td><td></td><td></td><td>中</td><td>+</td><td>A</td><td>美</td><td>E 中</td><td>山 ■</td></tr></table>
+
+![](images/6f753ddc54faa630d174173388e51aa61ebb7a9abc166c76703b9238728af6ca.jpg)  
+Figure 10: Saliency map and RectGrad attributions at Inception v4 intermediate layers as they are propagated toward the input layer. We show channel-wise average attributions for hidden layer inputs with respect to the output layer. For each subfigure, first row shows the input image and Saliency map and RectGrad attribution maps. Second and third rows show Saliency map and RectGrad attributions at intermediate layers, respectively. An attribution map is closer to the output layer if it is closer to the right.
+
+To verify our claims on the noise accumulation phenomenon, we compared Saliency map and RectGrad attributions as they are propagated towards the input layer. As Figure 10 shows, at higher layers, Saliency map attributions for objects of interest are generally larger than or equal to attributions on the background. However, as they are propagated towards the input layer, attributions for objects of interest diminish while background attributions grow. On the other hand, RectGrad removes background attributions from higher layers through importance score based thresholding, stopping noise accumulation in the first place.
+
+# A.3 QUALITATIVE EXPERIMENTS
+
+![](images/dec0b9887c199f5174e2a4aeca8dcbb356617624dcb551a75dec4d524e1b72d3.jpg)  
+Figure 11: Evaluation of coherence within the same class (rows) without and with final thresholding.
+
+![](images/3d2d74c8c6e46dabef905af385d8be02ba1a8ad83800deb155c66fdd3bad5fec.jpg)  
+Figure 12: Comparison of attribution maps for images (left column) and their adversarial examples (right column) without and with final thresholding. This figure shows examples where attribution maps produced by RectGrad did not change significantly.
+
+![](images/c846a8a3f988db84ef3eec5cf002026e1f9e26e5a2466a95535f8eb05c89b3a4.jpg)  
+Figure 13: Comparison of amount of attribution on the background. The left and right charts compare the amount of attribution outside mask (on background) without and with final thresholding respectively.
+
+![](images/ccad8a062180346160947de4eaa8b95149cabf0ec805ffab964a9f4e7791c5c1.jpg)  
+Figure 14: Comparison of average total variation. The left and right charts compare average total variation without and with final thresholding respectively.
+
+![](images/31871411c118bf3abddb9e25b2ff3615025f4733d61db7f07175ff6354808577.jpg)  
+Figure 15: Comparison of Sensitivity. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (patches are randomly removed) for reference. Lower AUC indicates a better attribution method. The red vertical line in the right plot indicates where RectGrad starts to perform worse than baseline global attribution methods (10 patches). We took the average over 500 randomly chosen test set images.
+
+![](images/238a91b6861d063ec49ddb5fe1333ff355fb702d8acbc3abdf02883bc0228158.jpg)  
+Figure 16: Comparison of Sensitivity after final thresholding. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (patches are randomly removed) for reference. Lower AUC indicates a better attribution method. We took the average over 500 randomly chosen test set images.
+
+![](images/e249aa58bdefd5409c2bb18d6c9a03a66d6db0e9837aa3fabb54f14e736f58b3.jpg)  
+Figure 17: Comparison of ROAR. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (pixels are randomly removed) for reference. Lower AUC indicates a better attribution method.
+
+![](images/e0077851dd47ab6f2e0fd856e69356df6e4a94086032660c55d7cfa2bfe0b07b.jpg)  
+Figure 18: Comparison of KAR. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (pixels are randomly removed) for reference. Higher AUC indicates a better attribution method.
+
+# B ADDITIONAL EXPLANATION FOR QUANTITATIVE EXPERIMENTS
+
+# B.1 SENSITIVITY
+
+In comparison with global attribution methods, RectGrad showed similar performance up to approximately 10 patches (red vertical line) but the performance dropped as more patches were removed (Figure 15). We speculate this happens due to the sparseness of RectGrad attribution maps. Since RectGrad attribution maps are sparser than those of other methods, occluding approximately 10 features will be enough to remove core features highlighted by RectGrad. Attributions for other features will not be as informative since they have trivial values. Figure 19 shows that it is indeed the case. For RectGrad, after occluding 10 top $2 \times 2$ patches, only attributions of small values remained. For Gradient \* Input, on the other hand, still had significant amount of nontrivial leftover attributions. We also see from Figure 16 that this phenomenon also happens for baseline methods with final thresholding. This implies that such behavior may be an inevitable consequence of sparseness.
+
+![](images/0efa1572ca2ccc7fdaa18d838adbd6033bee1d55b724a58ecf074ac0d8325f7d.jpg)  
+Figure 19: Comparison of attribution methods in sensitivity. The first row shows the image as top N $2 \times 2$ patches are occluded according to RectGrad. The second and third rows show the positive parts (indicated by $+$ ) of RectGrad and Gradient \* Input attribution maps as top $N \ : 2 \times 2$ patches are occluded respectively. We did not cap outlying values in this visualization.
+
+# B.2 ROAR
+
+We believe that the poor performance of RectGrad in ROAR is also due to its sparseness. Since RectGrad produces visually coherent attribution maps, the occluded regions can act as discriminative features. To verify this, we replaced $1 0 \%$ of all CIFAR-10 pixels that were estimated to be most important with the channel-wise mean. We then trained a CNN on the occluded dataset and visualized RectGrad attribution maps for images whose original and occluded versions were both classified correctly. Figure 20 shows the results. Attribution maps highlighted pixels around the occluded regions and moreover, similar regions were emphasized in the original image. This corroborates our claim that the occluded regions act as discriminative features. The assumption behind ROAR is that the occluded features do not influence the classification task (Hooker et al., 2018). Since the above observation contradicts this assumption, ROAR may not be suitable for objectively evaluating RectGrad.
+
+![](images/2a87e8f787e88874f751ebec957816b9d2a35bdd0b5391694043ce6213d265a1.jpg)  
+Figure 20: RectGrad attribution maps produced from a CNN trained on images occluded according to RectGrad. We show images whose original and occluded versions were both classified correctly.
+
+# C USEFUL TECHNIQUES
+
+Here, we present two useful techniques that can enhance the visual quality of attribution maps produced by RectGrad.
+
+# C.1 PADDING TRICK
+
+Convolution inputs are typically zero padded along the border in order to preserve the spatial dimension of feature maps.3 This occasionally leads to high activation values along the border if zero is out of input distribution. Since importance scores are calculated by multiplying activation with gradient, outlying border activation can cause RectGrad to be propagated through the border instead of relevant features. To solve this problem, we masked the border of gradient to zero before the backward pass through convolutions with padding. One possible concern with the padding trick is that attributions may be faint for features adjacent to the border of the image. However, we did not find this to be a significantly problem experimentally. Listing 2 in Appendix D.2 shows how to implement the padding trick in TensorFlow.
+
+C.2 PROPORTIONAL REDISTRIBUTION RULE (PRR) FOR POOLING LAYERS.
+
+Attribution maps produced by RectGrad tend to be rough due to the discrete nature of thresholding. This discontinuity can be compensated by using the proportional redistribution rule proposed by Montavon et al. (2017) for the backward pass through max-pooling layers. Instead of propagating the gradient through only the most activated unit in the pool, gradient is redistributed proportional to unit activations. Since the redistribution operation is continuous, attribution maps generated with the proportional redistribution rule are smoother. Listing 3 in Appendix D.3 shows how to implement the proportional redistribution rule in TensorFlow.
+
+# D TENSORFLOW CODES
+
+# D.1 IMPLEMENTATION OF RECTIFIED GRADIENT
+
+1 import tensorflow as tf   
+2   
+3 from tensorflow.contrib.distributions import percentile   
+4   
+5 @tf.RegisterGradient("RectifiedRelu")   
+6 def _RectifiedReluGrad(op, grad):   
+7   
+8 def threshold(x, q):   
+9   
+10 if len(x.shape.as_list()) $> 3$ :   
+11 thresh $=$ percentile(x, q, axis $=$ [1,2,3], keep_dims $=$ True)   
+12 else:   
+13 thresh $=$ percentile(x, q, axis $^ { = 1 }$ , keep_dims $=$ True)   
+14   
+15 return thresh   
+16   
+17 activation_grad $=$ op.outputs[0] $\star$ grad   
+18 thresh $=$ threshold(activation_grad, q)   
+19   
+20 return tf.where(thresh $<$ activation_grad, grad, tf.zeros_like(grad))
+
+Listing 1: Implementation of Rectified Gradient in TensorFlow. After registering this function as the gradient for ReLU activation functions, call tf.gradients() and multiply with inputs to generate attributions.
+
+# D.2 IMPLEMENTATION OF THE PADDING TRICK
+
+import tensorflow as tf   
+2   
+3 @tf.RegisterGradient("RectifiedConv2D")   
+4 def _RectifiedConv2DGrad(op, grad):   
+5   
+6 if op.get_attr(’padding’) $= =$ b’SAME’:   
+7   
+8 shape $=$ tf.shape(grad)   
+9 mask $=$ tf.ones([shape[0], shape[1] - 2, shape[2] - 2, shape[3]])   
+10 mask $=$ tf.pad(mask, [[0,0],[1,1],[1,1],[0,0]])   
+11 grad $=$ grad $\star$ mask   
+12   
+13 input_grad $=$ tf.nn.conv2d_backprop_input(tf.shape(op.inputs[0]), op.   
+inputs[1], grad, op.get_attr(’strides’), op.get_attr(’padding’))   
+14 filter_grad $=$ tf.nn.conv2d_backprop_filter(op.inputs[0], tf.shape(op.   
+inputs[1]), grad, op.get_attr(’strides’), op.get_attr(’padding’))   
+15   
+16 return input_grad, filter_grad
+
+Listing 2: Implementation of the padding trick in TensorFlow. After registering this function as the gradient for convolution operations, call tf.gradients() and multiply with inputs to generate attributions.
+
+# D.3 IMPLEMENTATION OF THE PROPORTIONAL REDISTRIBUTION RULE
+
+1 import tensorflow as tf   
+2   
+3 from tensorflow.python.ops import gen_nn_ops   
+4   
+5 @tf.RegisterGradient("RectifiedMaxPool")   
+6 def _RectifiedMaxPoolGrad(op, grad):   
+7   
+8 $_ { \textrm { } \textrm { } \textrm { } \textrm { } } \textrm { } \textrm { }$ tf.nn.avg_pool(op.inputs[0], op.get_attr(’ksize’), op.get_attr(’   
+strides’), op.get_attr(’padding’)) $^ +$ 1e-10   
+9 $_ { \textrm { { S } } } =$ grad / z   
+10 $\mathbf { \Sigma } _ { \subset } ~ =$ gen_nn_ops._avg_pool_grad(tf.shape(op.inputs[0]), s, op.get_attr(   
+’ksize’), op.get_attr(’strides’), op.get_attr(’padding’))   
+11   
+12 return op.inputs[0] \* c
+
+# E PROOF OF CLAIMS
+
+# E.1 PROOF OF CLAIM 1
+
+Proof. Note that the backward propagation rule for Deconvolution through the ReLU nonlinearity is given by
+
+$$
+R _ { i } ^ { ( l ) } = \mathbb { I } \left( R _ { i } ^ { ( l + 1 ) } > 0 \right) \cdot R _ { i } ^ { ( l + 1 ) } .
+$$
+
+Since the DNN uses ReLU activation functions, $a _ { i } ^ { ( l ) } + \epsilon > 0$ and therefore
+
+$$
+\mathbb { I } \left[ \left( a _ { i } ^ { ( l ) } + \epsilon \right) \cdot R _ { i } ^ { ( l + 1 ) } > 0 \right] = \mathbb { I } \left( R _ { i } ^ { ( l + 1 ) } > 0 \right)
+$$
+
+for all $l$ and $i$ . The result follows from Equation 2.
+
+# E.2 PROOF OF CLAIM 2
+
+Proof. Note that the backward propagation rule for Guided Backpropagation through the ReLU nonlinearity is given by
+
+$$
+R _ { i } ^ { ( l ) } = \mathbb { I } \left( z _ { i } ^ { ( l ) } > 0 \right) \cdot \mathbb { I } \left( R _ { i } ^ { ( l + 1 ) } > 0 \right) \cdot R _ { i } ^ { ( l + 1 ) } .
+$$
+
+Since the DNN uses ReLU activation functions, $a _ { i } ^ { ( l ) } \geq 0$ and therefore
+
+$$
+\mathbb { I } \left( a _ { i } ^ { ( l ) } \cdot R _ { i } ^ { ( l + 1 ) } > 0 \right) = \mathbb { I } \left( z _ { i } ^ { ( l ) } > 0 \right) \cdot \mathbb { I } \left( R _ { i } ^ { ( l + 1 ) } > 0 \right)
+$$
+
+for all $l$ and $i$ . The result follows from Equation 4.
+
+# F EXPERIMENTS SETUP
+
+# F.1 ATTRIBUTION MAP VISUALIZATION
+
+To visualize the attributions, we summed up the attributions along the color channel and then capped low outlying values to $0 . 5 ^ { \mathrm { t h } }$ percentile and high outlying values to $9 9 . 5 ^ { \mathrm { t h } }$ percentile for RGB images. We only capped outlying values for grayscale images.
+
+# F.2 CIFAR-10
+
+The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) was pre-processed to normalize the input images into range $[ - 1 ; 1 ]$ . We trained a CNN using ReLU activation functions with Adam for 20 epochs to achieve $7 9 . 4 \%$ test accuracy. For the dataset occluded with the random patch, we used the same settings to achieve $7 9 . 3 \%$ test accuracy.
+
+<table><tr><td rowspan=1 colspan=1>CIFAR-10 CNN</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3,32 kernels)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3,32 kernels)</td></tr><tr><td rowspan=1 colspan=1>Max-pooling (2 × 2)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.25)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3, 64 kernels)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3, 64 kernels)</td></tr><tr><td rowspan=1 colspan=1>Max-pooling (2 × 2)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.25)</td></tr><tr><td rowspan=1 colspan=1>Dense (256)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.5)</td></tr><tr><td rowspan=1 colspan=1>Dense (10)</td></tr></table>
+
+# F.3 INCEPTION V4
+
+We used a pre-trained Inception V4 network. The details of this architecture can be found in Szegedy et al. (2017). For the adversarial attack, we used the fast gradient sign method with $\epsilon = 0 . 0 1$ .

parse/train/Hkemdj09YQ/Hkemdj09YQ_content_list.json

@@ -0,0 +1,2138 @@
+[
+    {
+        "type": "text",
+        "text": "RECTIFIED GRADIENT: LAYER-WISE THRESHOLDING FOR SHARP AND COHERENT ATTRIBUTION MAPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            400,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Saliency map, or the gradient of the score function with respect to the input, is the most basic means of interpreting deep neural network decisions. However, saliency maps are often visually noisy. Although several hypotheses were proposed to account for this phenomenon, there is no work that provides a rigorous analysis of noisy saliency maps. This may be a problem as numerous advanced attribution methods were proposed under the assumption that the existing hypotheses are true. In this paper, we identify the cause of noisy saliency maps. Then, we propose Rectified Gradient, a simple method that significantly improves saliency maps by alleviating that cause. Experiments showed effectiveness of our method and its superiority to other attribution methods. Codes and examples for the experiments will be released in public. ",
+        "bbox": [
+            233,
+            273,
+            764,
+            426
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The gradient of the score function with respect to the input, also called the saliency map (Erhan et al., 2009; Baehrens et al., 2010; Simonyan et al., 2014), is the most basic means of interpreting deep neural networks (DNNs). It is also a baseline method for other advanced attribution-based methods. However, our understanding of saliency maps is still poor. ",
+        "bbox": [
+            174,
+            496,
+            823,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Previous studies such as Springenberg et al. (2015) and Selvaraju et al. (2017) have noted that saliency maps tend to be visually noisy. To explain this phenomenon, Sundararajan et al. (2016) and Smilkov et al. (2017) suggested saturation and discontinuous gradients as the causes (see Section 2.1 for further explanation). There were several studies attempting to improve saliency maps by tackling these hypothesized causes (Bach et al., 2015; Montavon et al., 2017; Sundararajan et al., 2016; Shrikumar et al., 2017; Smilkov et al., 2017; Sundararajan et al., 2017). ",
+        "bbox": [
+            174,
+            559,
+            823,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Even though such attribution methods generally produce better visualizations, we find troubling that the hypotheses regarding noisy saliency maps have not been rigorously verified (see Section 2.2 for more detail on attribution methods). In other words, numerous attribution methods were built upon unproven claims that gradient discontinuity or saturation truly causes saliency maps to be noisy. This situation gives rise to two major problems. First, if the hypotheses regarding noisy saliency maps are incorrect, current and future works based on those hypotheses will also be erroneous. Second, as we do not know precisely why saliency maps are noisy, we have to rely on heuristics and guessworks to develop better attribution methods. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we address these problems by identifying saliency maps are noisy because DNNs do not filter out irrelevant features during forward propagation. We then introduce Rectified Gradient, or RectGrad in short, a simple technique that significantly improves the quality of saliency maps by alleviating the cause through layer-wise thresholding during backpropagation. Finally, we demonstrate that RectGrad produces attributions qualitatively superior and quantitatively comparable to other attribution methods. Specifically, we have the following key contributions: ",
+        "bbox": [
+            174,
+            767,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• We explain why saliency maps are noisy. Noise occurs in saliency maps when irrelevant features have positive pre-activation values and consequently pass through ReLU activation functions. This causes gradients to be nonzero at unimportant regions. We perform experiments with networks trained on CIFAR-10 to justify our claims (Section 3). ",
+        "bbox": [
+            215,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/66ea85f99fe2f850dc4fb81bc964d16d6dcaf32b1b8cd556b679b4242651c1a0.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of attribution methods. See Section 5 for details on the visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            98,
+            810,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce Rectified Gradient, a method that removes noise from saliency maps by thresholding irrelevant units at ReLU binary gates during backpropagation (Section 4). We first explain the rationale behind Rectified Gradient (Section 4.1). We then prove that Rectified Gradient generalizes Deconvolution and Guided Backpropagation (Section 4.2). In addition, we discuss two techniques that enhance the visual quality of Rectified Gradient attribution maps (Appendix C). We first investigate the effect of threshold level on attribution maps produced by Rectified Gradient (Section 5.1). Then, we apply Rectified Gradient to networks trained on CIFAR10 and ImageNet to demonstrate that it produces qualitatively superior attribution maps (Section 5.2). We also compare Rectified Gradient with other attribution methods using several quantitative metrics (Section 5.3). ",
+        "bbox": [
+            215,
+            349,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND OVERVIEW",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            421,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $S : \\mathbb { R } ^ { d } \\mapsto \\mathbb { R } ^ { | C | }$ be an image classification network, where $x \\in \\mathbb { R } ^ { d }$ is a single image instance and $C$ is the set of image classes. Then, we can define a score function $S _ { c } : \\mathbb { R } ^ { d } \\stackrel { - } { \\mapsto } \\mathbb { R }$ for each class $c \\in C$ and the final class of the image $x$ is given by $c l a s s ( x ) = \\arg \\operatorname* { m a x } _ { c \\in C } S _ { c } ( x )$ . A typical score function is constructed by alternately composing affine transformations and nonlinear activation functions. A squashing function such as softmax is applied to the final layer. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since functions comprising $S _ { c }$ are differentiable or piecewise linear, the score function is also piecewise differentiable. Using this fact, Erhan et al. (2009), Baehrens et al. (2010) and Simonyan et al. (2014) proposed the saliency map, or the gradient of $S _ { c }$ with respect to $x$ , to highlight features within $x$ that the network associates with the given class. In an ideal case, saliency maps highlight objects of interest. However, previous studies such as Springenberg et al. (2015) and Selvaraju et al. (2017) have pointed out that saliency maps tend to be visually noisy, as verified by Figure 1. Three hypotheses were proposed to account for this phenomenon. We describe them in the next section. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PREVIOUS HYPOTHESES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            383,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Saliency Maps are Truthful. Smilkov et al. (2017) suggested that noisy saliency maps are faithful descriptions of what the network is doing. That is, pixels scattered seemingly at random are actually crucial to how the network makes a decision. In short, this hypothesis claims that noise is actually informative. ",
+        "bbox": [
+            174,
+            794,
+            823,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Discontinuous Gradients. Smilkov et al. (2017) and Shrikumar et al. (2017) proposed that saliency maps are noisy due to the piece-wise linearity of the score function. Specifically, since typical DNNs use ReLU activation functions and max pooling, the derivative of the score function with respect to the input will not be continuously differentiable. Under this hypothesis, noise is caused by meaningless local variations in the gradient. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Saturating Score Function. Shrikumar et al. (2017) and Sundararajan et al. (2017) suggested that important features may have small gradient due to saturation. In other words, the score function can flatten in the proximity of the input and have a small derivative. This hypothesis explains why informative features may not be highlighted in the saliency map even though they contributed significantly to the decision of the DNN. ",
+        "bbox": [
+            174,
+            109,
+            823,
+            179
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 PREVIOUS WORKS ON IMPROVING SALIENCY MAPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            195,
+            576,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNN interpretation methods that assign a signed attribution value to each input feature are collectively called attribution methods. Attributions are usually visualized as a heatmap by arranging them to have the same shape as the input sample. Such heatmaps are called attribution maps. We now describe attribution methods that have been proposed to improve saliency maps. ",
+        "bbox": [
+            174,
+            222,
+            823,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Attribution Methods Addressing Discontinuity. SmoothGrad (Smilkov et al., 2017) attempts to smooth discontinuous gradient with a Gaussian kernel. Since calculating the local average in a high dimensional space is intractable, the authors proposed a stochastic approximation which takes random samples in a neighborhood of the input $x$ and then averages their gradients. ",
+        "bbox": [
+            174,
+            284,
+            823,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Attribution Methods Addressing Saturation. Since saliency maps estimate the local importance of each input feature, they are vulnerable to saturation. Therefore, attribution methods such as Gradient \\* Input (Shrikumar et al., 2017), Layer-wise Relevance Propagation (LRP) (Bach et al., 2015), DeepLIFT (Shrikumar et al., 2017) and Integrated Gradient (Sundararajan et al., 2017) attempt to alleviate saturation by estimating the global importance of each pixel (Ancona et al., 2018). Ancona et al. (2018) has also shown that several global attribution methods are closely related under certain conditions. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other Attribution Methods. Some attribution methods take a different approach to improving saliency maps. Deconvolution (Zeiler & Fergus, 2014) and Guided Backpropagation (Springenberg et al., 2015) remove negative gradient during backpropagation. Due to this imputation procedure, Deconvolution and Guided Backpropagation yield attribution maps sharper than those of other methods. However, Nie et al. (2018) has recently proven that these methods are actually doing partial image recovery which is unrelated to DNN decisions. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OUR EXPLANATION FOR NOISY SALIENCY MAPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            616,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For brevity, we refer to pixels on the background as background features and pixels on the object as object features. Then, noise in a saliency map corresponds to background gradient, or gradient that highlights background features. We assume the DNN uses ReLU activation functions. Under this condition, nonzero background gradient indicates the presence of at least one positive pre-activation in each network layer corresponding to background features. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To verify this, we visualized intermediate layer activations of a convolutional neural network (CNN) trained on CIFAR-10. Figure 2b shows convolutional layer feature maps for an image that produced a noisy saliency map. Since CNN filters act as feature extractors, we expected the CNN to remove most background feature activations through convolutions. However, we found significant amounts of background feature activations in all convolution layers. As the last convolution layer is connected to fully connected layers, the majority of activations in the last convolution layer will have nonzero gradient. Hence, the gradient flowed through background feature activations up to the input. This gradient flow caused background gradient, as shown in Figure 2a. From our perspective, the answer to “why are saliency maps noisy?” is trivial. Saliency maps are noisy because background features pass through ReLU activation functions. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, rather than asking why saliency maps are noisy, we ask “do activations of background features highlighted by background gradient have nontrivial influence on the decision?” If the answer is yes, noise in saliency maps is informative as suggested by Smilkov et al. (2017), and saliency maps do not need any major improvement. However, if the answer is no, we should find a way to remove background gradient. We investigated this question through two experiments. ",
+        "bbox": [
+            176,
+            808,
+            823,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feature Map Occlusion. We evaluated the significance of background features by occluding activations at intermediate layers. Then, we analyzed the effect of this perturbation on the final decision. Note that this is different from the Sensitivity metric (Bach et al., 2015; Samek et al., 2017). Sensitivity measures the impact of occlusion in the data space (e.g. pixel occlusion) while we measured the impact of occlusion in each feature space. ",
+        "bbox": [
+            176,
+            885,
+            823,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/da762375abf069a3095a2d0368d4fb3ae062d1e54c20d86dc2e005c7188bf91b.jpg",
+        "image_caption": [
+            "Figure 2: Feature map visualization for an image with a noisy saliency map. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            98,
+            823,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            469,
+            823,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first created a background mask that covers background features in the images. We then plotted the average class logits as we incrementally occluded intermediate layer activations that fell on the background mask. We carried out occlusion following a random ordering and took the average over 50 trials. Figures 3a and 3b give an example of a background mask and a completely occluded feature map respectively. Figure 3c shows that the final decision did not change throughout the occlusion process for all convolution layers. Moreover, the difference between the top label logit and the next largest logit remained constant. Therefore, background feature activations are irrelevant to the classification task. To further support this claim, we conducted a larger-scale version of this experiment, and we describe the procedure and results in Appendix A.1. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training Dataset Occlusion. Next, we show that gradient can be nonzero for completely uninformative features. We occluded the upper left corner of all images in the training dataset with a $1 0 \\times 1 0$ random patch and trained a randomly initialized CNN on the modified dataset. We used the same patch for all images. Since the test accuracy did not change significantly $( 7 9 . 4 \\%$ to $7 9 . 3 \\%$ ), we expected the CNN to have learned to extract important features and ignore irrelevant ones. However, Figure 4 shows that gradient is nonzero for the patch although it is completely irrelevant to the classification task. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            734
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can draw three conclusions from these experiments: ",
+        "bbox": [
+            178,
+            741,
+            537,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. DNNs do not filter out irrelevant features during forward propagation.   \n2. DNNs are capable of making correct decisions even if we occlude the majority of background feature activations in intermediate layers. This implies that most background feature activations are irrelevant to the classification task.   \n3. Since DNNs do not remove irrelevant features through ReLU activation functions, zero threshold at ReLU binary gates during backpropagation also allow irrelevant information to flow through the gradient. ",
+        "bbox": [
+            209,
+            766,
+            823,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With the conclusions above, we can refute the first of three previous hypotheses. As for the second hypothesis, we can interpret meaningless local variation in the gradient as a side effect of irrelevant features contaminating the gradient. Why the network does not learn to filter out irrelevant features is (c) Average class logits as background feature activations are incrementally occluded in a random order. The average is taken over 50 trials. Image class is illustrated by a solid line and other classes by dotted lines. ",
+        "bbox": [
+            176,
+            885,
+            825,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/4de9ce5e9d8a6c774f0f287af3d00e83cd4f06aa88b490817e5fb309d29fc15e.jpg",
+        "image_caption": [
+            "Figure 3: Impact of background feature activation occlusion on the final decision. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            101,
+            794,
+            311
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            319,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4577a2f7227618e63fdfc31ac6940785d28ab1f0b3f4858c45bd351233526d0.jpg",
+        "image_caption": [
+            "Figure 4: Saliency maps produced from a CNN trained on occluded images. The upper left corner of all the images in the training dataset is replaced with a $1 0 \\times 1 0$ random patch, as shown above. Readers should examine the $8 \\times 8$ patch enclosed by the red square instead of the entire $1 0 \\times 1 0$ patch due to the receptive field of filters in the first convolution layer $( 3 \\times 3 )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            390,
+            820,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "a matter of optimization, which is out of scope of this paper. However, we believe it is a phenomenon worth investigating. ",
+        "bbox": [
+            173,
+            580,
+            823,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RECTIFIED GRADIENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            392,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now introduce our technique to improve saliency maps. As we have shown in Section 3, zero is a poor threshold at ReLU binary gates during backpropagation. This indicates that we need better thresholds at ReLU binary gates in order to remove uninformative gradient from saliency maps. To this end, we propose Rectified Gradient, or RectGrad in short, where the gradient propagates only through units whose importance scores exceed some threshold. Importance score for an unit is calculated by multiplying its activation with gradient propagated up to the unit. Formally, RectGrad is given as follows: ",
+        "bbox": [
+            173,
+            666,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ifuncti Suppose we have a $l$ as $\\bar { z } _ { i } ^ { ( l ) }$ , its activation as ien, the relation between (L) $L$ -layer ReLU DNN. Denote input feature $a _ { i } ^ { ( l ) }$ and gradient propagated up to $a _ { i } ^ { ( l ) }$ and ) $z _ { i } ^ { ( l ) }$ iis given by $a _ { i } ^ { ( l ) }$ $i$ as $a _ { i } ^ { ( l ) } = R e L U ( z _ { i } ^ { ( l ) } ) = \\operatorname* { m a x } ( z _ { i } ^ { ( l ) } , 0 )$ as $x _ { i }$ $R _ { i } ^ { \\bar { ( l + 1 ) } }$ , pre-activation of unit . Let $\\mathbb { I } ( \\cdot )$ be the indicator $i$ in layer when $l < L$ and $a _ { i } ^ { ( L ) } = s o f t m a x ( z _ { i } ^ { ( L ) } )$ . By the chain rule, backward pass through the ReLU nonlinearity for vanilla gradient is achieved by $R _ { i } ^ { ( l ) } = \\mathbb { I } ( a _ { i } ^ { ( l ) } > 0 ) \\cdot R _ { i } ^ { ( l + 1 ) }$ . ",
+        "bbox": [
+            173,
+            770,
+            825,
+            858
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We modify this rule such that $R _ { i } ^ { ( l ) } = \\mathbb { I } ( a _ { i } ^ { ( l ) } \\cdot R _ { i } ^ { ( l + 1 ) } > \\tau ) \\cdot R _ { i } ^ { ( l + 1 ) }$ for some threshold $\\tau$ . Backward pass through affine transformations and pooling operations is carried out in the same manner as backpropagation. Finally, importance scores for input features are calculated by multiplying gradient propagated up to input layer $l = 0$ ) with input features: $x _ { i } \\cdot R _ { i } ^ { ( 1 ) }$ . Instead of setting $\\tau$ to a constant value, we use the $q ^ { \\mathrm { t h } }$ percentile of importance scores at each layer. This prevents the gradient from entirely dying out during the backward pass. ",
+        "bbox": [
+            174,
+            863,
+            825,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            109,
+            821,
+            137
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Due to the simplicity of the propagation rule, RectGrad can easily be applied to DNNs in graph computation frameworks such as TensorFlow (Abadi et al., 2016) or PyTorch (Paszke et al., 2017). Listing 1 in Appendix D.1 shows how to implement RectGrad in TensorFlow. In Appendix C we also introduce two techniques, namely the padding trick and the proportional redistribution rule (PRR) that enhance the visual quality of RectGrad attribution maps. ",
+        "bbox": [
+            174,
+            143,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 RATIONALE BEHIND THE PROPAGATION RULE FOR RECTIFIED GRADIENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            231,
+            725,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This subsection explains the reason we have chosen $R _ { i } ^ { ( l ) } = \\mathbb { I } ( a _ { i } ^ { ( l ) } \\cdot R _ { i } ^ { ( l + 1 ) } > \\tau ) \\cdot R _ { i } ^ { ( l + 1 ) }$ and not $R _ { i } ^ { ( l ) } = \\mathbb { I } ( a _ { i } ^ { ( l ) } > \\tau ) \\cdot R _ { i } ^ { ( l + 1 ) }$ or $R _ { i } ^ { ( l ) } = \\mathbb { I } ( R _ { i } ^ { ( l + 1 ) } > \\tau ) \\cdot R _ { i } ^ { ( l + 1 ) }$ as the definition of RectGrad. The significance of multiplying an unit’s activation with gradient propagated up to the unit is that it estimates the marginal effect of that unit on the output (Ancona et al., 2018). For instance, consider the following linear model: $f ( a _ { 1 } , a _ { 2 } , a _ { 3 } ) = 2 \\cdot \\bar { a } _ { 1 } + 1 \\cdot a _ { 2 } + 3 \\cdot a _ { 3 }$ . We have $\\partial f / \\partial a _ { 1 } \\ = \\ 2$ , $\\partial f / \\partial a _ { 2 } = 1$ , and $\\partial f / a _ { 3 } = 3$ . Suppose we are given inputs $a _ { 1 } = 2$ , $a _ { 2 } = 3$ , $a _ { 3 } = 1$ and we apply RectGrad with $q \\ = \\ 6 7$ , i.e., we propagate the gradient through the unit with the highest importance score. Clearly $a _ { 1 }$ has the largest contribution of $2 \\cdot 2 = 4$ to the final output compared to $1 \\cdot 3 = 3 \\cdot 1 = 3$ of $a _ { 2 }$ and $a _ { 3 }$ . Only the first rule correctly propagates gradient through the most influential unit $a _ { 1 }$ while the latter two rules mistakenly choose $a _ { 2 }$ and $a _ { 3 }$ respectively. Since the latter two rules fail even for this simple example, it is highly likely that they will not work for DNNs which are constructed by composing multiple linear layers. On the other hand, the first rule propagates gradient through units with the largest marginal effect in a layer-wise manner. Hence, it makes sense to select the first propagation rule as the definition of RectGrad. Next, we show that RectGrad generalizes Deconvolution and Guided Backpropagation. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            469
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 RELATION TO DECONVOLUTION AND GUIDED BACKPROPAGATION ",
+        "bbox": [
+            176,
+            484,
+            676,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Claim 1. Deconvolution \\* Input is equivalent to Rectified Gradient with the propagation rule ",
+        "bbox": [
+            171,
+            511,
+            785,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d42ddcbf3e7d50ec3bf354a3f078a051165a0685623f4538ccd5e1552be5683f.jpg",
+        "text": "$$\nR _ { i } ^ { ( l ) } = \\mathbb { I } \\left[ \\left( a _ { i } ^ { ( l ) } + \\epsilon \\right) \\cdot R _ { i } ^ { ( l + 1 ) } > 0 \\right] \\cdot R _ { i } ^ { ( l + 1 ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            527,
+            643,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for some small $\\epsilon > 0$ ",
+        "bbox": [
+            173,
+            556,
+            315,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Claim 2. Guided Backpropagation $^ *$ Input is equivalent to Rectified Gradient when $\\tau = 0$ : ",
+        "bbox": [
+            168,
+            574,
+            771,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fee319e2bb6bcd2c5db76ca1b3722b79190c46be89a88ad50ec1411fbc25a993.jpg",
+        "text": "$$\nR _ { i } ^ { ( l ) } = \\mathbb { I } \\left( a _ { i } ^ { ( l ) } \\cdot R _ { i } ^ { ( l + 1 ) } > 0 \\right) \\cdot R _ { i } ^ { ( l + 1 ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            590,
+            622,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proofs for Claims 1 and 2 are provided in Appendix E.1 and E.2 respectively. These results indicate that RectGrad generalizes Deconvolution and Guided Backpropagation. Figure 1 illustrates the relation between the saliency map, Deconvolution, Guided Backpropagation and RectGrad. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, Nie et al. (2018) has recently proven that Deconvolution and Guided Backpropagation are actually doing partial image recovery which is unrelated to DNN decisions. RectGrad does not suffer from this problem as it does not satisfy the assumptions of the analyses of Nie et al. (2018) for two reasons. First, the threshold criterion is based on the product of activation and gradient which is not Gaussian distributed.1 Second, we set $\\tau$ as the $q ^ { \\mathrm { t h } }$ percentile of importance scores and therefore $\\tau$ will vary layer by layer. We also show in Section 5.2 with adversarial attacks that attributions produced by RectGrad are class sensitive. Therefore, RectGrad inherits the sharp visualizations of Deconvolution and Guided Backpropagation while amending their disadvantages with layer-wise importance score thresholding. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            326,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate RectGrad, we performed a series of experiments using Inception V4 network (Szegedy et al., 2017) trained on ImageNet (Russakovsky et al., 2015) and CNNs trained on CIFAR-10 (Krizhevsky & Hinton, 2009). See Appendix F.1 for details on the attribution map visualization method. ",
+        "bbox": [
+            174,
+            851,
+            825,
+            906
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/860840588f1f0c683182874049218e0e59f899bcd2140329aab288b369ba187f.jpg",
+        "image_caption": [
+            "Figure 5: Effect of threshold $\\tau$ (columns) on RectGrad for 3 images of the cabbage butterfly class in ImageNet (rows). The second column shows attribution maps with $\\tau = 0$ , which is equivalent to Guided Backpropagation \\* Input. For the following columns, $\\tau$ is set to $q ^ { \\mathrm { t h } }$ percentile of importance scores. The padding trick was used for all attribution maps above. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            820,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 EFFECT OF THRESHOLD PERCENTILE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            400,
+            472,
+            414
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RectGrad has one hyper-parameter $\\tau$ , which is set to $q ^ { \\mathrm { t h } }$ percentile of importance scores for each layer. Figure 5 shows the effect of threshold percentile for several images from ImageNet. While the attribution maps were incomprehensible for $q = 0$ , the visual quality dramatically improved as we incremented $q$ up to 20. There was no significant change up to $q = 8 0$ . Then the attribution maps began to sparse out again as we incremented $q$ further. We also observed that regions of high attributions did not change from $q > 2 0$ . ",
+        "bbox": [
+            173,
+            425,
+            825,
+            510
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We speculate that the attributions stay constant between $q = 2 0$ and 80 because of zero activations. That is, since we use ReLU activation functions, the majority of activations and consequently importance scores will be zero. Hence, $\\tau \\approx 0$ for $2 0 \\leq q \\leq 8 0$ . This causes RectGrad attribution maps to resemble those produced by Guided Backpropagation \\* Input. It indicates that we have to increment $q > 8 0$ in order to produce sparser attribution maps that highlight important regions instead of reconstruct input images. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 QUALITATIVE COMPARISON WITH BASELINE METHODS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            618,
+            601,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We used the saliency map, Gradient \\* Input, Guided Backpropagation, SmoothGrad, Integrated Gradient, Epsilon-LRP and DeepLIFT as baseline methods. As for RectGrad, we used the padding trick and $q = 9 8$ for all attribution maps. We show attributions both with and without application of the proportional redistribution rule. In this subsection, we compare RectGrad with other attribution methods through three experiments that each focus on different aspect of qualitative evaluation. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also show applying simple final thresholding to baseline methods is not enough to replicate the benefits of RectGrad. To demonstrate this, we applied 95 percentile final threshold to baseline attribution methods such that RectGrad and baseline attribution maps have similar levels of sparsity.2 ",
+        "bbox": [
+            174,
+            722,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Coherence. Following prior work (Simonyan et al., 2014; Zeiler & Fergus, 2014), we inspected two types of visual coherence. First, the attributions should fall on discriminative features (e.g. the object of interest), not the background. Second, the attributions should highlight similar features for images of the same class. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the first type of visual coherence, Figure 6 shows a side-by-side comparison between our method and baseline methods. It can clearly be seen that RectGrad produced attribution maps more visually coherent and focused than other methods—background noise was nearly nonexistent. This phenomenon may be due to noise accumulation. Specifically, irrelevant features may have trivial gradient near the output layer. However, since gradient is calculated by successive multiplication, the noise can grow exponentially as gradient is propagated towards the input layer. This can result in confusing attribution maps which assign high attribution to irrelevant regions (e.g. uniform background in “lighter”), especially for deep networks such as Inception. RectGrad does not suffer from this problem since it thresholds irrelevant features at every layer and hence stops noise accumulation. In this situation, final thresholding cannot replicate RectGrad’s ability to remove noise. In Appendix A.2, we corroborate this claim by comparing Saliency map and RectGrad attributions as they are propagated towards the input layer. ",
+        "bbox": [
+            174,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7ec0794a4ddbe7666531ef84d42c5d635c261364d619d42630ff37f04545976.jpg",
+        "image_caption": [
+            "Figure 6: Evaluation of coherence across different classes without and with final thresholding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b636665359e93b22baf6e515237ab8db9ee075525f59e434a494103ad8a45467.jpg",
+        "image_caption": [
+            "Figure 7: Comparison of attribution maps for images (left column) and their adversarial examples (right column) without and with final thresholding. This figure shows examples where attribution maps produced by RectGrad changed significantly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            400,
+            823,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            738,
+            825,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the second type of visual coherence, Figure 11 in Appendix A.3 shows attribution maps for a pair of images belonging to the same class. Attribution maps generated by RectGrad consistently emphasized similar parts of the object of interest. On the contrary, Saliency map, Gradient \\* Input and Epsilon-LRP emphasized different regions for each image instance. Attributions for Smooth",
+        "bbox": [
+            174,
+            871,
+            823,
+            926
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/31aaa66cea4f78c801a98553e95948e400bb218fbcafd378fe14aa02ab1d7cc2.jpg",
+        "image_caption": [
+            "Figure 8: Comparison of amount of attribution on occluded patch. The left and right charts compare the amount of attribution inside occluded patch without and with final thresholding respectively. The numbers in parentheses show the custom threshold levels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            106,
+            782,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Grad, Guided Backpropagation, Integrated Gradient and DeepLIFT were generally coherent across images of the same class. Nevertheless, they also highlighted background features and hence failed to satisfy the first type of visual coherence. This observation also holds for attribution maps with final thresholding. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Attack. We evaluated class sensitivity following prior work by Nie et al. (2018). Specifically, we compared the attributions for an image and its adversarial example. If the attribution method is class sensitive, attribution maps should change significantly since ReLU activations and consequently the predicted class have changed. On the other hand, if the attribution method merely does image reconstruction, attribution maps will not change much since we add an indistinguishable adversarial perturbation to the image. In this experiment, we used the fast gradient sign method (Goodfellow et al., 2015) with $\\epsilon = 0 . 0 1$ to generate adversarial examples. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows large changes in attribution maps produced by RectGrad. We observed that only RectGrad attributions were coherent with the class labels. Figure 12 in Appendix A.3 shows some instances where there was no significant change in attribution maps produced by RectGrad. In those cases, attribution maps for other methods also showed little change. Hence, we can conclude that RectGrad is equally or more class sensitive than baseline attribution methods. We observed that this conclusion also holds with final thresholding. It is also possible that adversarial attacks only modified a tiny amount of ReLU activations (i.e. the images were near the decision boundary), causing little change in attribution maps. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 QUANTITATIVE COMPARISON WITH BASELINE METHODS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            611,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we quantitatively compare RectGrad with baseline methods using DNNs trained on CIFAR-10. We did not include Epsilon-LRP since it is equivalent to Gradient \\* Input for ReLU DNNs (Ancona et al., 2018). We divided baseline attribution methods into local and global methods following the criterion proposed by Ancona et al. (2018). We also repeated the same experiments with final thresholding to the baselines to compare them with RectGrad in similar sparsity setting. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training Dataset Occlusion. Just like the training dataset occlusion experiment in Section 3, we occluded the upper left corner of all images in CIFAR-10 training dataset with a $1 0 \\times 1 0$ random patch and trained a randomly initialized CNN on the modified dataset. We then summed all absolute attribution within the patch and averaged across the test dataset. A reasonable attribution method should assign nearly zero attribution to the patch as it is completely irrelevant to the classification task. Figure 8 compares the amount of average attribution in the patch between attribution methods. We observed that without final thresholding, RectGrad assigned little or no attribution to the random patch. However, all other methods failed to do so. For this test, we found using $q \\ = \\ 9 5$ final threshold led to trivially different averages. Hence we used a custom threshold for each baseline method such that they had similar average attribution in the patch as RectGrad. We observed that RectGrad had smaller standard deviation than baseline methods. This indicates that RectGrad more consistently assigns near-zero attribution to the patch. Therefore RectGrad has advantages over baseline methods regardless of whether final threshold is used or not. Figures for the following quantitative experiment outcomes are in Appendix A.4. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            926
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            109,
+            823,
+            137
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noise Level. We evaluated whether RectGrad really reduces noise through two experiments. For the first test, we created segmentation masks for 10 correctly classified images of each class (total 100 images) and measured how much attribution falls on the background. Specifically, we compared the sum of absolute value of attribution on the background. For the second test, we measured the average total variation of attribution maps for each attribution method. The average was taken over the test dataset. Figure 13 shows that RectGrad assigned significantly less attribution to the background than baseline methods. Moreover, even with final thresholding, RectGrad outperformed baseline methods. In addition, Figure 14 shows that even though the total variation reduces for baseline methods after final thresholding, RectGrad outperforms baseline methods in both cases. The results imply that baselines with final thresholding cannot replicate RectGrad’s ability to reduce noise. ",
+        "bbox": [
+            174,
+            143,
+            825,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sensitivity. We evaluated RectGrad using the Sensitivity metric proposed by Bach et al. (2015) and Samek et al. (2017). Specifically, we measured how the logit for the initial class changed as features were occluded based on the ordering assigned by the attribution method. We split the image into non-overlapping patches of $2 \\times 2$ pixels. Next, we computed attributions and summed all the values within each patch. We sorted the patches in decreasing order based on the aggregate attribution values. We then incrementally replaced the first 100 patches with per-channel mean computed using the entire training set and measured the change in class logit. We calculated the average across 500 randomly chosen test set images. An attribution method is better if it has a lower sensitivity AUC. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Figure 15. All attribution methods outperformed the random baseline in which we randomly removed patches. We observed that RectGrad performed better than local attribution methods. In comparison with global attribution methods, RectGrad showed similar performance up to approximately 10 patches (red vertical line) but the performance dropped as more patches were removed. In Appendix B.1, we offer an explanation for this behavior. Figure 16 shows that after final thresholding, RectGrad still outperforms local attribution methods. For global attribution methods, RectGrad now shows similar performance. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ROAR and KAR. We evaluated RectGrad using Remove and Retrain (ROAR) and Keep and Retrain (KAR) proposed by Hooker et al. (2018). Specifically, we measured how the performance of the classifier changed as features were occluded based on the ordering assigned by the attribution method. For ROAR, given an attribution method, we replaced a fraction of all CIFAR-10 pixels that were estimated to be most important with a constant value. We then retrained a CNN on the modified dataset and measured the change in test accuracy. For KAR, we replaced a fraction of all CIFAR-10 pixels that were estimated to be least important. We trained 3 CNNs per estimator for each fraction $\\{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \\}$ . We measured test accuracy as the average of theses 3 CNNs. An attribution method is better if it has a lower ROAR AUC and a higher KAR AUC. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 17 presents ROAR scores. All attribution methods outperformed the random baseline in which we randomly removed pixels. RectGrad showed similar performance to local attribution methods but performed worse than all global attribution methods. Next, Figure 18 shows KAR scores. Interestingly, all baseline attribution methods failed to exceed even the random baseline. Only RectGrad had similar or better performance than the random baseline. In Appendix B.2, we offer an explanation for why RectGrad performed poorly in ROAR. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            328,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saliency map is the most basic means of interpreting deep neural network decisions. However, it is often visually noisy. Although several hypotheses were proposed to account for this phenomenon, there is no work that provides a thorough analysis of noisy saliency maps. Therefore, we first identified saliency maps are noisy because DNNs do not filter out irrelevant features during forward propagation. We then proposed RectGrad Gradient which significantly improves saliency maps by alleviating this problem through layer-wise thresholding during backpropagation. We showed that Rectified Gradient generalizes Deconvolution and Guided Backpropagation and moreover, overcomes the class-insensitivity problem. We also demonstrated through extensive experiments that Rectified Gradient outperforms previous attribution methods. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            906
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            108,
+            285,
+            123
+        ],
+        "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, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: A system for largescale machine learning. In Proceedings of the 12th USENIX Conference on Operating Systems Design and Implementation, OSDI’16, pp. 265–283, Berkeley, CA, USA, 2016. USENIX Association. ISBN 978-1-931971-33-1. URL http://dl.acm.org/citation.cfm?id $=$ 3026877.3026899. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marco Ancona, Enea Ceolini, Cengiz Oztireli, and Markus Gross. Towards better understanding ¨ of gradient-based attribution methods for deep neural networks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PLoS ONE, 10(7):1–46, 2015. ISSN 19326203. doi: 10.1371/journal. pone.0130140. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Baehrens, Timon Schroeter, Stefan Harmeling, Motoaki Kawanabe, Katja Hansen, and KlausRobert Muller. How to explain individual classification decisions. ¨ Journal of Machine Learning Research, 11(Jun):1803–1831, 2010. ",
+        "bbox": [
+            176,
+            378,
+            823,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Yoshua Bengio, Aaron Courville, and Pascal Vincent. Visualizing higher-layer features of a deep network. University of Montreal 1341.3, 2009. ",
+        "bbox": [
+            173,
+            434,
+            823,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Striving for simplicity: The all convolutional net. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            171,
+            474,
+            821,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. In ICML Workshop on Human Interpretability in Machine Learning, 2018. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            545
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ALex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregoire Montavon, Sebastian Lapuschkin, Alexander Binder, Wojciech Samek, and Klaus-Robert ´ Muller. Explaining nonlinear classification decisions with deep taylor decomposition. ¨ Pattern Recognition, 65:211–222, 2017. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weili Nie, Yang Zhang, and Ankit Patel. A theoretical explanation for perplexing behaviors of backpropagation-based visualizations. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS Workshop on Autodiff, 2017. ",
+        "bbox": [
+            176,
+            679,
+            823,
+            722
+        ],
+        "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, 115(3):211–252, 2015. ",
+        "bbox": [
+            173,
+            733,
+            825,
+            776
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE transactions on neural networks and learning systems, 28(11):2660–2673, 2017. ",
+        "bbox": [
+            176,
+            789,
+            823,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In The IEEE International Conference on Computer Vision, Oct 2017. ",
+        "bbox": [
+            174,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            173,
+            898,
+            823,
+            926
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In International Conference on Learning Representations Workshop, 2014. ",
+        "bbox": [
+            174,
+            109,
+            825,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. In ICML Workshop on Visualization for Deep Learning, 2017. ",
+        "bbox": [
+            173,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. International Conference on Learning Representations Workshop, 2015. ",
+        "bbox": [
+            174,
+            203,
+            823,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Gradients of counterfactuals. arXiv preprint arXiv:1611.02639, 2016. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            171,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI Conference on Artificial Intelligence, 2017. ",
+        "bbox": [
+            171,
+            338,
+            823,
+            381
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European Conference on Computer Vision, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            171,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            108,
+            401,
+            123
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 SUPPLEMENTARY EXPERIMENT FOR FEATURE MAP OCCLUSION ",
+        "bbox": [
+            173,
+            138,
+            663,
+            154
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/b95f58f6e2a7cc71a7978e187858c5a28d0e48b4ff1f123acbf2761b39bb7e8d.jpg",
+        "image_caption": [
+            "(c) Average of (class logit) − (largest logit among the other 9 classes) as background feature activations are incrementally occluded in a random order (average is taken over 50 random trials). The average is taken over 100 images. The average is illustrated by a solid red line, standard deviation by the shaded blue region, and 10 randomly selected instances by green dotted lines. ",
+            "Figure 9: Larger-scale study of the impact of background feature activation occlusion on the final decision. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            171,
+            820,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To further support our claim that background feature activations are irrelevant to the classification task, we conducted a larger-scale experiment. We created segmentation masks for 10 correctly classified images of each class (total 100 images) and repeated the feature map occlusion for each image. We then took the average of (class logit) − (largest logit among the other 9 classes) across all 100 images. Figures 9a and 9b give an example of a background segmentation mask and a completely occluded feature map. Figure 9c shows that the difference is generally positive throughout the occlusion process, that is, the class does not change for most images. From this, we can infer that background features are generally irrelevant to the classification task. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            867
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 SUPPLEMENTARY EXPERIMENT FOR NOISE ACCUMULATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            109,
+            637,
+            123
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/be530ac5a40f5b3212811c3708dd8303ac483b2ce369350743cb7f404e68b149.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tiger</td><td>Saliency Map</td><td>RectGrad</td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            143,
+            367,
+            200
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a194f812e1a8ef3afe13341fcf68c50679c1103371b04cea7925afdf5401f5fb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            205,
+            820,
+            255
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff67af697b9ad91520510f811d2f8cbafdc13def9c162fa47541ede8a07550b5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            261,
+            818,
+            310
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/75ea27c621f7326742d3dc224beb3fda0cb820ebfb497c0565debbf5d2dffed1.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            327,
+            367,
+            383
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/81354b1debd40de14b70dc21a2adffb53146a6c27f7cfc26128ac280e0417c29.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            388,
+            820,
+            438
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/fce7c0cebeb30301fa1077474f275eb208adf1982e6895189ed796659bea6c67.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            444,
+            818,
+            493
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/668ed407e0bdf8931fd246f3f705f1f7b734da73196a02fc9dacb4c8c6db0b75.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            510,
+            338,
+            558
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9dad4ccc0210c47146d744e90dea044c4acaaaa0ade18b0340c01c9eafcb0d2.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            561,
+            820,
+            611
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/256fe7329d8707ec6bb6e65c9ef7af660275500c12484479bc0578c0187991c3.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            617,
+            818,
+            666
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1af18a83b337877b4377e5505af12af08ce02142ed31245ec014e45fe4739971.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            683,
+            369,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f807aaea7402260d6271801530637840d8a8e66d24a53dc4214f47aa8766017.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            744,
+            818,
+            794
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/76bf3ef94bfe388af24090180e3fa8d213f14938e43f919685850fec558b7c56.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td></td><td>中</td><td>+</td><td>A</td><td>美</td><td>E 中</td><td>山 ■</td></tr></table>",
+        "bbox": [
+            178,
+            800,
+            821,
+            849
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f753ddc54faa630d174173388e51aa61ebb7a9abc166c76703b9238728af6ca.jpg",
+        "image_caption": [
+            "Figure 10: Saliency map and RectGrad attributions at Inception v4 intermediate layers as they are propagated toward the input layer. We show channel-wise average attributions for hidden layer inputs with respect to the output layer. For each subfigure, first row shows the input image and Saliency map and RectGrad attribution maps. Second and third rows show Saliency map and RectGrad attributions at intermediate layers, respectively. An attribution map is closer to the output layer if it is closer to the right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            93,
+            820,
+            455
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To verify our claims on the noise accumulation phenomenon, we compared Saliency map and RectGrad attributions as they are propagated towards the input layer. As Figure 10 shows, at higher layers, Saliency map attributions for objects of interest are generally larger than or equal to attributions on the background. However, as they are propagated towards the input layer, attributions for objects of interest diminish while background attributions grow. On the other hand, RectGrad removes background attributions from higher layers through importance score based thresholding, stopping noise accumulation in the first place. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            679
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 QUALITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            109,
+            418,
+            123
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/dec0b9887c199f5174e2a4aeca8dcbb356617624dcb551a75dec4d524e1b72d3.jpg",
+        "image_caption": [
+            "Figure 11: Evaluation of coherence within the same class (rows) without and with final thresholding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            142,
+            823,
+            386
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d2d74c8c6e46dabef905af385d8be02ba1a8ad83800deb155c66fdd3bad5fec.jpg",
+        "image_caption": [
+            "Figure 12: Comparison of attribution maps for images (left column) and their adversarial examples (right column) without and with final thresholding. This figure shows examples where attribution maps produced by RectGrad did not change significantly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            444,
+            823,
+            686
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c846a8a3f988db84ef3eec5cf002026e1f9e26e5a2466a95535f8eb05c89b3a4.jpg",
+        "image_caption": [
+            "Figure 13: Comparison of amount of attribution on the background. The left and right charts compare the amount of attribution outside mask (on background) without and with final thresholding respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            147,
+            821,
+            343
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ccad8a062180346160947de4eaa8b95149cabf0ec805ffab964a9f4e7791c5c1.jpg",
+        "image_caption": [
+            "Figure 14: Comparison of average total variation. The left and right charts compare average total variation without and with final thresholding respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            436,
+            823,
+            636
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/31871411c118bf3abddb9e25b2ff3615025f4733d61db7f07175ff6354808577.jpg",
+        "image_caption": [
+            "Figure 15: Comparison of Sensitivity. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (patches are randomly removed) for reference. Lower AUC indicates a better attribution method. The red vertical line in the right plot indicates where RectGrad starts to perform worse than baseline global attribution methods (10 patches). We took the average over 500 randomly chosen test set images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            106,
+            818,
+            279
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/238a91b6861d063ec49ddb5fe1333ff355fb702d8acbc3abdf02883bc0228158.jpg",
+        "image_caption": [
+            "Figure 16: Comparison of Sensitivity after final thresholding. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (patches are randomly removed) for reference. Lower AUC indicates a better attribution method. We took the average over 500 randomly chosen test set images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            414,
+            820,
+            588
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/e249aa58bdefd5409c2bb18d6c9a03a66d6db0e9837aa3fabb54f14e736f58b3.jpg",
+        "image_caption": [
+            "Figure 17: Comparison of ROAR. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (pixels are randomly removed) for reference. Lower AUC indicates a better attribution method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            106,
+            823,
+            276
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/e0077851dd47ab6f2e0fd856e69356df6e4a94086032660c55d7cfa2bfe0b07b.jpg",
+        "image_caption": [
+            "Figure 18: Comparison of KAR. The left plot compares RectGrad with local attribution methods and the right plot with with global attribution methods. We also include the random baseline (pixels are randomly removed) for reference. Higher AUC indicates a better attribution method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            369,
+            823,
+            540
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL EXPLANATION FOR QUANTITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            108,
+            738,
+            125
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "B.1 SENSITIVITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            138,
+            308,
+            154
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "In comparison with global attribution methods, RectGrad showed similar performance up to approximately 10 patches (red vertical line) but the performance dropped as more patches were removed (Figure 15). We speculate this happens due to the sparseness of RectGrad attribution maps. Since RectGrad attribution maps are sparser than those of other methods, occluding approximately 10 features will be enough to remove core features highlighted by RectGrad. Attributions for other features will not be as informative since they have trivial values. Figure 19 shows that it is indeed the case. For RectGrad, after occluding 10 top $2 \\times 2$ patches, only attributions of small values remained. For Gradient \\* Input, on the other hand, still had significant amount of nontrivial leftover attributions. We also see from Figure 16 that this phenomenon also happens for baseline methods with final thresholding. This implies that such behavior may be an inevitable consequence of sparseness. ",
+        "bbox": [
+            173,
+            165,
+            825,
+            304
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/0efa1572ca2ccc7fdaa18d838adbd6033bee1d55b724a58ecf074ac0d8325f7d.jpg",
+        "image_caption": [
+            "Figure 19: Comparison of attribution methods in sensitivity. The first row shows the image as top N $2 \\times 2$ patches are occluded according to RectGrad. The second and third rows show the positive parts (indicated by $+$ ) of RectGrad and Gradient \\* Input attribution maps as top $N \\ : 2 \\times 2$ patches are occluded respectively. We did not cap outlying values in this visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            320,
+            823,
+            493
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "B.2 ROAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            109,
+            264,
+            123
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "We believe that the poor performance of RectGrad in ROAR is also due to its sparseness. Since RectGrad produces visually coherent attribution maps, the occluded regions can act as discriminative features. To verify this, we replaced $1 0 \\%$ of all CIFAR-10 pixels that were estimated to be most important with the channel-wise mean. We then trained a CNN on the occluded dataset and visualized RectGrad attribution maps for images whose original and occluded versions were both classified correctly. Figure 20 shows the results. Attribution maps highlighted pixels around the occluded regions and moreover, similar regions were emphasized in the original image. This corroborates our claim that the occluded regions act as discriminative features. The assumption behind ROAR is that the occluded features do not influence the classification task (Hooker et al., 2018). Since the above observation contradicts this assumption, ROAR may not be suitable for objectively evaluating RectGrad. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            287
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a87e8f787e88874f751ebec957816b9d2a35bdd0b5391694043ce6213d265a1.jpg",
+        "image_caption": [
+            "Figure 20: RectGrad attribution maps produced from a CNN trained on images occluded according to RectGrad. We show images whose original and occluded versions were both classified correctly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            306,
+            823,
+            458
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "C USEFUL TECHNIQUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            392,
+            546
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Here, we present two useful techniques that can enhance the visual quality of attribution maps produced by RectGrad. ",
+        "bbox": [
+            176,
+            563,
+            821,
+            590
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "C.1 PADDING TRICK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            331,
+            622
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Convolution inputs are typically zero padded along the border in order to preserve the spatial dimension of feature maps.3 This occasionally leads to high activation values along the border if zero is out of input distribution. Since importance scores are calculated by multiplying activation with gradient, outlying border activation can cause RectGrad to be propagated through the border instead of relevant features. To solve this problem, we masked the border of gradient to zero before the backward pass through convolutions with padding. One possible concern with the padding trick is that attributions may be faint for features adjacent to the border of the image. However, we did not find this to be a significantly problem experimentally. Listing 2 in Appendix D.2 shows how to implement the padding trick in TensorFlow. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            760
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "C.2 PROPORTIONAL REDISTRIBUTION RULE (PRR) FOR POOLING LAYERS. ",
+        "bbox": [
+            176,
+            777,
+            707,
+            791
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Attribution maps produced by RectGrad tend to be rough due to the discrete nature of thresholding. This discontinuity can be compensated by using the proportional redistribution rule proposed by Montavon et al. (2017) for the backward pass through max-pooling layers. Instead of propagating the gradient through only the most activated unit in the pool, gradient is redistributed proportional to unit activations. Since the redistribution operation is continuous, attribution maps generated with the proportional redistribution rule are smoother. Listing 3 in Appendix D.3 shows how to implement the proportional redistribution rule in TensorFlow. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            901
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "D TENSORFLOW CODES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            108,
+            393,
+            125
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "D.1 IMPLEMENTATION OF RECTIFIED GRADIENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            527,
+            154
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "1 import tensorflow as tf   \n2   \n3 from tensorflow.contrib.distributions import percentile   \n4   \n5 @tf.RegisterGradient(\"RectifiedRelu\")   \n6 def _RectifiedReluGrad(op, grad):   \n7   \n8 def threshold(x, q):   \n9   \n10 if len(x.shape.as_list()) $> 3$ :   \n11 thresh $=$ percentile(x, q, axis $=$ [1,2,3], keep_dims $=$ True)   \n12 else:   \n13 thresh $=$ percentile(x, q, axis $^ { = 1 }$ , keep_dims $=$ True)   \n14   \n15 return thresh   \n16   \n17 activation_grad $=$ op.outputs[0] $\\star$ grad   \n18 thresh $=$ threshold(activation_grad, q)   \n19   \n20 return tf.where(thresh $<$ activation_grad, grad, tf.zeros_like(grad)) ",
+        "bbox": [
+            156,
+            164,
+            821,
+            417
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "Listing 1: Implementation of Rectified Gradient in TensorFlow. After registering this function as the gradient for ReLU activation functions, call tf.gradients() and multiply with inputs to generate attributions. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            463
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "D.2 IMPLEMENTATION OF THE PADDING TRICK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            482,
+            517,
+            496
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "import tensorflow as tf   \n2   \n3 @tf.RegisterGradient(\"RectifiedConv2D\")   \n4 def _RectifiedConv2DGrad(op, grad):   \n5   \n6 if op.get_attr(’padding’) $= =$ b’SAME’:   \n7   \n8 shape $=$ tf.shape(grad)   \n9 mask $=$ tf.ones([shape[0], shape[1] - 2, shape[2] - 2, shape[3]])   \n10 mask $=$ tf.pad(mask, [[0,0],[1,1],[1,1],[0,0]])   \n11 grad $=$ grad $\\star$ mask   \n12   \n13 input_grad $=$ tf.nn.conv2d_backprop_input(tf.shape(op.inputs[0]), op.   \ninputs[1], grad, op.get_attr(’strides’), op.get_attr(’padding’))   \n14 filter_grad $=$ tf.nn.conv2d_backprop_filter(op.inputs[0], tf.shape(op.   \ninputs[1]), grad, op.get_attr(’strides’), op.get_attr(’padding’))   \n15   \n16 return input_grad, filter_grad ",
+        "bbox": [
+            156,
+            508,
+            820,
+            736
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "Listing 2: Implementation of the padding trick in TensorFlow. After registering this function as the gradient for convolution operations, call tf.gradients() and multiply with inputs to generate attributions. ",
+        "bbox": [
+            171,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "D.3 IMPLEMENTATION OF THE PROPORTIONAL REDISTRIBUTION RULE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            109,
+            681,
+            125
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "1 import tensorflow as tf   \n2   \n3 from tensorflow.python.ops import gen_nn_ops   \n4   \n5 @tf.RegisterGradient(\"RectifiedMaxPool\")   \n6 def _RectifiedMaxPoolGrad(op, grad):   \n7   \n8 $_ { \\textrm { } \\textrm { } \\textrm { } \\textrm { } } \\textrm { } \\textrm { }$ tf.nn.avg_pool(op.inputs[0], op.get_attr(’ksize’), op.get_attr(’   \nstrides’), op.get_attr(’padding’)) $^ +$ 1e-10   \n9 $_ { \\textrm { { S } } } =$ grad / z   \n10 $\\mathbf { \\Sigma } _ { \\subset } ~ =$ gen_nn_ops._avg_pool_grad(tf.shape(op.inputs[0]), s, op.get_attr(   \n’ksize’), op.get_attr(’strides’), op.get_attr(’padding’))   \n11   \n12 return op.inputs[0] \\* c ",
+        "bbox": [
+            160,
+            135,
+            820,
+            313
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "E PROOF OF CLAIMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            364,
+            395
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "E.1 PROOF OF CLAIM 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            351,
+            424
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "Proof. Note that the backward propagation rule for Deconvolution through the ReLU nonlinearity is given by ",
+        "bbox": [
+            173,
+            435,
+            823,
+            464
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1573f2e7bb1b4bead7945d569812a5cf942fcd41229b6400a68ba3883f22ba4e.jpg",
+        "text": "$$\nR _ { i } ^ { ( l ) } = \\mathbb { I } \\left( R _ { i } ^ { ( l + 1 ) } > 0 \\right) \\cdot R _ { i } ^ { ( l + 1 ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            462,
+            606,
+            489
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "Since the DNN uses ReLU activation functions, $a _ { i } ^ { ( l ) } + \\epsilon > 0$ and therefore ",
+        "bbox": [
+            176,
+            493,
+            663,
+            511
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1da472b36b08511356e3465d6624ae429a26c58f36175b3584affc40c8beff4b.jpg",
+        "text": "$$\n\\mathbb { I } \\left[ \\left( a _ { i } ^ { ( l ) } + \\epsilon \\right) \\cdot R _ { i } ^ { ( l + 1 ) } > 0 \\right] = \\mathbb { I } \\left( R _ { i } ^ { ( l + 1 ) } > 0 \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            517,
+            653,
+            545
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "for all $l$ and $i$ . The result follows from Equation 2. ",
+        "bbox": [
+            173,
+            550,
+            504,
+            565
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "E.2 PROOF OF CLAIM 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            352,
+            597
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "Proof. Note that the backward propagation rule for Guided Backpropagation through the ReLU nonlinearity is given by ",
+        "bbox": [
+            173,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ae8ce6ed13c4523050d65242e1776ff64d4d25c3ece8dcad5bf9fa54ecade89.jpg",
+        "text": "$$\nR _ { i } ^ { ( l ) } = \\mathbb { I } \\left( z _ { i } ^ { ( l ) } > 0 \\right) \\cdot \\mathbb { I } \\left( R _ { i } ^ { ( l + 1 ) } > 0 \\right) \\cdot R _ { i } ^ { ( l + 1 ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            642,
+            653,
+            670
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "Since the DNN uses ReLU activation functions, $a _ { i } ^ { ( l ) } \\geq 0$ and therefore ",
+        "bbox": [
+            174,
+            679,
+            637,
+            696
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58a2a400de33bff42043bd200b25baf423c2915ea2d54d292401070545cc9111.jpg",
+        "text": "$$\n\\mathbb { I } \\left( a _ { i } ^ { ( l ) } \\cdot R _ { i } ^ { ( l + 1 ) } > 0 \\right) = \\mathbb { I } \\left( z _ { i } ^ { ( l ) } > 0 \\right) \\cdot \\mathbb { I } \\left( R _ { i } ^ { ( l + 1 ) } > 0 \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            702,
+            678,
+            729
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "for all $l$ and $i$ . The result follows from Equation 4. ",
+        "bbox": [
+            173,
+            736,
+            504,
+            751
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "F EXPERIMENTS SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            107,
+            388,
+            125
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "F.1 ATTRIBUTION MAP VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            138,
+            465,
+            154
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "To visualize the attributions, we summed up the attributions along the color channel and then capped low outlying values to $0 . 5 ^ { \\mathrm { t h } }$ percentile and high outlying values to $9 9 . 5 ^ { \\mathrm { t h } }$ percentile for RGB images. We only capped outlying values for grayscale images. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            207
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "F.2 CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            290,
+            238
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) was pre-processed to normalize the input images into range $[ - 1 ; 1 ]$ . We trained a CNN using ReLU activation functions with Adam for 20 epochs to achieve $7 9 . 4 \\%$ test accuracy. For the dataset occluded with the random patch, we used the same settings to achieve $7 9 . 3 \\%$ test accuracy. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            306
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7bdc83da3f8a9c46696ed5d7b0da28db9f2e3077ede4f65e1deb7ae69d221b9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>CIFAR-10 CNN</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3,32 kernels)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3,32 kernels)</td></tr><tr><td rowspan=1 colspan=1>Max-pooling (2 × 2)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.25)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3, 64 kernels)</td></tr><tr><td rowspan=1 colspan=1>Conv 2D (3 × 3, 64 kernels)</td></tr><tr><td rowspan=1 colspan=1>Max-pooling (2 × 2)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.25)</td></tr><tr><td rowspan=1 colspan=1>Dense (256)</td></tr><tr><td rowspan=1 colspan=1>Dropout (0.5)</td></tr><tr><td rowspan=1 colspan=1>Dense (10)</td></tr></table>",
+        "bbox": [
+            393,
+            320,
+            602,
+            527
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "F.3 INCEPTION V4 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            541,
+            318,
+            558
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "We used a pre-trained Inception V4 network. The details of this architecture can be found in Szegedy et al. (2017). For the adversarial attack, we used the fast gradient sign method with $\\epsilon = 0 . 0 1$ . ",
+        "bbox": [
+            173,
+            568,
+            823,
+            598
+        ],
+        "page_idx": 23
+    }
+]

parse/train/WtmMyno9Tq2/WtmMyno9Tq2.md

@@ -0,0 +1,253 @@
+# Multimodal Few-Shot Learning with Frozen Language Models
+
+Maria Tsimpoukelli∗ DeepMind mrts@deepmind.com
+
+Serkan Cabi∗ DeepMind cabi@deepmind.com
+
+Jacob Menick∗   
+DeepMind   
+University College London   
+jmenick@deepmind.com
+
+# S. M. Ali Eslami
+
+Oriol Vinyals DeepMind vinyals@deepmind.com
+
+DeepMind aeslami@deepmind.com
+
+Felix Hill DeepMind felixhill@deepmind.com
+
+# Abstract
+
+When trained at sufficient scale, auto-regressive language models exhibit the notable ability to learn a new language task after being prompted with just a few examples. Here, we present a simple, yet effective, approach for transferring this few-shot learning ability to a multimodal setting (vision and language). Using aligned image and caption data, we train a vision encoder to represent each image as a sequence of continuous embeddings, such that a pre-trained, frozen language model prompted with this prefix generates the appropriate caption. The resulting system is a multimodal few-shot learner, with the surprising ability to learn a variety of new tasks when conditioned on examples, represented as a sequence of multiple interleaved image and text embeddings. We demonstrate that it can rapidly learn words for new objects and novel visual categories, do visual question-answering with only a handful of examples, and make use of outside knowledge, by measuring a single model on a variety of established and new benchmarks.
+
+# 1 Introduction
+
+Auto-regressive transformers have been shown to be very impressive models of natural language [42]. Large-scale language transformers exhibit several surprising abilities beyond that of standard text generation [4, 31]. Perhaps most notably, they are few-shot learners; they can learn to perform a new task from a few examples without any further gradient updates. Equipped with this ability, these models have been shown to rapidly adapt to new tasks and styles of generation via prompting (e.g. switching from formal to informal language) [4], to retrieve relevant encyclopedic or general knowledge when primed with a relevant context (e.g. answering questions such as ‘When did the French Revolution begin?’) [34, 1, 28] and to use new words in appropriate ways straight after being taught what those words mean (sometimes referred to as ‘fast binding’) [12, 4].
+
+Despite these impressive capabilities, such large scale language models are ‘blind’ to modalities other than text, preventing us from communicating visual tasks, questions or concepts to them. Indeed, philosophers and linguists have questioned whether an un-grounded language model can ever achieve true understanding of the language it processes [5, 2]. Here, we present Frozen, a method for giving a pre-trained language model access to visual information in a way that extends its few-shot learning capabilities to a multimodal setting, without changing its weights. Frozen consists of a neural network trained to encode images into the word embedding space of a large pre-trained language model such that the language model generates captions for those images. The weights of the language model are kept frozen, but gradients are back-propagated through it to train the image encoder from scratch (Figure 2). Although Frozen is trained on single image-text pairs, once trained it can respond effectively to interleaved sequences of multiple images and text. This allows users to ‘prompt’ it with several examples of new multimodal tasks before evaluating its performance, or to ‘teach’ it the name of a new visual category before immediately asking about that category.
+
+![](images/acf5dae286c39fb8ccc2f2a653240478bf311b93577d21856222b9d240d7a89c.jpg)  
+Figure 1: Curated samples with about five seeds required to get past well-known language model failure modes of either repeating text for the prompt or emitting text that does not pertain to the image. These samples demonstrate the ability to generate open-ended outputs that adapt to both images and text, and to make use of facts that it has learned during language-only pre-training.
+
+By exploiting its pre-trained language model, Frozen exhibits nontrivial zero-shot performance on multimdodal tasks that it was not trained on, such as visual question answering (VQA). More surprisingly, it gets better at these tasks after seeing a handful of examples ‘in-context’ as in [4], and also performs above chance on tests of fast category learning such as miniImageNet [43]. In each case, comparisons with ‘blind’ baselines show that the model is adapting not only to the language distribution of these new tasks, but also to the relationship between language and images. Frozen is therefore a multimodal few-shot learner, bringing the aforementioned language-only capabilities of rapid task adaptation, encyclopedic knowledge and fast category binding to a multimodal setting.
+
+![](images/0f2404f4ab104428508fcfe3991e62e8eb09d80e537d1d39962aaffdb00fe1bd.jpg)  
+Figure 2: Gradients through a frozen language model’s self attention layers are used to train the vision encoder.
+
+Our goal in developing Frozen was not to maximise performance on any specific task, and in many cases it is far from state-of-the-art. Nonetheless, it performs well above trivial baselines across a wide range of tasks without ever seeing more than a handful of the training examples provided by these benchmarks. Moreover, as illustrated in Figure 1, Frozen is a system for genuinely open-ended and unconstrained linguistic interpretation of images that often produces compelling output.
+
+![](images/a5d8d10e6b2c45febfdd36f6abf48a41a9926d3309d27e3a788571806f955616.jpg)  
+Figure 3: Inference-Time interface for Frozen. The figure demonstrates how we can support (a) visual question answering, (b) outside-knowledge question answering and (c) few-shot image classification via in-context learning.
+
+To summarise, our contributions are as follows: 1. We present Frozen, a modular, scalable and efficient approach to training vision front-ends for large language models. The resulting combined model retains all of the capabilities of large language models, but can also process text and image inputs in any arbitrary sequence. 2. We show that such models transfer their capacity for rapid task adaptation, encyclopedic knowledge and fast category binding from a language-only to a multimodal setting, and verify that prompting them with both visual and language information can be strictly more effective than doing so with language information alone. 3. We quantify these capabilities on a range of existing and new benchmarks, paving the way for future analysis of these capabilities.
+
+# 2 Related Work
+
+The Frozen method is inspired by lots of recent work. [26] show that the knowledge encoded in transformer language models can be a valuable prior for tasks involving reasoning and memory across discrete sequences, and even classification of images presented as sequences of spatial regions. In that approach, a small subset of the pre-trained language model weights are fine-tuned to the various final applications. In contrast, applying Frozen to different tasks does not involve any weight updates to the transformer whatsoever; the system adapts to and improves at multimodal (vision and language) tasks as activations propagate through the model. The two studies thus reveal different ways in which knowledge acquired from text can transfer to non-linguistic settings.
+
+The effectiveness of prefix tuning [23] or prompt tuning [20] was another important motivation for Frozen. Prefix tuning is a method for prompting a language model to produce output of a particular style using gradient descent to learn a task-specific bias term which functions like the continuous embedding of a text prompt. Using prefix tuning, language models can be adapted to different natural language generation tasks like summarization. Frozen could also be considered a type of image-conditional prefix tuning, in which this continuous prefix is not a bias but an image-conditional activation produced by an external neural network.
+
+Learning to embed image representations into the ‘word’ space of a large pretrained language model was done previously by [16]. This work focused on image-text classification, and uses a BERT-style language model that is fine-tuned (rather than frozen) on multimodal data. [36] extend a similar image embedding+BERT system to create a generative model of text, using a pre-trained object extraction system to embed images into word space. Neither of these studies consider the problem of learning image-text correspondences in a few shots.
+
+A large body of work has applied either text-specific or multimodal representation-learning approaches like BERT [8] to visual question answering (VQA) and captioning (see e.g. [25, 40] and many more). In these approaches, models are first trained with aligned data on task-agnostic cross-modal objectives and then fine-tuned to specific tasks. This approach can yield state-of-the-art performance on a range of classification tasks. Unlike Frozen, the resulting systems are highly specialized to one task, and cannot learn new categories or adapt to new tasks in a few shots.
+
+By contrast, [7] propose text generation as an objective for task-general multimodal models, yielding a system that, like Frozen, produces unconstrained language output. Unlike Frozen, they do not use a pre-trained model trained on text only, and do not consider zero or few-shot learning, instead updating all weights of the system with training data for each task they consider – thus, again, specializing the models to one task at a time. Similarly, [46] and [6] show that a large pre-trained language model as decoder can improve a captioning performance when training data is limited. Unlike Frozen, they use pre-trained frozen visual encoders or object extractors and fine-tune the pre-trained weights in the text decoder on the captioning data. Similarly, they do not consider zero or few-shot adaptation across different multimodal tasks. Past work has also explored alternative approaches for post-hoc combination of models for different modalities using latent variables [41].
+
+Multimodal pre-training has recently been shown to enable strong zero-shot generalization in the discriminative setting using large-scale contrastive learning [29, 14]. Also in a discriminative setting, [45] has observed signs of emergent few-shot-learning from large-scale training. In contrast, our work enables strong generalization to new multimodal tasks both zero-shot or few-shot with completely open-ended generative text output.
+
+# 3 The Frozen Method
+
+Frozen is a method for grounding a large language model without changing its weights, closely related to prefix tuning [23, 20]. Prefix tuning trains a task-specific continuous bias term to function like the embedding of a constant, static text prompt used for all test-time examples. Frozen extends this approach by making this prefix dynamic, in that it is not a constant bias but an input-conditional activation emitted by a neural network.
+
+# 3.1 Architecture
+
+Pre-trained Autoregressive Language Models Our method starts from a pre-trained deep autoregressive language model, based on the Transformer architecture [42, 30], which parametrizes a probability distribution over text y. Text is decomposed into a sequence of discrete tokens $\mathbf { y } = y _ { 1 } , y _ { 2 } , . . . , y _ { L }$ by the SentencePiece tokenizer [18]. We use a vocabulary of size 32,000. The language model makes use of an embedding function $g _ { \theta }$ which independently transforms each token into a continuous embedding $t _ { l } : = g _ { \theta } ( y _ { l } )$ , as well as a transformer neural network $f _ { \theta }$ whose output is a vector of logits parameterizing a categorical distribution over the vocabulary. The distribution $p _ { \boldsymbol { \theta } } ( \mathbf { y } )$ is represented as follows:
+
+$$
+\log p _ { \theta } ( \mathbf { y } ) = \sum _ { l } \log p _ { \theta } ( y _ { l } | y _ { 1 } , y _ { 2 } , . . . , y _ { l - 1 } ) = \sum _ { l } f _ { \theta } ( t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } }
+$$
+
+The model we start from is pre-trained, i.e. $\theta$ has been optimised via the standard maximum-likelihood objective on a large dataset of text from the internet. We use a 7 billion parameter transformer trained on the public dataset C4 [31] – previous work has shown that the multi-billion parameter scale is sufficient to exhibit the key capacities we are interested in studying [30, 34].
+
+Vision Encoder Our vision encoder is based on NF-ResNet-50 [3]. We define $v _ { \phi }$ as a function that takes a raw image and emits a continuous sequence to be consumed by the transformer. We use the final output vector of the NF-Resnet after the global pooling layer.
+
+Visual Prefix One important requirement is to represent images in a form that the transformer already understands: a sequence of continuous embeddings, each having the same dimensionality $D$ as a token embedding $t _ { l }$ . We therefore form the visual prefix by linearly mapping the vision encoder’s output to $D * k$ channels, and then reshaping the result as a sequence of $k$ embeddings, each with dimensionality $D$ . We call this sequence a visual prefix since it plays the same functional role in the transformer architecture as (part of) an embedding sequence of prefix tokens. We experimented using different number of tokens $k$ , specifically 1, 2 and 4 and found that 2 performs best, though certainly this would be sensitive to other architectural details. See Appendix for more details on the architecture.
+
+# 3.2 Training
+
+During training, we update only the parameters $\phi$ of the vision encoder using paired image-caption data from the Conceptual Captions dataset [37]. Our experiments show that fine-tuning $\theta$ hurts generalization, as much less paired image-caption data is available than the amount of text-only data used to pre-train $\theta$ . Training only the parameters $\phi$ makes our system modular – it can use an existing language model off the shelf – and also quite simple: we only train a visual encoder and rely on the capabilities of an existing language model.
+
+Following standard captioning systems [22, 13], we treat captioning as conditional generation of caption text $\mathbf { y }$ given an image $\mathbf { x }$ . We represent $\mathbf { x }$ as $v _ { \phi } ( \mathbf { x } ) = i \bar { 1 } , i _ { 2 } , . . . , \bar { i } _ { n }$ and train $\phi$ to maximise the likelihood:
+
+$$
+\begin{array} { c } { { \log p _ { \theta , \phi } ( { \bf y } | x ) = \displaystyle \sum _ { l } \log p _ { \theta , \phi } ( y _ { l } | { \bf x } , y _ { 1 } , y _ { 2 } , . . . , y _ { l - 1 } ) } } \\ { { { } } } \\ { { = \displaystyle \sum _ { l } f _ { \theta } ( i _ { 1 } , i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } } } } \end{array}
+$$
+
+Whilst the parameters $\theta$ are frozen, each element $i _ { k }$ of the visual prefix receives gradients $\sum _ { l } \nabla _ { i _ { k } } f _ { \theta } ( i _ { 1 } \dot { , } i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } }$ , enabling the parameters of the visual encoder to be optimised with standard backpropagation and SGD (Figure 2).
+
+As the notation $f _ { \theta } ( i _ { 1 } , i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } )$ suggests, we present the visual prefix during training as if it were a sequence of embeddings occurring earlier in time than the caption (token embeddings) $t _ { 1 } , t _ { 2 } , \ldots$ . We use relative positional encoding [38], which enables the transformer to generalize to prefix sequences where an image is not always in the first absolute positions, and where more than one image may be present. In particular, we use the version of relative attention described in transformerxlDai.We leave improvements of this simple scheme for future work.
+
+# 3.3 Interface at Inference Time
+
+At inference time, a vanilla language model, conditioned upon an arbitrary text prompt $y _ { 1 } , y _ { 2 } , . . . , y _ { p }$ , generates text sequences $y _ { p + 1 } , y _ { p + 2 } , . . .$ autoregressively. In Frozen it is straightforward to include images in such prompt by placing an image’s embedding $i _ { 1 } , i _ { 2 }$ as a prefix to a text embedding subsequence $t _ { 1 } , t _ { 2 } , . . . , t _ { p }$ . Because the transformer $f _ { \theta }$ is modality-agnostic, we can interleave a sub-sequence of text token embeddings with a sub-sequence of image embeddings in any arbitrary order. In Figure 3, we show how this can support zero-shot visual question-answering (Figure 3a), few-shot visual question-answering (Figure 3b), and few-shot image classification (Figure 3c).
+
+To evaluate these tasks, the model decodes output sequences greedily and these outputs are compared against the ground truth answers of the task following the normalization technique used in [19]. To probe the open-ended capabilities of Frozen, we decided not to use common practice of short-lists of pre-canned answers, even though in some tasks this may hurt its performance in accuracy percentages.
+
+# 3.4 Few-Shot Learning Definitions
+
+The ability of Frozen to be conditioned on a sequence of interleaved images and text allows it not only to be able to perform different multimodal tasks, but also gives rise to different ways of ‘inducing’ the task to the model in order to improve its performance. We briefly define the terminology used in our settings, common amongst all the different tasks. See Figure 5 in the appendix for a visual illustration of these concepts.
+
+• Task induction Explanatory text that precedes the sequence of images and text. It is intended to describe the task to the model in natural language, for example ‘Please answer the question.’ Number of shots The number of distinct full examples of the task presented to the model prior to the evaluated example. For example, in Visual Question-Answering, a shot is an image along with the question and the answer.
+
+For tasks involving fast category binding (e.g., few-shot image classification), we define further specific terminology. See also Figure 4a and Figure 6 in the appendix.
+
+• Number of ways The number of object classes in the task (e.g. dog vs cat).   
+• Number of inner-shots The number of distinct exemplars from each category that are presented to the model (i.e. number of images of different dogs). In previous work with MiniImagenet, these were known as shots, but we modify the term here to distinguish from the more general usage of the term described above. Number of repeats The number of times each inner-shot is repeated in the context presented to the model. We use this setting as an ablation to explore how the model integrates visual information about a category.
+
+# 4 Experiments: A Multi-Modal Few-Shot Learner
+
+Our experiments are designed to quantify three capacities that should be characteristic of a MultiModal Few-Shot Learner: rapid adaptation to new tasks, fast access to general knowledge and fast binding of visual and linguistic elements. We train Frozen on Conceptual Captions, a public dataset that consists of around three million image-caption pairs [37]. We do early stopping on the validation set perplexity which usually reaches an optimum just after a single epoch with batch size 128. All experiments used the Adam optimizer with $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 5$ and a constant learning rate of $3 e$ -4 unless otherwise noted. We operate on $2 2 4 \times 2 2 4$ images at both train and test-time. Images which are not square are first padded with zeroes to square and then resized to $2 2 4 \times 2 2 4$ .
+
+Table 1: Transfer from Conceptual Captions to VQAv2. The $\tau$ column indicates whether a model uses training data from the VQAv2 training set. The row denoted Frozen train-blind is the blind baseline described in subsection 4.1. Frozen VQA is a baseline which mixes in VQAv2 training data.   
+
+<table><tr><td rowspan=1 colspan=1>n-shot Acc.     1</td><td rowspan=1 colspan=1>n=0</td><td rowspan=1 colspan=1>n=1</td><td rowspan=1 colspan=1>n=4</td><td rowspan=1 colspan=1>T</td></tr><tr><td rowspan=2 colspan=1>FrozenFrozen seratchFrozen finetunedFrozen train-blind</td><td rowspan=2 colspan=1>29.50.024.026.2</td><td rowspan=1 colspan=1>35.7</td><td rowspan=2 colspan=1>38.20.029.233.3</td><td rowspan=2 colspan=1>xxxx</td></tr><tr><td rowspan=1 colspan=1>0.028.233.5</td></tr><tr><td rowspan=1 colspan=1>Frozen vQAFrozen vQA-blind</td><td rowspan=1 colspan=1>48.439.1</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1√</td></tr><tr><td rowspan=1 colspan=1>Oscar [24]     1</td><td rowspan=1 colspan=1>173.8</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1  【</td><td rowspan=1 colspan=1>【</td></tr></table>
+
+Table 2: Transfer from Conceptual Captions to OKVQA. The $\tau$ column indicates if a model uses training data from the OKVQA training set. Frozen does not train on VQAv2 except in the baseline row, and it never trains on OKVQA.   
+
+<table><tr><td rowspan=1 colspan=1>n-shot Acc.     1</td><td rowspan=1 colspan=1>n=0</td><td rowspan=1 colspan=1>n=1</td><td rowspan=1 colspan=1>n=4</td><td rowspan=1 colspan=1>T</td></tr><tr><td rowspan=3 colspan=1>FrozenFrozen 400mLMFrozen finetunedFrozen train-blind</td><td rowspan=1 colspan=1>5.9</td><td rowspan=1 colspan=1>9.7</td><td rowspan=1 colspan=1>12.6</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=2 colspan=1>4.04.23.3</td><td rowspan=1 colspan=1>5.9</td><td rowspan=2 colspan=1>6.64.60.0</td><td rowspan=2 colspan=1>xxxx</td></tr><tr><td rowspan=1 colspan=1>4.17.2</td></tr><tr><td rowspan=1 colspan=1>Frozen vQAFrozen vQA-blind</td><td rowspan=1 colspan=1>19.612.5</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>××</td></tr><tr><td rowspan=1 colspan=1>MAVEx 44]   三</td><td rowspan=1 colspan=1>39.4</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=2>1  √</td></tr></table>
+
+# 4.1 Rapid Task Adaptation
+
+We first examine zero-shot and few-shot generalization from captioning to visual question-answering. This is a type of rapid adaptation from captioning behaviour to question-answering behaviour analogous to transfer from language modelling to open-domain question-answering in the text-only setting [34]. We evaluate on the VQAv2 [10] validation set.
+
+Zero-shot transfer from captioning to VQA We first observe that a version of our model in which the ability to embed images into a prefix is trained solely with a captioning objective can transfer moderately well to visual question-answering in the zero-shot setting, with no specific training towards that goal. We simply have to provide the system with an image and a textual prompt of the form Question: what colour is the dog sitting on the grass? Answer:, then observe how it completes the prompt. The ability to adapt to input of this form is presumably transferred from the training data of the pretrained language model component of the system.
+
+The strength of the pre-trained language model in the system is a double-edged sword. It powers the generalization abilities of Frozen but also enables the model to perform surprisingly well without considering the visual input at all. To guard against this possibility we also train blind baselines, in which the image presented to the visual encoder is blacked out, but the convnet weights are still trained (see Table 1). This amounts to prefix tuning [23]. We outperform this blind baseline which also inherits the few-shot learning abilities of the language model.
+
+In these experiments we also include two additional and important baselines: Frozen finetuned in which the language model is instead finetuned starting from the pretrained weights and Frozen scratch, wherein the whole system is trained from scratch end-to-end, both using the same dataset as Frozen. These baselines preferred a smaller learning rate of 1e-5. Results in Table 1 show that keeping the language model frozen generalizes substantially better to visual question-answering than finetuning. The model trained from scratch is not able to transfer at all from captioning to VQA; we interpret this to suggest that the tremendous generalization abilities of large language models are reliant upon large-scale training datasets in which the task of predicting the next token mimics the test setting (here question-answering) with non-negligible frequency.
+
+Improving performance with few-shot learning More importantly, for the present work, we observe that the ability of the model to transfer knowledge from captioning and text-modelling to visual question-answering improves if the model is presented with several examples of VQA data sequentially. We repeat the previous experiments with up to four examples of image-question-answer triples shown to the model as conditioning information in the continuous prefix sequence (using the interface in Figure 3).
+
+![](images/b3010e3cdc0d12c619e82d96167a277bfc023da41e63bfe21fe059edde7b6fa2.jpg)  
+Figure 4: Examples of (a) the Open-Ended miniImageNet evaluation (b) the Fast VQA evaluation.
+
+These results are presented in Table 1. For contrast, we compare this performance to a condition in which we mix in some data from the VQAv2 training set with the captioning data. As we might expect, few-shot learning on four examples is outperformed by SGD on tens of thousands of examples, but few-shot performance clearly improves with more examples, and goes some way $( 3 8 . 2 \% )$ toward closing the gap from zero-shot performance $( 2 9 . 5 \% )$ to full SGD training performance $( 4 8 . 4 \% )$
+
+There are two important takeaways from the results presented in this section. First, they show that training a visual encoder through a pretrained and frozen language model results in a system capable of strong out-of-distribution (zero-shot) generalization. Second, they confirm that the ability to rapidly adapt to new tasks given appropriate cntext is inherited from the pretrained language model and transfers directly to multimodal tasks.
+
+# 4.2 Encyclopedic Knowledge
+
+Here we study the extent to which Frozen can leverage the encyclopedic knowledge in the language model towards visual tasks. The Conceptual Captions dataset is hypernymed (e.g. proper names are replaced with a general word like person). This enables us to rigorously study the transfer of factual knowledge because all knowledge of named entities comes from language model pretraining.
+
+Consequently, when we show the model an image of an airplane and ask “who invented this?” (Figure 1), the visual encoder has determined that the image contains an airplane, and the language model has used this to retrieve the factual knowledge that airplanes were invented by the Wright brothers, a fact which is referenced in the C4 training set through (text-only) articles about airplanes. This is a fascinating chain of deduction. A detailed analysis of this behaviour with more examples is included in the Appendix (e.g. Figure 9, Figure 10, Figure 11).
+
+We bolster this finding quantitatively by evaluating performance on OKVQA [27], a visual questionanswering dataset designed to require outside knowledge in order to answer correctly. The pretrained language model’s command of factual knowledge is of course dependent upon its scale, so we examine the performance of Frozen using pretrained language models of varying sizes: the base model with 7 billion parameters, and a much smaller 400 million parameter language model pretrained on the same dataset. Table 2 shows the results: task performance scales with model size. Again finetuning performs worse than leaving the model frozen in terms of generalization performance. We stress that Frozen is never trained on OKVQA.
+
+# 4.3 Fast Word-to-Visual-Category Binding
+
+In the multi-modal setting, fast-binding refers to a model’s ability to associate a word with a visual category in a few shots and immediately use that word in an appropriate way.
+
+Open-Ended miniImageNet and Real-Name miniImageNet To quantify the fast-binding capacity of of Frozen, we evaluate it on the miniImageNet meta-learning task [43]. Note that there are important differences with how we attempt miniImageNet and how it is approached in previous work. First, unlike standard meta-learning, we do not train Frozen on the (meta) task. Second, we evaluate Frozen in an open-ended fashion, where it must successfully generate a correct category name (and then the EOS token) in order to be credited with a correct answer. Finally, although we use the same image classes as the miniImageNet test set, they are at higher resolution $( 2 2 4 \times 2 2 4 )$ and with integer class labels [0, 1] replaced with nonsense words (‘dax’, ‘blicket’ etc). We make this adjustment because the nonsense words should have no (or less) intrinsic meaning to the language model than integers, whose relative order (for instance) should have been reflected in a massive text training corpus. We refer to this task as Open-Ended miniImageNet. To assess how much difficulty is added by binding visual categories to nonsense words versus simply adapting to an image recognition task per se, we also consider a version – Real-Name miniImagenet – in which visual categories in both the support set and the answer retain their original names. See Figure 4a for an illustration.
+
+On both versions of this evaluation, we experiment by exposing the model to different numbers of inner-shots, repeats and task induction. On two-way Open-Ended miniImagenet, we observe that when Frozen is presented with a sequence of images and descriptions of new names for them, it is able to learn new names for the objects presented and then use these new names immediately with substantially above chance accuracy. Importantly, the ability of the model to use these new words improves with more examples of the corresponding category. Notably, this upward trend is more pronounced when this supporting information involves different exemplars from the visual category (inner-shots) rather than repetitions of a single exemplar (repeats). The fast-binding capacities of the model can thus be improved with richer and more varied visual support or prompting.
+
+On two-way Real-Name miniImagenet, we observe a similar trend but with higher absolute performance. This underlines the difficulty in Open-Ended miniImagenet introduced by having to assign novel words to categories that may otherwise be already known to the model, and because the real names may carry visual information leveraged from the captioning data the model was trained on.
+
+In Table 4, we show that the observed effects on Open-Ended miniImagenet do not transfer to the 5-way setting, where Frozen is not significantly above chance. This shows that learning to bind five new names to five visual categories in a single forward pass is beyond the current capabilities of Frozen. As before, however, we do observe an upward trend in the model’s capacity to return the actual name for a visual category among the five possibilities as the number of inner-shots or repeats increases. Further work is required and we look forward to progress in this more challenging setting.
+
+<table><tr><td>Task Induction Inner Shots Repeats</td><td>× 1 0</td><td>√ 1 0</td><td>√ 3 0</td><td>√ 5 0</td><td>√ 1 1</td><td>√ 1</td><td>√ 1</td></tr><tr><td>Frozen</td><td>29.0</td><td>54.1</td><td>55.2</td><td>57.6</td><td>51.8</td><td>3 57.7</td><td>5 58.6</td></tr><tr><td>Frozen (Real-Name)</td><td>1.7</td><td>49.2</td><td>67.0</td><td>68.4</td><td>63.8</td><td>65.2</td><td>64.0</td></tr><tr><td>Frozen test-blind</td><td>1</td><td>48.5</td><td>46.7</td><td>45.3</td><td>、</td><td></td><td>1</td></tr><tr><td>Frozen test-blind (Real-Name)</td><td></td><td>1.0</td><td>12.6</td><td>33.0</td><td>一</td><td></td><td></td></tr><tr><td>ANIL Baseline [32]</td><td>1</td><td>73.9</td><td>81.7</td><td>84.2</td><td>1</td><td>1</td><td>1</td></tr></table>
+
+Table 3: Performance of Frozen and baselines on Open-Ended miniImageNet 2-Way Tasks. Randomly picking between the two class labels (then emitting the EOS token) would yield $50 \%$ accuracy. As the model has to generate the answer, and is not counted correct if it paraphrases, this is not the best blind baseline, which is why we include open-ended blind baselines that also generate.
+
+Fast-VQA and Guided-VQA As transformers are trained to model text, their attention weights learn to associate – or ‘bind’– pairs of words across sentences. The experiments with miniImageNet show that this capacity can transfer directly to binding visual categories to their names, enabling the system to generate the name on demand. This raises the question of whether Frozen can integrate a newly-acquired visual category (and its names) more fully into the model’s language system, so that it can, for instance, describe or answer questions about that category.
+
+To test this capacity, we constructed a new task – Fast-VQA – out of two well-known datasets, ImageNet [35] and Visual Genome [17]. For each question, the model is presented with nonsense words (‘dax’ and ‘blicket’) and $n$ images of the referents of those words (e.g. of a ‘cat’ or a ‘dog’) taken from ImageNet. It is then asked a question containing at least one of those two words, about a further image (taken from Visual Genome) in which both of the referents appear (see Figure 4b). As with miniImagenet, the words ‘dax’ and ‘blicket’ (and how they refer) should be new to Frozen, but the corresponding visual categories may be known from the Conceptual Captions training data, albeit by different names.
+
+Table 4: Performance of Frozen and baselines on Open-Ended miniImageNet 5-Way Tasks. Randomly picking between the five class labels (then emitting the EOS token) would yield $20 \%$ accuracy.   
+
+<table><tr><td rowspan=3 colspan=1>Task InductionInner ShotsRepeats</td><td rowspan=2 colspan=1>X1</td><td rowspan=1 colspan=1>√      √    √</td><td rowspan=2 colspan=1>√      √    √1     1     1</td></tr><tr><td rowspan=1 colspan=1>1     3     5</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0     0     0</td><td rowspan=1 colspan=1>1     3     5</td></tr><tr><td rowspan=1 colspan=1>FrozenFrozen (Real-Name)</td><td rowspan=1 colspan=1>18.00.9</td><td rowspan=1 colspan=1>21.3 22.4 22.112.4 34.0 31.0</td><td rowspan=1 colspan=1>21.5 21.1 20.932.0 33.2 33.8</td></tr><tr><td rowspan=3 colspan=1>Frozen test-blindFrozen test-blind (Real-Name)ANIL Baseline [32]</td><td rowspan=3 colspan=1>、1</td><td rowspan=1 colspan=1>18.6 19.9 19.8</td><td rowspan=2 colspan=1>1              1</td></tr><tr><td rowspan=1 colspan=1>4.6   22.6 20.8</td></tr><tr><td rowspan=1 colspan=1>45.5 57.7 62.6</td><td rowspan=1 colspan=1>1     1      1</td></tr></table>
+
+To quantify how much harder the introduction of new words for known categories makes this task, we also created a variant (Guided-VQA) in which the original category names (‘cat’ or ‘dog’) are used instead of ‘dax’ and ‘blicket’. Guided-VQA is a special case of Fast-VQA involving questions from Visual Genome, where the model is reminded what the important entities in the question look like prior to answering the question by labeling sample images with real category names. Guided-VQA does not require the same ability to bind categories to new words, but it does measure how well a model can exploit task-relevant multimodal guidance when attempting a new task in an otherwise zero-shot manner.
+
+Fast-VQA and Guided-VQA are very challenging tasks because they are attempted without taskspecific training, and because the underlying questions come from Visual Genome (VQAv2 images do not come with the necessary meta-data to construct the task). Visual Genome questions are particularly challenging because only a single answer exists for each question. When scoring models, for simplicity we credit only an exact match with the output generated by the model, modulo the same post-processing applied for VQAv2. Because of the inherent difficulty of the task, we use strong baselines that can still utilize the large language model to verify strength of observed effects.
+
+Table 5: Performance of Frozen versus an equivalent blind model on Fast and Guided-VQA.   
+
+<table><tr><td></td><td colspan="5">Fast-VQA</td><td colspan="4">Guided-VQA</td></tr><tr><td>Inner Shots</td><td>0</td><td>1</td><td>3</td><td>5</td><td>0</td><td>1</td><td>3</td><td>5</td></tr><tr><td>Frozen</td><td>1.6</td><td>2.8</td><td>7.0</td><td>7.9</td><td>3.7</td><td>7.8</td><td>10.1</td><td>10.5</td></tr><tr><td>Frozen train-blind</td><td>0.7</td><td>0.3</td><td>1.3</td><td>0.4</td><td>1.9</td><td>2.3</td><td>3.7</td><td>3.7</td></tr></table>
+
+As shown in Table 5, the fact that the model improves with more shots in both Fast-VQA and GuidedVQA confirms that Frozen has some capacity to integrate novel words into its general capacity to process and generate natural language in a multimodal context. It is notable that a prefix-tuned model with no access to images improves moderately at Guided-VQA as more categories are presented, showing that additional linguistic cues (just being reminded of the words involved and the linguistic form of the task) goes some way to preparing for the upcoming question. As exemplified in Figure 4, inspection of the model output confirms that in many cases it is indeed the multimodal (and not just linguistic) support that enables Frozen to improve performance as the number of shots increases. We observed that there are diminishing returns in performance gain as the number of shots increase. One possible explanation is that the shift from the training distribution of contexts with single images to multiple images causes inaccuracies in the model.
+
+The Open-Ended miniImagenet, Real-Name miniImagenet, Fast-VQA and Guided-VQA evaluation sets are available to download at https://fh295.github.io/frozen.html.
+
+# 5 Discussion
+
+# 5.1 Limitations
+
+We believe this work is an important proof-of-concept for a desired, much more powerful system capable of open-ended multimodal few-shot learning. Frozen achieves the necessary capacities to some degree, but a key limitation is that it achieves far from state-of-the-art performance on the specific tasks that it learns in a few shots, compared to systems that use the full training set for those tasks. As such, the main contribution of this work should be seen as a starting point or baseline for this exciting area of research of multimodal few-shot learning.
+
+Further improvement can make the impressive zero-shot and few-shot generalization we observed more robust as reflected by higher accuracy and fewer seeds required to demonstrate our most compelling samples. Finally, there are many technical questions that were not explored in this proofof-concept study, such as whether performance could be improved with more elaborate architectures for mixing vision and language. We leave the exploration of these possibilities to future investigations. The Open-Ended miniImageNet, Real-Name miniImagenet, Fast-VQA and Guided-VQA benchmarks that we provide with this manuscript should facilitate the evaluation and analysis of future systems of this type.
+
+# 5.2 Societal Impact
+
+With the emergence of this new class of general purpose vision-language models, new capabilities of massive surveillance can be feasible. Both surveillance footage and publicly shared images can be analyzed for arbitrary questions without requiring any new labeled data or training of the system. As a mitigation for individuals, personal assistant software with similar capabilities can analyze publicly available documents about themselves to identify unintended exposures, even when novel concerns emerge either due to societal change or change of personal preferences.
+
+Generative models of text that can incorporate visual information can elevate the misuse of languagemodel generated content by making them even more convincing. Moreover, at this point we do not have sufficient tools to identify bias and toxicity issues of general purpose vision-guided language models. We invite the community to think about effective methods and benchmarks on this front.
+
+More positively, systems like Frozen could be applied to assist visually impaired users of technology. Frozen’s ability to adapt to different styles of caption or question could enable a more personalised user experience in these cases.
+
+There are environmental costs associated with training the large networks in systems like Frozen. On the other hand, a system that can be trained once and then flexibly adapted to different settings could have a lower energy footprint overall than one that requires re-training for different applications.
+
+# 5.3 Conclusion
+
+We have presented a method for transforming large language models into multimodal few-shot learning systems by extending the soft-prompting philosophy of prefix tuning [23] to ordered sets of images and text while preserving text prompting abilities of the language model. Our experiments confirm that the resulting system, Frozen, is capable both of open-ended interpretation of images and genuinely multimodal few-shot learning even though the system is only trained to do captioning. One corollary of these results is that the knowledge required to quickly bind together or associate different words in language is also pertinent to rapidly binding language to visual elements across an ordered set of inputs. This finding extends the conclusion of [26] – that knowledge in transformer language models can transfer to non-linguistic tasks – to the specific case of knowledge about few-shot learning.
+
+Acknowledgements We wish to thank Sebastian Borgeaud and Jack Rae for preparing the pretraining text dataset and pretraining a selection of transformer language models, as well as Trevor Cai for help with experiments and infrastructure. We also wish to thank Pauline Luc, Jeff Donahue, Malcolm Reynolds, Andy Brock, Karen Simonyan, Jean-Baptiste Alayrac, Antoine Miech, Charlie Nash, Aaron van den Oord, Marc Deisenroth, Aida Nematzadeh, Roman Ring, Francis Song, Eliza Rutherford, Kirsty Anderson, Esme Sutherland, Alexander Novikov, Daan Wierstra, and Nando de Freitas for insightful discussions during the course of the project.
+
+# References
+
+[1] Daniel Adiwardana, Minh-Thang Luong, David R. So, Jamie Hall, Noah Fiedel, Romal Thoppilan, Zi Yang, Apoorv Kulshreshtha, Gaurav Nemade, Yifeng Lu, and Quoc V. Le. Towards a human-like open-domain chatbot. CoRR, abs/2001.09977, 2020. [2] Emily M Bender and Alexander Koller. Climbing towards nlu: On meaning, form, and understanding in the age of data. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5185–5198, 2020.   
+[3] Andrew Brock, Soham De, Samuel L Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   
+[4] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+[5] David Chalmers. Gpt3 and general intelligence. Published in Daily Nous, 2021.   
+[6] Jun Chen, Han Guo, Kai Yi, Boyang Li, and Mohamed Elhoseiny. Visualgpt: Data-efficient adaptation of pretrained language models for image captioning. arXiv preprint arXiv:2102.10407, 2021.   
+[7] Jaemin Cho, Jie Lei, Hao Tan, and Mohit Bansal. Unifying vision-and-language tasks via text generation. arXiv preprint arXiv:2102.02779, 2021.   
+[8] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+[9] Allen Institute for AI. C4 search. https://c4-search.apps.allenai.org/. Accessed: 2021-04-06.   
+[10] Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the v in vqa matter: Elevating the role of image understanding in visual question answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 6904–6913, 2017.   
+[11] Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Realm: Retrieval-augmented language model pre-training, 2020.   
+[12] Tracy H Heibeck and Ellen M Markman. Word learning in children: An examination of fast mapping. Child development, pages 1021–1034, 1987.   
+[13] MD Zakir Hossain, Ferdous Sohel, Mohd Fairuz Shiratuddin, and Hamid Laga. A comprehensive survey of deep learning for image captioning. ACM Computing Surveys (CsUR), 51(6):1–36, 2019.   
+[14] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, and Tom Duerig. Scaling up visual and vision-language representation learning with noisy text supervision, 2021.   
+[15] Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre luc Cantin, Clifford Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, C. Richard Ho, Doug Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law, Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Matt Ross, Amir Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle, Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter performance analysis of a tensor processing unit, 2017.   
+[16] Douwe Kiela, Suvrat Bhooshan, Hamed Firooz, Ethan Perez, and Davide Testuggine. Supervised multimodal bitransformers for classifying images and text. arXiv preprint arXiv:1909.02950, 2019.   
+[17] Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International journal of computer vision, 123(1):32–73, 2017.   
+[18] Taku Kudo and John Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.   
+[19] Georgia Tech Visual Intelligence Lab. Vqa python api and evaluation code. https://github. com/GT-Vision-Lab/VQA.   
+[20] Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691, 2021.   
+[21] Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmented generation for knowledge-intensive nlp tasks, 2021.   
+[22] Sheng Li, Zhiqiang Tao, Kang Li, and Yun Fu. Visual to text: Survey of image and video captioning. IEEE Transactions on Emerging Topics in Computational Intelligence, 3(4):297– 312, 2019.   
+[23] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190, 2021.   
+[24] Xiujun Li, Xi Yin, Chunyuan Li, Pengchuan Zhang, Xiaowei Hu, Lei Zhang, Lijuan Wang, Houdong Hu, Li Dong, Furu Wei, Yejin Choi, and Jianfeng Gao. Oscar: Object-semantics aligned pre-training for vision-language tasks, 2020.   
+[25] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019.   
+[26] Kevin Lu, Aditya Grover, Pieter Abbeel, and Igor Mordatch. Pretrained transformers as universal computation engines. arXiv preprint arXiv:2103.05247, 2021.   
+[27] Kenneth Marino, Mohammad Rastegari, Ali Farhadi, and Roozbeh Mottaghi. Ok-vqa: A visual question answering benchmark requiring external knowledge. In 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 3190–3199. IEEE Computer Society, 2019.   
+[28] Fabio Petroni, Tim Rocktäschel, Patrick S. H. Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H. Miller, and Sebastian Riedel. Language models as knowledge bases? CoRR, abs/1909.01066, 2019.   
+[29] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision, 2021.   
+[30] Alec Radford, Jeffrey Wu, R. Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners, 2019.   
+[31] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.   
+[32] Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. arXiv preprint arXiv:1909.09157, 2019.   
+[33] Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning, 2016.   
+[34] Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.   
+[35] 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, 115(3):211–252, 2015.   
+[36] Thomas Scialom, Patrick Bordes, Paul-Alexis Dray, Jacopo Staiano, and Patrick Gallinari. What bert sees: Cross-modal transfer for visual question generation. arXiv preprint arXiv:2002.10832, 2020.   
+[37] Piyush Sharma, Nan Ding, Sebastian Goodman, and Radu Soricut. Conceptual captions: A cleaned, hypernymed, image alt-text dataset for automatic image captioning. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2556–2565, 2018.   
+[38] Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations, 2018.   
+[39] Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism, 2020.   
+[40] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pre-training of generic visual-linguistic representations. arXiv preprint arXiv:1908.08530, 2019.   
+[41] Yingtao Tian and Jesse Engel. Latent translation: Crossing modalities by bridging generative models, 2019.   
+[42] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   
+[43] Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. arXiv preprint arXiv:1606.04080, 2016.   
+[44] Jialin Wu, Jiasen Lu, Ashish Sabharwal, and Roozbeh Mottaghi. Multi-modal answer validation for knowledge-based vqa, 2021.   
+[45] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transformers, 2021.   
+[46] Zachary M Ziegler, Luke Melas-Kyriazi, Sebastian Gehrmann, and Alexander M Rush. Encoderagnostic adaptation for conditional language generation. arXiv preprint arXiv:1908.06938, 2019.

parse/train/WtmMyno9Tq2/WtmMyno9Tq2_content_list.json

@@ -0,0 +1,1175 @@
+[
+    {
+        "type": "text",
+        "text": "Multimodal Few-Shot Learning with Frozen Language Models ",
+        "text_level": 1,
+        "bbox": [
+            276,
+            122,
+            720,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maria Tsimpoukelli∗ DeepMind mrts@deepmind.com ",
+        "bbox": [
+            212,
+            226,
+            362,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Serkan Cabi∗ DeepMind cabi@deepmind.com ",
+        "bbox": [
+            635,
+            226,
+            784,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jacob Menick∗   \nDeepMind   \nUniversity College London   \njmenick@deepmind.com ",
+        "bbox": [
+            408,
+            226,
+            588,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "S. M. Ali Eslami ",
+        "text_level": 1,
+        "bbox": [
+            227,
+            303,
+            343,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals DeepMind vinyals@deepmind.com ",
+        "bbox": [
+            403,
+            303,
+            576,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "DeepMind aeslami@deepmind.com ",
+        "bbox": [
+            199,
+            318,
+            370,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill DeepMind felixhill@deepmind.com ",
+        "bbox": [
+            607,
+            303,
+            799,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            381,
+            535,
+            396
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When trained at sufficient scale, auto-regressive language models exhibit the notable ability to learn a new language task after being prompted with just a few examples. Here, we present a simple, yet effective, approach for transferring this few-shot learning ability to a multimodal setting (vision and language). Using aligned image and caption data, we train a vision encoder to represent each image as a sequence of continuous embeddings, such that a pre-trained, frozen language model prompted with this prefix generates the appropriate caption. The resulting system is a multimodal few-shot learner, with the surprising ability to learn a variety of new tasks when conditioned on examples, represented as a sequence of multiple interleaved image and text embeddings. We demonstrate that it can rapidly learn words for new objects and novel visual categories, do visual question-answering with only a handful of examples, and make use of outside knowledge, by measuring a single model on a variety of established and new benchmarks. ",
+        "bbox": [
+            233,
+            411,
+            766,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            310,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Auto-regressive transformers have been shown to be very impressive models of natural language [42]. Large-scale language transformers exhibit several surprising abilities beyond that of standard text generation [4, 31]. Perhaps most notably, they are few-shot learners; they can learn to perform a new task from a few examples without any further gradient updates. Equipped with this ability, these models have been shown to rapidly adapt to new tasks and styles of generation via prompting (e.g. switching from formal to informal language) [4], to retrieve relevant encyclopedic or general knowledge when primed with a relevant context (e.g. answering questions such as ‘When did the French Revolution begin?’) [34, 1, 28] and to use new words in appropriate ways straight after being taught what those words mean (sometimes referred to as ‘fast binding’) [12, 4]. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            771
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite these impressive capabilities, such large scale language models are ‘blind’ to modalities other than text, preventing us from communicating visual tasks, questions or concepts to them. Indeed, philosophers and linguists have questioned whether an un-grounded language model can ever achieve true understanding of the language it processes [5, 2]. Here, we present Frozen, a method for giving a pre-trained language model access to visual information in a way that extends its few-shot learning capabilities to a multimodal setting, without changing its weights. Frozen consists of a neural network trained to encode images into the word embedding space of a large pre-trained language model such that the language model generates captions for those images. The weights of the language model are kept frozen, but gradients are back-propagated through it to train the image encoder from scratch (Figure 2). Although Frozen is trained on single image-text pairs, once trained it can respond effectively to interleaved sequences of multiple images and text. This allows users to ‘prompt’ it with several examples of new multimodal tasks before evaluating its performance, or to ‘teach’ it the name of a new visual category before immediately asking about that category. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/acf5dae286c39fb8ccc2f2a653240478bf311b93577d21856222b9d240d7a89c.jpg",
+        "image_caption": [
+            "Figure 1: Curated samples with about five seeds required to get past well-known language model failure modes of either repeating text for the prompt or emitting text that does not pertain to the image. These samples demonstrate the ability to generate open-ended outputs that adapt to both images and text, and to make use of facts that it has learned during language-only pre-training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            92,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            825,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "By exploiting its pre-trained language model, Frozen exhibits nontrivial zero-shot performance on multimdodal tasks that it was not trained on, such as visual question answering (VQA). More surprisingly, it gets better at these tasks after seeing a handful of examples ‘in-context’ as in [4], and also performs above chance on tests of fast category learning such as miniImageNet [43]. In each case, comparisons with ‘blind’ baselines show that the model is adapting not only to the language distribution of these new tasks, but also to the relationship between language and images. Frozen is therefore a multimodal few-shot learner, bringing the aforementioned language-only capabilities of rapid task adaptation, encyclopedic knowledge and fast category binding to a multimodal setting. ",
+        "bbox": [
+            174,
+            422,
+            550,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f2404f4ab104428508fcfe3991e62e8eb09d80e537d1d39962aaffdb00fe1bd.jpg",
+        "image_caption": [
+            "Figure 2: Gradients through a frozen language model’s self attention layers are used to train the vision encoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            562,
+            420,
+            823,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our goal in developing Frozen was not to maximise performance on any specific task, and in many cases it is far from state-of-the-art. Nonetheless, it performs well above trivial baselines across a wide range of tasks without ever seeing more than a handful of the training examples provided by these benchmarks. Moreover, as illustrated in Figure 1, Frozen is a system for genuinely open-ended and unconstrained linguistic interpretation of images that often produces compelling output. ",
+        "bbox": [
+            173,
+            623,
+            825,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5d8d10e6b2c45febfdd36f6abf48a41a9926d3309d27e3a788571806f955616.jpg",
+        "image_caption": [
+            "Figure 3: Inference-Time interface for Frozen. The figure demonstrates how we can support (a) visual question answering, (b) outside-knowledge question answering and (c) few-shot image classification via in-context learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            704,
+            826,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarise, our contributions are as follows: 1. We present Frozen, a modular, scalable and efficient approach to training vision front-ends for large language models. The resulting combined model retains all of the capabilities of large language models, but can also process text and image inputs in any arbitrary sequence. 2. We show that such models transfer their capacity for rapid task adaptation, encyclopedic knowledge and fast category binding from a language-only to a multimodal setting, and verify that prompting them with both visual and language information can be strictly more effective than doing so with language information alone. 3. We quantify these capabilities on a range of existing and new benchmarks, paving the way for future analysis of these capabilities. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            248,
+            320,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Frozen method is inspired by lots of recent work. [26] show that the knowledge encoded in transformer language models can be a valuable prior for tasks involving reasoning and memory across discrete sequences, and even classification of images presented as sequences of spatial regions. In that approach, a small subset of the pre-trained language model weights are fine-tuned to the various final applications. In contrast, applying Frozen to different tasks does not involve any weight updates to the transformer whatsoever; the system adapts to and improves at multimodal (vision and language) tasks as activations propagate through the model. The two studies thus reveal different ways in which knowledge acquired from text can transfer to non-linguistic settings. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of prefix tuning [23] or prompt tuning [20] was another important motivation for Frozen. Prefix tuning is a method for prompting a language model to produce output of a particular style using gradient descent to learn a task-specific bias term which functions like the continuous embedding of a text prompt. Using prefix tuning, language models can be adapted to different natural language generation tasks like summarization. Frozen could also be considered a type of image-conditional prefix tuning, in which this continuous prefix is not a bias but an image-conditional activation produced by an external neural network. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning to embed image representations into the ‘word’ space of a large pretrained language model was done previously by [16]. This work focused on image-text classification, and uses a BERT-style language model that is fine-tuned (rather than frozen) on multimodal data. [36] extend a similar image embedding+BERT system to create a generative model of text, using a pre-trained object extraction system to embed images into word space. Neither of these studies consider the problem of learning image-text correspondences in a few shots. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A large body of work has applied either text-specific or multimodal representation-learning approaches like BERT [8] to visual question answering (VQA) and captioning (see e.g. [25, 40] and many more). In these approaches, models are first trained with aligned data on task-agnostic cross-modal objectives and then fine-tuned to specific tasks. This approach can yield state-of-the-art performance on a range of classification tasks. Unlike Frozen, the resulting systems are highly specialized to one task, and cannot learn new categories or adapt to new tasks in a few shots. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By contrast, [7] propose text generation as an objective for task-general multimodal models, yielding a system that, like Frozen, produces unconstrained language output. Unlike Frozen, they do not use a pre-trained model trained on text only, and do not consider zero or few-shot learning, instead updating all weights of the system with training data for each task they consider – thus, again, specializing the models to one task at a time. Similarly, [46] and [6] show that a large pre-trained language model as decoder can improve a captioning performance when training data is limited. Unlike Frozen, they use pre-trained frozen visual encoders or object extractors and fine-tune the pre-trained weights in the text decoder on the captioning data. Similarly, they do not consider zero or few-shot adaptation across different multimodal tasks. Past work has also explored alternative approaches for post-hoc combination of models for different modalities using latent variables [41]. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multimodal pre-training has recently been shown to enable strong zero-shot generalization in the discriminative setting using large-scale contrastive learning [29, 14]. Also in a discriminative setting, [45] has observed signs of emergent few-shot-learning from large-scale training. In contrast, our work enables strong generalization to new multimodal tasks both zero-shot or few-shot with completely open-ended generative text output. ",
+        "bbox": [
+            176,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 The Frozen Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            369,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Frozen is a method for grounding a large language model without changing its weights, closely related to prefix tuning [23, 20]. Prefix tuning trains a task-specific continuous bias term to function like the embedding of a constant, static text prompt used for all test-time examples. Frozen extends this approach by making this prefix dynamic, in that it is not a constant bias but an input-conditional activation emitted by a neural network. ",
+        "bbox": [
+            173,
+            122,
+            825,
+            191
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            300,
+            226
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pre-trained Autoregressive Language Models Our method starts from a pre-trained deep autoregressive language model, based on the Transformer architecture [42, 30], which parametrizes a probability distribution over text y. Text is decomposed into a sequence of discrete tokens $\\mathbf { y } = y _ { 1 } , y _ { 2 } , . . . , y _ { L }$ by the SentencePiece tokenizer [18]. We use a vocabulary of size 32,000. The language model makes use of an embedding function $g _ { \\theta }$ which independently transforms each token into a continuous embedding $t _ { l } : = g _ { \\theta } ( y _ { l } )$ , as well as a transformer neural network $f _ { \\theta }$ whose output is a vector of logits parameterizing a categorical distribution over the vocabulary. The distribution $p _ { \\boldsymbol { \\theta } } ( \\mathbf { y } )$ is represented as follows: ",
+        "bbox": [
+            173,
+            236,
+            826,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2a33292cad64cfb4f39edd6979eb6c3608ee8ea248e7102bc45cc9601ecdcf6.jpg",
+        "text": "$$\n\\log p _ { \\theta } ( \\mathbf { y } ) = \\sum _ { l } \\log p _ { \\theta } ( y _ { l } | y _ { 1 } , y _ { 2 } , . . . , y _ { l - 1 } ) = \\sum _ { l } f _ { \\theta } ( t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            357,
+            725,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The model we start from is pre-trained, i.e. $\\theta$ has been optimised via the standard maximum-likelihood objective on a large dataset of text from the internet. We use a 7 billion parameter transformer trained on the public dataset C4 [31] – previous work has shown that the multi-billion parameter scale is sufficient to exhibit the key capacities we are interested in studying [30, 34]. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Vision Encoder Our vision encoder is based on NF-ResNet-50 [3]. We define $v _ { \\phi }$ as a function that takes a raw image and emits a continuous sequence to be consumed by the transformer. We use the final output vector of the NF-Resnet after the global pooling layer. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            516
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Visual Prefix One important requirement is to represent images in a form that the transformer already understands: a sequence of continuous embeddings, each having the same dimensionality $D$ as a token embedding $t _ { l }$ . We therefore form the visual prefix by linearly mapping the vision encoder’s output to $D * k$ channels, and then reshaping the result as a sequence of $k$ embeddings, each with dimensionality $D$ . We call this sequence a visual prefix since it plays the same functional role in the transformer architecture as (part of) an embedding sequence of prefix tokens. We experimented using different number of tokens $k$ , specifically 1, 2 and 4 and found that 2 performs best, though certainly this would be sensitive to other architectural details. See Appendix for more details on the architecture. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            274,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During training, we update only the parameters $\\phi$ of the vision encoder using paired image-caption data from the Conceptual Captions dataset [37]. Our experiments show that fine-tuning $\\theta$ hurts generalization, as much less paired image-caption data is available than the amount of text-only data used to pre-train $\\theta$ . Training only the parameters $\\phi$ makes our system modular – it can use an existing language model off the shelf – and also quite simple: we only train a visual encoder and rely on the capabilities of an existing language model. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following standard captioning systems [22, 13], we treat captioning as conditional generation of caption text $\\mathbf { y }$ given an image $\\mathbf { x }$ . We represent $\\mathbf { x }$ as $v _ { \\phi } ( \\mathbf { x } ) = i \\bar { 1 } , i _ { 2 } , . . . , \\bar { i } _ { n }$ and train $\\phi$ to maximise the likelihood: ",
+        "bbox": [
+            176,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/625bb06848eb44bfc980d1442006760a0ae0e4a676c66c172b6cb30ac665fb84.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\log p _ { \\theta , \\phi } ( { \\bf y } | x ) = \\displaystyle \\sum _ { l } \\log p _ { \\theta , \\phi } ( y _ { l } | { \\bf x } , y _ { 1 } , y _ { 2 } , . . . , y _ { l - 1 } ) } } \\\\ { { { } } } \\\\ { { = \\displaystyle \\sum _ { l } f _ { \\theta } ( i _ { 1 } , i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            840,
+            674,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Whilst the parameters $\\theta$ are frozen, each element $i _ { k }$ of the visual prefix receives gradients $\\sum _ { l } \\nabla _ { i _ { k } } f _ { \\theta } ( i _ { 1 } \\dot { , } i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } ) _ { y _ { l } }$ , enabling the parameters of the visual encoder to be optimised with standard backpropagation and SGD (Figure 2). ",
+        "bbox": [
+            174,
+            92,
+            825,
+            142
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As the notation $f _ { \\theta } ( i _ { 1 } , i _ { 2 } , . . . , i _ { n } , t _ { 1 } , t _ { 2 } , . . . , t _ { l - 1 } )$ suggests, we present the visual prefix during training as if it were a sequence of embeddings occurring earlier in time than the caption (token embeddings) $t _ { 1 } , t _ { 2 } , \\ldots$ . We use relative positional encoding [38], which enables the transformer to generalize to prefix sequences where an image is not always in the first absolute positions, and where more than one image may be present. In particular, we use the version of relative attention described in transformerxlDai.We leave improvements of this simple scheme for future work. ",
+        "bbox": [
+            173,
+            148,
+            825,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Interface at Inference Time ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            247,
+            403,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At inference time, a vanilla language model, conditioned upon an arbitrary text prompt $y _ { 1 } , y _ { 2 } , . . . , y _ { p }$ , generates text sequences $y _ { p + 1 } , y _ { p + 2 } , . . .$ autoregressively. In Frozen it is straightforward to include images in such prompt by placing an image’s embedding $i _ { 1 } , i _ { 2 }$ as a prefix to a text embedding subsequence $t _ { 1 } , t _ { 2 } , . . . , t _ { p }$ . Because the transformer $f _ { \\theta }$ is modality-agnostic, we can interleave a sub-sequence of text token embeddings with a sub-sequence of image embeddings in any arbitrary order. In Figure 3, we show how this can support zero-shot visual question-answering (Figure 3a), few-shot visual question-answering (Figure 3b), and few-shot image classification (Figure 3c). ",
+        "bbox": [
+            174,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To evaluate these tasks, the model decodes output sequences greedily and these outputs are compared against the ground truth answers of the task following the normalization technique used in [19]. To probe the open-ended capabilities of Frozen, we decided not to use common practice of short-lists of pre-canned answers, even though in some tasks this may hurt its performance in accuracy percentages. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Few-Shot Learning Definitions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            449,
+            426,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ability of Frozen to be conditioned on a sequence of interleaved images and text allows it not only to be able to perform different multimodal tasks, but also gives rise to different ways of ‘inducing’ the task to the model in order to improve its performance. We briefly define the terminology used in our settings, common amongst all the different tasks. See Figure 5 in the appendix for a visual illustration of these concepts. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            544
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Task induction Explanatory text that precedes the sequence of images and text. It is intended to describe the task to the model in natural language, for example ‘Please answer the question.’ Number of shots The number of distinct full examples of the task presented to the model prior to the evaluated example. For example, in Visual Question-Answering, a shot is an image along with the question and the answer. ",
+        "bbox": [
+            215,
+            556,
+            825,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For tasks involving fast category binding (e.g., few-shot image classification), we define further specific terminology. See also Figure 4a and Figure 6 in the appendix. ",
+        "bbox": [
+            173,
+            657,
+            821,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Number of ways The number of object classes in the task (e.g. dog vs cat).   \n• Number of inner-shots The number of distinct exemplars from each category that are presented to the model (i.e. number of images of different dogs). In previous work with MiniImagenet, these were known as shots, but we modify the term here to distinguish from the more general usage of the term described above. Number of repeats The number of times each inner-shot is repeated in the context presented to the model. We use this setting as an ablation to explore how the model integrates visual information about a category. ",
+        "bbox": [
+            215,
+            696,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments: A Multi-Modal Few-Shot Learner ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            837,
+            607,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our experiments are designed to quantify three capacities that should be characteristic of a MultiModal Few-Shot Learner: rapid adaptation to new tasks, fast access to general knowledge and fast binding of visual and linguistic elements. We train Frozen on Conceptual Captions, a public dataset that consists of around three million image-caption pairs [37]. We do early stopping on the validation set perplexity which usually reaches an optimum just after a single epoch with batch size 128. All experiments used the Adam optimizer with $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 5$ and a constant learning rate of $3 e$ -4 unless otherwise noted. We operate on $2 2 4 \\times 2 2 4$ images at both train and test-time. Images which are not square are first padded with zeroes to square and then resized to $2 2 4 \\times 2 2 4$ . ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb6f0be3f7f62e2f057f06da50fee419d50354aef4bda43d1a2f6da52852b372.jpg",
+        "table_caption": [
+            "Table 1: Transfer from Conceptual Captions to VQAv2. The $\\tau$ column indicates whether a model uses training data from the VQAv2 training set. The row denoted Frozen train-blind is the blind baseline described in subsection 4.1. Frozen VQA is a baseline which mixes in VQAv2 training data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>n-shot Acc.     1</td><td rowspan=1 colspan=1>n=0</td><td rowspan=1 colspan=1>n=1</td><td rowspan=1 colspan=1>n=4</td><td rowspan=1 colspan=1>T</td></tr><tr><td rowspan=2 colspan=1>FrozenFrozen seratchFrozen finetunedFrozen train-blind</td><td rowspan=2 colspan=1>29.50.024.026.2</td><td rowspan=1 colspan=1>35.7</td><td rowspan=2 colspan=1>38.20.029.233.3</td><td rowspan=2 colspan=1>xxxx</td></tr><tr><td rowspan=1 colspan=1>0.028.233.5</td></tr><tr><td rowspan=1 colspan=1>Frozen vQAFrozen vQA-blind</td><td rowspan=1 colspan=1>48.439.1</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1√</td></tr><tr><td rowspan=1 colspan=1>Oscar [24]     1</td><td rowspan=1 colspan=1>173.8</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1  【</td><td rowspan=1 colspan=1>【</td></tr></table>",
+        "bbox": [
+            173,
+            87,
+            483,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ba4a17716444f425eb9c83d1c93a0c0291bbafa2548f63767af6990cae4d673.jpg",
+        "table_caption": [
+            "Table 2: Transfer from Conceptual Captions to OKVQA. The $\\tau$ column indicates if a model uses training data from the OKVQA training set. Frozen does not train on VQAv2 except in the baseline row, and it never trains on OKVQA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>n-shot Acc.     1</td><td rowspan=1 colspan=1>n=0</td><td rowspan=1 colspan=1>n=1</td><td rowspan=1 colspan=1>n=4</td><td rowspan=1 colspan=1>T</td></tr><tr><td rowspan=3 colspan=1>FrozenFrozen 400mLMFrozen finetunedFrozen train-blind</td><td rowspan=1 colspan=1>5.9</td><td rowspan=1 colspan=1>9.7</td><td rowspan=1 colspan=1>12.6</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=2 colspan=1>4.04.23.3</td><td rowspan=1 colspan=1>5.9</td><td rowspan=2 colspan=1>6.64.60.0</td><td rowspan=2 colspan=1>xxxx</td></tr><tr><td rowspan=1 colspan=1>4.17.2</td></tr><tr><td rowspan=1 colspan=1>Frozen vQAFrozen vQA-blind</td><td rowspan=1 colspan=1>19.612.5</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>××</td></tr><tr><td rowspan=1 colspan=1>MAVEx 44]   三</td><td rowspan=1 colspan=1>39.4</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=2>1  √</td></tr></table>",
+        "bbox": [
+            514,
+            87,
+            823,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            342,
+            825,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Rapid Task Adaptation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            375,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first examine zero-shot and few-shot generalization from captioning to visual question-answering. This is a type of rapid adaptation from captioning behaviour to question-answering behaviour analogous to transfer from language modelling to open-domain question-answering in the text-only setting [34]. We evaluate on the VQAv2 [10] validation set. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot transfer from captioning to VQA We first observe that a version of our model in which the ability to embed images into a prefix is trained solely with a captioning objective can transfer moderately well to visual question-answering in the zero-shot setting, with no specific training towards that goal. We simply have to provide the system with an image and a textual prompt of the form Question: what colour is the dog sitting on the grass? Answer:, then observe how it completes the prompt. The ability to adapt to input of this form is presumably transferred from the training data of the pretrained language model component of the system. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The strength of the pre-trained language model in the system is a double-edged sword. It powers the generalization abilities of Frozen but also enables the model to perform surprisingly well without considering the visual input at all. To guard against this possibility we also train blind baselines, in which the image presented to the visual encoder is blacked out, but the convnet weights are still trained (see Table 1). This amounts to prefix tuning [23]. We outperform this blind baseline which also inherits the few-shot learning abilities of the language model. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In these experiments we also include two additional and important baselines: Frozen finetuned in which the language model is instead finetuned starting from the pretrained weights and Frozen scratch, wherein the whole system is trained from scratch end-to-end, both using the same dataset as Frozen. These baselines preferred a smaller learning rate of 1e-5. Results in Table 1 show that keeping the language model frozen generalizes substantially better to visual question-answering than finetuning. The model trained from scratch is not able to transfer at all from captioning to VQA; we interpret this to suggest that the tremendous generalization abilities of large language models are reliant upon large-scale training datasets in which the task of predicting the next token mimics the test setting (here question-answering) with non-negligible frequency. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Improving performance with few-shot learning More importantly, for the present work, we observe that the ability of the model to transfer knowledge from captioning and text-modelling to visual question-answering improves if the model is presented with several examples of VQA data sequentially. We repeat the previous experiments with up to four examples of image-question-answer triples shown to the model as conditioning information in the continuous prefix sequence (using the interface in Figure 3). ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3010e3cdc0d12c619e82d96167a277bfc023da41e63bfe21fe059edde7b6fa2.jpg",
+        "image_caption": [
+            "Figure 4: Examples of (a) the Open-Ended miniImageNet evaluation (b) the Fast VQA evaluation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            825,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            356,
+            823,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These results are presented in Table 1. For contrast, we compare this performance to a condition in which we mix in some data from the VQAv2 training set with the captioning data. As we might expect, few-shot learning on four examples is outperformed by SGD on tens of thousands of examples, but few-shot performance clearly improves with more examples, and goes some way $( 3 8 . 2 \\% )$ toward closing the gap from zero-shot performance $( 2 9 . 5 \\% )$ to full SGD training performance $( 4 8 . 4 \\% )$ ",
+        "bbox": [
+            174,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are two important takeaways from the results presented in this section. First, they show that training a visual encoder through a pretrained and frozen language model results in a system capable of strong out-of-distribution (zero-shot) generalization. Second, they confirm that the ability to rapidly adapt to new tasks given appropriate cntext is inherited from the pretrained language model and transfers directly to multimodal tasks. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Encyclopedic Knowledge ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            387,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we study the extent to which Frozen can leverage the encyclopedic knowledge in the language model towards visual tasks. The Conceptual Captions dataset is hypernymed (e.g. proper names are replaced with a general word like person). This enables us to rigorously study the transfer of factual knowledge because all knowledge of named entities comes from language model pretraining. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Consequently, when we show the model an image of an airplane and ask “who invented this?” (Figure 1), the visual encoder has determined that the image contains an airplane, and the language model has used this to retrieve the factual knowledge that airplanes were invented by the Wright brothers, a fact which is referenced in the C4 training set through (text-only) articles about airplanes. This is a fascinating chain of deduction. A detailed analysis of this behaviour with more examples is included in the Appendix (e.g. Figure 9, Figure 10, Figure 11). ",
+        "bbox": [
+            173,
+            640,
+            826,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We bolster this finding quantitatively by evaluating performance on OKVQA [27], a visual questionanswering dataset designed to require outside knowledge in order to answer correctly. The pretrained language model’s command of factual knowledge is of course dependent upon its scale, so we examine the performance of Frozen using pretrained language models of varying sizes: the base model with 7 billion parameters, and a much smaller 400 million parameter language model pretrained on the same dataset. Table 2 shows the results: task performance scales with model size. Again finetuning performs worse than leaving the model frozen in terms of generalization performance. We stress that Frozen is never trained on OKVQA. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Fast Word-to-Visual-Category Binding ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            857,
+            482,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the multi-modal setting, fast-binding refers to a model’s ability to associate a word with a visual category in a few shots and immediately use that word in an appropriate way. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Open-Ended miniImageNet and Real-Name miniImageNet To quantify the fast-binding capacity of of Frozen, we evaluate it on the miniImageNet meta-learning task [43]. Note that there are important differences with how we attempt miniImageNet and how it is approached in previous work. First, unlike standard meta-learning, we do not train Frozen on the (meta) task. Second, we evaluate Frozen in an open-ended fashion, where it must successfully generate a correct category name (and then the EOS token) in order to be credited with a correct answer. Finally, although we use the same image classes as the miniImageNet test set, they are at higher resolution $( 2 2 4 \\times 2 2 4 )$ and with integer class labels [0, 1] replaced with nonsense words (‘dax’, ‘blicket’ etc). We make this adjustment because the nonsense words should have no (or less) intrinsic meaning to the language model than integers, whose relative order (for instance) should have been reflected in a massive text training corpus. We refer to this task as Open-Ended miniImageNet. To assess how much difficulty is added by binding visual categories to nonsense words versus simply adapting to an image recognition task per se, we also consider a version – Real-Name miniImagenet – in which visual categories in both the support set and the answer retain their original names. See Figure 4a for an illustration. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On both versions of this evaluation, we experiment by exposing the model to different numbers of inner-shots, repeats and task induction. On two-way Open-Ended miniImagenet, we observe that when Frozen is presented with a sequence of images and descriptions of new names for them, it is able to learn new names for the objects presented and then use these new names immediately with substantially above chance accuracy. Importantly, the ability of the model to use these new words improves with more examples of the corresponding category. Notably, this upward trend is more pronounced when this supporting information involves different exemplars from the visual category (inner-shots) rather than repetitions of a single exemplar (repeats). The fast-binding capacities of the model can thus be improved with richer and more varied visual support or prompting. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On two-way Real-Name miniImagenet, we observe a similar trend but with higher absolute performance. This underlines the difficulty in Open-Ended miniImagenet introduced by having to assign novel words to categories that may otherwise be already known to the model, and because the real names may carry visual information leveraged from the captioning data the model was trained on. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            478
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 4, we show that the observed effects on Open-Ended miniImagenet do not transfer to the 5-way setting, where Frozen is not significantly above chance. This shows that learning to bind five new names to five visual categories in a single forward pass is beyond the current capabilities of Frozen. As before, however, we do observe an upward trend in the model’s capacity to return the actual name for a visual category among the five possibilities as the number of inner-shots or repeats increases. Further work is required and we look forward to progress in this more challenging setting. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7dbf622efc63411b5c175f50bd939a2f7f3c779ecdb15067ace8ea26100ee7cb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task Induction Inner Shots Repeats</td><td>× 1 0</td><td>√ 1 0</td><td>√ 3 0</td><td>√ 5 0</td><td>√ 1 1</td><td>√ 1</td><td>√ 1</td></tr><tr><td>Frozen</td><td>29.0</td><td>54.1</td><td>55.2</td><td>57.6</td><td>51.8</td><td>3 57.7</td><td>5 58.6</td></tr><tr><td>Frozen (Real-Name)</td><td>1.7</td><td>49.2</td><td>67.0</td><td>68.4</td><td>63.8</td><td>65.2</td><td>64.0</td></tr><tr><td>Frozen test-blind</td><td>1</td><td>48.5</td><td>46.7</td><td>45.3</td><td>、</td><td></td><td>1</td></tr><tr><td>Frozen test-blind (Real-Name)</td><td></td><td>1.0</td><td>12.6</td><td>33.0</td><td>一</td><td></td><td></td></tr><tr><td>ANIL Baseline [32]</td><td>1</td><td>73.9</td><td>81.7</td><td>84.2</td><td>1</td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            218,
+            575,
+            774,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Performance of Frozen and baselines on Open-Ended miniImageNet 2-Way Tasks. Randomly picking between the two class labels (then emitting the EOS token) would yield $50 \\%$ accuracy. As the model has to generate the answer, and is not counted correct if it paraphrases, this is not the best blind baseline, which is why we include open-ended blind baselines that also generate. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fast-VQA and Guided-VQA As transformers are trained to model text, their attention weights learn to associate – or ‘bind’– pairs of words across sentences. The experiments with miniImageNet show that this capacity can transfer directly to binding visual categories to their names, enabling the system to generate the name on demand. This raises the question of whether Frozen can integrate a newly-acquired visual category (and its names) more fully into the model’s language system, so that it can, for instance, describe or answer questions about that category. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To test this capacity, we constructed a new task – Fast-VQA – out of two well-known datasets, ImageNet [35] and Visual Genome [17]. For each question, the model is presented with nonsense words (‘dax’ and ‘blicket’) and $n$ images of the referents of those words (e.g. of a ‘cat’ or a ‘dog’) taken from ImageNet. It is then asked a question containing at least one of those two words, about a further image (taken from Visual Genome) in which both of the referents appear (see Figure 4b). As with miniImagenet, the words ‘dax’ and ‘blicket’ (and how they refer) should be new to Frozen, but the corresponding visual categories may be known from the Conceptual Captions training data, albeit by different names. ",
+        "bbox": [
+            173,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/af602cb6aaffb350180ba2acf15730a6f2baf565d0a87ce636374f05b8d5b512.jpg",
+        "table_caption": [
+            "Table 4: Performance of Frozen and baselines on Open-Ended miniImageNet 5-Way Tasks. Randomly picking between the five class labels (then emitting the EOS token) would yield $20 \\%$ accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=3 colspan=1>Task InductionInner ShotsRepeats</td><td rowspan=2 colspan=1>X1</td><td rowspan=1 colspan=1>√      √    √</td><td rowspan=2 colspan=1>√      √    √1     1     1</td></tr><tr><td rowspan=1 colspan=1>1     3     5</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0     0     0</td><td rowspan=1 colspan=1>1     3     5</td></tr><tr><td rowspan=1 colspan=1>FrozenFrozen (Real-Name)</td><td rowspan=1 colspan=1>18.00.9</td><td rowspan=1 colspan=1>21.3 22.4 22.112.4 34.0 31.0</td><td rowspan=1 colspan=1>21.5 21.1 20.932.0 33.2 33.8</td></tr><tr><td rowspan=3 colspan=1>Frozen test-blindFrozen test-blind (Real-Name)ANIL Baseline [32]</td><td rowspan=3 colspan=1>、1</td><td rowspan=1 colspan=1>18.6 19.9 19.8</td><td rowspan=2 colspan=1>1              1</td></tr><tr><td rowspan=1 colspan=1>4.6   22.6 20.8</td></tr><tr><td rowspan=1 colspan=1>45.5 57.7 62.6</td><td rowspan=1 colspan=1>1     1      1</td></tr></table>",
+        "bbox": [
+            220,
+            85,
+            776,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            286,
+            825,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To quantify how much harder the introduction of new words for known categories makes this task, we also created a variant (Guided-VQA) in which the original category names (‘cat’ or ‘dog’) are used instead of ‘dax’ and ‘blicket’. Guided-VQA is a special case of Fast-VQA involving questions from Visual Genome, where the model is reminded what the important entities in the question look like prior to answering the question by labeling sample images with real category names. Guided-VQA does not require the same ability to bind categories to new words, but it does measure how well a model can exploit task-relevant multimodal guidance when attempting a new task in an otherwise zero-shot manner. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            487
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fast-VQA and Guided-VQA are very challenging tasks because they are attempted without taskspecific training, and because the underlying questions come from Visual Genome (VQAv2 images do not come with the necessary meta-data to construct the task). Visual Genome questions are particularly challenging because only a single answer exists for each question. When scoring models, for simplicity we credit only an exact match with the output generated by the model, modulo the same post-processing applied for VQAv2. Because of the inherent difficulty of the task, we use strong baselines that can still utilize the large language model to verify strength of observed effects. ",
+        "bbox": [
+            174,
+            493,
+            826,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ccada4bcc57a878e22de0fa6f3622ab3ea59372b2052e4a45baa58d159586565.jpg",
+        "table_caption": [
+            "Table 5: Performance of Frozen versus an equivalent blind model on Fast and Guided-VQA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"5\">Fast-VQA</td><td colspan=\"4\">Guided-VQA</td></tr><tr><td>Inner Shots</td><td>0</td><td>1</td><td>3</td><td>5</td><td>0</td><td>1</td><td>3</td><td>5</td></tr><tr><td>Frozen</td><td>1.6</td><td>2.8</td><td>7.0</td><td>7.9</td><td>3.7</td><td>7.8</td><td>10.1</td><td>10.5</td></tr><tr><td>Frozen train-blind</td><td>0.7</td><td>0.3</td><td>1.3</td><td>0.4</td><td>1.9</td><td>2.3</td><td>3.7</td><td>3.7</td></tr></table>",
+        "bbox": [
+            264,
+            611,
+            732,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 5, the fact that the model improves with more shots in both Fast-VQA and GuidedVQA confirms that Frozen has some capacity to integrate novel words into its general capacity to process and generate natural language in a multimodal context. It is notable that a prefix-tuned model with no access to images improves moderately at Guided-VQA as more categories are presented, showing that additional linguistic cues (just being reminded of the words involved and the linguistic form of the task) goes some way to preparing for the upcoming question. As exemplified in Figure 4, inspection of the model output confirms that in many cases it is indeed the multimodal (and not just linguistic) support that enables Frozen to improve performance as the number of shots increases. We observed that there are diminishing returns in performance gain as the number of shots increase. One possible explanation is that the shift from the training distribution of contexts with single images to multiple images causes inaccuracies in the model. ",
+        "bbox": [
+            174,
+            723,
+            826,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Open-Ended miniImagenet, Real-Name miniImagenet, Fast-VQA and Guided-VQA evaluation sets are available to download at https://fh295.github.io/frozen.html. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            292,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.1 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            121,
+            294,
+            136
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We believe this work is an important proof-of-concept for a desired, much more powerful system capable of open-ended multimodal few-shot learning. Frozen achieves the necessary capacities to some degree, but a key limitation is that it achieves far from state-of-the-art performance on the specific tasks that it learns in a few shots, compared to systems that use the full training set for those tasks. As such, the main contribution of this work should be seen as a starting point or baseline for this exciting area of research of multimodal few-shot learning. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Further improvement can make the impressive zero-shot and few-shot generalization we observed more robust as reflected by higher accuracy and fewer seeds required to demonstrate our most compelling samples. Finally, there are many technical questions that were not explored in this proofof-concept study, such as whether performance could be improved with more elaborate architectures for mixing vision and language. We leave the exploration of these possibilities to future investigations. The Open-Ended miniImageNet, Real-Name miniImagenet, Fast-VQA and Guided-VQA benchmarks that we provide with this manuscript should facilitate the evaluation and analysis of future systems of this type. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.2 Societal Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            363,
+            320,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "With the emergence of this new class of general purpose vision-language models, new capabilities of massive surveillance can be feasible. Both surveillance footage and publicly shared images can be analyzed for arbitrary questions without requiring any new labeled data or training of the system. As a mitigation for individuals, personal assistant software with similar capabilities can analyze publicly available documents about themselves to identify unintended exposures, even when novel concerns emerge either due to societal change or change of personal preferences. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Generative models of text that can incorporate visual information can elevate the misuse of languagemodel generated content by making them even more convincing. Moreover, at this point we do not have sufficient tools to identify bias and toxicity issues of general purpose vision-guided language models. We invite the community to think about effective methods and benchmarks on this front. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "More positively, systems like Frozen could be applied to assist visually impaired users of technology. Frozen’s ability to adapt to different styles of caption or question could enable a more personalised user experience in these cases. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are environmental costs associated with training the large networks in systems like Frozen. On the other hand, a system that can be trained once and then flexibly adapted to different settings could have a lower energy footprint overall than one that requires re-training for different applications. ",
+        "bbox": [
+            176,
+            589,
+            823,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            290,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented a method for transforming large language models into multimodal few-shot learning systems by extending the soft-prompting philosophy of prefix tuning [23] to ordered sets of images and text while preserving text prompting abilities of the language model. Our experiments confirm that the resulting system, Frozen, is capable both of open-ended interpretation of images and genuinely multimodal few-shot learning even though the system is only trained to do captioning. One corollary of these results is that the knowledge required to quickly bind together or associate different words in language is also pertinent to rapidly binding language to visual elements across an ordered set of inputs. This finding extends the conclusion of [26] – that knowledge in transformer language models can transfer to non-linguistic tasks – to the specific case of knowledge about few-shot learning. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements We wish to thank Sebastian Borgeaud and Jack Rae for preparing the pretraining text dataset and pretraining a selection of transformer language models, as well as Trevor Cai for help with experiments and infrastructure. We also wish to thank Pauline Luc, Jeff Donahue, Malcolm Reynolds, Andy Brock, Karen Simonyan, Jean-Baptiste Alayrac, Antoine Miech, Charlie Nash, Aaron van den Oord, Marc Deisenroth, Aida Nematzadeh, Roman Ring, Francis Song, Eliza Rutherford, Kirsty Anderson, Esme Sutherland, Alexander Novikov, Daan Wierstra, and Nando de Freitas for insightful discussions during the course of the project. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Daniel Adiwardana, Minh-Thang Luong, David R. So, Jamie Hall, Noah Fiedel, Romal Thoppilan, Zi Yang, Apoorv Kulshreshtha, Gaurav Nemade, Yifeng Lu, and Quoc V. Le. Towards a human-like open-domain chatbot. CoRR, abs/2001.09977, 2020. [2] Emily M Bender and Alexander Koller. Climbing towards nlu: On meaning, form, and understanding in the age of data. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5185–5198, 2020.   \n[3] Andrew Brock, Soham De, Samuel L Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   \n[4] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   \n[5] David Chalmers. Gpt3 and general intelligence. Published in Daily Nous, 2021.   \n[6] Jun Chen, Han Guo, Kai Yi, Boyang Li, and Mohamed Elhoseiny. Visualgpt: Data-efficient adaptation of pretrained language models for image captioning. arXiv preprint arXiv:2102.10407, 2021.   \n[7] Jaemin Cho, Jie Lei, Hao Tan, and Mohit Bansal. Unifying vision-and-language tasks via text generation. arXiv preprint arXiv:2102.02779, 2021.   \n[8] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   \n[9] Allen Institute for AI. C4 search. https://c4-search.apps.allenai.org/. Accessed: 2021-04-06.   \n[10] Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the v in vqa matter: Elevating the role of image understanding in visual question answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 6904–6913, 2017.   \n[11] Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Realm: Retrieval-augmented language model pre-training, 2020.   \n[12] Tracy H Heibeck and Ellen M Markman. Word learning in children: An examination of fast mapping. Child development, pages 1021–1034, 1987.   \n[13] MD Zakir Hossain, Ferdous Sohel, Mohd Fairuz Shiratuddin, and Hamid Laga. A comprehensive survey of deep learning for image captioning. ACM Computing Surveys (CsUR), 51(6):1–36, 2019.   \n[14] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, and Tom Duerig. Scaling up visual and vision-language representation learning with noisy text supervision, 2021.   \n[15] Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre luc Cantin, Clifford Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, C. Richard Ho, Doug Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law, Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Matt Ross, Amir Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle, Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter performance analysis of a tensor processing unit, 2017.   \n[16] Douwe Kiela, Suvrat Bhooshan, Hamed Firooz, Ethan Perez, and Davide Testuggine. Supervised multimodal bitransformers for classifying images and text. arXiv preprint arXiv:1909.02950, 2019.   \n[17] Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International journal of computer vision, 123(1):32–73, 2017.   \n[18] Taku Kudo and John Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.   \n[19] Georgia Tech Visual Intelligence Lab. Vqa python api and evaluation code. https://github. com/GT-Vision-Lab/VQA.   \n[20] Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691, 2021.   \n[21] Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmented generation for knowledge-intensive nlp tasks, 2021.   \n[22] Sheng Li, Zhiqiang Tao, Kang Li, and Yun Fu. Visual to text: Survey of image and video captioning. IEEE Transactions on Emerging Topics in Computational Intelligence, 3(4):297– 312, 2019.   \n[23] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190, 2021.   \n[24] Xiujun Li, Xi Yin, Chunyuan Li, Pengchuan Zhang, Xiaowei Hu, Lei Zhang, Lijuan Wang, Houdong Hu, Li Dong, Furu Wei, Yejin Choi, and Jianfeng Gao. Oscar: Object-semantics aligned pre-training for vision-language tasks, 2020.   \n[25] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019.   \n[26] Kevin Lu, Aditya Grover, Pieter Abbeel, and Igor Mordatch. Pretrained transformers as universal computation engines. arXiv preprint arXiv:2103.05247, 2021.   \n[27] Kenneth Marino, Mohammad Rastegari, Ali Farhadi, and Roozbeh Mottaghi. Ok-vqa: A visual question answering benchmark requiring external knowledge. In 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 3190–3199. IEEE Computer Society, 2019.   \n[28] Fabio Petroni, Tim Rocktäschel, Patrick S. H. Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H. Miller, and Sebastian Riedel. Language models as knowledge bases? CoRR, abs/1909.01066, 2019.   \n[29] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision, 2021.   \n[30] Alec Radford, Jeffrey Wu, R. Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners, 2019.   \n[31] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.   \n[32] Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. arXiv preprint arXiv:1909.09157, 2019.   \n[33] Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning, 2016.   \n[34] Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.   \n[35] 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, 115(3):211–252, 2015.   \n[36] Thomas Scialom, Patrick Bordes, Paul-Alexis Dray, Jacopo Staiano, and Patrick Gallinari. What bert sees: Cross-modal transfer for visual question generation. arXiv preprint arXiv:2002.10832, 2020.   \n[37] Piyush Sharma, Nan Ding, Sebastian Goodman, and Radu Soricut. Conceptual captions: A cleaned, hypernymed, image alt-text dataset for automatic image captioning. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2556–2565, 2018.   \n[38] Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations, 2018.   \n[39] Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism, 2020.   \n[40] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pre-training of generic visual-linguistic representations. arXiv preprint arXiv:1908.08530, 2019.   \n[41] Yingtao Tian and Jesse Engel. Latent translation: Crossing modalities by bridging generative models, 2019.   \n[42] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   \n[43] Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. arXiv preprint arXiv:1606.04080, 2016.   \n[44] Jialin Wu, Jiasen Lu, Ashish Sabharwal, and Roozbeh Mottaghi. Multi-modal answer validation for knowledge-based vqa, 2021.   \n[45] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transformers, 2021.   \n[46] Zachary M Ziegler, Luke Melas-Kyriazi, Sebastian Gehrmann, and Alexander M Rush. Encoderagnostic adaptation for conditional language generation. arXiv preprint arXiv:1908.06938, 2019. ",
+        "bbox": [
+            171,
+            103,
+            828,
+            910
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            496
+        ],
+        "page_idx": 12
+    }
+]

parse/train/cKnKJcTPRcV/cKnKJcTPRcV.md

@@ -0,0 +1,346 @@
+# HYPERSAGE: GENERALIZING INDUCTIVE REPRESENTATION LEARNING ON HYPERGRAPHS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graphs are the most ubiquitous form of structured data representation used in machine learning. They model, however, only pairwise relations between nodes and are not designed for encoding the higher-order relations found in many real-world datasets. To model such complex relations, hypergraphs have proven to be a natural representation. Learning the node representations in a hypergraph is more complex than in a graph as it involves information propagation at two levels: within every hyperedge and across the hyperedges. Most current approaches first transform a hypergraph structure to a graph for use in existing geometric deep learning algorithms. This transformation leads to information loss, and sub-optimal exploitation of the hypergraph’s expressive power. We present HyperSAGE, a novel hypergraph learning framework that uses a two-level neural message passing strategy to accurately and efficiently propagate information through hypergraphs. The flexible design of HyperSAGE facilitates different ways of aggregating neighborhood information. Unlike the majority of related work which is transductive, our approach, inspired by the popular GraphSAGE method, is inductive. Thus, it can also be used on previously unseen nodes, facilitating deployment in problems such as evolving or partially observed hypergraphs. Through extensive experimentation, we show that HyperSAGE outperforms state-of-the-art hypergraph learning methods on representative benchmark datasets. We also demonstrate that the higher expressive power of HyperSAGE makes it more stable in learning node representations as compared to the alternatives.
+
+# 1 INTRODUCTION
+
+Graphs are considered the most prevalent structures for discovering useful information within a network, especially because of their capability to combine object-level information with the underlying inter-object relations (Wu et al., 2020). However, most structures encountered in practical applications form groups and relations that cannot be properly represented using pairwise connections alone, hence a graph may fail to capture the collective flow of information across objects. In addition, the underlying data structure might be evolving and only partially observed. Such dynamic higher-order relations occur in various domains, such as social networks (Tan et al., 2011), computational chemistry (Gu et al., 2020), neuroscience (Gu et al., 2017) and visual arts (Arya et al., 2019), among others. These relations can be readily represented with hypergraphs, where an edge can connect an arbitrary number of vertices as opposed to just two vertices in graphs. Hypergraphs thus provide a more flexible and natural framework to represent such multi-way relations (Wolf et al., 2016), however, this requires a representation learning technique that exploits the full expressive power of hypergraphs and can generalize on unseen nodes from a partially observed hypergraph.
+
+Recent work in the field of geometric deep learning have presented formulations on graph structured data for the tasks of node classification (Kipf & Welling, 2016), link prediction (Zhang & Chen, 2018), or the classification of graphs (Zhang et al., 2018b). Subsequently, for data containing higher-order relations, a few recent papers have presented hypergraph-based learning approaches on similar tasks (Yadati et al., 2019; Feng et al., 2019). A common implicit premise in these papers is that a hypergraph can be viewed as a specific type of regular graph. Therefore, reduction of hypergraph learning problem to that of a graph should suffice. Strategies to reduce a hypergraph to a graph include transforming the hyperedges into multiple edges using clique expansion (Feng et al., 2019; Jiang et al., 2019; Zhang et al., 2018a), converting to a heterogeneous graph using star expansion (Agarwal et al., 2006), and replacing every hyperedge with an edge created using a certain predefined metric (Yadati et al., 2019). Yet these methods are based on the wrong premise, motivated chiefly by a larger availability of graph-based approaches. By reducing a hypergraph to regular graph, these approaches make existing graph learning algorithms applicable to hypergraphs. However, hypergraphs are not a special case of regular graphs. The opposite is true, regular graphs are simply a specific type of hypergraph (Berge & Minieka, 1976). Therefore, reducing the hypergraph problem to that of a graph cannot fully utilize the information available in hypergraph. Two schematic examples outlining this issue are shown in Fig.1. To address tasks based on complex structured data, a hypergraph-based formulation is needed that complies with the properties of a hypergraph.
+
+![](images/282bdbdd37a77e1a200176c4245ee9b07751c77e470f56e87ca64f112f3e8688.jpg)  
+Figure 1: (a) Example showing reduction of a hypergraph to a graph using clique and star expansion methods. The clique expansion loses the unique information associated with the hyperedge defined by the set of nodes $\{ v _ { 2 } , v _ { 3 } \}$ , and it cannot distinguish it from the hyperedge defined by the nodes $\{ \dot { v } _ { 1 } , v _ { 2 } , v _ { 3 } \}$ . Star expansion creates a heterogeneous graph that is difficult to handle using most well-studied graph methods (Hein et al., 2013). (b) Schematic representations of two Fano planes comprising 7 nodes and 7 hyperedges (6 straight lines and 1 circle.). The second Fano plane is a copy of the first with nodes $v _ { 2 }$ and $v _ { 3 }$ permuted. These two hypergraphs cannot be differentiated when transformed to a graph using clique expansion.
+
+A major limitation of the existing hypergraph learning frameworks is their inherently transductive nature. This implies that these methods can only predict characteristics of nodes that were present in the hypergraph at training time, and fail to infer on previously unseen nodes. The transductive nature of existing hypegraph approaches makes them inapplicable in, for example, finding the most promising target audience for a marketing campaign or making movie recommendations with new movies appearing all the time. An inductive solution would pave the way to solve such problems using hypergraphs. The inductive learning framework must be able to identify both the node’s local role in the hypergraph, as well as its global position (Hamilton et al., 2017). This is important for generalizing the learned node embeddings that the algorithm has optimized on to a newly observed hypergraph comprising previously unseen nodes, thus, making inductive learning a far more complex problem compared to the transductive learning methods.
+
+In this paper, we address the above mentioned limitations of the existing hypergraph learning methods. We propose a simple yet effective inductive learning framework for hypergraphs that is readily applicable to graphs as well. Our approach relies on neural message passing techniques due to which it can be used on hypergraphs of any degree of cardinality without the need for reduction to graphs. The points below highlight the contributions of this paper:
+
+• We address the challenging problem of representation learning on hypergraphs by proposing HyperSAGE, comprising a message passing scheme which is capable of jointly capturing the intra-relations (within a hyperedge) as well as inter-relations (across hyperedges). • The proposed hypergraph learning framework is inductive, i.e. it can perform predictions on previously unseen nodes, and can thus be used to model evolving hypergraphs. • HyperSAGE facilitates neighborhood sampling and provides the flexibility in choosing different ways to aggregate information from the neighborhood. • HyperSAGE is more stable than state-of-the-art methods, thus provides more accurate results on node classification tasks on hypergraphs with reduced variance in the output.
+
+# 2 RELATED WORK
+
+Learning node representations using graph neural networks has been a popular research topic in the field of geometric deep learning (Bronstein et al., 2017). Graph neural networks can be broadly classified into spatial (message passing) and spectral networks. We focus on a family of spatial message passing graph neural networks that take a graph with some labeled nodes as input and learn embeddings for each node by aggregating information from its neighbors (Xu et al., 2019). Message passing operations in a graph simply propagate information along the edge connecting two nodes. Many variants of such message passing neural networks have been proposed, with some popular ones including Gori et al. (2005); Li et al. (2015); Kipf & Welling (2016); Gilmer et al. (2017); Hamilton et al. (2017).
+
+Zhou et al. (2007) introduced learning on hypergraphs to model high-order relations for semisupervised classification and clustering of nodes. Emulating a graph-based message passing framework for hypergraphs is not straightforward since a hyperedge involves more than two nodes which makes the interactions inside each hyperedge more complex. Representing a hypergraph with a matrix makes it rigid in describing the structures of higher order relations (Li et al., 2013). On the other hand, formulating message passing on a higher dimensional representation of hypergraph using tensors makes it computationally expensive and restricts it to only small datasets (Zhang et al., 2019). Several tensor based methods do perform learning on hypergraphs (Shashua et al., 2006; Arya et al., 2019), however they are limited to uniform hypergraphs only.
+
+To resolve the above issues, Feng et al. (2019) and Bai et al. (2020) reduce a hypergraph to graph using clique expansion and perform graph convolutions on them. These approaches cannot utilize complete structural information in the hypergraph and lead to unreliable learning performance for e.g. classification, clustering and active learning (Li & Milenkovic, 2017; Chien et al., 2019). Another approach by Yadati et al. (2019), named HyperGCN, replaces a hyperedge with pair-wise weighted edges between vertices (called mediators). With the use of mediators, HyperGCN can be interpreted as an improved approach of clique expansion, and to the best of our knowledge, is also the state-of-the-art method for hypergraph representation learning. However, for many cases such as Fano plane where each hyperedge contains at most three nodes, HyperGCN becomes equivalent to the clique expansion (Dong et al., 2020). In spectral theory of hypergraphs, methods have been proposed that fully exploit the hypergraph structure using non-linear Laplacian operators (Chan et al., 2018; Hein et al., 2013). In this work, we focus on message passing frameworks. Drawing inspiration from GraphSAGE (Hamilton et al., 2017), we propose to eliminate matrix (or tensor) based formulations in our neural message passing frameworks, which not only facilitates utilization of all the available information in a hypergraph, but also makes the entire framework inductive in nature.
+
+# 3 PROPOSED MODEL: HYPERSAGE
+
+The core concept behind our approach is to aggregate feature information from the neighborhood of a node spanning across multiple hyperedges, where the edges can have varying cardinality. Below, we first define some preliminary terms, and then describe our generic aggregation framework. This framework performs message passing at two-levels for a hypergraph. Further, for any graphstructured data, our framework emulates the one-level aggregation similar to GraphSAGE (Hamilton et al., 2017). Our approach inherently allows inductive learning, which makes it also applicable on hypergraphs with unseen nodes.
+
+# 3.1 PRELIMINARIES
+
+Definition 1 (Hypergraph). A general hypergraph $\mathcal { H }$ can be represented as $\mathcal { H } = ( \boldsymbol { \vartheta } , \boldsymbol { \mathcal { E } } , \mathbf { X } )$ , where $\nabla = \{ v _ { 1 } , v _ { 2 } , . . . , \bar { v } _ { N } \}$ denotes a set of $N$ nodes (vertices) and $\mathfrak { E } = \{ \mathbf { e } _ { 1 } , \mathbf { e } _ { 2 } , . . . , \mathbf { e } _ { K } \}$ denotes a set of hyperedges, with each hyperedge comprising a non-empty subset from $\mathcal { V }$ . $\mathbf { X } \in \mathbb { R } ^ { N \times d }$ denote the feature matrix, such that $\mathbf { x } _ { i } \in \mathbf { X }$ is the feature vector characterizing node $v _ { i } \in \mathcal V$ . The maximum cardinality of the hyperedges in $\mathcal { H }$ is denoted as $M = { \underset { \mathbf { e } \in \mathbb { E } } { \operatorname* { m a x } } } | \mathbf { e } |$ .
+
+Unlike in a graph, the hyperedges of $\mathcal { H }$ can contain different number of nodes and $M$ denotes the largest number. From the definition above, we see that graphs are a special case of hypergraphs with
+
+$M { = } 2$ . Thus, compared to graphs, hypergraphs are designed to model higher-order relations between nodes. Further, we define three types of neighborhoods in a hypergraph:
+
+Definition 2 (Intra-edge neighborhood). The intra-edge neighborhood of a node $v _ { i } \in \mathcal V$ for any hyperedge $\mathbf { e } \in \mathcal { E }$ is defined as the set of nodes $v _ { j }$ belonging to e and is denoted by $\mathcal { N } ( v _ { i } , \mathbf { e } )$
+
+Further, let $E ( v _ { i } ) = \{ \mathbf { e } \in \mathcal { E } \mid v _ { i } \in \mathbf { e } \}$ be the sets of hyperedges that contain node $v _ { i }$ .
+
+Definition 3 (Inter-edge neighborhood). The inter-edge neighborhood of a node $\boldsymbol { v } _ { i } \in \mathcal { V }$ also referred as its global neighborhood, is defined as the neighborhood of $v _ { i }$ spanning across the set of hyperedges $E ( v _ { i } )$ and is represented by $\begin{array} { r } { \mathcal { N } ( v _ { i } ) = \bigcup _ { \mathbf { e } \in E ( v _ { i } ) } \mathcal { N } ( v _ { i } , \mathbf { e } ) } \end{array}$ .
+
+Definition 4 (Condensed neighborhood). The condensed neighborhood of any node $\boldsymbol { v } _ { i } ~ \in ~ \mathcal { V }$ is $a$ sampled set of $\alpha \leq | \mathbf { e } |$ nodes from a hyperedge $\mathbf { e } \in E ( v _ { i } )$ denoted by $N ( v _ { i } , \mathbf { e } ; \alpha ) \subset \mathbb { N } ( v _ { i } , \mathbf { e } )$ .
+
+# 3.2 GENERALIZED MESSAGE PASSING FRAMEWORK
+
+We propose to interpret the propagation of information in a given hypergraph as a two-level aggregation problem, where the neighborhood of any node is divided into intra-edge neighbors and inter-edge neighbors. For message aggregation, we define aggregation function $\mathcal { F } ( \cdot )$ as a permutation invariant set function on a hypergraph $\mathcal { H } = ( \mathcal { V } , \mathcal { E } , \mathbf { X } )$ that takes as input a countable unordered message set and outputs a reduced or aggregated message. Further, for two-level aggregation, let $\mathcal { F } _ { 1 } ( \cdot )$ and $\mathcal { F } _ { 2 } ( \cdot )$ denote the intra-edge and inter-edge aggregation functions, respectively. Schematic representation of the two aggregation functions is provided in Fig.2. Similar to $\mathbf { X }$ we also define $\mathbf { Z }$ as the encoded feature matrix built using the outputs $\mathbf { z } _ { i }$ of aggregation functions. Message passing at node $v _ { i }$ for aggregation of information at the $l ^ { \mathrm { { \bar { t h } } } }$ layer can then be stated as
+
+$$
+\begin{array} { r l } & { \mathbf { x } _ { i , l } ^ { ( \mathbf { e } ) }  \mathcal { F } _ { 1 } ( \{ \mathbf { x } _ { j , l - 1 } \mid v _ { j } \in \mathsf { N } ( v _ { i } , \mathbf { e } ; \alpha ) \} ) , } \\ & { \mathbf { x } _ { i , l }  \mathbf { x } _ { i , l - 1 } + \mathcal { F } _ { 2 } ( \{ \mathbf { x } _ { i , l } ^ { ( \mathbf { e } ) } \mid v _ { i } \in E ( v _ { i } ) \} ) , } \end{array}
+$$
+
+where, $\mathbf { x } _ { i , l } ^ { ( \mathbf { e } ) }$ refers to the aggregated feature set at $v _ { i }$ obtained with intra-edge aggregation for edge e.
+
+The combined two-level message passing is achieved using nested aggregation function $\mathcal { F } = \mathcal { F } _ { 2 }$ . To ensure that the expressive power of a hypergraph is preserved or at least the loss is minimized, the choice of aggregation function should comply with certain properties.
+
+Firstly, the aggregation function should be able to capture the features of neighborhood vertices in a manner that is invariant to the permutation of the nodes and hyperedges. Many graph representation learning methods use permutation invariant aggregation functions, such as mean, sum and max functions $\mathrm { { X u } }$ et al., 2019). These aggregations have proven to be successful for node classification problems. For the existing hypergraph frameworks, reduction to simple graphs along with a matrix-based message passing framework limits the possibilities of using different types of feature aggregation functions, and hence curtails the potential to explore unique node representations.
+
+![](images/085d45f84f12379d16cfb332faf13d5d16c9384c7b990d439d1057e2e3f252a8.jpg)  
+Figure 2: Schematic representation of the twolevel message passing scheme of HyperSAGE, with aggregation functions $\mathcal { F } _ { 1 } ( \cdot )$ and $\mathsf { \bar { F } } _ { 2 } ( \cdot )$ . It shows information aggregation from two hyperedges $\mathbf { e } _ { A }$ and $\mathbf { e } _ { B }$ , where the intra-edge aggregation is from sampled sets of 5 nodes $( \alpha = 5$ ) for each hyperedge. For node $v _ { i }$ , $\mathbf { x } _ { i }$ and $\mathbf { z } _ { i }$ denote the input and encoded feature vector, respectively.
+
+Secondly, the aggregation function should also preserve the global neighborhood invariance at the ‘dominant nodes’ of the graph. Here, dominant nodes refer to nodes that contain important features, thereby, impacting the learning process relatively more than their neighbors. The aggregation function should ideally be insensitive to the input, whether the provided hypergraph contains a few large hyperedges, or a larger number of smaller ones obtained from splitting them. Generally, a hyperedge would be split in a manner that the dominant nodes are shared across the resulting hyperedges. In such cases, global neighborhood invariance would imply that the aggregated output at these nodes before and after the splitting of any associated hyperedge stays the same. Otherwise, the learned representation of a node will change significantly with each hyperedge split.
+
+Based on these considerations, we define the following properties for a generic message aggregation function that should hold for accurate propagation of information through the hypergraphs.
+
+Property 1 (Hypergraph Isomorphic Equivariance). A message aggregation function $\mathcal { F } ( \cdot )$ is equivariant to hypergraph isomorphism, if for two isomorphic hypergraphs $\mathcal { H } = ( \boldsymbol { \nabla } , \boldsymbol { \mathcal { E } } , \mathbf { X } )$ and $\bar { \mathcal { H } } ^ { * } = ( \bar { \mathcal { V } } ^ { * } , \mathcal { E } ^ { * } , \bar { \bf X ^ { * } } )$ , given that $\mathcal { H } ^ { \ast } = \sigma \bullet \mathcal { H }$ , and $\mathbf { Z }$ and $\mathbf { Z } ^ { \ast }$ represent the encoded feature matrices obtained using $\mathcal { F } ( \cdot )$ on $\mathcal { H }$ and $\mathcal { H } ^ { * }$ , the condition $\mathbf { Z } ^ { * } = \sigma \bullet \mathbf { Z }$ holds. Here, $\sigma$ denotes a permutation operator on hypergraphs.
+
+Property 2 (Global Neighborhood Invariance). A message aggregation scheme $\mathcal { F } ( \cdot )$ satisfies global neighborhood invariance at any node $\boldsymbol { v } _ { i } ~ \in ~ \mathcal { V }$ for a given hypergraph $\mathcal { H } = ( \boldsymbol { \nabla } , \boldsymbol { \mathcal { E } } , \mathbf { X } )$ if for any operation $\Gamma ( \cdot )$ , such that $\mathcal { H } ^ { * } = \Gamma ( \mathcal { H } )$ , and $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i } ^ { * }$ denote the encoded feature vectors obtained using $\mathcal { F } ( \cdot )$ at node $v _ { i }$ on $\mathcal { H }$ and $\mathcal { H } ^ { * }$ , the condition $\mathbf { z } _ { i } ^ { * } ~ = ~ \mathbf { z } _ { i }$ holds. Here $\Gamma ( \mathcal { \mathrm { H } } )$ could refer to operations such as hyperedge contraction or expansion.
+
+The flexibility of our message passing framework allows us to go beyond the simple aggregation functions on hypergraphs without violating Property 1. We introduce a series of power mean functions as aggregators, which have recently been shown to generalize well on graphs (Li et al., 2020). We perform message aggregation in hypergraphs using these generalized means, denoted by $M _ { p }$ and provide in section 4.2, a study on their performances. We also show that with appropriate combinations of the intra-edge and inter-edge aggregations Property 2 is also satisfied. This property ensures that the representation of a node after message passing is invariant to the cardinality of the hyperedge, i.e., the aggregation scheme should not be sensitive to hyperedge contraction or expansion, as long as the global neighborhood of a node remains the same in the hypergraph.
+
+Aggregation Functions. One major advantage of our strategy is that the message passing module is decoupled from the choice of the aggregation itself. This allows our approach to be used with a broad set of aggregation functions. We discuss below a few such possible choices.
+
+Generalized means. Also referred to as power means, this class of functions are very commonly used for getting an aggregated measure over a given set of samples. Mathematically, generalized means can be expressed as $\begin{array} { r } { M _ { p } = \left( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } x _ { i } ^ { p } \right) ^ { \frac { 1 } { p } } } \end{array}$ , where $n$ refers to the number of samples in the aggregation, and denotes its power. The choice of allows providing different interpretations to the aggregation function. For example, $p = 1$ denotes arithmetic mean aggregation, $p = 2$ refers to mean squared estimate and a large value of $p$ corresponds to max pooling from the group. Similarly, $M _ { p }$ can be used for geometric and harmonic means with $p  0$ and $p = - 1$ , respectively.
+
+Similar to the recent work of Li et al. (2020), we use generalized means for intra-edge as well as inter-edge aggregation. The two functions $\mathcal { F } _ { 1 } ( \cdot )$ and $\mathcal { F } _ { 2 } ( \cdot )$ for aggregation at node $v _ { i }$ is defined as
+
+$$
+\begin{array} { l } { \displaystyle \mathfrak { F } _ { 1 } ^ { ( i ) } ( \mathbf { s } ) = \left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } ) | | \mathscr { N } ( v _ { i } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } ) } \left( \sum _ { m = 1 } ^ { | E ( v _ { i } ) | } \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } _ { m } ) | } \right) ^ { - 1 } \mathbf { x } _ { j } ^ { p } \right) ^ { \frac { 1 } { p } } } \\ { \displaystyle \mathfrak { F } _ { 2 } ^ { ( i ) } ( \mathbf { s } ) = \left( \frac { 1 } { | E ( v _ { i } ) | } \sum _ { \mathbf { e } \in E ( v _ { i } ) } ( \mathscr { F } _ { 1 } ( \mathbf { s } ) ) ^ { p } \right) ^ { \frac { 1 } { p } } } \end{array}
+$$
+
+where we use ‘s’ for concise representation of the unordered set of input as shown in Eq.1. Here and henceforth in this paper, we remove the superscript index $\mathbf { \rho } ( i ) ^ { \prime }$ for the sake of clarity and further occurrences of the two aggregation functions shall be interpreted in terms of node $v _ { i }$ . Note that in Eq. 3 and Eq. 4, we have chosen the power term $p$ to be same for ${ \mathcal { F } } _ { 1 }$ and $\mathcal { F } _ { 2 }$ so as to satisfy the global neighborhood invariance as stated in Property 2. Note, the scaling term added to ${ \mathcal { F } } _ { 1 }$ is added to balance the bias in the weighting introduced in intra-edge aggregation due to varying cardinality across the hyperedges. These restrictions ensure that the joint aggregation $\mathcal { F } _ { 2 } ( \cdot )$ satisfies the property of global neighborhood invariance at all times. Proof of the two aggregations satisfying Property 2 is stated in Appendix B.
+
+Sampling-based Aggregation. Our neural message passing scheme provides the flexibility to adapt the message aggregation module to fit the desired computational budget through aggregating information from only a subset $N ( v _ { i } , \mathbf { e } ; \alpha )$ of the full neighborhood $N ( v _ { i } , \mathbf { e } )$ , if needed. We propose to apply sub-sampling only on the nodes from the training set, and use information from the full neighborhood for the test set. The advantages of this are twofold. First, reduced number of samples per aggregation at training time reduces the relative computational burden. Second, similar to dropout (Srivastava et al., 2014), it serves to add regularization to the optimization process. Using the full neighborhood on test data avoids randomness in the test predictions, and generates consistent output.
+
+# 3.3 INDUCTIVE LEARNING ON HYPERGRAPHS
+
+HyperSAGE is a general framework for learning node representations on hypergraphs, on even unseen nodes. Our approach uses a neural network comprising $L$ layers, and feature-aggregation is performed at each of these layers, as well as across the hyperedges.
+
+Algorithm 1 describes the forward propagation mechanism which implements the aggregation function $\mathcal { F } ( \cdot ) ~ = ~ \mathcal { F } _ { 2 } ( \cdot )$ described above. At each iteration, nodes first aggregate information from their neighbors within a specific hyperedge. This is repeated over all the hyperedges across all the $L$ layers of the network. The trainable weight matrices $\mathbf { W } ^ { l }$ with $l \in L$ are used to aggregate information across the feature dimension and propagate it through the various layers of the hypergraph.
+
+Generalizability of HyperSAGE. HyperSAGE can be interpreted as a generalized formulation that unifies various existing graphbased as well as hypergraph formulations. Our approach unifies them, identifying each of these as special variants/cases of our method. We discuss here briefly the two popular algorithms.
+
+Graph Convolution Networks (GCN). The GCN approach proposed by Kipf & Welling (2016) is a graph-based method that can be derived as a special case of HyperSAGE with maximum
+
+# Algorithm 1 HyperSAGE Message Passing
+
+Input : $\mathcal { H } = ( \boldsymbol { \nabla } , \mathcal { E } , \mathbf { X } )$ ; depth $L$ ; weight matrices $\mathbf { W } ^ { l }$ for $l = 1 \ldots L$ ; non-linearity $\sigma$ ; intra-edge aggregation function $\mathcal { F } _ { 1 } ( \cdot )$ ; inter-edge aggregation function $\mathcal { F } _ { 2 } ( \cdot )$   
+Output: Node embeddings $\mathbf { z } _ { i } |$ $v _ { i } \in \mathcal V$   
+$\mathbf { h } _ { i } ^ { 0 } \bar {  } \mathbf { x } _ { i } \in \mathbf { X } \mid v _ { i } \in \mathcal { V }$   
+for $l = 1 \ldots L$ do for e ∈ E do hl ← hl−1 for vi ∈ e do h l ← h l + F ( i ) ( s ) end end $\mathbf { h } _ { i } ^ { l }  \sigma ( \mathbf { W } ^ { l } ( \mathbf { h } _ { i } ^ { l } / | | \mathbf { h } _ { i } ^ { l } | | _ { 2 } ) ) \mid v _ { i } \in \mathcal { V }$   
+end   
+$\mathbf { z } _ { i }  \mathbf { h } _ { i } ^ { L } \mid v _ { i } \in \mathcal { V }$
+
+cardinality $| M | = 2$ , and setting the agggregation function $\mathcal { F } _ { 2 } = M _ { p }$ with $p = 1$ . This being a graph-based method, ${ \mathcal { F } } _ { 1 }$ will not be used.
+
+GraphSAGE. Our approach, when reduced for graphs using $| M | = 2$ , is similar to GraphSAGE. For exact match, the aggregation function $\mathcal { F } _ { 2 }$ should be one of mean, max or $L S T M$ . Further, the sampling term $\alpha$ can be adjusted to match the number of samples per aggregation as in GraphSAGE.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENTAL SETUP
+
+For the experiments in this paper, we use co-citation and co-authorship network datasets: CiteSeer, PubMed, Cora (Sen et al., 2008) and DBLP (Rossi & Ahmed, 2015). The task for each dataset is to predict the topic to which a document belongs (multi-class classification). For these datasets, $\mathbf { x } _ { i }$ corresponds to a bag of words such that $x _ { i , j } \in \mathbf { x } _ { i }$ represents the normalized frequency of occurence of the $j ^ { t h }$ word. Additional details related to the hypergraph topology are presented in Appendix
+
+Table 1: Performance of HyperSAGE and other hypergraph learning methods on co-authorship and co-citation datasets.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Co-authorship Data</td><td colspan="3">Co-citation Data</td></tr><tr><td>DBLP</td><td>Cora</td><td>Pubmed</td><td>Citeseer</td><td>Cora</td></tr><tr><td>MLP +HLR</td><td>63.6 ± 4.7</td><td>59.8 ± 4.7</td><td>64.7 ± 3.1</td><td>56.1 ± 2.6</td><td>61.0 ± 4.1</td></tr><tr><td>HGNN</td><td>69.2 ± 5.1</td><td>63.2 ± 3.1</td><td>66.8 ± 3.7</td><td>56.7 ± 3.8</td><td>70.0 ± 2.9</td></tr><tr><td>FastHyperGCN</td><td>68.1 ± 9.6</td><td>61.1 ± 8.2</td><td>65.7 ± 11.1</td><td>56.2 ± 8.1</td><td>61.3 ± 10.3</td></tr><tr><td>HyperGCN</td><td>70.9 ± 8.3</td><td>63.9 ± 7.3</td><td>68.3 ± 9.5</td><td>57.3 ± 7.3</td><td>62.5 ± 9.7</td></tr><tr><td>HyperSAGE (p = 2)</td><td>71.5 ± 4.4</td><td>69.8 ± 2.6</td><td>71.3 ± 2.4</td><td>59.8 ± 3.3</td><td>62.9 ± 2.1</td></tr><tr><td>HyperSAGE (p = 1)</td><td>77.2 ± 4.3</td><td>72.4 ± 1.6</td><td>72.6 ± 2.1</td><td>61.8 ± 2.3</td><td>69.3 ± 2.7</td></tr><tr><td>HyperSAGE (p = 0.01)</td><td>77.4 ± 3.8</td><td>72.1 ± 1.8</td><td>72.9 ± 1.3</td><td>61.3 ± 2.4</td><td>68.2 ± 2.4</td></tr><tr><td>HyperSAGE (p = -1)</td><td>70.9 ± 2.3</td><td>67.4 ± 2.1</td><td>68.3 ± 3.1</td><td>59.8 ± 2.0</td><td>62.3 ± 5.7</td></tr></table>
+
+A.2. Further, for all experiments, we use a neural network with 2 layers. All models are implemented in Pytorch and trained using Adam optimizer. See Appendix A.2 for implementation details.
+
+# 4.2 SEMI-SUPERVISED NODE CLASSIFICATION ON HYPERGRAPHS
+
+Performance comparison with existing methods. We implemented HyperSAGE for the task of semi-supervised classification of nodes on a hypergraph, and the results are compared with stateof-the art methods. These include (a) Multi-layer perceptron with explicit hypergraph Laplacian regularisation $( \mathbf { M L P } + \mathbf { H L R } )$ , (b) Hypergraph Neural Networks (HGNN) (Feng et al., 2019) which uses a clique expansion, and (c) HyperGCN and its variants (Yadati et al., 2019) that collapse the hyperedges using mediators. For HyperSAGE method, we use 4 variants of generalized means $M _ { p }$ with $p = 1 , 2 , - 1$ and 0.01 with complete neighborhood i.e., $\alpha = | \mathbf { e } |$ . For all the cases, 10 data splits over 8 random weight initializations are used, totalling 80 experiments per method and for every dataset. The data splits are the same as in HyperGCN described in Appendix A.1.
+
+Table 1 shows the results obtained for the node classification task. We see that the different variants of HyperSAGE consistently show better scores across our benchmark datasets, except Cora cocitation where no improvement is observed compared to HGNN. Cora co-citation data is relatively small in size with a cardinality of $3 . 0 \pm 1 . 1$ , and we speculate that there does not exist enough scope of improving with HyperSAGE beyond what HGNN can express with the clique expansion.
+
+For the larger datasets such as DBLP and Pubmed, we see that the improvements obtained in performance with HyperSAGE over the best baselines are $6 . 3 \%$ and $4 . 3 \%$ respectively. Apart from its superior performance, HyperSAGE is also stable, and is less sensitive to the choice of data split and initialization of the weights. This is evident from the scores of standard deviation (SD) for the various experiments in Table 1. We see that the SD scores for our method are lower than other methods, and there is a significant gain in performance compared to HyperGCN. Another observation is that the HyperGCN method is very sensitive to the data splits as well as initializations with very large errors in the predictions. This is even higher for the FastHyperGCN variant. Also, we have found that all the 4 choices of $p$ work well with HyperSAGE for these datasets. We further perform a more comprehensive study analyzing the effect of $p$ on model performance later in this section.
+
+Stability analysis. We further study the stability of our method in terms of the variance observed in performance for different ratios of train and test splits, and compare results with that of HyperGCN implemented under similar settings. Fig. 3 shows results for the two learning methods on 5 different train-test ratios. We see that the performance of both models improves when a higher fraction of data is used for training, and the performances are approximately the same at the train-test ratio of 1/3.
+
+![](images/4340dbb94053c5b51e118b854005a17380a988c0817c660e92e9a0b05c4368c5.jpg)  
+Figure 3: Accuracy scores for HyperSAGE and HyperGCN obtained for different train-test ratios for multi-class classification datasets.
+
+Table 2: Performance of HyperSAGE for multiple values of $p$ in generalized means aggregator $( M _ { p } )$ on varying number of neighborhood samples $( \alpha )$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="4">DBLP</td><td colspan="4">Pubmed</td></tr><tr><td>α=2</td><td>α=3</td><td>α=5</td><td>α=10</td><td>α=2</td><td>α=3</td><td>α=5</td><td>α=10</td></tr><tr><td>p=-1</td><td>59.6</td><td>61.2</td><td>69.9</td><td>70.9</td><td>60.1</td><td>60.2</td><td>67.9</td><td>66.4</td></tr><tr><td>p = 0.01</td><td>61.2</td><td>64.8</td><td>73.1</td><td>77.4</td><td>65.5</td><td>67.4</td><td>73.4</td><td>72.9</td></tr><tr><td>p=1</td><td>62.3</td><td>64.5</td><td>73.1</td><td>77.2</td><td>64.8</td><td>64.3</td><td>72.2</td><td>72.6</td></tr><tr><td>p=2</td><td>63.1</td><td>63.8</td><td>71.9</td><td>71.5</td><td>63.7</td><td>63.9</td><td>70.8</td><td>71.3</td></tr><tr><td>p=3</td><td>62.7</td><td>63.6</td><td>71.3</td><td>71.4</td><td>62.2</td><td>61.3</td><td>70.1</td><td>67.9</td></tr><tr><td>p=5</td><td>62.8</td><td>63.3</td><td>69.4</td><td>70.6</td><td>62.1</td><td>60.4</td><td>69.3</td><td>68.0</td></tr></table>
+
+Table 3: Performance of HyperSAGE and its variants on nodes which were part of the training hypergraph (seen) and nodes which were not part of the training hypergraph (unseen).   
+
+<table><tr><td></td><td colspan="2">DBLP</td><td colspan="2">Pubmed</td><td colspan="2">Citeseer</td><td colspan="2">Cora (citation)</td></tr><tr><td>Method</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td></tr><tr><td>MLP + HLR</td><td>64.5</td><td>58.7</td><td>66.8</td><td>62.4</td><td>60.1</td><td>58.2</td><td>65.7</td><td>64.2</td></tr><tr><td>HyperSAGE (p = 0.01)</td><td>78.1</td><td>73.1</td><td>81.0</td><td>80.4</td><td>69.2</td><td>67.1</td><td>68.2</td><td>65.7</td></tr><tr><td>HyperSAGE (p =1)</td><td>78.1</td><td>73.2</td><td>78.5</td><td>76.4</td><td>69.3</td><td>67.9</td><td>71.3</td><td>66.8</td></tr><tr><td>HyperSAGE (p = 2)</td><td>76.1</td><td>70.2</td><td>71.2</td><td>69.8</td><td>65.9</td><td>63.8</td><td>65.9</td><td>64.5</td></tr></table>
+
+However, for smaller ratios, we see that HyperSAGE outperforms HyperGCN by a significant margin across all datasets. Further, the standard deviation for the predictions of HyperSAGE are significantly lower than that of HyperGCN. Clearly, this implies that HyperSAGE is able to better exploit the information contained in the hypergraph compared to HyperGCN, and can thus produce more accurate and stable predictions. Results on Cora and Citeseer can be found in Appendix C.
+
+Effect of generalized mean aggregations and neighborhood sampling. We study here the effect of different choices of the aggregation functions $\mathcal { F } _ { 1 } ( \cdot )$ and $\mathcal { F } _ { 2 } ( \cdot )$ on the performance of the model. Further, we also analyze how the number of samples chosen for aggregation affect its performance. Aggregation functions from $M _ { p }$ are chosen with $p = 1 , 2 , 3 , 4 , 5 , 0 . 0 1$ and $- 1$ , and to comply with global neighborhood invariance, we use aggregation function as in Eq. 4. The number of neighbors $\alpha$ for intra-edge aggregation are chosen to be 2, 3, 5 and 10. Table 2 shows the accuracy scores obtained for different choices of $p$ and $\alpha$ on DBLP and Pubmed datasets. For most cases, higher value of $p$ reduces the performance of the model. For $\alpha = 2$ on DBLP, performance seems to be independent of the choice of $p$ . A possible explanation could be that the number of neighbors is very small, and change in $p$ does not affect the propagation of information significantly. An exception is $p = - 1$ , where the performance drops for all cases. For Pubmed, the choice of $p$ seems to be very important, and we find that $p = 0 . 0 1$ seems to fit best.
+
+We also see that the number of samples per aggregation can significantly affect the performance of the model. For DBLP, model performance increases with increasing value of $\alpha$ . However, for Pubmed, we observe that performance improves up to $\alpha = 5$ , but then a slight drop is observed for larger sets of neighbors. Note that for Pubmed, the majority of the hyperedges have cardinality less than or equal to 10. This means that during aggregation, information will most often be aggregated from all the neighbors, thereby involving almost no stochastic sampling. Stochastic sampling of nodes could serve as a regularization mechanism and reduce the impact of noisy hyperedges. However, at $\alpha = 1 0$ , it is almost absent, due to which the noise in the data affects the performance of the model which is not the case in DBLP.
+
+# 4.3 INDUCTIVE LEARNING ON EVOLVING GRAPHS
+
+For inductive learning experiment, we consider the case of evolving hypergraphs. We create 4 inductive learning datasets from DBLP, Pubmed, Citeseer and Core (co-citation) by splitting each of the datasets into a train-test ratio of 1:4. Further, the test data is split into two halves: seen and unseen. The seen test set comprises nodes that are part of the hypergraph used for representation learning. Further, unseen nodes refer to those that are never a part of the hypergraph during training. To study how well HyperSAGE generalizes for inductive learning, we classify the unseen nodes and compare the performance with the scores obtained on the seen nodes. Further, we also compare our results on unseen nodes with those of $\mathrm { M L P { + } H L R }$ . The results are shown in Table 3. We see that results obtained with HyperSAGE on unseen nodes are significantly better than the baseline method. Further, these results seem to not differ drastically from those obtained on the seen nodes, thereby confirming that HyperSAGE can work with evolving graphs as well.
+
+# 5 CONCLUSION
+
+We have proposed HyperSAGE, a generic neural message passing framework for inductive learning on hypergraphs. The proposed approach fully utilizes the inherent higher-order relations in a hypergraph structure without reducing it to a regular graph. Through experiments on several representative datasets, we have shown that HyperSAGE outperforms the other methods for hypergraph learning. Several variants of graph-based learning algorithm such as GCN and GraphSAGE can be derived from the flexible aggregation and neighborhood sampling framework, thus making HyperSAGE a universal framework for learning node representations on hypergraphs as well as graphs.
+
+# REFERENCES
+
+Sameer Agarwal, Kristin Branson, and Serge Belongie. Higher order learning with graphs. In Proceedings of the 23rd international conference on Machine learning, pp. 17–24, 2006.
+
+Devanshu Arya, Stevan Rudinac, and Marcel Worring. Hyperlearn: a distributed approach for representation learning in datasets with many modalities. In Proceedings of the 27th ACM International Conference on Multimedia, pp. 2245–2253, 2019.
+
+Song Bai, Feihu Zhang, and Philip HS Torr. Hypergraph convolution and hypergraph attention. Pattern Recognition, pp. 107637, 2020.
+
+C. Berge and E. Minieka. Graphs and Hypergraphs. North-Holland mathematical library. North-Holland Publishing Company, 1976. ISBN 9780720424539. URL https://books. google.nl/books?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ ARoVvgAACAAJ.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+T-H Hubert Chan, Anand Louis, Zhihao Gavin Tang, and Chenzi Zhang. Spectral properties of hypergraph laplacian and approximation algorithms. Journal of the ACM (JACM), 65(3):1–48, 2018.
+
+I Eli Chien, Huozhi Zhou, and Pan Li. hsˆ2: Active learning over hypergraphs with pointwise and pairwise queries. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 2466–2475, 2019.
+
+Yihe Dong, Will Sawin, and Yoshua Bengio. HNHN: Hypergraph networks with hyperedge neurons. arXiv preprint arXiv:2006.12278, 2020.
+
+Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3558–3565, 2019.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. Proceedings of the 34th International Conference on Machine Learning, 2017.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Proceedings. 2005 IEEE International Joint Conference on Neural Networks, 2005., volume 2, pp. 729–734. IEEE, 2005.
+
+Shi Gu, Muzhi Yang, John D Medaglia, Ruben C Gur, Raquel E Gur, Theodore D Satterthwaite, and Danielle S Bassett. Functional hypergraph uncovers novel covariant structures over neurodevelopment. Human brain mapping, 38(8):3823–3835, 2017.
+
+Xuemei Gu, Lijun Chen, and Mario Krenn. Quantum experiments and hypergraphs: Multiphoton sources for quantum interference, quantum computation, and quantum entanglement. Physical Review A, 101(3):033816, 2020.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pp. 1024–1034, 2017.
+
+Matthias Hein, Simon Setzer, Leonardo Jost, and Syama Sundar Rangapuram. The total variation on hypergraphs-learning on hypergraphs revisited. In Advances in Neural Information Processing Systems, pp. 2427–2435, 2013.
+
+Jianwen Jiang, Yuxuan Wei, Yifan Feng, Jingxuan Cao, and Yue Gao. Dynamic hypergraph neural networks. In IJCAI, pp. 2635–2641, 2019.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2016.
+
+Guohao Li, Chenxin Xiong, Ali Thabet, and Bernard Ghanem. Deepergcn: All you need to train deeper gcns. arXiv preprint arXiv:2006.07739, 2020.
+
+Guoyin Li, Liqun Qi, and Gaohang Yu. The z-eigenvalues of a symmetric tensor and its application to spectral hypergraph theory. Numerical Linear Algebra with Applications, 20(6):1001–1029, 2013.
+
+Pan Li and Olgica Milenkovic. Inhomogeneous hypergraph clustering with applications. In Advances in Neural Information Processing Systems, pp. 2308–2318, 2017.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Ryan A. Rossi and Nesreen K. Ahmed. The network data repository with interactive graph analytics and visualization. In AAAI, 2015. URL http://networkrepository.com.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Amnon Shashua, Ron Zass, and Tamir Hazan. Multi-way clustering using super-symmetric nonnegative tensor factorization. In European conference on computer vision, pp. 595–608. Springer, 2006.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.
+
+Shulong Tan, Jiajun Bu, Chun Chen, Bin Xu, Can Wang, and Xiaofei He. Using rich social media information for music recommendation via hypergraph model. ACM Transactions on Multimedia Computing, Communications, and Applications (TOMM), 7(1):1–22, 2011.
+
+Michael M Wolf, Alicia M Klinvex, and Daniel M Dunlavy. Advantages to modeling relational data using hypergraphs versus graphs. In 2016 IEEE High Performance Extreme Computing Conference (HPEC), pp. 1–7. IEEE, 2016.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? International Conference on Learning Representations (ICLR), 2019.
+
+Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Vikram Nitin, Anand Louis, and Partha Talukdar. Hypergcn: A new method for training graph convolutional networks on hypergraphs. In Advances in Neural Information Processing Systems, pp. 1511–1522, 2019.
+
+Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pp. 5165–5175, 2018.
+
+Muhan Zhang, Zhicheng Cui, Shali Jiang, and Yixin Chen. Beyond link prediction: Predicting hyperlinks in adjacency space. In AAAI, volume 1, pp. 6, 2018a.
+
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018b.
+
+Songyang Zhang, Zhi Ding, and Shuguang Cui. Introducing hypergraph signal processing: theoretical foundation and practical applications. IEEE Internet of Things Journal, 7(1):639–660, 2019.
+
+Dengyong Zhou, Jiayuan Huang, and Bernhard Scholkopf. Learning with hypergraphs: Clustering, ¨ classification, and embedding. In Advances in neural information processing systems, pp. 1601– 1608, 2007.
+
+# APPENDICES
+
+# A EXPERIMENTS: ADDITIONAL DETAILS
+
+We perform multi-class classification on co-authorship and co-citation datasets, where the task is to predict the topic (class) for each document.
+
+# A.1 DATASET DESCRIPTION
+
+Hypergraphs are created on these datasets by assigning each document as a node and each hyperedge represents (a) all documents co-authored by an author in co-authorship dataset and (b) all documents cited together by a document in co-citation dataset. Each document (node) is represented by bagof-words features. The details about nodes, hyperedges and features is shown in Table 4. We use the same dataset and train-test splits as provided by Yadati et al. (2019) in their publically available implementation 1.
+
+Table 4: Details of real-world hypergraph datasets used in our work   
+
+<table><tr><td rowspan="3"></td><td colspan="2">Co-authorship Data</td><td colspan="3">Co-citation Data</td></tr><tr><td>DBLP</td><td>Cora</td><td>Pubmed</td><td>Citeseer</td><td>Cora</td></tr><tr><td>Nodes (|VI)</td><td>43413</td><td>2708</td><td>19717</td><td>3312</td><td>2708</td></tr><tr><td>Hyperedges (|ε|)</td><td>22535</td><td>1072</td><td>7963</td><td>1079</td><td>1579</td></tr><tr><td>average hyperedge size</td><td>4.7±6.1</td><td>4.2±4.1</td><td>4.3 ± 5.7</td><td>3.2±2.0</td><td>3.0 ± 1.1</td></tr><tr><td>number of features, |xl</td><td>1425</td><td>1433</td><td>500</td><td>3703</td><td>1433</td></tr><tr><td>number of classes</td><td>6</td><td>7</td><td>3</td><td>6</td><td>7</td></tr></table>
+
+# A.2 IMPLEMENTATION DETAILS
+
+We use the following set of hyperparameters similar to the prior work by Kipf & Welling (2016) for all the models.
+
+• hidden layer size: 32   
+• dropout rate: 0.5   
+• learning rate: 0.01   
+• weight decay: 0.0005   
+• number of training epochs: 150   
+• $\lambda$ for explicit Laplacian regularisation: 0.001
+
+# B CHOICE OF INTER-EDGE AND INTRA-EDGE AGGREGATIONS
+
+Proof. For any given hypergraph $\mathcal { H } _ { 1 } = ( \mathcal { V } , \mathcal { E } _ { 1 } , \mathbf { X } )$ , let $v _ { i }$ denote a node at which global neighborhood equivariance exists. The aggregation output $\mathcal { F } _ { 1 } ( \mathbf { s } )$ at $v _ { i }$ can then be written using generalized means $M _ { p }$ as
+
+$$
+\mathcal { F } _ { 1 } ( \mathbf { s } ) = \left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { 1 } { p _ { 1 } } } .
+$$
+
+To reiterate here, s denotes the unordered set of input as shown in Eq. 5. Further, the inter-edge aggregation $\mathcal { F } _ { 2 } ( \cdot )$ can be stated as
+
+![](images/877a500373a1d0b53df5de13b506a47cf4917820b32e4bb44bb0c7a2f91b3076.jpg)  
+Figure 4: (a) Example showing node $v _ { i }$ shared across 4 hyperedges. (b) Hyperedge $e _ { q }$ is split into $r$ hyperedges to reduce the cardinality of $e _ { q }$ . Note that the global neighborhood of $v _ { i }$ still remains the same, however its intra-edge neighborhood has changed due to such splitting.
+
+$$
+\mathcal { F } _ { 2 } ( \mathbf { s } ) = \left( \frac { 1 } { | E ( v _ { i } ) | } \sum _ { \mathbf { e } \in E ( v _ { i } ) } \left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } \right) ^ { \frac { 1 } { p _ { 2 } } }
+$$
+
+This equation can be rewritten as
+
+$$
+\mathsf { F } _ { 2 } ( \mathbf { s } ) = \left( \frac { 1 } { | E ( v _ { i } ) | } \left( \left( \frac { 1 } { | \mathsf { N } ( v _ { i } , \mathbf { e } _ { q } ) | } \sum _ { v _ { j } \in \mathsf { N } ( v _ { i } , \mathbf { e } _ { q } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } + \sum _ { \mathbf { e } \in E ( v _ { i } ) , \mathbf { e } \neq \mathbf { e } _ { q } } \left( \frac { 1 } { | \mathsf { N } ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \mathsf { N } ( v _ { i } , \mathbf { e } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } \right) \right) ^ { \frac { p _ { 1 } } { p _ { 2 } } }
+$$
+
+Further, let
+
+$$
+\Psi = \sum _ { \mathbf { e } \in E ( v _ { i } ) , \mathbf { e } \neq \mathbf { e } _ { q } } \left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } ,
+$$
+
+then Eq. 7 can be rewritten as
+
+$$
+\mathcal { F } _ { 2 } ( \mathbf { s } ) = \left( \frac { 1 } { | E ( v _ { i } ) | } \left( \left( \frac { 1 } { | \Re ( v _ { i } , \mathbf { e } _ { q } ) | } \sum _ { v _ { j } \in \Re ( v _ { i } , \mathbf { e } _ { q } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } + \Psi \right) \right) ^ { \frac { 1 } { p _ { 2 } } }
+$$
+
+Let us assume now that hyperedge $\mathbf { e } _ { q }$ is split into $r$ hyperedges given by $\begin{array} { r l } { E ( v _ { i } , \mathbf { e } _ { q } ) } & { { } = } \end{array}$ $\{ \mathbf { e } _ { q _ { 1 } } , \mathbf { e } _ { q _ { 2 } } \ldots \mathbf { e } _ { q _ { r } } \}$ . Stating the aggregation on the new set of hyperedges as $\tilde { \mathcal { F } } _ { 2 } ( \mathbf { s } )$ , we assemble the contribution from this new set of hyperedges with added weight terms $w _ { j }$ as stated below.
+
+$$
+\tilde { \mathcal { F } } _ { 2 } ( \mathbf { s } ) = \left( \frac { 1 } { | E ( v _ { i } ) | } \left( \sum _ { \mathbf { e } \in E ( v _ { i } , \mathbf { e } _ { q } ) } \left( \frac { 1 } { | \Re ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \Re ( v _ { i } , \mathbf { e } ) } w _ { j } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } + \Psi \right) \right) ^ { \frac { 1 } { p _ { 2 } } }
+$$
+
+For the property of global neighborhood invariance to hold at $v _ { i }$ , the following condition should be satisfied: $\mathcal { F } _ { 2 } ( v _ { i } ) = \tilde { \mathcal { F } } _ { 2 } ( v _ { i } )$ . Based on this, we would like to solve for the weights $w _ { j }$ . For this, we equate the two terms and obtain
+
+$$
+\left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } _ { q } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } _ { q } ) } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } } = \sum _ { \mathbf { e } \in E ( v _ { i } , \mathbf { e } _ { q } ) } \left( \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } ) | } \sum _ { v _ { j } \in \mathscr { N } ( v _ { i } , \mathbf { e } ) } w _ { j } \mathbf { x } _ { j } ^ { p _ { 1 } } \right) ^ { \frac { p _ { 2 } } { p _ { 1 } } }
+$$
+
+We further solve for the variables simplify Eq. 11 using the follow $p _ { 1 } , p _ { 2 }$ and bstitu $w _ { j }$ whns: 1, e sakand t, $\begin{array} { r } { \alpha = \frac { p _ { 2 } } { p _ { 1 } } } \end{array}$ $\begin{array} { r } { \beta = \frac { 1 } { | \mathcal { N } ( v _ { i } , \mathbf { e } _ { q } ) | } } \end{array}$ βmj = j|N(vi,em)| where the index $m$ here is used to refer to the $m ^ { \mathrm { t h } }$ hyperedge from among the $r$ hyperedges obtained on splitting $\mathbf { e } _ { q }$ . Further, let $z _ { j } = \mathbf { x } _ { j } ^ { p _ { 1 } }$ for $v _ { j } \in \mathcal { N } ( v _ { i } , \mathbf { e } _ { q } )$ and $z _ { m j } = \bar { \bf x } _ { j } ^ { p _ { 1 } }$ for $v _ { j } \in \mathcal { N } ( v _ { i } , \mathbf { e } _ { m } )$ and $\mathbf { e } _ { m } \in E ( v _ { i } , \mathbf { e } _ { q } )$ .
+
+Based on these substitutions, Eq. 11 can be restated as
+
+$$
+\begin{array} { r l r } & { } & { \beta ^ { \alpha } ( z _ { 1 } + z _ { 2 } + . . . + z _ { N } ) ^ { \alpha } = ( \beta _ { 1 1 } z _ { 1 } + \beta _ { 1 2 } z _ { 2 } + . . . + \beta _ { 1 j } z _ { j } + . . . + \beta _ { 1 N } z _ { N } ) ^ { \alpha } } \\ & { } & { + ( \beta _ { 2 1 } z _ { 1 } + \beta _ { 2 2 } z _ { 2 } + . . . + \beta _ { 2 j } z _ { j } + . . . + \beta _ { 2 N } z _ { N } ) ^ { \alpha } + } \\ & { } & \\ & { } & { \vdots } & \\ & { } & { + ( \beta _ { r 1 } z _ { 1 } + \beta _ { r 2 } z _ { 2 } + . . . + \beta _ { r j } z _ { j } + . . . + \beta _ { r N } z _ { N } ) ^ { \alpha } . } \end{array}
+$$
+
+We seek general solutions for $w _ { j }$ and $\alpha$ which holds for all values of $z _ { j } \in [ 0 , 1 ]$ since every element in the normalized feature vectors $\mathbf { x } _ { j }$ lies in $[ 0 , 1 ]$ .
+
+For a generalized solution, the coefficients of $z _ { j }$ on the right should be equal to the coefficient of $z _ { j }$ on the left. The term on the left can be reformulated as
+
+$$
+\beta ^ { \alpha } ( z _ { 1 } + z _ { 2 } + . . . + z _ { N } ) ^ { \alpha } = \beta ^ { \alpha } ( z _ { 1 } + ( z _ { 2 } + z _ { 3 } + . . . + z _ { N } ) ) ^ { \alpha }
+$$
+
+Consider the case when $| z _ { 1 } | \le | z _ { 2 } + z _ { 3 } + . . . |$ , we expand Eq. 13. using binomial expansion for real co-efficients,
+
+$$
+\begin{array} { r l } & { \beta ^ { \alpha } ( z _ { 1 } + ( z _ { 2 } + z _ { 3 } + \dots ) ) ^ { \alpha } = \beta ^ { \alpha } ( \binom { \alpha } { 0 } z _ { 1 } ^ { \alpha } + \binom { \alpha } { 1 } z _ { 1 } ^ { \alpha - 1 } ( z _ { 2 } + z _ { 3 } + \dots + z _ { N } ) + } \\ & { \vdots } \\ & { \qquad \quad + \ } \\ & { \qquad \quad + \ \binom { \alpha } { \alpha - 1 } z _ { 1 } ( z _ { 2 } + z _ { 3 } + \dots + z _ { N } ) ) } \\ & { \qquad = \beta ^ { \alpha } ( z _ { 1 } ^ { \alpha } + \alpha ( z _ { 1 } ^ { \alpha - 1 } z _ { 2 } + z _ { 1 } ^ { \alpha - 1 } z _ { 3 } + \dots + z _ { 1 } ^ { \alpha - 1 } z _ { N } ) + } \\ & { \vdots } \\ & { \qquad \quad + \ } \\ & { \quad + \alpha z _ { 1 } ( z _ { 2 } + z _ { 3 } + \dots + z _ { N } ) ^ { \alpha - 1 } ) } \end{array}
+$$
+
+Without any loss of generality, we consider splitting of hyperedge $e _ { q }$ into $r$ hyperedges such that nodes $v _ { \gamma _ { 1 } }$ and $v _ { \gamma _ { 2 } }$ are not contained in the same hyperedge anymore. This implies that RHS in Eq. 14 should not contain product terms of $z _ { 1 }$ and $z _ { 2 }$ . Hence, the term $z _ { 1 } ^ { \alpha - 1 } z _ { 2 }$ should be such that
+
+$$
+\alpha - 1 = 0 \Rightarrow \alpha = 1 \Rightarrow p 1 = p 2
+$$
+
+Putting $\alpha = 1$ and comparing the coefficients in Eq.12, we get
+
+$$
+\begin{array} { c } { \beta = \beta _ { 1 1 } + \beta _ { 1 2 } + . . . + \beta _ { 2 1 } + \beta _ { 2 2 } . . . + \beta _ { r 1 } + \beta _ { r 2 } + . . . } \\ { \displaystyle \frac { 1 } { | \mathbb { N } ( v _ { i } , \mathbf { e } _ { q } ) | } = \displaystyle \sum _ { m = 1 } ^ { r } \frac { w _ { j } } { | \mathbb { N } ( v _ { i } , \mathbf { e } _ { m } ) | } } \\ { w _ { j } = \displaystyle \frac { 1 } { | \mathbb { N } ( v _ { i } , \mathbf { e } _ { q } ) | } * \left( \displaystyle \sum _ { m = 1 } ^ { r } \frac { 1 } { | \mathbb { N } ( v _ { i } , \mathbf { e } _ { m } ) | } \right) ^ { - 1 } } \end{array}
+$$
+
+Thus, if an edge ${ \bf e } _ { q }$ is split into multiple edges $E ( v _ { i } , { \bf e } _ { q } )$ , then for the two aggregations to hold, the conditions are $p _ { 1 } = p _ { 2 }$ and $\begin{array} { r } { w _ { j } = \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } _ { q } ) | } * \left( \sum _ { m = 1 } ^ { r } \frac { 1 } { | \mathscr { N } ( v _ { i } , \mathbf { e } _ { m } ) | } \right) ^ { - 1 } \forall \mathbf { e } \in E ( v _ { i } , \mathbf { e } _ { q } ) . } \end{array}$
+
+While we provide above a description related to splitting a certain hyperedge $\mathbf { e } _ { q }$ into $r$ hyperedges, the derived results can be used to compute global neighborhood itself on any given node $v _ { i }$ . Similar to $\mathbf { e } _ { q }$ above, node $v _ { i }$ together with its global neighborhood (counted as $\mathcal { N } ( v _ { i } ) )$ ) can be interpreted as a virtual hyperedge that has been split into a number of hyperedges that actually exist and contain $v _ { i }$ . These resultant hyperdges are equivalent to the $r$ hyperdges obtained after splitting, as stated above.
+
+![](images/aec376f6f4c1d4ff877471c5364b6e9877d8e635e870c3f6e6938f8a3fcd8f6f.jpg)  
+Figure 5: Results on cora and citeseer for multiple train test ratio

parse/train/cKnKJcTPRcV/cKnKJcTPRcV_content_list.json

@@ -0,0 +1,1773 @@
+[
+    {
+        "type": "text",
+        "text": "HYPERSAGE: GENERALIZING INDUCTIVE REPRESENTATION LEARNING ON HYPERGRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            759,
+            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": "Graphs are the most ubiquitous form of structured data representation used in machine learning. They model, however, only pairwise relations between nodes and are not designed for encoding the higher-order relations found in many real-world datasets. To model such complex relations, hypergraphs have proven to be a natural representation. Learning the node representations in a hypergraph is more complex than in a graph as it involves information propagation at two levels: within every hyperedge and across the hyperedges. Most current approaches first transform a hypergraph structure to a graph for use in existing geometric deep learning algorithms. This transformation leads to information loss, and sub-optimal exploitation of the hypergraph’s expressive power. We present HyperSAGE, a novel hypergraph learning framework that uses a two-level neural message passing strategy to accurately and efficiently propagate information through hypergraphs. The flexible design of HyperSAGE facilitates different ways of aggregating neighborhood information. Unlike the majority of related work which is transductive, our approach, inspired by the popular GraphSAGE method, is inductive. Thus, it can also be used on previously unseen nodes, facilitating deployment in problems such as evolving or partially observed hypergraphs. Through extensive experimentation, we show that HyperSAGE outperforms state-of-the-art hypergraph learning methods on representative benchmark datasets. We also demonstrate that the higher expressive power of HyperSAGE makes it more stable in learning node representations as compared to the alternatives. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            336,
+            595
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graphs are considered the most prevalent structures for discovering useful information within a network, especially because of their capability to combine object-level information with the underlying inter-object relations (Wu et al., 2020). However, most structures encountered in practical applications form groups and relations that cannot be properly represented using pairwise connections alone, hence a graph may fail to capture the collective flow of information across objects. In addition, the underlying data structure might be evolving and only partially observed. Such dynamic higher-order relations occur in various domains, such as social networks (Tan et al., 2011), computational chemistry (Gu et al., 2020), neuroscience (Gu et al., 2017) and visual arts (Arya et al., 2019), among others. These relations can be readily represented with hypergraphs, where an edge can connect an arbitrary number of vertices as opposed to just two vertices in graphs. Hypergraphs thus provide a more flexible and natural framework to represent such multi-way relations (Wolf et al., 2016), however, this requires a representation learning technique that exploits the full expressive power of hypergraphs and can generalize on unseen nodes from a partially observed hypergraph. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work in the field of geometric deep learning have presented formulations on graph structured data for the tasks of node classification (Kipf & Welling, 2016), link prediction (Zhang & Chen, 2018), or the classification of graphs (Zhang et al., 2018b). Subsequently, for data containing higher-order relations, a few recent papers have presented hypergraph-based learning approaches on similar tasks (Yadati et al., 2019; Feng et al., 2019). A common implicit premise in these papers is that a hypergraph can be viewed as a specific type of regular graph. Therefore, reduction of hypergraph learning problem to that of a graph should suffice. Strategies to reduce a hypergraph to a graph include transforming the hyperedges into multiple edges using clique expansion (Feng et al., 2019; Jiang et al., 2019; Zhang et al., 2018a), converting to a heterogeneous graph using star expansion (Agarwal et al., 2006), and replacing every hyperedge with an edge created using a certain predefined metric (Yadati et al., 2019). Yet these methods are based on the wrong premise, motivated chiefly by a larger availability of graph-based approaches. By reducing a hypergraph to regular graph, these approaches make existing graph learning algorithms applicable to hypergraphs. However, hypergraphs are not a special case of regular graphs. The opposite is true, regular graphs are simply a specific type of hypergraph (Berge & Minieka, 1976). Therefore, reducing the hypergraph problem to that of a graph cannot fully utilize the information available in hypergraph. Two schematic examples outlining this issue are shown in Fig.1. To address tasks based on complex structured data, a hypergraph-based formulation is needed that complies with the properties of a hypergraph. ",
+        "bbox": [
+            174,
+            799,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/282bdbdd37a77e1a200176c4245ee9b07751c77e470f56e87ca64f112f3e8688.jpg",
+        "image_caption": [
+            "Figure 1: (a) Example showing reduction of a hypergraph to a graph using clique and star expansion methods. The clique expansion loses the unique information associated with the hyperedge defined by the set of nodes $\\{ v _ { 2 } , v _ { 3 } \\}$ , and it cannot distinguish it from the hyperedge defined by the nodes $\\{ \\dot { v } _ { 1 } , v _ { 2 } , v _ { 3 } \\}$ . Star expansion creates a heterogeneous graph that is difficult to handle using most well-studied graph methods (Hein et al., 2013). (b) Schematic representations of two Fano planes comprising 7 nodes and 7 hyperedges (6 straight lines and 1 circle.). The second Fano plane is a copy of the first with nodes $v _ { 2 }$ and $v _ { 3 }$ permuted. These two hypergraphs cannot be differentiated when transformed to a graph using clique expansion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            818,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            383,
+            825,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A major limitation of the existing hypergraph learning frameworks is their inherently transductive nature. This implies that these methods can only predict characteristics of nodes that were present in the hypergraph at training time, and fail to infer on previously unseen nodes. The transductive nature of existing hypegraph approaches makes them inapplicable in, for example, finding the most promising target audience for a marketing campaign or making movie recommendations with new movies appearing all the time. An inductive solution would pave the way to solve such problems using hypergraphs. The inductive learning framework must be able to identify both the node’s local role in the hypergraph, as well as its global position (Hamilton et al., 2017). This is important for generalizing the learned node embeddings that the algorithm has optimized on to a newly observed hypergraph comprising previously unseen nodes, thus, making inductive learning a far more complex problem compared to the transductive learning methods. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we address the above mentioned limitations of the existing hypergraph learning methods. We propose a simple yet effective inductive learning framework for hypergraphs that is readily applicable to graphs as well. Our approach relies on neural message passing techniques due to which it can be used on hypergraphs of any degree of cardinality without the need for reduction to graphs. The points below highlight the contributions of this paper: ",
+        "bbox": [
+            176,
+            689,
+            825,
+            760
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We address the challenging problem of representation learning on hypergraphs by proposing HyperSAGE, comprising a message passing scheme which is capable of jointly capturing the intra-relations (within a hyperedge) as well as inter-relations (across hyperedges). • The proposed hypergraph learning framework is inductive, i.e. it can perform predictions on previously unseen nodes, and can thus be used to model evolving hypergraphs. • HyperSAGE facilitates neighborhood sampling and provides the flexibility in choosing different ways to aggregate information from the neighborhood. • HyperSAGE is more stable than state-of-the-art methods, thus provides more accurate results on node classification tasks on hypergraphs with reduced variance in the output. ",
+        "bbox": [
+            215,
+            772,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning node representations using graph neural networks has been a popular research topic in the field of geometric deep learning (Bronstein et al., 2017). Graph neural networks can be broadly classified into spatial (message passing) and spectral networks. We focus on a family of spatial message passing graph neural networks that take a graph with some labeled nodes as input and learn embeddings for each node by aggregating information from its neighbors (Xu et al., 2019). Message passing operations in a graph simply propagate information along the edge connecting two nodes. Many variants of such message passing neural networks have been proposed, with some popular ones including Gori et al. (2005); Li et al. (2015); Kipf & Welling (2016); Gilmer et al. (2017); Hamilton et al. (2017). ",
+        "bbox": [
+            174,
+            136,
+            825,
+            261
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Zhou et al. (2007) introduced learning on hypergraphs to model high-order relations for semisupervised classification and clustering of nodes. Emulating a graph-based message passing framework for hypergraphs is not straightforward since a hyperedge involves more than two nodes which makes the interactions inside each hyperedge more complex. Representing a hypergraph with a matrix makes it rigid in describing the structures of higher order relations (Li et al., 2013). On the other hand, formulating message passing on a higher dimensional representation of hypergraph using tensors makes it computationally expensive and restricts it to only small datasets (Zhang et al., 2019). Several tensor based methods do perform learning on hypergraphs (Shashua et al., 2006; Arya et al., 2019), however they are limited to uniform hypergraphs only. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To resolve the above issues, Feng et al. (2019) and Bai et al. (2020) reduce a hypergraph to graph using clique expansion and perform graph convolutions on them. These approaches cannot utilize complete structural information in the hypergraph and lead to unreliable learning performance for e.g. classification, clustering and active learning (Li & Milenkovic, 2017; Chien et al., 2019). Another approach by Yadati et al. (2019), named HyperGCN, replaces a hyperedge with pair-wise weighted edges between vertices (called mediators). With the use of mediators, HyperGCN can be interpreted as an improved approach of clique expansion, and to the best of our knowledge, is also the state-of-the-art method for hypergraph representation learning. However, for many cases such as Fano plane where each hyperedge contains at most three nodes, HyperGCN becomes equivalent to the clique expansion (Dong et al., 2020). In spectral theory of hypergraphs, methods have been proposed that fully exploit the hypergraph structure using non-linear Laplacian operators (Chan et al., 2018; Hein et al., 2013). In this work, we focus on message passing frameworks. Drawing inspiration from GraphSAGE (Hamilton et al., 2017), we propose to eliminate matrix (or tensor) based formulations in our neural message passing frameworks, which not only facilitates utilization of all the available information in a hypergraph, but also makes the entire framework inductive in nature. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED MODEL: HYPERSAGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            490,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The core concept behind our approach is to aggregate feature information from the neighborhood of a node spanning across multiple hyperedges, where the edges can have varying cardinality. Below, we first define some preliminary terms, and then describe our generic aggregation framework. This framework performs message passing at two-levels for a hypergraph. Further, for any graphstructured data, our framework emulates the one-level aggregation similar to GraphSAGE (Hamilton et al., 2017). Our approach inherently allows inductive learning, which makes it also applicable on hypergraphs with unseen nodes. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            326,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Hypergraph). A general hypergraph $\\mathcal { H }$ can be represented as $\\mathcal { H } = ( \\boldsymbol { \\vartheta } , \\boldsymbol { \\mathcal { E } } , \\mathbf { X } )$ , where $\\nabla = \\{ v _ { 1 } , v _ { 2 } , . . . , \\bar { v } _ { N } \\}$ denotes a set of $N$ nodes (vertices) and $\\mathfrak { E } = \\{ \\mathbf { e } _ { 1 } , \\mathbf { e } _ { 2 } , . . . , \\mathbf { e } _ { K } \\}$ denotes a set of hyperedges, with each hyperedge comprising a non-empty subset from $\\mathcal { V }$ . $\\mathbf { X } \\in \\mathbb { R } ^ { N \\times d }$ denote the feature matrix, such that $\\mathbf { x } _ { i } \\in \\mathbf { X }$ is the feature vector characterizing node $v _ { i } \\in \\mathcal V$ . The maximum cardinality of the hyperedges in $\\mathcal { H }$ is denoted as $M = { \\underset { \\mathbf { e } \\in \\mathbb { E } } { \\operatorname* { m a x } } } | \\mathbf { e } |$ . ",
+        "bbox": [
+            173,
+            811,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike in a graph, the hyperedges of $\\mathcal { H }$ can contain different number of nodes and $M$ denotes the largest number. From the definition above, we see that graphs are a special case of hypergraphs with ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$M { = } 2$ . Thus, compared to graphs, hypergraphs are designed to model higher-order relations between nodes. Further, we define three types of neighborhoods in a hypergraph: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (Intra-edge neighborhood). The intra-edge neighborhood of a node $v _ { i } \\in \\mathcal V$ for any hyperedge $\\mathbf { e } \\in \\mathcal { E }$ is defined as the set of nodes $v _ { j }$ belonging to e and is denoted by $\\mathcal { N } ( v _ { i } , \\mathbf { e } )$ ",
+        "bbox": [
+            171,
+            138,
+            821,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Further, let $E ( v _ { i } ) = \\{ \\mathbf { e } \\in \\mathcal { E } \\mid v _ { i } \\in \\mathbf { e } \\}$ be the sets of hyperedges that contain node $v _ { i }$ . ",
+        "bbox": [
+            174,
+            172,
+            736,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3 (Inter-edge neighborhood). The inter-edge neighborhood of a node $\\boldsymbol { v } _ { i } \\in \\mathcal { V }$ also referred as its global neighborhood, is defined as the neighborhood of $v _ { i }$ spanning across the set of hyperedges $E ( v _ { i } )$ and is represented by $\\begin{array} { r } { \\mathcal { N } ( v _ { i } ) = \\bigcup _ { \\mathbf { e } \\in E ( v _ { i } ) } \\mathcal { N } ( v _ { i } , \\mathbf { e } ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            195,
+            826,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 4 (Condensed neighborhood). The condensed neighborhood of any node $\\boldsymbol { v } _ { i } ~ \\in ~ \\mathcal { V }$ is $a$ sampled set of $\\alpha \\leq | \\mathbf { e } |$ nodes from a hyperedge $\\mathbf { e } \\in E ( v _ { i } )$ denoted by $N ( v _ { i } , \\mathbf { e } ; \\alpha ) \\subset \\mathbb { N } ( v _ { i } , \\mathbf { e } )$ . ",
+        "bbox": [
+            173,
+            246,
+            826,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 GENERALIZED MESSAGE PASSING FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            292,
+            552,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose to interpret the propagation of information in a given hypergraph as a two-level aggregation problem, where the neighborhood of any node is divided into intra-edge neighbors and inter-edge neighbors. For message aggregation, we define aggregation function $\\mathcal { F } ( \\cdot )$ as a permutation invariant set function on a hypergraph $\\mathcal { H } = ( \\mathcal { V } , \\mathcal { E } , \\mathbf { X } )$ that takes as input a countable unordered message set and outputs a reduced or aggregated message. Further, for two-level aggregation, let $\\mathcal { F } _ { 1 } ( \\cdot )$ and $\\mathcal { F } _ { 2 } ( \\cdot )$ denote the intra-edge and inter-edge aggregation functions, respectively. Schematic representation of the two aggregation functions is provided in Fig.2. Similar to $\\mathbf { X }$ we also define $\\mathbf { Z }$ as the encoded feature matrix built using the outputs $\\mathbf { z } _ { i }$ of aggregation functions. Message passing at node $v _ { i }$ for aggregation of information at the $l ^ { \\mathrm { { \\bar { t h } } } }$ layer can then be stated as ",
+        "bbox": [
+            173,
+            318,
+            825,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/48dcda05f7406c512c09feb0cf9d1918ce7a8e82143a2f42026f985412070b6e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { x } _ { i , l } ^ { ( \\mathbf { e } ) }  \\mathcal { F } _ { 1 } ( \\{ \\mathbf { x } _ { j , l - 1 } \\mid v _ { j } \\in \\mathsf { N } ( v _ { i } , \\mathbf { e } ; \\alpha ) \\} ) , } \\\\ & { \\mathbf { x } _ { i , l }  \\mathbf { x } _ { i , l - 1 } + \\mathcal { F } _ { 2 } ( \\{ \\mathbf { x } _ { i , l } ^ { ( \\mathbf { e } ) } \\mid v _ { i } \\in E ( v _ { i } ) \\} ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            468,
+            633,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where, $\\mathbf { x } _ { i , l } ^ { ( \\mathbf { e } ) }$ refers to the aggregated feature set at $v _ { i }$ obtained with intra-edge aggregation for edge e. ",
+        "bbox": [
+            171,
+            526,
+            823,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The combined two-level message passing is achieved using nested aggregation function $\\mathcal { F } = \\mathcal { F } _ { 2 }$ . To ensure that the expressive power of a hypergraph is preserved or at least the loss is minimized, the choice of aggregation function should comply with certain properties. ",
+        "bbox": [
+            174,
+            563,
+            483,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Firstly, the aggregation function should be able to capture the features of neighborhood vertices in a manner that is invariant to the permutation of the nodes and hyperedges. Many graph representation learning methods use permutation invariant aggregation functions, such as mean, sum and max functions $\\mathrm { { X u } }$ et al., 2019). These aggregations have proven to be successful for node classification problems. For the existing hypergraph frameworks, reduction to simple graphs along with a matrix-based message passing framework limits the possibilities of using different types of feature aggregation functions, and hence curtails the potential to explore unique node representations. ",
+        "bbox": [
+            174,
+            654,
+            483,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/085d45f84f12379d16cfb332faf13d5d16c9384c7b990d439d1057e2e3f252a8.jpg",
+        "image_caption": [
+            "Figure 2: Schematic representation of the twolevel message passing scheme of HyperSAGE, with aggregation functions $\\mathcal { F } _ { 1 } ( \\cdot )$ and $\\mathsf { \\bar { F } } _ { 2 } ( \\cdot )$ . It shows information aggregation from two hyperedges $\\mathbf { e } _ { A }$ and $\\mathbf { e } _ { B }$ , where the intra-edge aggregation is from sampled sets of 5 nodes $( \\alpha = 5$ ) for each hyperedge. For node $v _ { i }$ , $\\mathbf { x } _ { i }$ and $\\mathbf { z } _ { i }$ denote the input and encoded feature vector, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            526,
+            561,
+            797,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the aggregation function should also preserve the global neighborhood invariance at the ‘dominant nodes’ of the graph. Here, dominant nodes refer to nodes that contain important features, thereby, impacting the learning process relatively more than their neighbors. The aggregation function should ideally be insensitive to the input, whether the provided hypergraph contains a few large hyperedges, or a larger number of smaller ones obtained from splitting them. Generally, a hyperedge would be split in a manner that the dominant nodes are shared across the resulting hyperedges. In such cases, global neighborhood invariance would imply that the aggregated output at these nodes before and after the splitting of any associated hyperedge stays the same. Otherwise, the learned representation of a node will change significantly with each hyperedge split. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on these considerations, we define the following properties for a generic message aggregation function that should hold for accurate propagation of information through the hypergraphs. ",
+        "bbox": [
+            173,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Property 1 (Hypergraph Isomorphic Equivariance). A message aggregation function $\\mathcal { F } ( \\cdot )$ is equivariant to hypergraph isomorphism, if for two isomorphic hypergraphs $\\mathcal { H } = ( \\boldsymbol { \\nabla } , \\boldsymbol { \\mathcal { E } } , \\mathbf { X } )$ and $\\bar { \\mathcal { H } } ^ { * } = ( \\bar { \\mathcal { V } } ^ { * } , \\mathcal { E } ^ { * } , \\bar { \\bf X ^ { * } } )$ , given that $\\mathcal { H } ^ { \\ast } = \\sigma \\bullet \\mathcal { H }$ , and $\\mathbf { Z }$ and $\\mathbf { Z } ^ { \\ast }$ represent the encoded feature matrices obtained using $\\mathcal { F } ( \\cdot )$ on $\\mathcal { H }$ and $\\mathcal { H } ^ { * }$ , the condition $\\mathbf { Z } ^ { * } = \\sigma \\bullet \\mathbf { Z }$ holds. Here, $\\sigma$ denotes a permutation operator on hypergraphs. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Property 2 (Global Neighborhood Invariance). A message aggregation scheme $\\mathcal { F } ( \\cdot )$ satisfies global neighborhood invariance at any node $\\boldsymbol { v } _ { i } ~ \\in ~ \\mathcal { V }$ for a given hypergraph $\\mathcal { H } = ( \\boldsymbol { \\nabla } , \\boldsymbol { \\mathcal { E } } , \\mathbf { X } )$ if for any operation $\\Gamma ( \\cdot )$ , such that $\\mathcal { H } ^ { * } = \\Gamma ( \\mathcal { H } )$ , and $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { i } ^ { * }$ denote the encoded feature vectors obtained using $\\mathcal { F } ( \\cdot )$ at node $v _ { i }$ on $\\mathcal { H }$ and $\\mathcal { H } ^ { * }$ , the condition $\\mathbf { z } _ { i } ^ { * } ~ = ~ \\mathbf { z } _ { i }$ holds. Here $\\Gamma ( \\mathcal { \\mathrm { H } } )$ could refer to operations such as hyperedge contraction or expansion. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The flexibility of our message passing framework allows us to go beyond the simple aggregation functions on hypergraphs without violating Property 1. We introduce a series of power mean functions as aggregators, which have recently been shown to generalize well on graphs (Li et al., 2020). We perform message aggregation in hypergraphs using these generalized means, denoted by $M _ { p }$ and provide in section 4.2, a study on their performances. We also show that with appropriate combinations of the intra-edge and inter-edge aggregations Property 2 is also satisfied. This property ensures that the representation of a node after message passing is invariant to the cardinality of the hyperedge, i.e., the aggregation scheme should not be sensitive to hyperedge contraction or expansion, as long as the global neighborhood of a node remains the same in the hypergraph. ",
+        "bbox": [
+            173,
+            368,
+            825,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Aggregation Functions. One major advantage of our strategy is that the message passing module is decoupled from the choice of the aggregation itself. This allows our approach to be used with a broad set of aggregation functions. We discuss below a few such possible choices. ",
+        "bbox": [
+            174,
+            501,
+            821,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generalized means. Also referred to as power means, this class of functions are very commonly used for getting an aggregated measure over a given set of samples. Mathematically, generalized means can be expressed as $\\begin{array} { r } { M _ { p } = \\left( \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } x _ { i } ^ { p } \\right) ^ { \\frac { 1 } { p } } } \\end{array}$ , where $n$ refers to the number of samples in the aggregation, and denotes its power. The choice of allows providing different interpretations to the aggregation function. For example, $p = 1$ denotes arithmetic mean aggregation, $p = 2$ refers to mean squared estimate and a large value of $p$ corresponds to max pooling from the group. Similarly, $M _ { p }$ can be used for geometric and harmonic means with $p  0$ and $p = - 1$ , respectively. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to the recent work of Li et al. (2020), we use generalized means for intra-edge as well as inter-edge aggregation. The two functions $\\mathcal { F } _ { 1 } ( \\cdot )$ and $\\mathcal { F } _ { 2 } ( \\cdot )$ for aggregation at node $v _ { i }$ is defined as ",
+        "bbox": [
+            174,
+            660,
+            825,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a55fa1efc776183c8afdbe360d48ea39b135f324adab946b3ceee8f30d7bfaea.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathfrak { F } _ { 1 } ^ { ( i ) } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } ) | | \\mathscr { N } ( v _ { i } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } ) } \\left( \\sum _ { m = 1 } ^ { | E ( v _ { i } ) | } \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } _ { m } ) | } \\right) ^ { - 1 } \\mathbf { x } _ { j } ^ { p } \\right) ^ { \\frac { 1 } { p } } } \\\\ { \\displaystyle \\mathfrak { F } _ { 2 } ^ { ( i ) } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | E ( v _ { i } ) | } \\sum _ { \\mathbf { e } \\in E ( v _ { i } ) } ( \\mathscr { F } _ { 1 } ( \\mathbf { s } ) ) ^ { p } \\right) ^ { \\frac { 1 } { p } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            712,
+            738,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we use ‘s’ for concise representation of the unordered set of input as shown in Eq.1. Here and henceforth in this paper, we remove the superscript index $\\mathbf { \\rho } ( i ) ^ { \\prime }$ for the sake of clarity and further occurrences of the two aggregation functions shall be interpreted in terms of node $v _ { i }$ . Note that in Eq. 3 and Eq. 4, we have chosen the power term $p$ to be same for ${ \\mathcal { F } } _ { 1 }$ and $\\mathcal { F } _ { 2 }$ so as to satisfy the global neighborhood invariance as stated in Property 2. Note, the scaling term added to ${ \\mathcal { F } } _ { 1 }$ is added to balance the bias in the weighting introduced in intra-edge aggregation due to varying cardinality across the hyperedges. These restrictions ensure that the joint aggregation $\\mathcal { F } _ { 2 } ( \\cdot )$ satisfies the property of global neighborhood invariance at all times. Proof of the two aggregations satisfying Property 2 is stated in Appendix B. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sampling-based Aggregation. Our neural message passing scheme provides the flexibility to adapt the message aggregation module to fit the desired computational budget through aggregating information from only a subset $N ( v _ { i } , \\mathbf { e } ; \\alpha )$ of the full neighborhood $N ( v _ { i } , \\mathbf { e } )$ , if needed. We propose to apply sub-sampling only on the nodes from the training set, and use information from the full neighborhood for the test set. The advantages of this are twofold. First, reduced number of samples per aggregation at training time reduces the relative computational burden. Second, similar to dropout (Srivastava et al., 2014), it serves to add regularization to the optimization process. Using the full neighborhood on test data avoids randomness in the test predictions, and generates consistent output. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 INDUCTIVE LEARNING ON HYPERGRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            286,
+            508,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "HyperSAGE is a general framework for learning node representations on hypergraphs, on even unseen nodes. Our approach uses a neural network comprising $L$ layers, and feature-aggregation is performed at each of these layers, as well as across the hyperedges. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 describes the forward propagation mechanism which implements the aggregation function $\\mathcal { F } ( \\cdot ) ~ = ~ \\mathcal { F } _ { 2 } ( \\cdot )$ described above. At each iteration, nodes first aggregate information from their neighbors within a specific hyperedge. This is repeated over all the hyperedges across all the $L$ layers of the network. The trainable weight matrices $\\mathbf { W } ^ { l }$ with $l \\in L$ are used to aggregate information across the feature dimension and propagate it through the various layers of the hypergraph. ",
+        "bbox": [
+            174,
+            364,
+            483,
+            517
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Generalizability of HyperSAGE. HyperSAGE can be interpreted as a generalized formulation that unifies various existing graphbased as well as hypergraph formulations. Our approach unifies them, identifying each of these as special variants/cases of our method. We discuss here briefly the two popular algorithms. ",
+        "bbox": [
+            174,
+            525,
+            483,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Graph Convolution Networks (GCN). The GCN approach proposed by Kipf & Welling (2016) is a graph-based method that can be derived as a special case of HyperSAGE with maximum ",
+        "bbox": [
+            174,
+            630,
+            485,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 HyperSAGE Message Passing ",
+        "text_level": 1,
+        "bbox": [
+            500,
+            387,
+            785,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input : $\\mathcal { H } = ( \\boldsymbol { \\nabla } , \\mathcal { E } , \\mathbf { X } )$ ; depth $L$ ; weight matrices $\\mathbf { W } ^ { l }$ for $l = 1 \\ldots L$ ; non-linearity $\\sigma$ ; intra-edge aggregation function $\\mathcal { F } _ { 1 } ( \\cdot )$ ; inter-edge aggregation function $\\mathcal { F } _ { 2 } ( \\cdot )$   \nOutput: Node embeddings $\\mathbf { z } _ { i } |$ $v _ { i } \\in \\mathcal V$   \n$\\mathbf { h } _ { i } ^ { 0 } \\bar {  } \\mathbf { x } _ { i } \\in \\mathbf { X } \\mid v _ { i } \\in \\mathcal { V }$   \nfor $l = 1 \\ldots L$ do for e ∈ E do hl ← hl−1 for vi ∈ e do h l ← h l + F ( i ) ( s ) end end $\\mathbf { h } _ { i } ^ { l }  \\sigma ( \\mathbf { W } ^ { l } ( \\mathbf { h } _ { i } ^ { l } / | | \\mathbf { h } _ { i } ^ { l } | | _ { 2 } ) ) \\mid v _ { i } \\in \\mathcal { V }$   \nend   \n$\\mathbf { z } _ { i }  \\mathbf { h } _ { i } ^ { L } \\mid v _ { i } \\in \\mathcal { V }$ ",
+        "bbox": [
+            495,
+            402,
+            823,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "cardinality $| M | = 2$ , and setting the agggregation function $\\mathcal { F } _ { 2 } = M _ { p }$ with $p = 1$ . This being a graph-based method, ${ \\mathcal { F } } _ { 1 }$ will not be used. ",
+        "bbox": [
+            176,
+            685,
+            821,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "GraphSAGE. Our approach, when reduced for graphs using $| M | = 2$ , is similar to GraphSAGE. For exact match, the aggregation function $\\mathcal { F } _ { 2 }$ should be one of mean, max or $L S T M$ . Further, the sampling term $\\alpha$ can be adjusted to match the number of samples per aggregation as in GraphSAGE. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            326,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            375,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the experiments in this paper, we use co-citation and co-authorship network datasets: CiteSeer, PubMed, Cora (Sen et al., 2008) and DBLP (Rossi & Ahmed, 2015). The task for each dataset is to predict the topic to which a document belongs (multi-class classification). For these datasets, $\\mathbf { x } _ { i }$ corresponds to a bag of words such that $x _ { i , j } \\in \\mathbf { x } _ { i }$ represents the normalized frequency of occurence of the $j ^ { t h }$ word. Additional details related to the hypergraph topology are presented in Appendix ",
+        "bbox": [
+            174,
+            852,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1992da76821ec16a05ee31bdaa32f884187bf4f4f874d1c5627119e5b362b6e0.jpg",
+        "table_caption": [
+            "Table 1: Performance of HyperSAGE and other hypergraph learning methods on co-authorship and co-citation datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">Co-authorship Data</td><td colspan=\"3\">Co-citation Data</td></tr><tr><td>DBLP</td><td>Cora</td><td>Pubmed</td><td>Citeseer</td><td>Cora</td></tr><tr><td>MLP +HLR</td><td>63.6 ± 4.7</td><td>59.8 ± 4.7</td><td>64.7 ± 3.1</td><td>56.1 ± 2.6</td><td>61.0 ± 4.1</td></tr><tr><td>HGNN</td><td>69.2 ± 5.1</td><td>63.2 ± 3.1</td><td>66.8 ± 3.7</td><td>56.7 ± 3.8</td><td>70.0 ± 2.9</td></tr><tr><td>FastHyperGCN</td><td>68.1 ± 9.6</td><td>61.1 ± 8.2</td><td>65.7 ± 11.1</td><td>56.2 ± 8.1</td><td>61.3 ± 10.3</td></tr><tr><td>HyperGCN</td><td>70.9 ± 8.3</td><td>63.9 ± 7.3</td><td>68.3 ± 9.5</td><td>57.3 ± 7.3</td><td>62.5 ± 9.7</td></tr><tr><td>HyperSAGE (p = 2)</td><td>71.5 ± 4.4</td><td>69.8 ± 2.6</td><td>71.3 ± 2.4</td><td>59.8 ± 3.3</td><td>62.9 ± 2.1</td></tr><tr><td>HyperSAGE (p = 1)</td><td>77.2 ± 4.3</td><td>72.4 ± 1.6</td><td>72.6 ± 2.1</td><td>61.8 ± 2.3</td><td>69.3 ± 2.7</td></tr><tr><td>HyperSAGE (p = 0.01)</td><td>77.4 ± 3.8</td><td>72.1 ± 1.8</td><td>72.9 ± 1.3</td><td>61.3 ± 2.4</td><td>68.2 ± 2.4</td></tr><tr><td>HyperSAGE (p = -1)</td><td>70.9 ± 2.3</td><td>67.4 ± 2.1</td><td>68.3 ± 3.1</td><td>59.8 ± 2.0</td><td>62.3 ± 5.7</td></tr></table>",
+        "bbox": [
+            174,
+            140,
+            818,
+            323
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A.2. Further, for all experiments, we use a neural network with 2 layers. All models are implemented in Pytorch and trained using Adam optimizer. See Appendix A.2 for implementation details. ",
+        "bbox": [
+            174,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 SEMI-SUPERVISED NODE CLASSIFICATION ON HYPERGRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            643,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Performance comparison with existing methods. We implemented HyperSAGE for the task of semi-supervised classification of nodes on a hypergraph, and the results are compared with stateof-the art methods. These include (a) Multi-layer perceptron with explicit hypergraph Laplacian regularisation $( \\mathbf { M L P } + \\mathbf { H L R } )$ , (b) Hypergraph Neural Networks (HGNN) (Feng et al., 2019) which uses a clique expansion, and (c) HyperGCN and its variants (Yadati et al., 2019) that collapse the hyperedges using mediators. For HyperSAGE method, we use 4 variants of generalized means $M _ { p }$ with $p = 1 , 2 , - 1$ and 0.01 with complete neighborhood i.e., $\\alpha = | \\mathbf { e } |$ . For all the cases, 10 data splits over 8 random weight initializations are used, totalling 80 experiments per method and for every dataset. The data splits are the same as in HyperGCN described in Appendix A.1. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the results obtained for the node classification task. We see that the different variants of HyperSAGE consistently show better scores across our benchmark datasets, except Cora cocitation where no improvement is observed compared to HGNN. Cora co-citation data is relatively small in size with a cardinality of $3 . 0 \\pm 1 . 1$ , and we speculate that there does not exist enough scope of improving with HyperSAGE beyond what HGNN can express with the clique expansion. ",
+        "bbox": [
+            174,
+            561,
+            823,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the larger datasets such as DBLP and Pubmed, we see that the improvements obtained in performance with HyperSAGE over the best baselines are $6 . 3 \\%$ and $4 . 3 \\%$ respectively. Apart from its superior performance, HyperSAGE is also stable, and is less sensitive to the choice of data split and initialization of the weights. This is evident from the scores of standard deviation (SD) for the various experiments in Table 1. We see that the SD scores for our method are lower than other methods, and there is a significant gain in performance compared to HyperGCN. Another observation is that the HyperGCN method is very sensitive to the data splits as well as initializations with very large errors in the predictions. This is even higher for the FastHyperGCN variant. Also, we have found that all the 4 choices of $p$ work well with HyperSAGE for these datasets. We further perform a more comprehensive study analyzing the effect of $p$ on model performance later in this section. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Stability analysis. We further study the stability of our method in terms of the variance observed in performance for different ratios of train and test splits, and compare results with that of HyperGCN implemented under similar settings. Fig. 3 shows results for the two learning methods on 5 different train-test ratios. We see that the performance of both models improves when a higher fraction of data is used for training, and the performances are approximately the same at the train-test ratio of 1/3. ",
+        "bbox": [
+            174,
+            785,
+            483,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4340dbb94053c5b51e118b854005a17380a988c0817c660e92e9a0b05c4368c5.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy scores for HyperSAGE and HyperGCN obtained for different train-test ratios for multi-class classification datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            791,
+            823,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/133afbf49d0e9d900ecfb834456d284c773560c7b5682e2919b326da38af056e.jpg",
+        "table_caption": [
+            "Table 2: Performance of HyperSAGE for multiple values of $p$ in generalized means aggregator $( M _ { p } )$ on varying number of neighborhood samples $( \\alpha )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">DBLP</td><td colspan=\"4\">Pubmed</td></tr><tr><td>α=2</td><td>α=3</td><td>α=5</td><td>α=10</td><td>α=2</td><td>α=3</td><td>α=5</td><td>α=10</td></tr><tr><td>p=-1</td><td>59.6</td><td>61.2</td><td>69.9</td><td>70.9</td><td>60.1</td><td>60.2</td><td>67.9</td><td>66.4</td></tr><tr><td>p = 0.01</td><td>61.2</td><td>64.8</td><td>73.1</td><td>77.4</td><td>65.5</td><td>67.4</td><td>73.4</td><td>72.9</td></tr><tr><td>p=1</td><td>62.3</td><td>64.5</td><td>73.1</td><td>77.2</td><td>64.8</td><td>64.3</td><td>72.2</td><td>72.6</td></tr><tr><td>p=2</td><td>63.1</td><td>63.8</td><td>71.9</td><td>71.5</td><td>63.7</td><td>63.9</td><td>70.8</td><td>71.3</td></tr><tr><td>p=3</td><td>62.7</td><td>63.6</td><td>71.3</td><td>71.4</td><td>62.2</td><td>61.3</td><td>70.1</td><td>67.9</td></tr><tr><td>p=5</td><td>62.8</td><td>63.3</td><td>69.4</td><td>70.6</td><td>62.1</td><td>60.4</td><td>69.3</td><td>68.0</td></tr></table>",
+        "bbox": [
+            209,
+            140,
+            789,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/00c52090c0a5f752b50b13a2afecf924665e7c5a1f627ee247e25b1f71dbcd9e.jpg",
+        "table_caption": [
+            "Table 3: Performance of HyperSAGE and its variants on nodes which were part of the training hypergraph (seen) and nodes which were not part of the training hypergraph (unseen). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">DBLP</td><td colspan=\"2\">Pubmed</td><td colspan=\"2\">Citeseer</td><td colspan=\"2\">Cora (citation)</td></tr><tr><td>Method</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td><td>Seen</td><td>Unseen</td></tr><tr><td>MLP + HLR</td><td>64.5</td><td>58.7</td><td>66.8</td><td>62.4</td><td>60.1</td><td>58.2</td><td>65.7</td><td>64.2</td></tr><tr><td>HyperSAGE (p = 0.01)</td><td>78.1</td><td>73.1</td><td>81.0</td><td>80.4</td><td>69.2</td><td>67.1</td><td>68.2</td><td>65.7</td></tr><tr><td>HyperSAGE (p =1)</td><td>78.1</td><td>73.2</td><td>78.5</td><td>76.4</td><td>69.3</td><td>67.9</td><td>71.3</td><td>66.8</td></tr><tr><td>HyperSAGE (p = 2)</td><td>76.1</td><td>70.2</td><td>71.2</td><td>69.8</td><td>65.9</td><td>63.8</td><td>65.9</td><td>64.5</td></tr></table>",
+        "bbox": [
+            173,
+            328,
+            831,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            462,
+            480,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "However, for smaller ratios, we see that HyperSAGE outperforms HyperGCN by a significant margin across all datasets. Further, the standard deviation for the predictions of HyperSAGE are significantly lower than that of HyperGCN. Clearly, this implies that HyperSAGE is able to better exploit the information contained in the hypergraph compared to HyperGCN, and can thus produce more accurate and stable predictions. Results on Cora and Citeseer can be found in Appendix C. ",
+        "bbox": [
+            174,
+            476,
+            823,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of generalized mean aggregations and neighborhood sampling. We study here the effect of different choices of the aggregation functions $\\mathcal { F } _ { 1 } ( \\cdot )$ and $\\mathcal { F } _ { 2 } ( \\cdot )$ on the performance of the model. Further, we also analyze how the number of samples chosen for aggregation affect its performance. Aggregation functions from $M _ { p }$ are chosen with $p = 1 , 2 , 3 , 4 , 5 , 0 . 0 1$ and $- 1$ , and to comply with global neighborhood invariance, we use aggregation function as in Eq. 4. The number of neighbors $\\alpha$ for intra-edge aggregation are chosen to be 2, 3, 5 and 10. Table 2 shows the accuracy scores obtained for different choices of $p$ and $\\alpha$ on DBLP and Pubmed datasets. For most cases, higher value of $p$ reduces the performance of the model. For $\\alpha = 2$ on DBLP, performance seems to be independent of the choice of $p$ . A possible explanation could be that the number of neighbors is very small, and change in $p$ does not affect the propagation of information significantly. An exception is $p = - 1$ , where the performance drops for all cases. For Pubmed, the choice of $p$ seems to be very important, and we find that $p = 0 . 0 1$ seems to fit best. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also see that the number of samples per aggregation can significantly affect the performance of the model. For DBLP, model performance increases with increasing value of $\\alpha$ . However, for Pubmed, we observe that performance improves up to $\\alpha = 5$ , but then a slight drop is observed for larger sets of neighbors. Note that for Pubmed, the majority of the hyperedges have cardinality less than or equal to 10. This means that during aggregation, information will most often be aggregated from all the neighbors, thereby involving almost no stochastic sampling. Stochastic sampling of nodes could serve as a regularization mechanism and reduce the impact of noisy hyperedges. However, at $\\alpha = 1 0$ , it is almost absent, due to which the noise in the data affects the performance of the model which is not the case in DBLP. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 INDUCTIVE LEARNING ON EVOLVING GRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            532,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For inductive learning experiment, we consider the case of evolving hypergraphs. We create 4 inductive learning datasets from DBLP, Pubmed, Citeseer and Core (co-citation) by splitting each of the datasets into a train-test ratio of 1:4. Further, the test data is split into two halves: seen and unseen. The seen test set comprises nodes that are part of the hypergraph used for representation learning. Further, unseen nodes refer to those that are never a part of the hypergraph during training. To study how well HyperSAGE generalizes for inductive learning, we classify the unseen nodes and compare the performance with the scores obtained on the seen nodes. Further, we also compare our results on unseen nodes with those of $\\mathrm { M L P { + } H L R }$ . The results are shown in Table 3. We see that results obtained with HyperSAGE on unseen nodes are significantly better than the baseline method. Further, these results seem to not differ drastically from those obtained on the seen nodes, thereby confirming that HyperSAGE can work with evolving graphs as well. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            248,
+            318,
+            265
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have proposed HyperSAGE, a generic neural message passing framework for inductive learning on hypergraphs. The proposed approach fully utilizes the inherent higher-order relations in a hypergraph structure without reducing it to a regular graph. Through experiments on several representative datasets, we have shown that HyperSAGE outperforms the other methods for hypergraph learning. Several variants of graph-based learning algorithm such as GCN and GraphSAGE can be derived from the flexible aggregation and neighborhood sampling framework, thus making HyperSAGE a universal framework for learning node representations on hypergraphs as well as graphs. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            285,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sameer Agarwal, Kristin Branson, and Serge Belongie. Higher order learning with graphs. In Proceedings of the 23rd international conference on Machine learning, pp. 17–24, 2006. ",
+        "bbox": [
+            176,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Devanshu Arya, Stevan Rudinac, and Marcel Worring. Hyperlearn: a distributed approach for representation learning in datasets with many modalities. In Proceedings of the 27th ACM International Conference on Multimedia, pp. 2245–2253, 2019. ",
+        "bbox": [
+            176,
+            457,
+            821,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Bai, Feihu Zhang, and Philip HS Torr. Hypergraph convolution and hypergraph attention. Pattern Recognition, pp. 107637, 2020. ",
+        "bbox": [
+            176,
+            506,
+            821,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. Berge and E. Minieka. Graphs and Hypergraphs. North-Holland mathematical library. North-Holland Publishing Company, 1976. ISBN 9780720424539. URL https://books. google.nl/books?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ ARoVvgAACAAJ. ",
+        "bbox": [
+            176,
+            542,
+            821,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017. ",
+        "bbox": [
+            176,
+            593,
+            823,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T-H Hubert Chan, Anand Louis, Zhihao Gavin Tang, and Chenzi Zhang. Spectral properties of hypergraph laplacian and approximation algorithms. Journal of the ACM (JACM), 65(3):1–48, 2018. ",
+        "bbox": [
+            176,
+            643,
+            823,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "I Eli Chien, Huozhi Zhou, and Pan Li. hsˆ2: Active learning over hypergraphs with pointwise and pairwise queries. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 2466–2475, 2019. ",
+        "bbox": [
+            173,
+            694,
+            823,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yihe Dong, Will Sawin, and Yoshua Bengio. HNHN: Hypergraph networks with hyperedge neurons. arXiv preprint arXiv:2006.12278, 2020. ",
+        "bbox": [
+            171,
+            743,
+            823,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3558–3565, 2019. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. Proceedings of the 34th International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            173,
+            830,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Proceedings. 2005 IEEE International Joint Conference on Neural Networks, 2005., volume 2, pp. 729–734. IEEE, 2005. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shi Gu, Muzhi Yang, John D Medaglia, Ruben C Gur, Raquel E Gur, Theodore D Satterthwaite, and Danielle S Bassett. Functional hypergraph uncovers novel covariant structures over neurodevelopment. Human brain mapping, 38(8):3823–3835, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuemei Gu, Lijun Chen, and Mario Krenn. Quantum experiments and hypergraphs: Multiphoton sources for quantum interference, quantum computation, and quantum entanglement. Physical Review A, 101(3):033816, 2020. ",
+        "bbox": [
+            176,
+            156,
+            821,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pp. 1024–1034, 2017. ",
+        "bbox": [
+            173,
+            209,
+            820,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthias Hein, Simon Setzer, Leonardo Jost, and Syama Sundar Rangapuram. The total variation on hypergraphs-learning on hypergraphs revisited. In Advances in Neural Information Processing Systems, pp. 2427–2435, 2013. ",
+        "bbox": [
+            173,
+            248,
+            823,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Jiang, Yuxuan Wei, Yifan Feng, Jingxuan Cao, and Yue Gao. Dynamic hypergraph neural networks. In IJCAI, pp. 2635–2641, 2019. ",
+        "bbox": [
+            169,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2016. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guohao Li, Chenxin Xiong, Ali Thabet, and Bernard Ghanem. Deepergcn: All you need to train deeper gcns. arXiv preprint arXiv:2006.07739, 2020. ",
+        "bbox": [
+            171,
+            380,
+            823,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guoyin Li, Liqun Qi, and Gaohang Yu. The z-eigenvalues of a symmetric tensor and its application to spectral hypergraph theory. Numerical Linear Algebra with Applications, 20(6):1001–1029, 2013. ",
+        "bbox": [
+            173,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pan Li and Olgica Milenkovic. Inhomogeneous hypergraph clustering with applications. In Advances in Neural Information Processing Systems, pp. 2308–2318, 2017. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            176,
+            511,
+            823,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan A. Rossi and Nesreen K. Ahmed. The network data repository with interactive graph analytics and visualization. In AAAI, 2015. URL http://networkrepository.com. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008. ",
+        "bbox": [
+            171,
+            590,
+            821,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amnon Shashua, Ron Zass, and Tamir Hazan. Multi-way clustering using super-symmetric nonnegative tensor factorization. In European conference on computer vision, pp. 595–608. Springer, 2006. ",
+        "bbox": [
+            174,
+            628,
+            821,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shulong Tan, Jiajun Bu, Chun Chen, Bin Xu, Can Wang, and Xiaofei He. Using rich social media information for music recommendation via hypergraph model. ACM Transactions on Multimedia Computing, Communications, and Applications (TOMM), 7(1):1–22, 2011. ",
+        "bbox": [
+            173,
+            736,
+            826,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael M Wolf, Alicia M Klinvex, and Daniel M Dunlavy. Advantages to modeling relational data using hypergraphs versus graphs. In 2016 IEEE High Performance Extreme Computing Conference (HPEC), pp. 1–7. IEEE, 2016. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Vikram Nitin, Anand Louis, and Partha Talukdar. Hypergcn: A new method for training graph convolutional networks on hypergraphs. In Advances in Neural Information Processing Systems, pp. 1511–1522, 2019. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pp. 5165–5175, 2018. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Shali Jiang, and Yixin Chen. Beyond link prediction: Predicting hyperlinks in adjacency space. In AAAI, volume 1, pp. 6, 2018a. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018b. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Songyang Zhang, Zhi Ding, and Shuguang Cui. Introducing hypergraph signal processing: theoretical foundation and practical applications. IEEE Internet of Things Journal, 7(1):639–660, 2019. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Jiayuan Huang, and Bernhard Scholkopf. Learning with hypergraphs: Clustering, ¨ classification, and embedding. In Advances in neural information processing systems, pp. 1601– 1608, 2007. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            282,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTS: ADDITIONAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            529,
+            152
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We perform multi-class classification on co-authorship and co-citation datasets, where the task is to predict the topic (class) for each document. ",
+        "bbox": [
+            173,
+            167,
+            823,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 DATASET DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            213,
+            383,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hypergraphs are created on these datasets by assigning each document as a node and each hyperedge represents (a) all documents co-authored by an author in co-authorship dataset and (b) all documents cited together by a document in co-citation dataset. Each document (node) is represented by bagof-words features. The details about nodes, hyperedges and features is shown in Table 4. We use the same dataset and train-test splits as provided by Yadati et al. (2019) in their publically available implementation 1. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/c81c10ac99019a6625e2f67c246ce4178a72ea3246bd1de019768e6fbf94ee39.jpg",
+        "table_caption": [
+            "Table 4: Details of real-world hypergraph datasets used in our work "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"2\">Co-authorship Data</td><td colspan=\"3\">Co-citation Data</td></tr><tr><td>DBLP</td><td>Cora</td><td>Pubmed</td><td>Citeseer</td><td>Cora</td></tr><tr><td>Nodes (|VI)</td><td>43413</td><td>2708</td><td>19717</td><td>3312</td><td>2708</td></tr><tr><td>Hyperedges (|ε|)</td><td>22535</td><td>1072</td><td>7963</td><td>1079</td><td>1579</td></tr><tr><td>average hyperedge size</td><td>4.7±6.1</td><td>4.2±4.1</td><td>4.3 ± 5.7</td><td>3.2±2.0</td><td>3.0 ± 1.1</td></tr><tr><td>number of features, |xl</td><td>1425</td><td>1433</td><td>500</td><td>3703</td><td>1433</td></tr><tr><td>number of classes</td><td>6</td><td>7</td><td>3</td><td>6</td><td>7</td></tr></table>",
+        "bbox": [
+            215,
+            363,
+            781,
+            500
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            406,
+            537
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We use the following set of hyperparameters similar to the prior work by Kipf & Welling (2016) for all the models. ",
+        "bbox": [
+            176,
+            549,
+            825,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• hidden layer size: 32   \n• dropout rate: 0.5   \n• learning rate: 0.01   \n• weight decay: 0.0005   \n• number of training epochs: 150   \n• $\\lambda$ for explicit Laplacian regularisation: 0.001 ",
+        "bbox": [
+            215,
+            589,
+            527,
+            702
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B CHOICE OF INTER-EDGE AND INTRA-EDGE AGGREGATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            723,
+            699,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof. For any given hypergraph $\\mathcal { H } _ { 1 } = ( \\mathcal { V } , \\mathcal { E } _ { 1 } , \\mathbf { X } )$ , let $v _ { i }$ denote a node at which global neighborhood equivariance exists. The aggregation output $\\mathcal { F } _ { 1 } ( \\mathbf { s } )$ at $v _ { i }$ can then be written using generalized means $M _ { p }$ as ",
+        "bbox": [
+            174,
+            753,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b90af7a44be9f18906a9c2321d540f3ecab6059e066170db9b3487fa765a9b5e.jpg",
+        "text": "$$\n\\mathcal { F } _ { 1 } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { 1 } { p _ { 1 } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            813,
+            638,
+            867
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To reiterate here, s denotes the unordered set of input as shown in Eq. 5. Further, the inter-edge aggregation $\\mathcal { F } _ { 2 } ( \\cdot )$ can be stated as ",
+        "bbox": [
+            174,
+            869,
+            825,
+            898
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/877a500373a1d0b53df5de13b506a47cf4917820b32e4bb44bb0c7a2f91b3076.jpg",
+        "image_caption": [
+            "Figure 4: (a) Example showing node $v _ { i }$ shared across 4 hyperedges. (b) Hyperedge $e _ { q }$ is split into $r$ hyperedges to reduce the cardinality of $e _ { q }$ . Note that the global neighborhood of $v _ { i }$ still remains the same, however its intra-edge neighborhood has changed due to such splitting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            99,
+            754,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41e9e0f04ce39fb5341294a24fd4ff0dcf87d8069fe342ba17c1bf883858fe84.jpg",
+        "text": "$$\n\\mathcal { F } _ { 2 } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | E ( v _ { i } ) | } \\sum _ { \\mathbf { e } \\in E ( v _ { i } ) } \\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } \\right) ^ { \\frac { 1 } { p _ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            351,
+            707,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This equation can be rewritten as ",
+        "bbox": [
+            174,
+            421,
+            393,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76429d14ee390651a8440e984500849f4220b977b1d74fc8f9a8281bc6acf60c.jpg",
+        "text": "$$\n\\mathsf { F } _ { 2 } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | E ( v _ { i } ) | } \\left( \\left( \\frac { 1 } { | \\mathsf { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } \\sum _ { v _ { j } \\in \\mathsf { N } ( v _ { i } , \\mathbf { e } _ { q } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } + \\sum _ { \\mathbf { e } \\in E ( v _ { i } ) , \\mathbf { e } \\neq \\mathbf { e } _ { q } } \\left( \\frac { 1 } { | \\mathsf { N } ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\mathsf { N } ( v _ { i } , \\mathbf { e } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } \\right) \\right) ^ { \\frac { p _ { 1 } } { p _ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            443,
+            839,
+            497
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Further, let ",
+        "bbox": [
+            173,
+            506,
+            250,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f83dd14df100b85e2068ee8f2bea56dfe09d410a1cc2800f0be212f41cb1afed.jpg",
+        "text": "$$\n\\Psi = \\sum _ { \\mathbf { e } \\in E ( v _ { i } ) , \\mathbf { e } \\neq \\mathbf { e } _ { q } } \\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            537,
+            666,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "then Eq. 7 can be rewritten as ",
+        "bbox": [
+            173,
+            592,
+            370,
+            607
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cf403850d14a2bc93f5d8ab6676cc832e19b6ce9c3d44fe7310b338efbad8a9.jpg",
+        "text": "$$\n\\mathcal { F } _ { 2 } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | E ( v _ { i } ) | } \\left( \\left( \\frac { 1 } { | \\Re ( v _ { i } , \\mathbf { e } _ { q } ) | } \\sum _ { v _ { j } \\in \\Re ( v _ { i } , \\mathbf { e } _ { q } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } + \\Psi \\right) \\right) ^ { \\frac { 1 } { p _ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            622,
+            720,
+            685
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Let us assume now that hyperedge $\\mathbf { e } _ { q }$ is split into $r$ hyperedges given by $\\begin{array} { r l } { E ( v _ { i } , \\mathbf { e } _ { q } ) } & { { } = } \\end{array}$ $\\{ \\mathbf { e } _ { q _ { 1 } } , \\mathbf { e } _ { q _ { 2 } } \\ldots \\mathbf { e } _ { q _ { r } } \\}$ . Stating the aggregation on the new set of hyperedges as $\\tilde { \\mathcal { F } } _ { 2 } ( \\mathbf { s } )$ , we assemble the contribution from this new set of hyperedges with added weight terms $w _ { j }$ as stated below. ",
+        "bbox": [
+            176,
+            694,
+            823,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e27b92a365fad120a545840395de293b379666832eac70834228fa912d285b6a.jpg",
+        "text": "$$\n\\tilde { \\mathcal { F } } _ { 2 } ( \\mathbf { s } ) = \\left( \\frac { 1 } { | E ( v _ { i } ) | } \\left( \\sum _ { \\mathbf { e } \\in E ( v _ { i } , \\mathbf { e } _ { q } ) } \\left( \\frac { 1 } { | \\Re ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\Re ( v _ { i } , \\mathbf { e } ) } w _ { j } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } + \\Psi \\right) \\right) ^ { \\frac { 1 } { p _ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            756,
+            756,
+            819
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the property of global neighborhood invariance to hold at $v _ { i }$ , the following condition should be satisfied: $\\mathcal { F } _ { 2 } ( v _ { i } ) = \\tilde { \\mathcal { F } } _ { 2 } ( v _ { i } )$ . Based on this, we would like to solve for the weights $w _ { j }$ . For this, we equate the two terms and obtain ",
+        "bbox": [
+            176,
+            825,
+            823,
+            869
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d974d7bc3e90a60dc0fc85fee1a0fd3c27985fa255a350ca459fd5a9d55fd5b.jpg",
+        "text": "$$\n\\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } _ { q } ) } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } } = \\sum _ { \\mathbf { e } \\in E ( v _ { i } , \\mathbf { e } _ { q } ) } \\left( \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } ) | } \\sum _ { v _ { j } \\in \\mathscr { N } ( v _ { i } , \\mathbf { e } ) } w _ { j } \\mathbf { x } _ { j } ^ { p _ { 1 } } \\right) ^ { \\frac { p _ { 2 } } { p _ { 1 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            873,
+            767,
+            929
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We further solve for the variables simplify Eq. 11 using the follow $p _ { 1 } , p _ { 2 }$ and bstitu $w _ { j }$ whns: 1, e sakand t, $\\begin{array} { r } { \\alpha = \\frac { p _ { 2 } } { p _ { 1 } } } \\end{array}$ $\\begin{array} { r } { \\beta = \\frac { 1 } { | \\mathcal { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } } \\end{array}$ βmj = j|N(vi,em)| where the index $m$ here is used to refer to the $m ^ { \\mathrm { t h } }$ hyperedge from among the $r$ hyperedges obtained on splitting $\\mathbf { e } _ { q }$ . Further, let $z _ { j } = \\mathbf { x } _ { j } ^ { p _ { 1 } }$ for $v _ { j } \\in \\mathcal { N } ( v _ { i } , \\mathbf { e } _ { q } )$ and $z _ { m j } = \\bar { \\bf x } _ { j } ^ { p _ { 1 } }$ for $v _ { j } \\in \\mathcal { N } ( v _ { i } , \\mathbf { e } _ { m } )$ and $\\mathbf { e } _ { m } \\in E ( v _ { i } , \\mathbf { e } _ { q } )$ . ",
+        "bbox": [
+            173,
+            102,
+            825,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Based on these substitutions, Eq. 11 can be restated as ",
+        "bbox": [
+            174,
+            189,
+            532,
+            204
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e18148939aa17b7ec1f07ff3144dd32acf5d7cee376d28f09208c70afb9d0334.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\beta ^ { \\alpha } ( z _ { 1 } + z _ { 2 } + . . . + z _ { N } ) ^ { \\alpha } = ( \\beta _ { 1 1 } z _ { 1 } + \\beta _ { 1 2 } z _ { 2 } + . . . + \\beta _ { 1 j } z _ { j } + . . . + \\beta _ { 1 N } z _ { N } ) ^ { \\alpha } } \\\\ & { } & { + ( \\beta _ { 2 1 } z _ { 1 } + \\beta _ { 2 2 } z _ { 2 } + . . . + \\beta _ { 2 j } z _ { j } + . . . + \\beta _ { 2 N } z _ { N } ) ^ { \\alpha } + } \\\\ & { } & \\\\ & { } & { \\vdots } & \\\\ & { } & { + ( \\beta _ { r 1 } z _ { 1 } + \\beta _ { r 2 } z _ { 2 } + . . . + \\beta _ { r j } z _ { j } + . . . + \\beta _ { r N } z _ { N } ) ^ { \\alpha } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            204,
+            764,
+            287
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We seek general solutions for $w _ { j }$ and $\\alpha$ which holds for all values of $z _ { j } \\in [ 0 , 1 ]$ since every element in the normalized feature vectors $\\mathbf { x } _ { j }$ lies in $[ 0 , 1 ]$ . ",
+        "bbox": [
+            173,
+            294,
+            823,
+            324
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For a generalized solution, the coefficients of $z _ { j }$ on the right should be equal to the coefficient of $z _ { j }$ on the left. The term on the left can be reformulated as ",
+        "bbox": [
+            173,
+            329,
+            821,
+            358
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0326695e1e0aa38e9813cb1e5f853736c85a920621d8f400d155c999b41bf913.jpg",
+        "text": "$$\n\\beta ^ { \\alpha } ( z _ { 1 } + z _ { 2 } + . . . + z _ { N } ) ^ { \\alpha } = \\beta ^ { \\alpha } ( z _ { 1 } + ( z _ { 2 } + z _ { 3 } + . . . + z _ { N } ) ) ^ { \\alpha }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            359,
+            704,
+            377
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Consider the case when $| z _ { 1 } | \\le | z _ { 2 } + z _ { 3 } + . . . |$ , we expand Eq. 13. using binomial expansion for real co-efficients, ",
+        "bbox": [
+            171,
+            386,
+            825,
+            414
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/900aa8e33885f79b33a8b0a14e8f920f59f48371311c43bee5ed6662bbc4a810.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\beta ^ { \\alpha } ( z _ { 1 } + ( z _ { 2 } + z _ { 3 } + \\dots ) ) ^ { \\alpha } = \\beta ^ { \\alpha } ( \\binom { \\alpha } { 0 } z _ { 1 } ^ { \\alpha } + \\binom { \\alpha } { 1 } z _ { 1 } ^ { \\alpha - 1 } ( z _ { 2 } + z _ { 3 } + \\dots + z _ { N } ) + } \\\\ & { \\vdots } \\\\ & { \\qquad \\quad + \\ } \\\\ & { \\qquad \\quad + \\ \\binom { \\alpha } { \\alpha - 1 } z _ { 1 } ( z _ { 2 } + z _ { 3 } + \\dots + z _ { N } ) ) } \\\\ & { \\qquad = \\beta ^ { \\alpha } ( z _ { 1 } ^ { \\alpha } + \\alpha ( z _ { 1 } ^ { \\alpha - 1 } z _ { 2 } + z _ { 1 } ^ { \\alpha - 1 } z _ { 3 } + \\dots + z _ { 1 } ^ { \\alpha - 1 } z _ { N } ) + } \\\\ & { \\vdots } \\\\ & { \\qquad \\quad + \\ } \\\\ & { \\quad + \\alpha z _ { 1 } ( z _ { 2 } + z _ { 3 } + \\dots + z _ { N } ) ^ { \\alpha - 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            415,
+            766,
+            583
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Without any loss of generality, we consider splitting of hyperedge $e _ { q }$ into $r$ hyperedges such that nodes $v _ { \\gamma _ { 1 } }$ and $v _ { \\gamma _ { 2 } }$ are not contained in the same hyperedge anymore. This implies that RHS in Eq. 14 should not contain product terms of $z _ { 1 }$ and $z _ { 2 }$ . Hence, the term $z _ { 1 } ^ { \\alpha - 1 } z _ { 2 }$ should be such that ",
+        "bbox": [
+            173,
+            589,
+            823,
+            635
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7848f0386fbc0f82c79a27efc29603f289f96ce0ec182f41c14338205ae6aa66.jpg",
+        "text": "$$\n\\alpha - 1 = 0 \\Rightarrow \\alpha = 1 \\Rightarrow p 1 = p 2\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            637,
+            607,
+            652
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Putting $\\alpha = 1$ and comparing the coefficients in Eq.12, we get ",
+        "bbox": [
+            173,
+            661,
+            583,
+            676
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3a7d1a15e1fe0244367bbe406bb85d4a8101ee7ea8dd1a5f7dd2466ae91d311.jpg",
+        "text": "$$\n\\begin{array} { c } { \\beta = \\beta _ { 1 1 } + \\beta _ { 1 2 } + . . . + \\beta _ { 2 1 } + \\beta _ { 2 2 } . . . + \\beta _ { r 1 } + \\beta _ { r 2 } + . . . } \\\\ { \\displaystyle \\frac { 1 } { | \\mathbb { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } = \\displaystyle \\sum _ { m = 1 } ^ { r } \\frac { w _ { j } } { | \\mathbb { N } ( v _ { i } , \\mathbf { e } _ { m } ) | } } \\\\ { w _ { j } = \\displaystyle \\frac { 1 } { | \\mathbb { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } * \\left( \\displaystyle \\sum _ { m = 1 } ^ { r } \\frac { 1 } { | \\mathbb { N } ( v _ { i } , \\mathbf { e } _ { m } ) | } \\right) ^ { - 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            678,
+            718,
+            785
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Thus, if an edge ${ \\bf e } _ { q }$ is split into multiple edges $E ( v _ { i } , { \\bf e } _ { q } )$ , then for the two aggregations to hold, the conditions are $p _ { 1 } = p _ { 2 }$ and $\\begin{array} { r } { w _ { j } = \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } _ { q } ) | } * \\left( \\sum _ { m = 1 } ^ { r } \\frac { 1 } { | \\mathscr { N } ( v _ { i } , \\mathbf { e } _ { m } ) | } \\right) ^ { - 1 } \\forall \\mathbf { e } \\in E ( v _ { i } , \\mathbf { e } _ { q } ) . } \\end{array}$ ",
+        "bbox": [
+            169,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "While we provide above a description related to splitting a certain hyperedge $\\mathbf { e } _ { q }$ into $r$ hyperedges, the derived results can be used to compute global neighborhood itself on any given node $v _ { i }$ . Similar to $\\mathbf { e } _ { q }$ above, node $v _ { i }$ together with its global neighborhood (counted as $\\mathcal { N } ( v _ { i } ) )$ ) can be interpreted as a virtual hyperedge that has been split into a number of hyperedges that actually exist and contain $v _ { i }$ . These resultant hyperdges are equivalent to the $r$ hyperdges obtained after splitting, as stated above. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/aec376f6f4c1d4ff877471c5364b6e9877d8e635e870c3f6e6938f8a3fcd8f6f.jpg",
+        "image_caption": [
+            "Figure 5: Results on cora and citeseer for multiple train test ratio "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            141,
+            769,
+            253
+        ],
+        "page_idx": 14
+    }
+]

parse/train/ryxjnREFwH/ryxjnREFwH.md

@@ -0,0 +1,413 @@
+# NEURAL SYMBOLIC READER: SCALABLE INTEGRATION OF DISTRIBUTED AND SYMBOLIC REPRESENTATIONS FOR READING COMPREHENSION
+
+Xinyun Chen ∗   
+UC Berkeley   
+xinyun.chen@berkeley.edu
+
+Chen Liang, Adams Wei Yu, Denny Zhou Google Brain {crazydonkey,adamsyuwei,dennyzhou}@google.com
+
+Dawn Song   
+UC Berkeley   
+dawnsong@cs.berkeley.edu
+
+Quoc V. Le Google Brain qvl@google.com
+
+# ABSTRACT
+
+Integrating distributed representations with symbolic operations is essential for reading comprehension requiring complex reasoning, such as counting, sorting and arithmetics, but most existing approaches rely on specialized neural modules and are hard to adapt to multiple domains or multi-step reasoning. In this work, we propose the Neural Symbolic Reader (NeRd), which includes a reader, e.g., BERT, to encode the passage and question, and a programmer, e.g., LSTM, to generate a program for multi-step reasoning. By using operators like span selection, the program can be executed over text to generate the answer. Compared to previous works, NeRd is more scalable in two aspects: (1) domain-agnostic, i.e., the same neural architecture works for different domains; (2) compositional, i.e., complex programs can be generated by compositionally applying the symbolic operators. Furthermore, to overcome the challenge of training NeRd with weak supervision, we apply data augmentation techniques and hard ExpectationMaximization (EM) with thresholding. On DROP, a challenging reading comprehension dataset requiring discrete reasoning, NeRd achieves $1 . 3 7 \% / 1 . 1 8 \%$ absolute gain over the state-of-the-art on Exact-Match/F1 metrics. With the same architecture, NeRd significantly outperforms the baselines on MathQA, a math problem benchmark that requires multiple steps of reasoning, by $2 5 . 5 \%$ absolute gain on accuracy when trained on all the annotated programs, and more importantly, still beats the baselines even with only $20 \%$ of the program annotations.
+
+# 1 INTRODUCTION
+
+Deep neural networks have achieved remarkable successes in natural language processing recently. In particular, pretrained language models, e.g., BERT (Devlin et al., 2019), have significantly advanced the state-of-the-art in reading comprehension. While neural models have demonstrated performance superior to humans on some benchmarks, e.g., SQuAD (Rajpurkar et al., 2016), so far such progress is mostly limited to extractive question answering, in which the answer is a single span from the text. In other words, this type of benchmarks usually test the capability of text pattern matching, but not of reasoning. Some recent datasets, e.g., DROP (Dua et al., 2019) and MathQA (Amini et al., 2019), are collected to examine the capability of both language understanding and discrete reasoning, where the direct application of the state-of-the-art pre-trained language models, such as BERT or QANet (Yu et al., 2018), achieves very low accuracy. This is especially challenging for pure neural network approaches, because discrete operators learned by neural networks, such as addition and sorting, can hardly generalize to inputs of arbitrary size without specialized design (Reed & de Freitas, 2016; Cai et al., 2017; Kaiser & Sutskever, 2015). Therefore, integrating neural networks with symbolic reasoning is crucial for solving those new tasks.
+
+The recent progress on neural semantic parsing (Jia & Liang, 2016; Liang et al., 2017) is sparked to address this problem. However, such success is mainly restricted to question answering with structured data sources, e.g., knowledge graphs (Berant et al., 2013) or tabular databases (Pasupat & Liang, 2015). Extending it to reading comprehension by parsing the text into structured representations suffers severely from the cascade errors, i.e., the issues of the structured parsing for data preprocessing account for the poor performance of the learned neural model (Dua et al., 2019).
+
+![](images/1d8be7796f712432c914bbb50a5dce2faf567e4d766a9b1753c1ebe888dce093.jpg)  
+Figure 1: Comparison of NeRd with previous approaches for reading comprehension requiring complex reasoning. The components in grey boxes are the neural architectures. Previous works mainly take two approaches: (1) augmenting pre-trained language model such as BERT with specialized modules for each type of questions, which is hard to scale to multiple domains or multi-step complex reasoning; (2) applying neural semantic parser to the structured parses of the passage, which suffers severely from the cascade error. In contrast, the neural architecture of NeRd is domain-agnostic, which includes a reader, e.g., BERT, and a programmer, e.g., LSTM, to generate compositional programs that are directly executed over the passages.
+
+A recent line of work (Dua et al., 2019; Hu et al., 2019; Andor et al., 2019) extends BERT/QANet to perform reasoning on the DROP dataset. However, they cannot easily scale to multiple domains or multi-step complex reasoning because: (1) they usually rely on handcrafted and specialized modules for each type of questions; (2) they don’t support compositional applications of the operators, so it is hard to perform reasoning of more than one step.
+
+In this work, we propose the Neural Symbolic Reader (NeRd) for reading comprehension, which consists of (1) a reader that encodes passages and questions into vector representations; and (2) a programmer that generates programs, which are executed to produce answers. The key insights behind NeRd are as follows: (1) by introducing a set of span selection operators, the compositional programs, usually executed against structured data such as databases in semantic parsing, can now be executed over text; (2) the same architecture can be applied to different domains by simply extending the set of symbolic operators.
+
+A main challenge of training NeRd is that it is often expensive to collect program annotations, so the model needs to learn from weak supervision, i.e., with access only to the final answers. This raises two problems for learning: (1) cold start problem. There are no programs available at the beginning of training, so the training cannot proceed. We address this problem through data augmentation that generates noisy training data to bootstrap the training; (2) spurious program problem, where some programs produce the right answer for wrong rationales. We propose an iterative process using hard EM with thresholding, which filters out the spurious programs during training.
+
+In our evaluation, NeRd demonstrates three major advantages over previous methods: (1) better accuracy. It outperforms the previous state-of-the-art on DROP by $1 . 3 7 \% / 1 . 1 8 \%$ on EM/F1, and the baselines on MathQA by a large margin of $2 5 . 5 \%$ on accuracy if trained with all annotated programs. Notably, it still outperforms the MathQA baselines using only $20 \%$ of the program annotations; (2) more scalable (domain-agnostic and compositional). Unlike previous approaches, which rely on specialized modules that do not support compositional application of the operators, NeRd can be applied to tasks of different domains, e.g., DROP and MathQA, without changing the architecture, and more complex programs can be simply generated by extending the set of operators and compositionally applying them; (3) better interpretability. It is easier to interpret and verify an answer by inspecting the program that produces it, especially for the questions involving complex reasoning such as counting and sorting.
+
+# 2 NEURAL SYMBOLIC READER
+
+In this section, we present the design of NeRd. It consists of a reader that encodes the passages and questions into vector representations, and a programmer that generates programs in a domain specific language. The overall comparison between NeRd and previous works is visualized in Figure 1.
+
+# 2.1 NEURAL ARCHITECTURE
+
+We provide an overview of the two components in NeRd, and defer more details to Appendix C.
+
+Reader. Given the natural language text including a question and a passage, the reader component encodes each token $t _ { i }$ in the text into an embedding $e _ { i }$ . Note that our framework is agnostic to the architecture choice of the encoder, so any neural module that turns words into vectors is applicable, e.g., BERT (Devlin et al., 2019).
+
+Programmer. The programmer takes the output of the reader as input, and then decodes a program as a sequence of tokens. Again, our model is agnostic to the design of decoder. For simplicity, we use an LSTM (Hochreiter & Schmidhuber, 1997) decoder with attention (Bahdanau et al., 2014) over the encoded text, and self-attention (Vaswani et al., 2017) over the previously generated tokens.
+
+A major advantage of our architecture is that it is domain-agnostic, i.e., the same architecture can be used for different domains. Compared to previous approaches that craft separate specialized modules for each answer type, we use a unified programmer component to generate programs for multi-step reasoning, and we can simply extend the operator set in the domain specific language (see the next section) to adapt to a different domain. See Section 4.3 for a more detailed discussion.
+
+# 2.2 DOMAIN SPECIFIC LANGUAGE
+
+In this section, we introduce our domain specific language (DSL), which is used to interpret the tokens generated by the programmer component as an executable program.
+
+We list the operators in our DSL in Table 1. To handle discrete reasoning, the DSL includes operators that perform arithmetics (DIFF, SUM), counting (COUNT) and sorting (ARGMAX, ARGMIN, MAX, MIN). These operators have been used in previous work in semantic parsing over structured data sources such as a knowledge graph or a tabular database.
+
+However, the main challenge of applying such operations for reading comprehension is that the model needs to manipulate unstructured data, i.e., natural language text, and parsing the text into structured representations may introduce a lot of cascade errors. For example, Dua et al. (2019) found that their best performing semantic parsing pipeline using SRL (Carreras & Marquez, 2004) \` can only find the logical forms for $3 5 \%$ of the questions, resulting in poor performance.
+
+To address this issue, a key insight in our DSL design is to introduce the span selection operators, so that all the arithmetics, counting and sorting operators can be applied to text. Specifically, we introduce PASSAGE_SPAN, QUESTION_SPAN, VALUE, KEY-VALUE for selecting spans or numbers from the passage and question. For example, COUNT can use PASSAGE_SPAN to pick out the spans that mention the relevant entities or events, e.g., touchdowns made by a certain person, and then returns the total number; ARGMAX relies on applying KEY-VALUE to pick out the spans (keys) for relevant mentions and their associated numbers (values), e.g., touchdowns and their lengths, and then returns the key with the highest value, e.g., the player kicking the longest touchdown. More examples can be found in Table 2. In summary, the introduction of span selection operators in the DSL enables the application of the discrete reasoning operators to text, and the resulting programs act as executable and interpretable representations of the reasoning process.
+
+As mentioned above, our architecture is domain-agnostic and the only change needed, to apply to a different domain, is to extend the DSL with new operators. For example, MathQA benchmark requires adding more advanced mathematical operations beyond addition and subtraction, which are defined in Amini et al. (2019). We defer the details to Section 4.1.
+
+A major advantage of our DSL is its compositionality, i.e., complex programs can be generated by compositionally applying the operators. Previous works (Andor et al., 2019) only allow applying the operators for one step, which requires them to introduce operators to mimic two-step compositions, e.g., Merge (selecting two spans) and Sum3 (summing up three numbers). However, this would not scale to more steps of reasoning, as the number of required operators will grow exponentially w.r.t the number of steps. In contrast, NeRd can compose different operators to synthesize complex programs for multi-step reasoning. For example, on MathQA, the average number of operations per question is 5, and some programs apply more than 30 operations to compute the final answer.
+
+<table><tr><td>Operator</td><td>Arguments</td><td>Outputs</td><td>Description</td></tr><tr><td>PASSAGE_SPAN QUESTION_SPAN</td><td>vO: the start index. v1: the end index.</td><td>a span.</td><td>Select a span from the passage or question.</td></tr><tr><td>VALUE</td><td>vO: an index.</td><td>a number.</td><td>Select a number from the passage.</td></tr><tr><td>KEY-VALUE (KV)</td><td>vo: a span. v1: a number.</td><td>a key-value pair.</td><td>Select a key (span) value (number) pair from the passage.</td></tr><tr><td>DIFF SUM</td><td>vO:a number or index. vl: a number or index.</td><td>a number.</td><td>Compute the difference or sum of two numbers.</td></tr><tr><td>COUNT</td><td>v: a set of spans.</td><td>a number.</td><td>Count the number of given spans.</td></tr><tr><td>MAX MIN</td><td>v:a set of numbers.</td><td>a number.</td><td>Select the maximum /minimum among the given numbers.</td></tr><tr><td>ARGMAX ARGMIN</td><td>v:a set of key-value pairs.</td><td>a span.</td><td>Select the key (span) with the highest /lowest value.</td></tr></table>
+
+Table 1: Overview of our domain-specific language. See Table 2 for the sample usage.
+
+# 3 TRAINING WITH WEAK SUPERVISION
+
+Although it is relatively easy to collect question-answer pairs, it is often hard and expensive to obtain program annotations that represent the reasoning behind the answers. Thus, how to train NeRd with only weak supervision becomes a main challenge. In this section, we revisit the cold start and spurious program problems described in Section 1, and present our solutions.
+
+# 3.1 DATA AUGMENTATION FOR COLD START
+
+The cold start problem means that the training cannot get started when there isn’t any program available. For example, a question “How many touchdowns did Brady throw” annotated with only an answer $\mathbf { \ddot { \delta } } ^ { 6 } 3 ^ { \mathit { * } }$ cannot be directly used to train our model due to the lack of the target program to optimize on. To obtain program annotations from question-answer pairs, we first follow previous work to find programs for questions answerable by span selection or arithmetic operations via an exhaustive search, and we defer the details to Section 4.2. However, for questions involving counting or sorting operations, the space becomes too large for an exhaustive search, since these operations rely on the span selection as their sub-routines. For example, the number of possible spans in a text with 200 words is in the order of $1 0 ^ { 4 }$ , and what’s more, counting and sorting operators usually include more than one span as their arguments.
+
+We apply data augmentation to address the search space explosion problem for counting and sorting operations. For counting, we augment the span selection questions by replacing the interrogatives, e.g., “what” and “who”, with “how many” when applicable, and adding a call to COUNT over the selected spans in the answer. For example, a question “What areas have a Muslim population of more than 50000 people?” is changed into “How many areas...”. For sorting, we extract the key-value pairs by first applying CoreNLP (Manning et al., 2014) for entity recognition, and then heuristically find an associated number for each entity. If including them as the arguments of any sorting operator yields the correct answer, then such programs are added to the training set. More details can be found in Appendix D.1. Although the programs found for counting and sorting through this data augmentation process is noisy, they help bootstrap the training. Throughout the training, we also use the model to decode programs, and add those leading to correct answers into our training set.
+
+# 3.2 HARD EM WITH THRESHOLDING AGAINST SPURIOUS PROGRAMS
+
+After collecting a set of programs for each question-answer pair, another obstacle is the spurious program problem, the phenomenon that a wrong program accidentally predicts a right answer. For example, per arithmetic question in DROP, there are on average 9.8 programs that return correct answers, but usually only one of them is semantically correct.
+
+# Algorithm 1 Hard EM with Thresholding
+
+Input: question-answer pairs $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { N }$ ,   
+a model $p _ { \theta }$ , initial threshold $\alpha _ { 0 }$ , decay factor $\gamma$   
+for each $( x _ { i } , y _ { i } )$ do $Z _ { i } \gets$ DataAugmentation $( x _ { i } , y _ { i } )$   
+$T \gets 0$   
+repeat $\mathbf { \Delta } _ { \mathcal { D } } ^ { \alpha  \alpha _ { 0 } * \gamma ^ { T } }$ for each $( x _ { i } , y _ { i } )$ do $z _ { i } ^ { * } = \mathrm { a r g } \operatorname* { m a x } _ { k } p _ { \theta } ( z _ { i } ^ { k } | x _ { i } ) , z _ { i } ^ { k } \in Z _ { i }$ if $p _ { \theta } \big ( z _ { i } ^ { * } \big ) > \alpha$ or $T = 0$ and $| Z _ { i } | = 1$ then $\mathcal { D }  \mathcal { D } \cup ( x _ { i } , z _ { i } ^ { * } ) _ { - }$ Update $\theta$ by maximizing $\begin{array} { r } { \sum _ { \mathcal { D } } \log p _ { \theta } ( z ^ { * } | x ) } \end{array}$ $T \gets T + 1$   
+until converge or early stop
+
+To filter out spurious programs, we adopt hard EM (Liang et al., 2018; Min et al., 2019) due to its simplicity and efficiency. Specifically, this approach uses the current model to select the program with the highest model probability among the ones that return the correct answer, and then maximizes the likelihood of the selected program. In other words, it relies on the neural model itself to filter out spurious programs. This algorithm is usually faster than the marginalized approach (Berant et al., 2013) because at most one program per question-answer pair is used to compute the gradient, and the selection process is fast since it only has a forward pass.
+
+Hard EM assumes that for any question
+
+answer pair, at least one of the generated programs is correct. However, there exist questions without any semantically correct program found, e.g., when the annotated answer itself is wrong. In this case, when directly applying the hard EM algorithm, even if the model probabilities for all the programs are very small, it will still select a program for training. RL-based approaches such as MAPO (Liang et al., 2018) avoid this issue by optimizing the expected return, which weighs the gradient by the model probability. Thus, when all the programs of a question-answer pair have very small probabilities, they will be largely ignored during training. We incorporate this intuition into hard EM by introducing a decaying threshold $\alpha$ , so that a program’s probability has to be at least $\alpha$ in order to be included for training. Our experiments show that both hard EM and thresholding are crucial for successful training. The pseudo-code of our training procedure is presented in Algorithm 1, and we defer more details to Appendix D.2.
+
+# 4 EVALUATION
+
+In this section, we demonstrate the effectiveness of our approach on DROP (Dua et al., 2019) and MathQA (Amini et al., 2019), two recent benchmarks that require discrete reasoning over passages.
+
+# 4.1 DATASETS
+
+DROP. DROP (Discrete Reasoning Over Paragraphs) (Dua et al., 2019) is designed to combine the challenges from both reading comprehension and semantic parsing communities. Specifically, the passages are collected from Wikipedia, each having at least twenty numbers. The question-answer pairs are crowdsourced in an adversarial way that they are accepted only when the questions cannot be correctly answered by the BiDAF model (Seo et al., 2017). The dataset has 96.6K questionanswer pairs from 6.7K passages. Unlike most existing datasets that are solely based on the single span selection, the questions in DROP require complex reasoning, such as selecting multiple spans, arithmetic operations over numbers in the passage, counting and sorting, etc., which poses extra challenge for existing models. For example, vanilla BERT only gets around $30 \%$ F1 score. Table 2 provides some sample questions in DROP, and their corresponding programs in our DSL (Table 1).
+
+For evaluation, we use the same metrics in Dua et al. (2019): (1) Exact Match (EM), where the score is 1 if the prediction exactly matches the ground truth, and 0 otherwise; (2) F1 score, which gives partial credits to a prediction that is not exactly the same as the ground truth, but overlaps with it.
+
+MathQA. MathQA (Amini et al., 2019) is a dataset with 37K question-answer pairs selected from AQuA (Ling et al., 2017), but it is further annotated with gold programs in their domain-specific language. The passage length in MathQA is 38 on average, much shorter than DROP with 224. However, the questions in MathQA require more complex and advanced mathematical reasoning than DROP. To this aim, they design 58 math operations, which cover various advanced math topics including geometry, physics, probability, etc. Accordingly, we augment our DSL with those operators to support more advanced numerical reasoning. In these annotated programs, the average number of operations per question is 5, and some programs involve more than 30 steps of computation. Table 3 shows an example from MathQA.
+
+Table 2: Examples of correct predictions on DROP development set.   
+
+<table><tr><td>Passage</td><td>Question&amp;Answer</td></tr><tr><td colspan="2">Multiple spans</td></tr><tr><td>...the population was spread out with 26.20% under the age of18,9.30% from 18 to 24, 26.50% from 25 to 44,23.50% from 45 to 64, and 14.6o% who were 65 years of age or older..</td><td>Question:Which groups in percent are larger than 16%? Program: PASSAGE_SPAN(26,30), PASSAGE_SPAN(46,48), PASSAGE_SPAN(55,57)</td></tr><tr><td>Date When major general Nathanael Greene took</td><td>Result: ‘under the age of 18’,‘25 to 44&#x27;,‘45 to 64&#x27; Question: When did Marion rescue the American force?</td></tr><tr><td>command in the south,Marion and lieutenant colonel Henry Lee were ordered in January 1781... On August 31, Marion rescued a small American force trapped by 5Oo British sol- diers...</td><td>Program: PASSAGE_SPAN(71,71), PASSAGE_SPAN(72,72), PASSAGE_SPAN(32.32)</td></tr><tr><td>Numerical operations</td><td>Result: &#x27;August&#x27;,&#x27;3i&#x27;,&#x27;1781&#x27;</td></tr><tr><td>...Lassen county had a population of 34,895. The racial makeup of Lassen county was 25.532 (73.2%) white (U.S. census),2,834 (8.1%)</td><td>Question: How many people were not either solely white or solely African American? Program: DIFF(9,SUM(10,12))</td></tr><tr><td>African American (U.S.census)... ...the Bolshevik party came to powerin Novem-</td><td>Result: 34895 - (25532 + 2834)= 6529 Counting</td></tr><tr><td>ber 1917 through the simultaneous election in the soviets and an organized uprising sup- ported by military mutiny..</td><td>Question: How many factors were involved in bringing the Bolsheviks to power? Program: COUNT(PASSAGE_SPAN(62,66),PASSAGE_SPAN(69,74)) Result: COUNT( &#x27;simultaneous election in the soviets&#x27;,</td></tr><tr><td>Sorting</td><td>&#x27;organized uprising supported by military mutiny&#x27;)= 2</td></tr><tr><td>...Jaguarskicker Josh Scobee managed to get a 48-yard field goal..with kicker Nate Kaeding getting a 23-yard field goal...</td><td>Question:Who kicked the longest field goal? Program: ARGMAX( KV(PASSAGE_SPAN(50,53),VALUE(9)), KV(PASSAGE_SPAN(92,94),VALUE(11))) Result: ARGMAX(KV(Josh Scobee&#x27;,48),KV(Nate Kaeding&#x27;,23))</td></tr><tr><td>...Leftwich flippeda1-yard touchdown pass to Wrighster..Leftwich threw a 16- yard touch- down pass to Williams for a 38-O lead.</td><td>=‘Josh Scobee&#x27; Question:How many yardswas the shortest touchdown pass? Program: MIN(VALUE(17), VALUE(19)) Result: MIN(1,16)= 1</td></tr></table>
+
+<table><tr><td>Question</td><td>Answer</td></tr><tr><td>Someone on a skateboard is traveling 8 miles per hour.How many feet does she travel in 5 seconds? (1 mile = 5280 feet)</td><td>Program: multiply(5,divide(multiply(8,5280),const_3600)) Result: 5 *((8* 5280)/3600)=58.67 ft</td></tr></table>
+
+Table 3: An example in MathQA dataset.
+
+Note that each question in MathQA is accompanied with 4 options, where 1 of them is the correct answer. However, since we do not have the full knowledge of the operation semantics, we choose a conservative metric to evaluate the accuracy: a predicted program is considered to be correct only if it is exactly the same as the annotated program. Thus, this metric is an under-estimation of the accuracy based on the execution results. Despite that we use a much stricter measurement in our evaluation, we show that NeRd still outperforms the baselines by a large margin.
+
+# 4.2 IMPLEMENTATION DETAILS
+
+DROP. Similar to previous work (Dua et al., 2019), for span prediction, we perform an exhaustive search to find all mentions of the ground truth spans in the passage, then include all of them as candidate programs. For numerical questions, we perform another exhaustive search over all expressions applying addition and subtraction over up to 3 numbers. In this way, we are able to find at least one program for over $9 5 \%$ of the training samples with a number as the answer. Our data augmentation approach for counting and sorting questions can be seen in Section 3.1.
+
+MathQA. Besides the setting where all the ground truth programs are provided during training, we also evaluate the weak supervision setting on MathQA. Due to the lack of program executor, we are unable to perform the search similar to what we have done on DROP. To enable the first training iteration of the model, we assume that we have access to the ground truth programs for a small fraction of training samples at the beginning, and only know the final answer for the rest of training samples. In the first training iteration, the model only trains on the samples annotated with programs. In each of the following iterations, we first run a beam search with a beam size 64 to generate programs for each training sample that has not been annotated in previous iterations, and add the generated program only if it is exactly the same as the ground truth annotation.
+
+For a fair comparison, our reader uses the same pre-trained model as (Hu et al., 2019; Andor et al., 2019), i.e., BERTLARGE. For both benchmarks, we perform greedy decoding during the evaluation.
+
+# 4.3 BASELINES
+
+DROP. We evaluate NeRd against three types of baselines: (1) previous models on DROP; (2) NeRd with and without counting and sorting operations; (3) NeRd with different training algorithms, and we discuss the details below.
+
+Previous approaches. We compare with NAQANet (Dua et al., 2019), NABERT (Hu et al., 2019), MTMSN (Hu et al., 2019), and BERT-Calc (Andor et al., 2019). We have discussed the key differences between NeRd and BERT-Calc, the baseline with the best performance, in Section 2.2. On the other hand, NAQANet, NABERT, MTMSN share the same overall framework, where they augment an existing model to include individual modules for span selection, numerical expression generation, counting, negation, etc. While NAQANet is based on QANet, other baselines as well as NeRd are based on BERT. Note that the span selection modules themselves are not able to handle questions that return multiple spans as the answer, which causes the exact match accuracy to be zero on multiple-span selection questions for both NAQANet and NABERT. To tackle this issue, MTMSN adapts the non-maximum suppression algorithm (Rosenfeld & Thurston, 1971) to select multiple spans from the candidates with the top prediction probabilities.
+
+Operator variants of NeRd. To show that NeRd learns to apply counting and sorting operations appropriately, we also evaluate the following two variants: (1) NeRd without counting: we remove the COUNT operation in Table 1, and introduce 10 operations COUNT_0, COUNT_1, ..., COUNT_9, where the execution engine returns the number $x$ for operation COUNT_X. This counting process is the same as (Andor et al., 2019). (2) NeRd without sorting: we remove ARGMAX, ARGMIN, MAX and MIN operations, so that the model needs to use span selection operations for sorting questions.
+
+Training variants of NeRd. To show the effectiveness of our training algorithm, we compare with the following baselines: (1) Hard EM described in Section 3.2; and (2) Maximum Likelihood, which maximizes the likelihood of each program that returns the correct answer for a training sample.
+
+MathQA. We compare with Seq2prog and Seq2prog+cat models in Amini et al. (2019), which are LSTM-based encoder-decoder architectures implemented in OpenNMT (Klein et al., 2018). In particular, Seq2prog+cat extracts the category label of each question, then trains separate LSTMs to handle different categories, which improves the accuracy by $\mathrm { \bar { 2 . 3 \% } }$ .
+
+# 4.4 RESULTS
+
+DROP. Table 4 summarizes our main evaluation results on DROP dataset, with 9.5K samples in the development set and 9.6K hidden samples in the test set. Note that NABERTLARGE was not evaluated on the test set (Hu et al., 2019). Specifically, we train $1 0 \ \mathrm { N e R d }$ models with the best configuration from different random initialization, present the mean and standard error of the results on the development set, and submit a single model to obtain the result on the hidden test set. We can observe that on test set, NeRd outperforms previous models by $1 . 3 7 \%$ on exact match, and $1 . 1 8 \%$ on F1 score. Notice that in (Andor et al., 2019), they train their BERT-Calc model on CoQA (Reddy et al., 2019) in addition to DROP, and they also evaluate an ensemble with 6 models, resulting in the exact match of 78.14, and F1 score of 81.78 on test set. However, we can see that without additional training data and ensembling, NeRd still beats their single model, and the performance is on par with their ensemble model.
+
+<table><tr><td></td><td colspan="2">Overall Dev</td><td colspan="2">Overall Test</td><td colspan="2">Number (62%)</td><td colspan="2">Span (32%)</td><td colspan="2">Spans (4.4%)</td><td colspan="2">Date (1.6%)</td></tr><tr><td>NAQANet</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>NABERTLARGE</td><td>46.75</td><td>50.39</td><td>44.24</td><td>47.77</td><td>44.9</td><td>45.0</td><td>58.2</td><td>64.8</td><td>0.0</td><td>27.3</td><td>32.0</td><td>39.6</td></tr><tr><td></td><td>64.61</td><td>67.35</td><td>1</td><td>一</td><td>63.8</td><td>64.0</td><td>75.9</td><td>80.6</td><td>0.0</td><td>22.7</td><td>55.7</td><td>60.8</td></tr><tr><td>MTMSNLARGE</td><td>76.68</td><td>80.54</td><td>75.85</td><td>79.85</td><td>80.9</td><td>81.1</td><td>77.5</td><td>82.8</td><td>25.1</td><td>62.8</td><td>55.7</td><td>69.0</td></tr><tr><td>BERT-Calc</td><td>78.09</td><td>81.65</td><td>76.96</td><td>80.53</td><td>82.0</td><td>82.1</td><td>78.8</td><td>83.4</td><td>5.1</td><td>45.0</td><td>58.1</td><td>61.8</td></tr><tr><td>NeRd</td><td>78.55 ±0.27</td><td>81.85 ±0.20</td><td>78.33</td><td>81.71</td><td>82.4 ±0.3</td><td>82.6 ±0.2</td><td>76.2 ±0.4</td><td>81.8 ±0.2</td><td>51.3 ±0.8</td><td>77.6 ±1.2</td><td>58.3 ±1.8</td><td>67.2 ±1.7</td></tr></table>
+
+Table 4: Results on DROP dataset. On the development set, we present the mean and standard error of $1 0 \ \mathrm { N e R d }$ models, and the test result of a single model. For all models, the performance breakdown of different question types is on the development set. Note that the training data of BERT-Calc model (Andor et al., 2019) for test set evaluation is augmented with $\mathrm { C o Q A }$ (Reddy et al., 2019).
+
+<table><tr><td></td><td>with Sort Ops</td><td>w/o Sort Ops</td></tr><tr><td>EM</td><td>83.9</td><td>82.1</td></tr><tr><td>F1</td><td>86.8</td><td>85.5</td></tr></table>
+
+Table 5: Results of counting and sorting questions on DROP development set, where we compare variants of NeRd with and without the corresponding operations. (a): counting; (b): sorting. For each setting, we present the best results on development set.   
+
+<table><tr><td></td><td>with Count Op</td><td>w/o Count op</td></tr><tr><td>EM</td><td>73.1</td><td>71.2</td></tr><tr><td>F1</td><td>73.1</td><td>71.2</td></tr></table>
+
+To understand the strengths of NeRd, we first show examples of correct predictions in Table 2. We can observe that NeRd is able to compose multiple operations so as to obtain the correct answer, which helps boost the performance. In particular, for questions that require the selection of multiple spans, the exact match accuracy of NeRd is more than double of the best previous approach that specially designed for multi-span prediction, and the F1 score also improves around $1 5 \%$ . Meanwhile, NeRd is able to generate more complicated arithmetic expressions than Andor et al. (2019), thanks to the compositionality of our approach.
+
+We further present our ablation studies of counting and sorting operations in Tables 5 and 6. Specifically, we evaluate on two subsets of DROP development set that include counting and sorting questions only, using the variants of NeRd with and without the corresponding operations. We can observe that adding these advanced operations can not only boost the performance, but also enable the model to provide the rationale behind its predictions. For counting problems, NeRd is able to select the spans related to the question. For sorting problems, NeRd first associates the entities with their corresponding values to compose the key-value pairs, then picks the most relevant ones for prediction. None of the previous models is able to demonstrate such reasoning processes, which suggests better interpretability of NeRd.
+
+Finally, we present the results of different training algorithms in Table 7. First, we observe that by filtering spurious programs, the hard EM significantly boosts the performance of the maximum likelihood training for $1 \bar { 0 } \%$ , which may be due to the fact that the exhaustive search finds plenty of spurious programs that yield the correct answer. Adding the threshold for program selection provides further improvement of about $7 \%$ , indicating that our training algorithm can better handle the issue of spurious programs and be more tolerant to the noise of answer annotations. In Appendix E, we show some examples discarded by NeRd using the threshold, which mostly have the wrong answer annotations, e.g., incorrect numerical operations or missing part of the information in the question.
+
+MathQA. We present the results on MathQA test set with around 3K samples in Table 8. NeRd dramatically boosts the accuracy of the baselines by $2 5 . 5 \%$ . In addition, we also evaluate a variant of NeRd with the same model architecture, but the BERT encoder is not pre-trained and is randomly initialized. We observe that this variant still yields a performance gain of $1 7 . 4 \%$ . Note that NeRd is measured by the program accuracy, which is a much stricter criterion and thus is an underestimation of the execution accuracy computed in (Amini et al., 2019). Moreover, even with only $2 0 \%$ training data labeled with ground truth programs, NeRd still outperforms the baseline.
+
+# 5 RELATED WORK
+
+Reading comprehension and question answering have recently attracted a lot of attention from the NLP community. A plethora of datasets have been available to evaluate different capabilities of
+
+<table><tr><td rowspan=1 colspan=3>Passage</td><td rowspan=1 colspan=1>Question&amp;Prediction</td></tr><tr><td rowspan=3 colspan=3>...with field goals of 38and 36 yards by kickerDan Carpenter.. fol-lowed bya 43-yard fieldgoal by Carpenter... 52-yard field goal...</td><td rowspan=1 colspan=1>Question:Howmany total field goalswere kicked in the game?</td></tr><tr><td rowspan=1 colspan=1>PredictedProgram:COUNT(PASSAGE_SPAN(75,75),PASSAGE_SPAN(77,78),PASSAGE_SPAN(133,135),PASSAGE_SPAN(315,317))Result:COUNT(‘38&#x27;,36 yards&#x27;,‘43-yard&#x27;,‘52-yard&#x27;)= 4</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Predicted Program (-counting): COUNT5 Result: 5</td></tr><tr><td rowspan=3 colspan=3>with the five mostcommon surgeries beingbreast augmentation,li-posuction, breast reduc-tion,eyelid surgery andabdominoplasty..</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Predicted Program:COUNT(PASSAGE_SPAN(132,135),PASSAGE_SPAN(140,142),PASSAGE_SPAN(144,149))Result: COUNT(‘liposuction&#x27;,‘eyelid surgery&#x27;,‘abdominoplasty&#x27;) = 3</td></tr><tr><td rowspan=1 colspan=1>Predicted Program (-counting): COUNT4 Result: 4</td></tr></table>
+
+(a)   
+(b)   
+
+<table><tr><td rowspan=1 colspan=1>Passage</td><td rowspan=1 colspan=1>Question&amp;Prediction</td></tr><tr><td rowspan=2 colspan=1>...Inthe third quarter,Arizona&#x27;sdeficit continued to climb as Cas-sel completed a 76-yard touchdownpass to wide receiver Randy Moss... quarterback Matt Leinart com-pleted a 78-yard touchdown pass to</td><td rowspan=1 colspan=1>Question:Who threw the longest touchdown pass?</td></tr><tr><td rowspan=1 colspan=1>Predicted Program:ARGMAX(KV(PASSAGE_SPAN(205,208),VALUE(18)),KV(PASSAGE_SPAN(142,143), VALUE(14)))Result:ARGMAX(KV(Matt Leinart&#x27;,78),KV(‘Cassel&#x27;,76))=‘MattLeinart&#x27;</td></tr><tr><td rowspan=1 colspan=1>wide receiver Larry Fitzgerald ..</td><td rowspan=1 colspan=1>Predicted Program (-sorting):PASSAGE_SPAN(82,84) Result:Matt Cassel</td></tr><tr><td rowspan=3 colspan=1>Carney got a 38-yard field goal... with Carney connecting on a 39-yard field goal..</td><td rowspan=1 colspan=1>Question: How many yards was the longest field goal?</td></tr><tr><td rowspan=1 colspan=1>Predicted Program: MAX(VALUE(14),VALUE(11))Result: MAX(39,38)= 39</td></tr><tr><td rowspan=1 colspan=1>Predicted Program (-sorting): VALUE(11) Result: 38</td></tr></table>
+
+Table 6: Examples of counting and sorting questions on DROP development set, where NeRd with the corresponding operations gives the correct predictions, while the variants without them do not. (a): counting; (b): sorting.
+
+Table 7: Results of different training algorithms on DROP development set. For each setting, we present the best results on the development set.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>EM</td><td rowspan=1 colspan=1>F1</td></tr><tr><td rowspan=1 colspan=1>HardEMwith thresholding</td><td rowspan=1 colspan=1>80.58</td><td rowspan=1 colspan=1>83.42</td></tr><tr><td rowspan=1 colspan=1>Hard EM</td><td rowspan=1 colspan=1>73.72</td><td rowspan=1 colspan=1>77.46</td></tr><tr><td rowspan=1 colspan=1>MaximumLikelihood</td><td rowspan=1 colspan=1>63.96</td><td rowspan=1 colspan=1>67.98</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>Seq2prog</td><td rowspan=1 colspan=1>51.9</td></tr><tr><td rowspan=1 colspan=1>Seq2prog+cat</td><td rowspan=1 colspan=1>54.2</td></tr><tr><td rowspan=1 colspan=1>NeRd</td><td rowspan=1 colspan=1>79.7</td></tr><tr><td rowspan=1 colspan=1>NeRd (-pretraining)</td><td rowspan=1 colspan=1>71.6</td></tr><tr><td rowspan=1 colspan=1>NeRd (20%)</td><td rowspan=1 colspan=1>56.5</td></tr></table>
+
+Table 8: Results on MathQA test set, with NeRd and two variants: (1) no pre-training; (2) using $20 \%$ of the program annotations in training.
+
+the models, such as SQuAD (Rajpurkar et al., 2016), CoQA (Reddy et al., 2019), GLUE (Wang et al., 2019), etc. A bunch of representative models are proposed for these benchmarks, including BiDAF (Seo et al., 2017), r-net (Wang et al., 2017), DrQA (Chen et al., 2017), DCN (Xiong et al., 2016) and QANet (Yu et al., 2018). More recently, massive text pre-training techniques, e.g., ELMo (Peters et al., 2018), BERT (Devlin et al., 2019), XLNet (Yang et al., 2019) and Roberta (Liu et al., 2019), have achieved superior performance on these tasks. However, for more complicated tasks that require logical reasoning, pre-trained models alone are insufficient.
+
+On the other hand, semantic parsing has recently seen a lot of progress from the neural symbolic approaches. Jia & Liang (2016); Dong & Lapata (2016); Zhong et al. (2017) applied neural sequenceto-sequence and sequence-to-tree models to semantic parsing with full supervision. Liang et al. (2017); Neelakantan et al. (2016); Krishnamurthy et al. (2017); Guu et al. (2017); Liang et al. (2018) have advanced the state-of-the-art in weakly supervised semantic parsing on knowledge graphs and tabular databases. However, most of the successes of semantic parsing are limited to structured data sources. In contrast, our work naturally extends the complex reasoning in semantic parsing to reading comprehension by introducing the span selection operators. Several methods for training with weak supervision have been proposed in the context of weakly supervised semantic parsing including Maximum Marginal Likelihood (Berant et al., 2013; Krishnamurthy et al., 2017; Dasigi et al., 2019; Guu et al., 2017), RL (Liang et al., 2017; 2018) and Hard EM (Liang et al., 2017; Min et al., 2019). Our approach is based on Hard EM due to its simplicity and efficiency, and extends it by adding a decaying threshold, which improves its robustness against spurious programs.
+
+In the broader context, neural symbolic approaches have been applied to Visual Question Answering (Andreas et al., 2016; Mao et al., 2019; Johnson et al., 2017), where the neural architecture is composed with sub-modules based on the structured parses of the questions. Another line of work studied neural symbolic approaches to learn the execution of symbolic operations such as addition and sorting (Graves et al., 2014; Reed & de Freitas, 2016; Cai et al., 2017; Dong et al., 2019). In this work, we study neural symbolic approaches for reading comprehension tasks that require discrete reasoning over the text (Dua et al., 2019; Hu et al., 2019; Andor et al., 2019; Amini et al., 2019).
+
+# 6 CONCLUSION
+
+We presented the Neural Symbolic Reader (NeRd) as a scalable integration of distributed representations and symbolic operations for reading comprehension. NeRd architecture consists of a reader that encodes text into vector representation, and a programmer that generates programs, which will be executed to produce the answer. By introducing the span selection operators, our domain-agnostic architecture can generate compositional programs to perform complex reasoning over text for different domains by only extending the set of operators. We also overcome the challenge of weak supervision by applying data augmentation techniques and hard EM with thresholding. In our evaluation, using the same model architecture without any change, NeRd significantly surpasses previous state-of-the-arts on two challenging reading comprehension tasks, DROP and MathQA. We hope to motivate future works to introduce complex reasoning to other domains or other tasks in NLP, e.g., machine translation and language modeling, by extending the set of operators.
+
+# REFERENCES
+
+Aida Amini, Saadia Gabriel, Peter Lin, Rik Koncel-Kedziorski, Yejin Choi, and Hannaneh Hajishirzi. Mathqa: Towards interpretable math word problem solving with operation-based formalisms. arXiv preprint arXiv:1905.13319, 2019.   
+Daniel Andor, Luheng He, Kenton Lee, and Emily Pitler. Giving bert a calculator: Finding operations and arguments with reading comprehension. arXiv preprint arXiv:1909.00109, 2019.   
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to compose neural networks for question answering. arXiv:1601.01705, 2016.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv:1409.0473, 2014.   
+Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. Semantic parsing on freebase from question-answer pairs. EMNLP, 2(5):6, 2013.   
+Rudy Bunel, Matthew Hausknecht, Jacob Devlin, Rishabh Singh, and Pushmeet Kohli. Leveraging grammar and reinforcement learning for neural program synthesis. In International Conference on Learning Representations, 2018.   
+Jonathon Cai, Richard Shin, and Dawn Song. Making neural programming architectures generalize via recursion. ICLR, 2017.   
+Xavier Carreras and Llu´ıs Marquez. Introduction to the conll-2004 shared task: Semantic role \` labeling. In Proceedings of the Eighth Conference on Computational Natural Language Learning (CoNLL-2004) at HLT-NAACL 2004, pp. 89–97, 2004.   
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1870–1879, 2017.   
+Pradeep Dasigi, Matt Gardner, Shikhar Murty, Luke Zettlemoyer, and Eduard Hovy. Iterative search for weakly supervised semantic parsing. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 2669–2680, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4171–4186, 2019.
+
+Honghua Dong, Jiayuan Mao, Tian Lin, Chong Wang, Lihong Li, and Denny Zhou. Neural logic machines. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Li Dong and Mirella Lapata. Language to logical form with neural attention. ACL, 2016.
+
+Dheeru Dua, Yizhong Wang, Pradeep Dasigi, Gabriel Stanovsky, Sameer Singh, and Matt Gardner. DROP: A reading comprehension benchmark requiring discrete reasoning over paragraphs. In Proc. of NAACL, 2019.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.
+
+Kelvin Guu, Panupong Pasupat, Evan Liu, and Percy Liang. From language to programs: Bridging reinforcement learning and maximum marginal likelihood. ACL, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Comput., 1997.
+
+Minghao Hu, Yuxing Peng, Zhen Huang, and Dongsheng Li. A multi-type multi-span network for reading comprehension that requires discrete reasoning. arXiv preprint arXiv:1908.05514, 2019.
+
+Robin Jia and Percy Liang. Data recombination for neural semantic parsing. ACL, 2016.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Inferring and executing programs for visual reasoning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2989–2998, 2017.
+
+Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. arXiv:1511.08228, 2015.
+
+Guillaume Klein, Yoon Kim, Yuntian Deng, Vincent Nguyen, Jean Senellart, and Alexander M Rush. Opennmt: Neural machine translation toolkit. arXiv preprint arXiv:1805.11462, 2018.
+
+Jayant Krishnamurthy, Pradeep Dasigi, and Matt Gardner. Neural semantic parsing with type constraints for semi-structured tables. EMNLP, 2017.
+
+Chen Liang, Jonathan Berant, Quoc Le, Kenneth D. Forbus, and Ni Lao. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. ACL, 2017.
+
+Chen Liang, Mohammad Norouzi, Jonathan Berant, Quoc V. Le, and Ni Lao. Memory augmented policy optimization for program synthesis and semantic parsing. In NeurIPS, pp. 10015–10027, 2018.
+
+Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. Program induction by rationale generation: Learning to solve and explain algebraic word problems. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 158–167, 2017.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized BERT pretraining approach. CoRR, abs/1907.11692, 2019.
+
+Christopher Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In Proceedings of 52nd annual meeting of the association for computational linguistics: system demonstrations, pp. 55–60, 2014.
+
+Jiayuan Mao, Chuang Gan, Pushmeet Kohli, Joshua B. Tenenbaum, and Jiajun Wu. The neurosymbolic concept learner: Interpreting scenes, words, and sentences from natural supervision. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Sewon Min, Danqi Chen, Hannaneh Hajishirzi, and Luke Zettlemoyer. A discrete hard em approach for weakly supervised question answering. arXiv preprint arXiv:1909.04849, 2019.
+
+Arvind Neelakantan, Quoc V Le, Martin Abadi, Andrew McCallum, and Dario Amodei. Learning a natural language interface with neural programmer. arXiv preprint arXiv:1611.08945, 2016.
+
+Panupong Pasupat and Percy Liang. Compositional semantic parsing on semi-structured tables. ACL, 2015.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 2227–2237, 2018.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 2383–2392, 2016.
+
+Siva Reddy, Danqi Chen, and Christopher D. Manning. Coqa: A conversational question answering challenge. TACL, 7:249–266, 2019.
+
+Scott Reed and Nando de Freitas. Neural programmer-interpreters. ICLR, 2016.
+
+Azriel Rosenfeld and Mark Thurston. Edge and curve detection for visual scene analysis. IEEE Transactions on computers, (5):562–569, 1971.
+
+Min Joon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. In ICLR, 2017.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. NIPS, 2015.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Wenhui Wang, Nan Yang, Furu Wei, Baobao Chang, and Ming Zhou. Gated self-matching networks for reading comprehension and question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 189–198, 2017.
+
+Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. CoRR, abs/1611.01604, 2016. URL http://arxiv.org/abs/1611.01604.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime G. Carbonell, Ruslan Salakhutdinov, and Quoc V. Le. Xlnet: Generalized autoregressive pretraining for language understanding. CoRR, abs/1906.08237, 2019.
+
+Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V. Le. Qanet: Combining local convolution with global self-attention for reading comprehension. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. arXiv:1709.00103, 2017.
+
+# A MORE DETAILS ABOUT THE INPUT PREPROCESSING
+
+We preprocess the input passages and questions in a similar way as the input preprocessing of DROP dataset described in (Andor et al., 2019). Specifically, to facilitate the usage of BERT, we split up the documents longer than $L = 5 1 2$ tokens. Meanwhile, we extract the locations and values of the numbers, so that they can be retrieved via indices when applying numerical operators. We apply the same input preprocessing on MathQA as well.
+
+# B MORE DISCUSSION ABOUT THE DOMAIN SPECIFIC LANGUAGE
+
+To better support numerical reasoning, sometimes we need to leverage pre-defined constants for our computation. On MathQA, we have shown that applying the constant 3600, which is provided in their pre-defined question-agnostic constant list, is necessary for the calculation in Table 3. Meanwhile, we find that defining such a constant list is also helpful on DROP benchmark. For example, a variant of the sample numerical operation question in Table 2 is “How many people, in terms of percentage, were not either solely white or solely African American?”, and such questions are included in DROP dataset as well. In this case, unless we are able to use the number 100 in our calculation, there is no way to obtain the correct answer. Again, previous works design specialized modules to deal with such questions, which is the main role of the negation module illustrated in Figure 1. On the contrary, we introduce a constant list that is callable for every question, so that the model can learn to apply any constant covered in the list, without the need of manually designing separate modules for questions requiring different constants.
+
+In our evaluation, for DROP, we used $[ 1 0 0 , 1 2 , 2 8 , 2 9 , 3 0 , 3 1 , 1 , 0 ]$ as the constant list, which is helpful for percentage and date time calculation. For MathQA, we used the constant list provided in their public dataset, which includes 23 constants that cover common conversion between different units, domain-specific constants for geometry, physics and probability, etc.
+
+# C MORE DETAILS ABOUT THE MODEL ARCHITECTURE
+
+# C.1 READER
+
+The reader implementation is largely the same as (Andor et al., 2019). Specifically, for the embedding representation of the reader component, we feed the question and passage jointly into BERT, which provides the output vector of each input token $t _ { i }$ as $e _ { i }$ . Unless otherwise specified, the encoder is initialized with the uncased whole-word-masking version of BERTLARGE. We denote the size of $e _ { i }$ as $H _ { 0 }$ .
+
+# C.2 PROGRAMMER
+
+The core architecture of the programmer is a 1-layer LSTM with the hidden size of $H = 5 1 2$ . To formally describe the input space and output space of the programmer, we denote $R$ as the size of the reserved tokens, which include both operators and constants in a domain-specific language, and the special start and end tokens [GO] and [EOF]; and $L = 5 1 2$ as the total number of the question and passage tokens in a single sample. Samples with fewer than $L = 5 1 2$ tokens will be padded with [EOF] tokens to achieve this length. In the following, we discuss the details of each component.
+
+Input embedding. At each timestep, the programmer could generate a program token from: (1) the reserved tokens of the domain-specific language; and (2) the input question and passage tokens. The embedding of the $i$ -th reserved token is
+
+$$
+h r _ { i } = E _ { r } ^ { T } r _ { i }
+$$
+
+Where $E _ { r }$ is a trainable embedding matrix of size $R \times H$ , and $r _ { i }$ is the one-hot encoding of the token.
+
+For the $i$ -th token in the input question and passage token list, their embedding is
+
+$$
+h t _ { i } = P _ { t } e _ { i }
+$$
+
+Where $P _ { t }$ is a trainable projection matrix of size $H \times H _ { 0 }$ .
+
+Attention module over the input. At each timetstep $T$ , let $\left[ p _ { 1 } , p _ { 2 } , . . . , p _ { T - 1 } \right]$ denote the list of program tokens that are already generated in previous timesteps, and we define $[ h p _ { 0 } , h p _ { 1 } , h \bar { p } _ { 2 } , . . . , h p _ { T - 1 } ]$ as the decoder history, where $h p _ { 0 }$ is the embedding vector of the [GO] token calculated as above; $[ h p _ { 1 } , h p _ { 2 } , . . . , h p _ { T - 1 } ]$ are $H$ -dimensional vectors corresponding to the generated program token list, and we will discuss how they are computed later.
+
+Denote $\mathbf { \Phi } ( h _ { T } , c _ { T } ) \ = \ \mathrm { L S T M } \big ( h p _ { T - 1 } , \big ( h _ { T - 1 } , c _ { T - 1 } \big ) \big )$ as the hidden state of the LSTM decoder at timestep T, where $\left( { { h _ { 0 } } , { c _ { 0 } } } \right)$ is the trainable initial state, and $h p _ { T - 1 }$ is the LSTM input.
+
+For each of $h p _ { i }$ in the decoder history, we compute
+
+$$
+v h i = W _ { h } h p _ { i }
+$$
+
+Where $W _ { h }$ is a trainable matrix of size $H \times H$
+
+The attention weight of each $h p _ { i }$ in the decoder history is computed as
+
+$$
+w h _ { i } = \frac { \exp ( h _ { T } ^ { T } v h _ { i } ) } { \sum _ { j = 0 } ^ { T - 1 } \exp ( h _ { T } ^ { T } v h _ { j } ) }
+$$
+
+The attention vector of the decoder history is thus
+
+$$
+a t t _ { h } = \sum _ { i = 0 } ^ { T - 1 } w h _ { i } \cdot h p _ { i }
+$$
+
+This formulation is similar to the attention mechanism introduced in prior work (Bahdanau et al., 2014). Correspondingly, we compute the attention vector of the passage tokens $a t t _ { p }$ , and the attention vector of the question tokens $a t t _ { q }$ .
+
+Afterwards, we compute
+
+$$
+v _ { T } = W _ { v } [ a t t _ { h } ; a t t _ { q } ; a t t _ { p } ; h _ { T } ]
+$$
+
+Where $W _ { v }$ is a trainable matrix of size $H \times 4 H$ , and $[ a ; b ]$ denotes the concatenation of $a$ and $b$ .
+
+Program token prediction. We compute another attention vector of the question tokens $a t t _ { q } ^ { \prime }$ in a similar way as above, but with a different set of trainable parameters. Then for each input token, we have
+
+$$
+\begin{array} { r l } & { h t _ { i } ^ { \prime } = P ^ { \prime } [ h t _ { i } ; h t _ { i } \circ a t t _ { q } ^ { \prime } ] } \\ & { } \\ & { h r _ { i } ^ { \prime } = P ^ { \prime } [ h r _ { i } ; h r _ { i } \circ a t t _ { q } ^ { \prime } ] } \end{array}
+$$
+
+Where $P ^ { \prime }$ is a trainable matrix of size $H \times 2 H$ , and $\circ$ is the Hadamard product.
+
+Let $H _ { T } ^ { \prime }$ be a $( R + L ) \times H$ -dimensional matrix, where the first $R$ rows are $h r _ { i } ^ { \prime }$ for $0 \leq i < R$ , and the next $L$ rows are $h t _ { i } ^ { \prime }$ for $0 \leq i < L$ . Then we compute
+
+$$
+w _ { T } ^ { \prime } = H _ { T } ^ { \prime } \cdot v _ { T }
+$$
+
+Where $w _ { T i } ^ { \prime }$ denotes the weight of selecting the $i$ -th token as the next program token. This design is similar to the pointer network (Vinyals et al., 2015).
+
+Note that a valid program should satisfy the grammar constraints, for instance, those listed in Table 1 on DROP dataset. Therefore, we compute a mask $m _ { T }$ as an $( R + L )$ -dimensional vector, where $m _ { T i } = 1$ when the $i$ -th token is a valid next program token, and $m _ { T i } = 0$ if it is invalid. In the following, we take the DROP dataset as the example, and list some sample rules for mask generation:
+
+(1) At the beginning of the program generation, $m _ { T i } = 1$ iff the $i$ -th token denotes an operator;
+
+(2) When the previous generated program token $p _ { T - 1 }$ is PASSAGE_SPAN, then $m _ { T i } = 1$ iff the $i$ -th token is from the passage. Similarly, if $p _ { T - 1 }$ is QUESTION_SPAN, then $m _ { T i } = 1$ iff the $i$ -th token is from the question.
+
+(3) As discussed in Appendix A, we preprocess the data to extract the locations and values of numbers in the input question and passage, thus we can leverage it to generate masks for numerical calculation operators. Specifically, when $p _ { T - 1 } \in \{ \mathsf { D I F F }$ , SUM, VALUE}, $m _ { T i } = 1$ iff the $i$ -th token is from the constant list, or a number from either the input question or the passage.
+
+With the generated program mask, we compute
+
+$$
+w _ { T } = w _ { T } ^ { \prime } - C ( 1 - m _ { T } )
+$$
+
+Where $C$ is a large positive constant to ensure that the weight of an invalid program token is much smaller than the valid program tokens. In practice, we use $C ~ = ~ 1 e 6$ . Such a grammar-based decoding process is a common practice in order to ensure the syntactic correctness of the generated programs (Krishnamurthy et al., 2017; Liang et al., 2017; Bunel et al., 2018).
+
+Afterwards, the model predicts $p _ { T } = \arg \operatorname* { m a x } _ { i } ( w _ { T } )$ as the next program token. We can also apply the beam search for decoding, but we find that the greedy decoding is already sufficient to provide good results, while the inference process is also much faster than the beam search.
+
+Finally, decoder $h p _ { T } = H _ { T p _ { T } } ^ { \prime }$ is the vector representation corresponding to nerating the next program token. $p _ { T }$ , which is appended to the
+
+# D MORE DETAILS ABOUT TRAINING
+
+# D.1 DATA AUGMENTATION
+
+In this section, we discuss the details of our data augmentation process for counting and sorting questions on DROP. To obtain training samples for counting questions with ground truth annotations, starting from the span selection questions in the training set, we filter out those questions that either can be answered by using the QUESTION_SPAN operation, or do not start with any interrogative in [“What”, “Which”, “Who”, “Where”]. Afterwards, we replace the interrogative with “How many”, and modify the ground truth program correspondingly. In this way, we can augment 15K additional questions for counting in DROP training set.
+
+To annotate the key-value pairs, for each entity recognized by the CoreNLP tool, we search for the numbers that are in the same clause as the entity, i.e., not separated by any punctuation mark, and discard those entities that do not have any nearby number satisfying this constraint. Afterwards, we filter out those questions that do not include any superlative in [“longest”, “shortest”, “largest”, “smallest”, “most” and “least”]. For the remaining questions, we call each of the sorting operations, i.e., ARGMAX, ARGMIN, MAX, MIN, with all extracted key-value pairs as the arguments. For ARGMAX and MAX operators, the key-value pairs are sorted in the descending order of their values; for ARGMIN and MIN operators, they are sorted in the increasing order of their values. If any of the resulted sorting program yields the correct answer, the program is included into the training set. In this way, we can annotate 0.9K questions using ARGMAX or ARGMIN operations, and 1.8K questions using MAX or MIN operations in DROP training set.
+
+# D.2 TRAINING CONFIGURATION
+
+For the training algorithm described in Algorithm 1, the initial threshold $\alpha _ { 0 } = 0 . 5$ , and the decay factor $\gamma = 0 . 5$ . We perform early stopping when both exact match and F1 score on the development
+
+Table 9: Some samples in DROP training set with the wrong annotations, which are discarded by NeRd because none of the annotated programs passes the threshold of our training algorithm.   
+
+<table><tr><td>Passage</td><td>Question</td><td>Ground truth</td></tr><tr><td>buthad to settle fora 23-yard field … goal by kicker Matt Bryant ...</td><td>How many field goals shorter than 30 yards did Matt Bryant kick?</td><td>3</td></tr><tr><td>... from a sample of 4O Sherman tanks, 33 tanks burned (82 percent） and 7 tanks remained unburned .</td><td>How many more Sherman tanks burned out than survived in the Nor- mandy Campaign?</td><td>22</td></tr></table>
+
+Table 10: Examples of wrong predictions on DROP dev set.   
+
+<table><tr><td rowspan=1 colspan=1>Question type</td><td rowspan=1 colspan=1>Passage</td><td rowspan=1 colspan=1>Question</td><td rowspan=1 colspan=1>Prediction</td></tr><tr><td rowspan=1 colspan=1>Question span</td><td rowspan=1 colspan=1>The campaigns of 1702 and 1703showedhislimitationsasafield of-ficer...In early 1704,he spoke withthe envoy of Savoy about possibleopportunities in their army ...</td><td rowspan=1 colspan=1>What happened first,the Hague campaignsas field officer or hespoke with envoy ofSavoy for opportuni-ties in the army?</td><td rowspan=1 colspan=1>Prediction:QUESTION_SPAN(7,10)Result:“campaigns as field offi-cer”Ground truth: “campaigns of1702 and 1703&quot;</td></tr><tr><td rowspan=1 colspan=1>Counting</td><td rowspan=1 colspan=1>.. The five regions with the lowestfertility rates were Beijing (0.71),Shanghai (0.74), Liaoning (0.74),Heilongjiang (0.75.）..</td><td rowspan=1 colspan=1>Howmanyareas hada fertility rate of .74?</td><td rowspan=1 colspan=1>Prediction: COUNT(PASSAGE_SPAN(216,216),PASSAGE_SPAN(223,223),PASSAGE_SPAN(230,231))Result: COUNT(&quot;Beijing&quot;,“Shanghai”,“Liaoning&quot;)= 3Ground truth: 2</td></tr><tr><td rowspan=1 colspan=1>Sorting</td><td rowspan=1 colspan=1>.to set up Nugent&#x27;s career-long54-yard field goal to give the Jetsa 9-3 lead ... The half ended whenBrown came up five yards short ona 59-yard field goal attempt ...</td><td rowspan=1 colspan=1>How many yardswas the longest fieldgoal?</td><td rowspan=1 colspan=1>Program:MAX(VALUE(16), VALUE(20))Result: MAX(54,59) = 59Ground truth: 54</td></tr></table>
+
+set do not improve for two consecutive training iterations. For both DROP and MathQA datasets, the training typically takes around $5 0 K \sim 6 0 K$ training steps.
+
+For both tasks in our evaluation, we train the model with Adam optimizer, with an initial learning rate of 5e-5, and batch size of 32. Gradients with $L _ { 2 }$ norm larger than 1.0 are clipped.
+
+# E EXAMPLES OF WRONG ANNOTATIONS ON DROP
+
+Table 9 lists some examples of wrong annotations in DROP training set. Specifically, the first annotation is wrong because the crowd worker simply counts the number of field goals included in the entire passage, without considering the constraints of lengths and the kicker’s name; on the other hand, the second mistake comes from the wrong numerical calculations. For both samples, the highest likelihood among all programs with the annotated answer is smaller than 1e-4, thus are not included during training, which is why the thresholding helps significantly.
+
+# F EXAMPLES OF WRONG PREDICTIONS ON DROP
+
+Table 10 presents some error cases of NeRd on DROP development set.

parse/train/ryxyCeHtPB/ryxyCeHtPB.md

@@ -0,0 +1,308 @@
+# Pay Attention to Features, Transfer Learn Faster CNNs
+
+Kafeng Wang∗†1, Xitong Gao $^ 2$ ∗, Yiren Zhao3, Xingjian Li4, Dejing Dou5, Cheng-Zhong Xu6
+
+$^ { 1 , 2 }$ Shenzhen Institutes of Advanced Technology, Chinese Academy of Sciences.   
+1 University of Chinese Academy of Sciences. $^ 3$ University of Cambridge.   
+$^ { 4 , 5 }$ Big Data Lab, Baidu Research. 6 University of Macau.   
+1 kf.wang@siat.ac.cn, 2 xt.gao@siat.ac.cn.
+
+# Abstract
+
+Deep convolutional neural networks are now widely deployed in vision applications, but a limited size of training data can restrict their task performance. Transfer learning offers the chance for CNNs to learn with limited data samples by transferring knowledge from models pretrained on large datasets. Blindly transferring all learned features from the source dataset, however, brings unnecessary computation to CNNs on the target task. In this paper, we propose attentive feature distillation and selection (AFDS), which not only adjusts the strength of transfer learning regularization but also dynamically determines the important features to transfer. By deploying AFDS on ResNet-101, we achieved a state-of-the-art computation reduction at the same accuracy budget, outperforming all existing transfer learning methods. With a $1 0 \times$ MACs reduction budget, a ResNet-101 equipped with AFDS transfer learned from ImageNet to Stanford Dogs 120, can achieve an accuracy $1 1 . 0 7 \%$ higher than its best competitor.
+
+# 1 Introduction
+
+Despite recent successes of CNNs achieving state-of-the-art performance in vision applications (Tan & Le, 2019; Cai & Vasconcelos, 2018; Zhao et al., 2018; Ren et al., 2015), there are two major shortcomings limiting their deployments in real life. First, training CNNs from random initializations to achieve high task accuracy generally requires a large amount of data that is expensive to collect. Second, CNNs are typically compute-intensive and memory-demanding, hindering their adoption to power-limited scenarios.
+
+To address the former challenge, transfer learning (Pan $\&$ Yang, 2009) is thus designed to transfer knowledge learned from the source task to a target dataset that has limited data samples. In practice, we often choose a source dataset such that the input domain of the source comprises the domain of the target. A common paradigm for transfer learning is to train a model on a large source dataset, and then fine-tune the pre-trained weights with regularization methods on the target dataset (Zagoruyko & Komodakis, 2017; Yim et al., 2017; Li et al., 2018; Li & Hoiem, 2018; Li et al., 2019). For example, one regularization method, $L ^ { 2 }$ - $S P$ (Li et al., 2018), penalizes the $L ^ { 2 }$ -distances of pretrained weights on the source dataset and the weights being trained on the target dataset. The pretrained source weights serves as a starting point when training on the target data. During fine-tuning on the target dataset, the regularization constrains the search space around this starting point, which in turn prevents overfitting the target dataset.
+
+Intuitively, the responsibility of transfer learning is to preserve the source knowledge acquired by important neurons. The neurons thereby retain their abilities to extract features from the source domain, and contribute to the network’s performance on the target dataset.
+
+Moreover, by determining the importance of neurons, unimportant ones can further be removed from computation during inference with network pruning methods (Luo et al., 2017; He et al., 2017; Zhuang et al., 2018; Ye et al., 2018; Gao et al., 2019). The removal of unnecessary compute not only makes CNNs smaller in size but also reduces computational costs while minimizing possible accuracy degradations. As the source domain encompasses the target, many neurons responsible for extracting features from the source domain may become irrelevant to the target domain and can be removed. In Figure 1, a simple empirical study of the channel neurons’ activation magnitudes corroborates our intuition: as deeper layers extract higher-level features, more neurons become either specialized or irrelevant to dogs. The discussion above hence prompts two questions regarding the neurons: which neurons should we transfer source knowledge to, and which are actually important to the target model?
+
+![](images/5f9ecf6ecf2ea5aa072a3bf34fd0abd8f35fd0c7cd52a2184afd3a656f895479.jpg)  
+Figure 1: (a) shows sample images from two datasets, ImageNet contains images with greater diversity. (b) shows the average maximum activations of 20 channel neurons in 3 layers of ResNet-101 that are most excited by images from Dogs.
+
+Yet traditional transfer learning methods fail to provide answers to both, as generally they transfer knowledge either equally for each neuron with the same regularized weights, or determine the strength of regularization using only the source dataset (Li et al., 2018). The source domain could be vastly larger than the target, giving importance to weights that are irrelevant to the target task.
+
+Recent years have seen a surge of interest in network pruning techniques, many of which induce sparsity by pushing neuron weights or outputs to zeros, allowing them to be pruned without a detrimental impact on the task accuracies. Even though pruning methods present a solution to neuron/weight importance, unfortunately they do not provide an answer to the latter question, i.e. whether these neurons/weights are important to the target dataset. The reason for this is that pruning optimization objectives are often in conflict with traditional transfer learning, as both drive weight values in different directions: zero for pruning and the initial starting point for transfer learning. As we will see later, a na¨ıve composition of the two methods could have a disastrous impact on the accuracy of a pruned CNN transferlearned on the target dataset.
+
+In this paper, to tackle the challenge of jointly transferring source knowledge and pruning target CNNs, we propose a new method based on attention mechanism (Vaswani et al., 2017), attentive feature distillation and selection (AFDS). For the images in the target dataset, AFDS dynamically learns not only the features to transfer, but also the unimportant neurons to skip.
+
+During transfer learning, instead of fine-tuning with $L ^ { 2 }$ -SP regularization which explores the proximity of the pre-trained weights, we argue that a better alternative is to mimic the feature maps, i.e. the output response of each convolutional layer in the source model when images from the target dataset are shown, with $L ^ { 2 }$ -distances. This way the fine-tuned model can still learn the behavior of the source model. Additionally, without the restriction of searching only the proximity of the initial position, the weights in the target model can be optimized freely and thus increasing their generalization capacity. Therefore, we present attentive feature distillation (AFD) to learn which relevant features to transfer.
+
+To accelerate the transfer-learned model, we further propose attentive feature selection (AFS) to prune networks dynamically. AFS is designed to learn to predictively select important output channels in the convolution to evaluate and skip unimportant ones, depending on the input to the convolution. Rarely activated channel neurons can further be removed from the network, reducing the model’s memory footprint.
+
+From an informal perspective, both AFD and AFS learn to adjust the “valves” that control the flow of information for each channel neuron. The former adjusts the strength of regularization, thereby tuning the flow of knowledge being transferred from the source model. The latter allows salient information to pass on to the subsequent layer and stops the flow of unimportant information. A significant attribute that differentiates AFD and AFS from their existing counterparts is that we employ attention mechanisms to adaptively learn to “turn the valves” dynamically with small trainable auxiliary networks.
+
+Our main contributions are as follows:
+
+• We present attentive feature distillation and selection (AFDS) to effectively transfer learn CNNs, and demonstrate state-of-the-art performance on many publicly available datasets with ResNet-101 (He et al., 2016) models transfer learned from ImageNet (Deng et al., 2009). We paired a large range of existing transfer learning and network pruning methods, and examined their abilities to trade-off FLOPs with task accuracy. • By changing the fraction of channel neurons to skip for each convolution, AFDS can further accelerate the transfer learned models while minimizing the impact on task accuracy. We found that AFDS generally provides the best FLOPs and accuracy trade-off when compared to a broad range of paired methods.
+
+# 2 Related Work
+
+# 2.1 Transfer Learning
+
+Training a deep CNN to achieve high accuracy generally require a large amount of training data, which may be expensive to collect. Transfer learning (Pan & Yang, 2009) addresses this challenge by transferring knowledge learned on a large dataset that has a similar domain to the training dataset. A typical approach for CNNs is to first train the model on a large source dataset, and make use of their feature extraction abilities (Donahue et al., 2014; Razavian et al., 2014). Moreover, it has been demonstrated that the task accuracy can be further improved by fine-tuning the resulting pre-trained model on a smaller target dataset with a similar domain but a different task (Yosinski et al., 2014; Azizpour et al., 2015). Li et al. (2018) proposed $L ^ { 2 }$ -SP regularization to minimize the $L ^ { 2 }$ -distance between each fine-tuned parameter and its initial pre-trained value, thus preserving knowledge learned in the pre-trained model. In addition, they presented $L ^ { 2 }$ -SP-Fisher, which further weighs each $L ^ { 2 }$ -distance using Fisher information matrix estimated from the source dataset. Instead of constraining the parameter search space, Li et al. (2019) showed that it is often more effective to regularize feature maps during fine-tuning, and further learns which features to pay attention to. Learning without Forgetting (Li & Hoiem, 2018) learns to adapt the model to new tasks, while trying to match the output response on the original task of the original model using knowledge distillation (KD) (Hinton et al., 2014). Methods proposed by Zagoruyko & Komodakis (2017) and Yim et al. (2017) transfer knowledge from a teacher model to a student by regularizing features. The former computes and regularizes spatial statistics across all feature maps channels, whereas the latter estimates the flow of information across layers for each pair of channels, and transfers this knowledge to the student. Instead of manually deciding the regularization penalties and what to regularize as in the previous approaches, Jang et al. (2019) used meta-learning to automatically learn what knowledge to transfer from the teacher and to where in the student model.
+
+Inspired by Li et al. (2019) and Jang et al. (2019), this paper introduces attentive feature distillation (AFD), which similarly transfers knowledge by learning from the teacher’s feature maps. It however differs from Jang et al. (2019) as the teacher and student models share the same network topology, and it instead learns which channel to transfer from the teacher to the student in the same convolutional output.
+
+# 2.2 Structured Sparsity
+
+Sparsity in neural networks has been a long-studied subject (Reed, 1993; LeCun et al., 1990; Chauvin, 1989; Mozer & Smolensky, 1989; Hassibi et al., 1994). Related techniques have been applied to modern deep CNNs with great success (Guo et al., 2016; Dong et al., 2017a), significantly lowering their storage requirements. In general, as these methods zero out individual weights, producing irregular sparse connections, which cannot be efficiently exploited by GPUs to speed up computation.
+
+For this, many recent work turned their attention to structured sparsity (Alvarez & Salzmann, 2016; Wen et al., 2016; Liu et al., 2017; He et al., 2017; 2018). This approach aims to find coarse-grained sparsity and preserves dense structures, thus allowing conventional GPUs to compute them efficiently. Alvarez & Salzmann (2016) and Wen et al. (2016) both added group Lasso to penalize non-zero weights, and removed channels entirely that have been reduced to zero. Liu et al. (2017) proposed network slimming (NS), which adds $L ^ { 1 }$ regularization to the trainable channel-wise scaling parameters $\gamma$ used in batch normalization, and gradually prunes channels with small $\gamma$ values by threshold. He et al. (2018) introduced soft filter pruning (SFP), which iteratively fine-tunes and sets channels with small $L ^ { 2 }$ -norms to zero.
+
+Pruning algorithms remove weights or neurons from the network. The network may therefore lose its ability to process some difficult inputs correctly, as the neurons responsible for them are permanently discarded. Gao et al. (2019) have found empirically that task accuracies degrades considerably when most of the computation are removed from the network, and introduced feature boosting and suppression (FBS). Instead of removing neurons permanently from the network, FBS learns to dynamically prune unimportant channels, depending on the current input image. In this paper, attentive feature selection (AFS) builds on top of the advantages of both static and dynamic pruning algorithms. AFS not only preserves neurons that are important to some input images, but also removes unimportant ones for most inputs from the network, reducing both the memory and compute requirements for inference.
+
+There are methods that dynamically select which paths to evaluate in a network dependent on the input (Figurnov et al., 2017; Dong et al., 2017b; Bolukbasi et al., 2017; Lin et al., 2017; Shazeer et al., 2017; Wu et al., 2018; Ren et al., 2018). They however introduce architectural and/or training method changes, and thus cannot be applied directly on existing popular models pre-trained on ImageNet (Deng et al., 2009).
+
+# 3 Attentive Feature Distillation and Selection
+
+# 3.1 High-Level Overview
+
+![](images/b7719b358eb331301639881d83e52a26d996e5e43c873f8fd630be5867ac9503.jpg)  
+Figure 2: High-level overview of AFDS.
+
+We begin by providing a high-level overview of attentive feature distillation and selection (AFDS). AFDS introduces two new components to augment each conventional batchnormalized convolutional (ConvBN) layer (Ioffe & Szegedy, 2015), as illustrated in Figure 2. The AFS preemptively learns the importance of each channel, in the output of the ConvBN layer, and can suppress unimportant channels, thus allowing the expensive convolution operation to skip evaluating these channels. The AFD learns the importance of each channel in the output activation, and use the importance as weights to regularize feature maps in the target model with $L ^ { 2 }$ -distance. Each component is a small neural network containing a small number of parameters that can be trained with conventional stochastic gradient descent (SGD).
+
+# 3.2 Preliminaries
+
+Consider a set of training data $\mathcal { D }$ where each sample $( { \pmb x } , y )$ consists of an input image $\pmb { x } \in \mathbb { R } ^ { C \times H \times W }$ , and a ground-truth label $y \in \mathbb N$ . Here $C$ , $H$ and $W$ respectively denote the number of channels, and the height and width of the input image. Training a deep CNN classifier thus minimizes the following loss function with an optimization method based on SGD:
+
+$$
+\mathcal { L } ( \pmb { \theta } ) = \mathbb { E } _ { ( \pmb { x } , \pmb { y } ) \sim \mathcal { D } } [ \mathcal { L } ^ { \mathrm { C E } } ( f ( \pmb { x } , \pmb { \theta } ) , \pmb { y } ) + \mathcal { R } ( \pmb { \theta } , \pmb { x } ) + \lambda \| \pmb { \theta } \| _ { 2 } ^ { 2 } ] ,
+$$
+
+where $\pmb { \theta }$ comprises all parameters of the model, the loss $\mathcal { L } ^ { \mathrm { C E } } ( f ( \pmb { x } , \pmb { \theta } ) , y )$ denotes the crossentropy loss between the CNN output $f ( { \pmb x } , { \pmb \theta } )$ and the label $y$ . The regularizer $\mathcal { R } ( \pmb \theta , \pmb x )$ is often used to reduce the risk of overfitting. In conventional training, $\mathcal { R } ( \pmb \theta , \pmb x ) = 0$ . Finally, we impose a $L ^ { 2 }$ penalty on $\pmb { \theta }$ , where $\left. \ z \right. _ { 2 }$ represents the $L ^ { 2 }$ -norm of $_ z$ across all its elements.
+
+We assume that $f ( { \pmb x } , { \pmb \theta } )$ is a feed-forward CNN composed of $N$ ConvBN layers for feature extraction, $f _ { l } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } )$ with $l \in L = \{ 1 , 2 , \ldots , N \}$ , and a final fully-connected layer for classification, $g ( \pmb { x } _ { N } , \pmb { \theta } _ { g } )$ . Here, for the $l ^ { \mathrm { t h } }$ layer, ${ \bf { \Delta } } x _ { l - 1 }$ is the input to the layer, with ${ \boldsymbol { \mathbf { \mathit { x } } } } _ { 0 }$ indicating $_ { x }$ , and $\theta _ { l }$ is the layer’s parameters. Therefore, the $l ^ { \mathrm { t h } }$ layer is defined as:
+
+$$
+\pmb { x } _ { l } = f _ { l } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } ) = \mathrm { r e l u } ( \gamma _ { l } \cdot \mathrm { n o r m } ( \mathrm { c o n v } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } ) ) + \beta _ { l } ) ,
+$$
+
+where $\pmb { x } _ { l } \in \mathbb { R } ^ { C _ { l } \times H _ { l } \times W _ { l } }$ contains $C _ { l }$ feature maps of the layer, each with a $H _ { l }$ height and $W _ { l }$ width. The function $\mathrm { c o n v } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } )$ is a convolution that takes ${ \bf { \Delta } } x _ { l - 1 }$ as input and uses trainable parameters $\theta _ { l }$ , and $\operatorname { n o r m } ( z )$ performs batch normalization. Finally, $\gamma _ { l } , \beta _ { l } \in \mathbb { R } ^ { C _ { l } }$ are trainable vectors, the multiplications (·) and additions $( + )$ are channel-wise, and $\mathrm { r e l u } ( z ) = \mathrm { m a x } ( z , 0 )$ stands for the ReLU activation. Although we use the feed-forward classifier above for simplicity, it can be easily modified to contain additional structures such as residual connections (He et al., 2016) and computations for object detection (Ren et al., 2015).
+
+During transfer learning, as we fine-tune the network with a different task, the final layer $g ( \pmb { x } _ { N } , \pmb { \theta } _ { g } )$ is generally replaced with a new randomly-initialized one $h ( \pmb { x } _ { N } , \pmb { \theta } _ { h } )$ . To prevent overfitting, additional terms are used during transfer learning, for instance, $L ^ { z }$ - $S P$ (Li et al., 2018) further constrains the parameters $\pmb { \theta } _ { l }$ to explore around their initial values $\pmb { \theta } _ { l } ^ { \star }$ :
+
+$$
+\mathcal { R } ( \pmb { \theta } , \pmb { x } ) = \lambda _ { \mathrm { S P } } \sum _ { l \in L } \lVert \pmb { \theta } _ { l } - \pmb { \theta } _ { l } ^ { \star } \rVert _ { 2 } ^ { 2 } + \lambda _ { \mathrm { L 2 } } \lVert \pmb { \theta } \rVert _ { 2 } ^ { 2 } .
+$$
+
+Instead of regularizing parameters, methods based on knowledge distillation (Hinton et al., 2014) encourages the model to mimic the behavior of the original while learning the target task. Learning without Forgetting (LwF) (Li $\&$ Hoiem, 2018) uses the following regularizer to mimic the response from the original classifiers:
+
+$$
+\mathcal { R } ( \pmb { \theta } , \pmb { x } ) = \lambda _ { \mathrm { L w F } } \mathcal { L } ^ { \mathrm { C E } } ( g ^ { \star } ( f _ { L } ( \pmb { x } , \pmb { \theta } _ { L } ) , \pmb { \theta } _ { g } ^ { \star } ) ) ,
+$$
+
+where $f _ { L } ( \pmb { x } , \pmb { \theta } _ { L } )$ indicates the first $N$ layers, and $g ^ { \star }$ and $\theta _ { g } ^ { \star }$ respectively denote the original fully-connected (FC) layer and its associated parameters, and generally $\lambda _ { \mathrm { L w F } } ~ = ~ 1$ . Zagoruyko $\&$ Komodakis (2017), Yim et al. (2017) and Li et al. (2019) chose to regularize feature maps in some intermediate layers $L ^ { \prime } \subseteq L$ . We assume that $\mathbf { \boldsymbol { x } } _ { l } ^ { \star }$ is the $l ^ { \mathrm { t h } }$ layer output of the original model with weights $\theta ^ { \star }$ when the input $_ { x }$ is shown to the model, and $r$ is a method-dependent function that constrains the relationship between $\mathbf { \boldsymbol { x } } _ { l } ^ { \star }$ and $\mathbf { \Delta } x _ { l }$ . The regularizer can then be defined as follows:
+
+$$
+\mathcal { R } ( \pmb { \theta } , \pmb { x } ) = \lambda _ { \mathrm { K D } } \sum _ { l \in L ^ { \prime } } r ( \pmb { x } _ { l } ^ { \star } , \pmb { x } _ { l } ) .
+$$
+
+# 3.3 Attentive Feature Distillation
+
+A simple way to extend Equation (5) is to constrain the $L ^ { 2 }$ -norm-distance between $\mathbf { \boldsymbol { x } } _ { l } ^ { \star }$ and $\mathbf { \Delta } x _ { l }$ , and thus pushing the target model to learn the feature map responses of the source:
+
+$$
+\mathcal { R } ( \pmb { \theta } , \pmb { x } ) = \lambda _ { \mathrm { F D } } \sum _ { l \in L ^ { \prime } } \| \pmb { x } _ { l } ^ { \star } - \pmb { x } _ { l } \| _ { 2 } ^ { 2 } .
+$$
+
+The above formulation, however, places equal weight to each channel neurons of the feature maps. As we discussed earlier, the importance of channel neurons varies drastically when different input images are shown. it is thus desirable to enforce a different penalty for each channel depending on the input $_ { x }$ . For this purpose, we design the regularizer:
+
+$$
+\mathcal { R } ( \pmb { \theta } , \pmb { x } ) = \lambda _ { \mathrm { A F D } } \sum _ { l \in L ^ { \prime } } \sum _ { c \in C _ { l } } \pmb { \rho } _ { l } ^ { [ c ] } ( \pmb { x } _ { l } ^ { \star } ) \| ( \pmb { x } _ { l } ^ { \star } - \pmb { x } _ { l } ) ^ { [ c ] } \| _ { 2 } ^ { 2 } .
+$$
+
+Note that in Equation (7), for any tensor $_ z$ , the term $z ^ { [ c ] }$ denotes the $c ^ { \mathrm { t h } }$ slice of the tensor. The transfer importance predictor ${ \pmb \rho } _ { l } : \mathbb { R } ^ { C _ { l } \times H _ { l } \times W _ { l } }  \mathbb { R } ^ { C _ { l } }$ computes for each channel the importance of the source activation maps, which governs the strength of the $L ^ { 2 }$ regularization for each channel. The predictor function is trainable and is defined as a small network with two FC layers:
+
+$$
+\rho _ { l } ^ { [ c ] } ( { \pmb x } _ { l } ^ { \star } ) = \mathrm { s o f t m a x } ( \mathrm { r e l u } ( { \sf b } ( { \pmb x } _ { l } ^ { \star } ) { \pmb \varphi } _ { l } + { \pmb \nu } _ { l } ) { \pmb \varphi } _ { l } ^ { \prime } + { \pmb \nu } _ { l } ^ { \prime } ) .
+$$
+
+The function $\flat : \mathbb { R } ^ { C \times H \times W }  \mathbb { R } ^ { C \times H W }$ flattens the spatial dimensions in a channel-wise fashion; The parameters $\varphi _ { l } \in \mathbb { R } ^ { H W \times H }$ , $\pmb { \nu } _ { l } \in \mathbb { R } ^ { 1 \times H }$ , $\varphi _ { l } ^ { \prime } \in \mathbb { R } ^ { H }$ and $\pmb { \nu } _ { l } ^ { \prime } \in \mathbb { R } ^ { C }$ can thus be trained to adjust the importance of each channel dynamically; finally, the softmax activation is borrowed from attention mechanism (Vaswani et al., 2017) to normalize the importance values. In our experiments, $\varphi _ { l }$ and $\varphi _ { l } ^ { \prime }$ use He et al. (2015)’s initialization, $\pmb { \nu } _ { l }$ and $\nu _ { l } ^ { \prime }$ are both initialized to $\mathbf { 0 }$ .
+
+# 3.4 Attentive Feature Selection
+
+In a fashion similar to feature boosting and suppression (FBS) (Gao et al., 2019), AFS modifies the ConvBN layers from Equation (2):
+
+$$
+\hat { f } _ { l } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } ) = \mathrm { r e l u } ( \pi _ { l } ( \pmb { x } _ { l - 1 } ) \cdot \mathrm { n o r m } ( \mathrm { c o n v } ( \pmb { x } _ { l - 1 } , \pmb { \theta } _ { l } ) ) + \beta _ { l } ) ,
+$$
+
+where the predictor function takes as input the activation maps of the previous layer, i.e. : $\mathbb { R } ^ { C _ { l - 1 } \times H _ { l - 1 } \times W _ { l - 1 } } \to \mathbb { R } ^ { C }$ , is used to replace the vector $\gamma _ { l }$ . This function dynamically predicts the importance of each channel, and suppresses certain unimportant channels by setting them to zero. The expensive conv function can hence be accelerated by skipping the disabled output channels. The predictor function is defined as below:
+
+$$
+\begin{array} { r } { \pi _ { l } ( \pmb { x } _ { l - 1 } ) = \pmb { \mathrm { m } } _ { l } \cdot \ b { q } _ { l } ( \pmb { x } _ { l - 1 } ) , \mathrm { ~ w h e r e ~ } \pmb { q } _ { l } ( \pmb { x } _ { l - 1 } ) = \mathrm { w t a } _ { \lceil d C _ { l } \rceil } ( \mathbf { s } _ { l } \cdot h _ { l } ( \pmb { x } _ { l - 1 } ) + ( 1 - \mathbf { s } _ { l } ) \cdot \gamma _ { l } ) , } \end{array}
+$$
+
+where $\mathbf { m } _ { l } , \mathbf { s } _ { l } \in \{ 0 , 1 \} ^ { C _ { l } }$ are both constant masks that take binary values: $\mathbf { I I I }$ prunes output channels by permanently setting them to zeros, and $\mathbf { s } _ { l }$ decides for each channel whether the output of $h _ { l } ( \pmb { x } _ { l - 1 } )$ or $\gamma _ { l }$ should be used. It is clear that when ${ \bf m } _ { l } = { \bf 1 }$ , no channel neurons are removed from the network. In Section 3.5, we explain how $\mathbf { I I I }$ and $\gamma _ { l }$ can be determined during the fine-tuning process. The winner-take-all function w $\tan _ { [ d C _ { l } ] } ( z )$ preserves the $\lceil d C _ { l } \rceil$ most salient values in $_ { z }$ , and suppresses the remaining ones by setting them to zeros. The density value $0 < d \leq 1$ is a constant that controls the number of channels to preserve during inference, with 1 preserving all $C _ { l }$ channels. The smaller $d$ gets, the more channels can be skipped, which in turn accelerates the model. Finally, the function $h _ { l } : \mathbb { R } ^ { C _ { l - 1 } \times H \times W }  \mathbb { R } ^ { C _ { l } }$ is a small network that is used to predict the importance of each channel. It is composed of a global average pool followed by a FC layer, where pool : $: \mathbb { R } ^ { C _ { l - 1 } \times H \times W }  \mathbb { R } ^ { C _ { l - 1 } }$ computes the average across the spatial dimensions for each channel:
+
+$$
+h ( \pmb { x } _ { l - 1 } ) = \mathrm { r e l u } ( \mathrm { p o o l } ( \pmb { x } _ { l - 1 } ) \pmb { \varphi } _ { l } ^ { \prime \prime } + \pmb { \nu } _ { l } ^ { \prime \prime } ) .
+$$
+
+For the initialization of the FC parameters, we apply He et al. (2015)’s method on the trainable weights $\varphi _ { l } ^ { \prime \prime } \in \mathbb { R } ^ { C _ { l - 1 } \times C _ { l } }$ and $\pmb { \nu } _ { l } ^ { \prime \prime } \in \mathbb { R } ^ { C _ { l } }$ is initialized to zeros.
+
+# 3.5 Training Procedure
+
+In this section, we describe the pipeline of AFDS for transferring knowledge from a source model to a new model by fine-tuning on target dataset. The detailed algorithm can be found in Appendix A.
+
+Initially, we have a pre-trained model $f$ with parameters $\theta ^ { \star }$ for the source dataset (e.g. ImageNet). To ensure better accuracies on compressed target models, All ConvBN layers $f _ { l }$ in $f$ are extended with AFS as discussed in Section 3.4, with $d$ initially set to 1, which means that all output channels in a convolutional layer are evaluated during inference, i.e. no acceleration. The pre-trained model is then fine-tuned on the target training dataset $\mathcal { D }$ with the AFD regularization proposed in Section 3.3.
+
+Empirically we found that in residual networks with greater depths, AFS could become notably challenging to train to high accuracies. To mitigate this, for each output channel of a layer $\it l$ we update $\mathbf { s } _ { l }$ according to the variance of $h _ { l } ( \pmb { x } _ { l - 1 } )$ observed on the target dataset. For each channel if the variance is smaller than a threshold $\delta _ { s }$ , then we set the entry in $\mathbf { s } _ { l }$ to zero for that particular channel. This action replaces the output of $h _ { l } ( \pmb { x } _ { l - 1 } )$ with $\gamma _ { l }$ , which is a trainable parameter initialized to the mean of $h _ { l } ( \pmb { x } _ { l - 1 } )$ . We compute the mean and variance statistics using Welford (1962)’s online algorithm which can efficiently compute the statistics in a single-pass with $O ( 1 )$ storage. In our experiments, $\delta _ { \mathrm { s } }$ is set to a value such that $5 0 \%$ of the channel neurons use the predictor function $h _ { l }$ .
+
+Moreover, we discovered that many of the channel neurons are rarely activated in a AFSbased network. We further propose to remove the channel neurons that are activated with a low frequency. In each layer $\it l$ , the mask $\mathbf { m } _ { l }$ is used to disable certain channels from the network by setting their output to a constant $\mathbf { 0 }$ , if the probability of a channel neuron being active is lower than $\delta _ { \mathrm { m } }$ . Zeroed-out channels can thus be permanently removed when the model is used in inference.
+
+# 4 Experiments
+
+In this section we provide an extensive empirical study of the joint methods of transfer learning and channel pruning. We evaluate the methods with 6 different benchmark datasets: Caltech-256 (Griffin et al., 2007) of 256 general object categories; Stanford Dogs 120 (Khosla et al., 2011) specializes to images containing dogs; MIT Indoors 67 (Quattoni & Torralba, 2009) for indoor scene classification; Caltech-UCSD Birds-200-2011 (CUB-200-2011) (Wah et al., 2011) for classifying birds; and Food-101 (Bossard et al., 2014) for food categories. We refer to Li et al. (2018) and Li et al. (2019), for a detailed description of the benchmark datasets. For Caltech-256, we randomly sample either 30 or 60 images from the training set for each category to produce Caltech-256-30 and - $6 0$ training datasets.
+
+We use the ResNet-101 from torchvision1 pre-trained on ImageNet as the network for experiments. For ResNet-101 equipped with AFS, we start by extending the pre-trained model and replacing each batch normalization with a randomly initialized AFS, and fine-tune the resulting model on ImageNet for 90 epochs with a learning rate of 0.01 decaying by a factor of 10 every 30 epochs. The resulting model matches its original baseline accuracy.
+
+For each benchmark dataset, the final FC layer of the network is replaced with a new FC randomly initialized with He et al. (2015)’s method to match the number of output categories accordingly. We then perform transfer learning with 4 different methods: $L ^ { 2 }$ (fine-tuning without additional regularization), $L ^ { 2 }$ -SP (Li et al., 2018), learning without forgetting (LwF) (Li & Hoiem, 2018), and finally AFD for models using AFS.
+
+To accelerate the resulting fine-tuned models, we continue fine-tuning the model while gradually pruning away channels used during inference. For this, we separately examine 3 pruning strategies: network slimming (NS) (Liu et al., 2017), soft filter pruning (SFP) (He et al., 2018) and finally AFS for models transfer learned with AFD. Note that NS prunes channels by sorting them globally, while SFP does so in a layer-wise manner with identical prune ratios. During this procedure, we start with an unpruned model and incrementally remove $1 0 \%$ of the channels used in inference, i.e. preserving $9 0 \%$ , $8 0 \%$ , and etc., down to $1 0 \%$ of all channels for the accelerated models. At each step, we fine-tune each model using 4500 steps of SGD with a batch size of 48, at a learning rate of 0.01, before fine-tuning for a further 4500 steps at a learning rate of 0.001. AFS additionally updates the $\mathbf { m }$ and s masks between the two fine-tuning runs.
+
+Table 1: Top-1 accuracy ( $\%$ ) comparisons of NS, SFP and AFDS on 6 datasets fine-tuned with their respective best transfer learning methods under various speed-up constraints.   
+
+<table><tr><td colspan="2">MACs reduction</td><td>NS</td><td>SFP</td><td>AFDS</td></tr><tr><td rowspan="3">MIT Indoors 67</td><td>2×</td><td>81.83 ± 0.35</td><td>79.43± 0.50</td><td>82.05 ± 0.43</td></tr><tr><td>5×</td><td>69.38 ± 0.27</td><td>60.43 ± 0.31</td><td>69.93 ± 0.52</td></tr><tr><td>10×</td><td>1.50 ± 0.30</td><td>58.49 ± 0.34</td><td>66.72 ± 0.53</td></tr><tr><td rowspan="3">Stanford Dogs 120</td><td>2×</td><td>87.21 ± 0.58</td><td>81.74 ± 0.26</td><td>87.41 ± 0.56</td></tr><tr><td>5×</td><td>73.44 ± 0.27</td><td>61.20 ± 0.31</td><td>75.14 ± 0.52</td></tr><tr><td>10×</td><td>1.33 ± 0.50</td><td>59.63 ± 0.23</td><td>70.70 ± 0.33</td></tr><tr><td rowspan="3">Caltech-256-30</td><td>2×</td><td>85.87 ± 0.38</td><td>77.26 ± 0.28</td><td>85.15 ± 0.75</td></tr><tr><td>5×</td><td>66.57 ± 0.23</td><td>64.27 ± 0.31</td><td>66.64 ± 0.32</td></tr><tr><td>10×</td><td>0.39 ±0.04</td><td>57.11 ± 0.54</td><td>61.45 ± 0.43</td></tr><tr><td rowspan="3">Caltech-256-60</td><td>2×</td><td>88.02 ± 0.45</td><td>84.59 ± 0.28</td><td>87.15 ± 0.75</td></tr><tr><td>5×</td><td>73.95 ± 0.27</td><td>68.38 ± 0.59</td><td>74.46 ± 0.52</td></tr><tr><td>10×</td><td>5.05 ± 0.11</td><td>61.27 ± 0.49</td><td>70.16 ± 0.53</td></tr><tr><td rowspan="3">CUB-200-2011</td><td>2×</td><td>78.88± 0.65</td><td>75.65± 0.26</td><td>78.03 ± 0.45</td></tr><tr><td>5×</td><td>73.44 ± 0.27</td><td>61.50 ± 0.31</td><td>73.35 ± 0.52</td></tr><tr><td>10×</td><td>0.52 ± 0.50</td><td>57.88 ± 0.23</td><td>69.07 ± 0.43</td></tr><tr><td rowspan="3">Food-101</td><td>2×</td><td>83.78 ± 0.61</td><td>75.65 ± 0.26</td><td>84.21 ± 0.65</td></tr><tr><td>5×</td><td>73.36 ± 0.45</td><td>17.10 ± 0.17</td><td>79.12 ± 0.52</td></tr><tr><td>10×</td><td>0.99 ± 0.04</td><td>3.85 ± 0.09</td><td>76.95 ± 0.49</td></tr></table>
+
+Table 2: Top-1 accuracy ( $\%$ ) comparisons of $L ^ { 2 }$ , $L ^ { 2 }$ -SP, LwF, AFDS on 6 datasets fine-tuned with their respective best pruning methods under various speed-up constraints.   
+
+<table><tr><td colspan="2">MACs reduction</td><td>L²</td><td>L²-SP</td><td>LwF</td><td>AFDS</td></tr><tr><td rowspan="3">MIT Indoors 67</td><td>2×</td><td>79.13 ± 0.16</td><td>78.09 ± 0.56</td><td>81.83 ± 0.35</td><td>82.05 ± 0.43</td></tr><tr><td>5×</td><td>64.02 ± 0.21</td><td>62.00 ± 0.31</td><td>69.38 ± 0.27</td><td>69.93 ± 0.52</td></tr><tr><td>10×</td><td>58.04 ± 0.38</td><td>58.49 ± 0.34</td><td>48.09 ± 0.52</td><td>66.72 ± 0.53</td></tr><tr><td rowspan="3">Stanford Dogs 120</td><td>2×</td><td>85.38 ± 0.67</td><td>87.21 ± 0.58</td><td>87.07 ± 0.35</td><td>87.41 ± 0.56</td></tr><tr><td>5×</td><td>70.20 ± 0.37</td><td>67.10 ± 0.31</td><td>73.44 ± 0.27</td><td>75.14 ± 0.52</td></tr><tr><td>10×</td><td>59.63 ± 0.23</td><td>42.89 ± 0.48</td><td>17.79 ± 0.50</td><td>70.70 ± 0.33</td></tr><tr><td rowspan="3">Caltech-256-30</td><td>2×</td><td>83.83 ± 0.62</td><td>83.67 ± 0.53</td><td>85.87 ± 0.38</td><td>85.15 ± 0.75</td></tr><tr><td>5×</td><td>61.45 ± 0.17</td><td>60.03 ± 0.21</td><td>66.57 ± 0.23</td><td>66.64 ± 0.32</td></tr><tr><td>10×</td><td>57.11 ± 0.54</td><td>56.12 ± 0.31</td><td>40.32 ± 0.34</td><td>61.45 ± 0.43</td></tr><tr><td rowspan="3">Caltech-256-60</td><td>2×</td><td>86.27 ± 0.47</td><td>85.84 ± 0.51</td><td>88.02 ± 0.45</td><td>87.15 ± 0.75</td></tr><tr><td>5×</td><td>71.02 ± 0.37</td><td>69.9 ± 0.31</td><td>73.95 ± 0.27</td><td>74.46 ± 0.52</td></tr><tr><td>10×</td><td>61.27 ± 0.49</td><td>39.41 ± 0.71</td><td>26.75 ± 0.50</td><td>70.16 ± 0.53</td></tr><tr><td rowspan="3">CUB-200-2011</td><td>2×</td><td>76.27 ± 0.37</td><td>75.58 ± 0.46</td><td>78.88 ± 0.65</td><td>78.03 ± 0.45</td></tr><tr><td>5×</td><td>66.48 ± 0.37</td><td>64.49 ± 0.31</td><td>73.44 ± 0.27</td><td>73.35 ± 0.52</td></tr><tr><td>10×</td><td>57.88 ± 0.23</td><td>57.13 ± 0.38</td><td>29.57 ± 0.31</td><td>69.07 ± 0.43</td></tr><tr><td rowspan="3">Food-101</td><td>2×</td><td>83.78 ± 0.61</td><td>82.27 ± 0.23</td><td>82.38 ± 0.85</td><td>84.21 ± 0.65</td></tr><tr><td>5×</td><td>73.36 ± 0.33</td><td>70.12 ± 0.71</td><td>73.05 ± 0.64</td><td>79.12 ± 0.52</td></tr><tr><td>10×</td><td>1.6 ± 0.04</td><td>3.56 ± 0.08</td><td>3.85 ± 0.09</td><td>76.95 ± 0.49</td></tr></table>
+
+For each pruned model, we can compute the number of multiply-accumulate operations (MACs) required to perform inference on an image. For each accelerated convolution, the required number of MACs is $k ^ { 2 } H W C _ { \mathrm { i n } } C _ { \mathrm { o u t } }$ , where $C _ { \mathrm { i n } }$ and $C _ { \mathrm { o u t } }$ are the number of input and output channels that are not pruned, respectively. We compute the total number of MACs by summing up the MACs in all convolutions, residual connections, and the final pooling and FC layers. For AFS as we dynamically select which channels to evaluate during inference, we additionally add the overhead of the importance predictor layers to the number of total MACs.
+
+Table 3: Comparison to related transfer learning methods.   
+
+<table><tr><td>Dataset</td><td>Method</td><td>Model</td><td>Accuracy</td><td>MACs</td></tr><tr><td rowspan="4">CUB-200-2011</td><td rowspan="2">Zagoruyko &amp; Komodakis (2017)</td><td>ResNet-34</td><td>73.5</td><td>3.6G</td></tr><tr><td>ResNet-18</td><td>73.0</td><td>1.8G</td></tr><tr><td rowspan="2">Jang et al. (2019)</td><td>ResNet-18</td><td>65.05</td><td>1.8G</td></tr><tr><td>ResNet-101</td><td>76.34</td><td>2.4G</td></tr><tr><td rowspan="4">MIT Indoors 67</td><td rowspan="2">AFDS</td><td>ResNet-101</td><td>73.35</td><td>1.9G</td></tr><tr><td>ResNet-34</td><td>74.0</td><td>3.6G</td></tr><tr><td rowspan="2">Zagoruyko &amp; Komodakis (2017) Jang et al. (2019)</td><td>ResNet-18</td><td>72.9</td><td>1.8G</td></tr><tr><td>ResNet-18</td><td>64.85</td><td>1.8G</td></tr><tr><td rowspan="2"></td><td rowspan="2">AFDS</td><td>ResNet-101</td><td>78.09</td><td>2.4G</td></tr><tr><td>ResNet-101</td><td>74.57</td><td>1.9G</td></tr></table>
+
+![](images/54d449f402811faa6fb736dad205decbb6120fc9757ea4d3388ed2ebe0b04cb2.jpg)  
+Figure 3: MACs and accuracy $\%$ ) trade-off comparisons among different joint methods.
+
+In Figure 3, we present the trade-off relationship between the number of vs. the target dataset accuracies for Stanford Dogs and Caltech-256-60. It is clear that AFDS (ours) exceeds various combinations of pruning methods (NS, SFP) and transfer learning methods ( $L ^ { 2 }$ , $L ^ { 2 }$ -SP, LwF). The results for the remaining datasets can be found in Appendix B. The trade-off curves show that AFDS minimizes accuracy degradation even if 47% of the total MACs are removed from the original model, AFDS resulted in only $1 . 8 3 \%$ drop in accuracy for the model trained on Stanford Dogs. In extreme cases where we permit only $\textstyle { \frac { 1 } { 1 0 } }$ of the original computations, our method can still manage abstantially better when compared to other pruning algorithm $7 0 . 7 0 \%$ accuracrops to ch is and $1 . 3 3 \%$ SFP only has $5 9 . 6 3 \%$ .
+
+Table 1 provide numerical comparisons of different pruning methods against AFS under various speed-up constraints. Table 2 similarly compares transfer learning strategies against AFD. Under most acceleration requirements, the combined method, AFDS, achieves the best accuracies on the target datasets. Finally, Table 3 compares AFDS against other literatures that performs transfer learning. AFDS can achieve state-of-the-art accuracies when compared to methods that produce models with similar number of MACs.
+
+# 5 Conclusion
+
+In this paper, we introduced attentive feature distillation and selection (AFDS), a dualattention method that aims to reap the advantages of transfer learning and channel pruning methods. By applying AFDS during fine-tuning, we can not only learn a new model with a higher target task accuracy, but also further accelerates it by computing a subset of channel neurons in each convolutional layers. Under a wide range of datasets, we demonstrated the smallest drop in validation accuracies under the same speed-up constraints when compared to traditional compression methods such as network slimming (Liu et al., 2017) and soft filter pruning (He et al., 2018).
+
+# Acknowledgements
+
+This work is supported in part by National Key R&D Program of China (No. 2019YFB2102100), Science and Technology Development Fund of Macao S.A.R (FDCT) under number 0015/2019/AKP, Shenzhen Discipline Construction Project for Urban Computing and Data Intelligence, the National Natural Science Foundation of China (Nos. 61806192, 61802387), Shenzhen Science and Technology Innovation Commission (No. JCYJ2017081853518789, JCYJ20190812160003719), the Guangdong Science and Technology Plan Guangdong-Hong Kong Cooperation Innovation Platform (No. 2018B050502009), and China’s Post-doctoral Science Fund (No. 2019M663183).
+
+# References
+
+Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 2270–2278. 2016.
+
+Hossein Azizpour, Ali Sharif Razavian, Josephine Sullivan, Atsuto Maki, and Stefan Carlsson. From generic to specific deep representations for visual recognition. In Proceedings of the 2015 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’15, pp. 36–45, 2015.
+
+Tolga Bolukbasi, Joseph Wang, Ofer Dekel, and Venkatesh Saligrama. Adaptive neural networks for efficient inference. In Proceedings of the 34th International Conference on Machine Learning (ICML), pp. 527–536, 2017.
+
+Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101 – mining discriminative components with random forests. In European Conference on Computer Vision, 2014.
+
+Zhaowei Cai and Nuno Vasconcelos. Cascade R-CNN: Delving into high quality object detection. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 6154–6162, 2018.
+
+Yves Chauvin. A back-propagation algorithm with optimal use of hidden units. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 1, pp. 519–526. Morgan-Kaufmann, 1989.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A largescale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, June 2009.
+
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A deep convolutional activation feature for generic visual recognition. In Eric P. Xing and Tony Jebara (eds.), Proceedings of the 31st International Conference on Machine Learning, volume 32 of Proceedings of Machine Learning Research, pp. 647–655, Bejing, China, 22–24 Jun 2014. PMLR.
+
+Xin Dong, Shangyu Chen, and Sinno Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 4857–4867. Curran Associates, Inc., 2017a.
+
+Xuanyi Dong, Junshi Huang, Yi Yang, and Shuicheng Yan. More is less: A more complicated network with less inference complexity. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017b.
+
+Michael Figurnov, Maxwell D. Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Xitong Gao, Yiren Zhao, Lukasz Dudziak, Robert Mullins, and Cheng-zhong Xu. Dynamic channel pruning: Feature boosting and suppression. In International Conference on Learning Representations (ICLR), 2019.
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. Technical report, 2007.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient DNNs. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Babak Hassibi, David G. Stork, and Gregory Wolff. Optimal brain surgeon: Extensions and performance comparisons. In J. D. Cowan, G. Tesauro, and J. Alspector (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 263–270. 1994.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 1026– 1034, Washington, DC, USA, 2015. IEEE Computer Society. ISBN 978-1-4673-8391-2. doi: 10.1109/ICCV.2015.123.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In International Joint Conference on Artificial Intelligence (IJCAI), pp. 2234–2240, 2018.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. Advances in neural information processing systems 2014, Deep Learning Workshop, 2014.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 448–456. JMLR.org, 2015. URL http://dl.acm.org/citation.cfm?id=3045118.3045167.
+
+Yunhun Jang, Hankook Lee, Sung Ju Hwang, and Jinwoo Shin. Learning what and where to transfer. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 3030–3039, Long Beach, California, USA, 09–15 Jun 2019. PMLR.
+
+Aditya Khosla, Nityananda Jayadevaprakash, Bangpeng Yao, and Li Fei-Fei. Novel dataset for fine-grained image categorization. In First Workshop on Fine-Grained Visual Categorization, IEEE Conference on Computer Vision and Pattern Recognition, Colorado Springs, CO, June 2011.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems (NIPS), pp. 598–605. 1990.
+
+Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, and Jun Huan. DELTA: Deep learning transfer using feature map with attention for convolutional networks. In International Conference on Learning Representations (ICLR), 2019.
+
+Xuhong Li, Yves Grandvalet, and Franck Davoine. Explicit inductive bias for transfer learning with convolutional networks. Thirty-fifth International Conference on Machine Learning, 2018.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, Dec 2018. ISSN 0162-8828. doi: 10.1109/TPAMI.2017.2773081.
+
+Ji Lin, Yongming Rao, Jiwen Lu, and Jie Zhou. Runtime neural pruning. In Advances in Neural Information Processing Systems (NIPS), pp. 2181–2191. 2017.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In International Conference on Computer Vision (ICCV), 2017.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. ThiNet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision, pp. 5058–5066, 2017.
+
+Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 1, pp. 107–115. Morgan-Kaufmann, 1989.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009.
+
+Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 413–420, June 2009. doi: 10.1109/CVPR.2009.5206537.
+
+Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features off-the-shelf: An astounding baseline for recognition. In Proceedings of the 2014 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’14, pp. 512–519, Washington, DC, USA, 2014. IEEE Computer Society. ISBN 978-1-4799- 4308-1. doi: 10.1109/CVPRW.2014.131.
+
+R. Reed. Pruning algorithms–a survey. IEEE Transactions on Neural Networks, 4(5):740– 747, Sep. 1993. doi: 10.1109/72.248452.
+
+Mengye Ren, Andrei Pokrovsky, Bin Yang, and Raquel Urtasun. SBNet: Sparse blocks network for fast inference. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards realtime object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015.
+
+Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-ofexperts layer. 2017.
+
+Mingxing Tan and Quoc Le. EfficientNet: Rethinking model scaling for convolutional neural networks. In International Conference on Machine Learning, pp. 6105–6114, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011.
+
+B. P. Welford. Note on a method for calculating corrected sums of squares and products. Technometrics, 4(3):419–420, 1962. ISSN 00401706. URL http://www.jstor.org/ stable/1266577.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2074–2082. 2016.
+
+Zuxuan Wu, Tushar Nagarajan, Abhishek Kumar, Steven Rennie, Larry S. Davis, Kristen Grauman, and Rogerio Feris. BlockDrop: Dynamic inference paths in residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-lessinformative assumption in channel pruning of convolution layers. 2018.
+
+Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7130–7138, July 2017. doi: 10.1109/CVPR.2017.754.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 3320–3328. Curran Associates, Inc., 2014.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In International Conference on Learning Representations (ICLR), 2017.
+
+Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. ICNet for realtime semantic segmentation on high-resolution images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 405–420, 2018.
+
+Zhuangwei Zhuang, Mingkui Tan, Bohan Zhuang, Jing Liu, Yong Guo, Qingyao Wu, Junzhou Huang, and Jinhui Zhu. Discrimination-aware channel pruning for deep neural networks. In Advances in Neural Information Processing Systems, pp. 875–886, 2018.
+
+# A The Overall Training Algorithm
+
+In Algorithm 1 we illustrate the complete training procedure described above. Here, the function takes as input the target training dataset $\mathcal { D }$ , the source model $f$ and its parameters $\theta ^ { \star }$ , the total number of steps to fine-tune $S$ , the initial learning rate $\alpha$ , and the threshold hyperparameters $\delta _ { \mathrm { s } }$ and $\delta _ { \mathrm { m } }$ respectively for $\mathbf { s } _ { l }$ and $\mathbf { I I I }$ . The function returns the optimized parameters $\pmb { \theta }$ for the target dataset, and both constant masks for all layers $\mathbf { s } = ( \mathbf { s } _ { 1 } , \mathbf { s } _ { 2 } , \ldots , \mathbf { s } _ { L } )$ and $\mathbf { m } = \left( \mathbf { m } _ { 1 } , \mathbf { m } _ { 2 } , \ldots , \mathbf { m } _ { L } \right)$ . The function SGD then fine-tunes the model parameters. For each layer $\it { \Delta } l$ , we compute the mean $\pmb { \mu } _ { l }$ and variance $\sigma _ { \mathit { l } }$ statistics of $q _ { l } ( \pmb { x } _ { l - 1 } )$ , and use it to compute $\mathbf { s } _ { l }$ .
+
+<table><tr><td>Algorithm 1 Training Procedure</td></tr><tr><td>1: function AFDS(D,f,0*,S,α,δs,δm)</td></tr><tr><td>2: forl∈L:st←1</td></tr><tr><td>3: forl∈L:m ←1</td></tr><tr><td>4: 0 ← SGD(D,f,0*,s,m,「],a,R) 5: forl∈Ldo</td></tr><tr><td>6: μ ←E(x,y)~D[q(xl-1)]</td></tr><tr><td>7: σ²←E(,y)~D[(q(xl-1）-μt)²]</td></tr><tr><td>8: Pl ←E(χ,y)~D[πt(xl-1) &gt;0]</td></tr><tr><td>9: st←σ²&gt;δs</td></tr><tr><td>10:</td></tr><tr><td>Y←μ 11: m ←p&gt;δm</td></tr><tr><td>end for</td></tr><tr><td>12:</td></tr><tr><td>13: 0 ← SGD(D,f,0,s,m,「2],1,R)</td></tr><tr><td>14: return 0,s,m</td></tr><tr><td>15: :end function</td></tr></table>
+
+![](images/197b538790b49855ed0dac130f6f7382640fe64ee680053e799e991fa6266aa0.jpg)  
+Figure 4: MACs and accuracy $\%$ ) trade-off comparisons among different joint methods.

parse/train/ryxyCeHtPB/ryxyCeHtPB_content_list.json

@@ -0,0 +1,1615 @@
+[
+    {
+        "type": "text",
+        "text": "Pay Attention to Features, Transfer Learn Faster CNNs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            606,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kafeng Wang∗†1, Xitong Gao $^ 2$ ∗, Yiren Zhao3, Xingjian Li4, Dejing Dou5, Cheng-Zhong Xu6 ",
+        "bbox": [
+            181,
+            167,
+            746,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^ { 1 , 2 }$ Shenzhen Institutes of Advanced Technology, Chinese Academy of Sciences.   \n1 University of Chinese Academy of Sciences. $^ 3$ University of Cambridge.   \n$^ { 4 , 5 }$ Big Data Lab, Baidu Research. 6 University of Macau.   \n1 kf.wang@siat.ac.cn, 2 xt.gao@siat.ac.cn. ",
+        "bbox": [
+            186,
+            199,
+            746,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            292,
+            545,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep convolutional neural networks are now widely deployed in vision applications, but a limited size of training data can restrict their task performance. Transfer learning offers the chance for CNNs to learn with limited data samples by transferring knowledge from models pretrained on large datasets. Blindly transferring all learned features from the source dataset, however, brings unnecessary computation to CNNs on the target task. In this paper, we propose attentive feature distillation and selection (AFDS), which not only adjusts the strength of transfer learning regularization but also dynamically determines the important features to transfer. By deploying AFDS on ResNet-101, we achieved a state-of-the-art computation reduction at the same accuracy budget, outperforming all existing transfer learning methods. With a $1 0 \\times$ MACs reduction budget, a ResNet-101 equipped with AFDS transfer learned from ImageNet to Stanford Dogs 120, can achieve an accuracy $1 1 . 0 7 \\%$ higher than its best competitor. ",
+        "bbox": [
+            233,
+            325,
+            764,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            339,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite recent successes of CNNs achieving state-of-the-art performance in vision applications (Tan & Le, 2019; Cai & Vasconcelos, 2018; Zhao et al., 2018; Ren et al., 2015), there are two major shortcomings limiting their deployments in real life. First, training CNNs from random initializations to achieve high task accuracy generally requires a large amount of data that is expensive to collect. Second, CNNs are typically compute-intensive and memory-demanding, hindering their adoption to power-limited scenarios. ",
+        "bbox": [
+            174,
+            579,
+            823,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address the former challenge, transfer learning (Pan $\\&$ Yang, 2009) is thus designed to transfer knowledge learned from the source task to a target dataset that has limited data samples. In practice, we often choose a source dataset such that the input domain of the source comprises the domain of the target. A common paradigm for transfer learning is to train a model on a large source dataset, and then fine-tune the pre-trained weights with regularization methods on the target dataset (Zagoruyko & Komodakis, 2017; Yim et al., 2017; Li et al., 2018; Li & Hoiem, 2018; Li et al., 2019). For example, one regularization method, $L ^ { 2 }$ - $S P$ (Li et al., 2018), penalizes the $L ^ { 2 }$ -distances of pretrained weights on the source dataset and the weights being trained on the target dataset. The pretrained source weights serves as a starting point when training on the target data. During fine-tuning on the target dataset, the regularization constrains the search space around this starting point, which in turn prevents overfitting the target dataset. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the responsibility of transfer learning is to preserve the source knowledge acquired by important neurons. The neurons thereby retain their abilities to extract features from the source domain, and contribute to the network’s performance on the target dataset. ",
+        "bbox": [
+            176,
+            844,
+            823,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Moreover, by determining the importance of neurons, unimportant ones can further be removed from computation during inference with network pruning methods (Luo et al., 2017; He et al., 2017; Zhuang et al., 2018; Ye et al., 2018; Gao et al., 2019). The removal of unnecessary compute not only makes CNNs smaller in size but also reduces computational costs while minimizing possible accuracy degradations. As the source domain encompasses the target, many neurons responsible for extracting features from the source domain may become irrelevant to the target domain and can be removed. In Figure 1, a simple empirical study of the channel neurons’ activation magnitudes corroborates our intuition: as deeper layers extract higher-level features, more neurons become either specialized or irrelevant to dogs. The discussion above hence prompts two questions regarding the neurons: which neurons should we transfer source knowledge to, and which are actually important to the target model? ",
+        "bbox": [
+            174,
+            103,
+            825,
+            268
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f9ecf6ecf2ea5aa072a3bf34fd0abd8f35fd0c7cd52a2184afd3a656f895479.jpg",
+        "image_caption": [
+            "Figure 1: (a) shows sample images from two datasets, ImageNet contains images with greater diversity. (b) shows the average maximum activations of 20 channel neurons in 3 layers of ResNet-101 that are most excited by images from Dogs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            281,
+            813,
+            398
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Yet traditional transfer learning methods fail to provide answers to both, as generally they transfer knowledge either equally for each neuron with the same regularized weights, or determine the strength of regularization using only the source dataset (Li et al., 2018). The source domain could be vastly larger than the target, giving importance to weights that are irrelevant to the target task. ",
+        "bbox": [
+            174,
+            464,
+            823,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent years have seen a surge of interest in network pruning techniques, many of which induce sparsity by pushing neuron weights or outputs to zeros, allowing them to be pruned without a detrimental impact on the task accuracies. Even though pruning methods present a solution to neuron/weight importance, unfortunately they do not provide an answer to the latter question, i.e. whether these neurons/weights are important to the target dataset. The reason for this is that pruning optimization objectives are often in conflict with traditional transfer learning, as both drive weight values in different directions: zero for pruning and the initial starting point for transfer learning. As we will see later, a na¨ıve composition of the two methods could have a disastrous impact on the accuracy of a pruned CNN transferlearned on the target dataset. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            679
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, to tackle the challenge of jointly transferring source knowledge and pruning target CNNs, we propose a new method based on attention mechanism (Vaswani et al., 2017), attentive feature distillation and selection (AFDS). For the images in the target dataset, AFDS dynamically learns not only the features to transfer, but also the unimportant neurons to skip. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "During transfer learning, instead of fine-tuning with $L ^ { 2 }$ -SP regularization which explores the proximity of the pre-trained weights, we argue that a better alternative is to mimic the feature maps, i.e. the output response of each convolutional layer in the source model when images from the target dataset are shown, with $L ^ { 2 }$ -distances. This way the fine-tuned model can still learn the behavior of the source model. Additionally, without the restriction of searching only the proximity of the initial position, the weights in the target model can be optimized freely and thus increasing their generalization capacity. Therefore, we present attentive feature distillation (AFD) to learn which relevant features to transfer. ",
+        "bbox": [
+            174,
+            762,
+            823,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To accelerate the transfer-learned model, we further propose attentive feature selection (AFS) to prune networks dynamically. AFS is designed to learn to predictively select important output channels in the convolution to evaluate and skip unimportant ones, depending on the input to the convolution. Rarely activated channel neurons can further be removed from the network, reducing the model’s memory footprint. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From an informal perspective, both AFD and AFS learn to adjust the “valves” that control the flow of information for each channel neuron. The former adjusts the strength of regularization, thereby tuning the flow of knowledge being transferred from the source model. The latter allows salient information to pass on to the subsequent layer and stops the flow of unimportant information. A significant attribute that differentiates AFD and AFS from their existing counterparts is that we employ attention mechanisms to adaptively learn to “turn the valves” dynamically with small trainable auxiliary networks. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are as follows: ",
+        "bbox": [
+            176,
+            243,
+            447,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We present attentive feature distillation and selection (AFDS) to effectively transfer learn CNNs, and demonstrate state-of-the-art performance on many publicly available datasets with ResNet-101 (He et al., 2016) models transfer learned from ImageNet (Deng et al., 2009). We paired a large range of existing transfer learning and network pruning methods, and examined their abilities to trade-off FLOPs with task accuracy. • By changing the fraction of channel neurons to skip for each convolution, AFDS can further accelerate the transfer learned models while minimizing the impact on task accuracy. We found that AFDS generally provides the best FLOPs and accuracy trade-off when compared to a broad range of paired methods. ",
+        "bbox": [
+            215,
+            271,
+            825,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            354,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Transfer Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            377,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Training a deep CNN to achieve high accuracy generally require a large amount of training data, which may be expensive to collect. Transfer learning (Pan & Yang, 2009) addresses this challenge by transferring knowledge learned on a large dataset that has a similar domain to the training dataset. A typical approach for CNNs is to first train the model on a large source dataset, and make use of their feature extraction abilities (Donahue et al., 2014; Razavian et al., 2014). Moreover, it has been demonstrated that the task accuracy can be further improved by fine-tuning the resulting pre-trained model on a smaller target dataset with a similar domain but a different task (Yosinski et al., 2014; Azizpour et al., 2015). Li et al. (2018) proposed $L ^ { 2 }$ -SP regularization to minimize the $L ^ { 2 }$ -distance between each fine-tuned parameter and its initial pre-trained value, thus preserving knowledge learned in the pre-trained model. In addition, they presented $L ^ { 2 }$ -SP-Fisher, which further weighs each $L ^ { 2 }$ -distance using Fisher information matrix estimated from the source dataset. Instead of constraining the parameter search space, Li et al. (2019) showed that it is often more effective to regularize feature maps during fine-tuning, and further learns which features to pay attention to. Learning without Forgetting (Li & Hoiem, 2018) learns to adapt the model to new tasks, while trying to match the output response on the original task of the original model using knowledge distillation (KD) (Hinton et al., 2014). Methods proposed by Zagoruyko & Komodakis (2017) and Yim et al. (2017) transfer knowledge from a teacher model to a student by regularizing features. The former computes and regularizes spatial statistics across all feature maps channels, whereas the latter estimates the flow of information across layers for each pair of channels, and transfers this knowledge to the student. Instead of manually deciding the regularization penalties and what to regularize as in the previous approaches, Jang et al. (2019) used meta-learning to automatically learn what knowledge to transfer from the teacher and to where in the student model. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Li et al. (2019) and Jang et al. (2019), this paper introduces attentive feature distillation (AFD), which similarly transfers knowledge by learning from the teacher’s feature maps. It however differs from Jang et al. (2019) as the teacher and student models share the same network topology, and it instead learns which channel to transfer from the teacher to the student in the same convolutional output. ",
+        "bbox": [
+            176,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Structured Sparsity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            390,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sparsity in neural networks has been a long-studied subject (Reed, 1993; LeCun et al., 1990; Chauvin, 1989; Mozer & Smolensky, 1989; Hassibi et al., 1994). Related techniques have been applied to modern deep CNNs with great success (Guo et al., 2016; Dong et al., 2017a), significantly lowering their storage requirements. In general, as these methods zero out individual weights, producing irregular sparse connections, which cannot be efficiently exploited by GPUs to speed up computation. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For this, many recent work turned their attention to structured sparsity (Alvarez & Salzmann, 2016; Wen et al., 2016; Liu et al., 2017; He et al., 2017; 2018). This approach aims to find coarse-grained sparsity and preserves dense structures, thus allowing conventional GPUs to compute them efficiently. Alvarez & Salzmann (2016) and Wen et al. (2016) both added group Lasso to penalize non-zero weights, and removed channels entirely that have been reduced to zero. Liu et al. (2017) proposed network slimming (NS), which adds $L ^ { 1 }$ regularization to the trainable channel-wise scaling parameters $\\gamma$ used in batch normalization, and gradually prunes channels with small $\\gamma$ values by threshold. He et al. (2018) introduced soft filter pruning (SFP), which iteratively fine-tunes and sets channels with small $L ^ { 2 }$ -norms to zero. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pruning algorithms remove weights or neurons from the network. The network may therefore lose its ability to process some difficult inputs correctly, as the neurons responsible for them are permanently discarded. Gao et al. (2019) have found empirically that task accuracies degrades considerably when most of the computation are removed from the network, and introduced feature boosting and suppression (FBS). Instead of removing neurons permanently from the network, FBS learns to dynamically prune unimportant channels, depending on the current input image. In this paper, attentive feature selection (AFS) builds on top of the advantages of both static and dynamic pruning algorithms. AFS not only preserves neurons that are important to some input images, but also removes unimportant ones for most inputs from the network, reducing both the memory and compute requirements for inference. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are methods that dynamically select which paths to evaluate in a network dependent on the input (Figurnov et al., 2017; Dong et al., 2017b; Bolukbasi et al., 2017; Lin et al., 2017; Shazeer et al., 2017; Wu et al., 2018; Ren et al., 2018). They however introduce architectural and/or training method changes, and thus cannot be applied directly on existing popular models pre-trained on ImageNet (Deng et al., 2009). ",
+        "bbox": [
+            174,
+            526,
+            823,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Attentive Feature Distillation and Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            673,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 High-Level Overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            395,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7719b358eb331301639881d83e52a26d996e5e43c873f8fd630be5867ac9503.jpg",
+        "image_caption": [
+            "Figure 2: High-level overview of AFDS. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            678,
+            782,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by providing a high-level overview of attentive feature distillation and selection (AFDS). AFDS introduces two new components to augment each conventional batchnormalized convolutional (ConvBN) layer (Ioffe & Szegedy, 2015), as illustrated in Figure 2. The AFS preemptively learns the importance of each channel, in the output of the ConvBN layer, and can suppress unimportant channels, thus allowing the expensive convolution operation to skip evaluating these channels. The AFD learns the importance of each channel in the output activation, and use the importance as weights to regularize feature maps in the target model with $L ^ { 2 }$ -distance. Each component is a small neural network containing a small number of parameters that can be trained with conventional stochastic gradient descent (SGD). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            330,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consider a set of training data $\\mathcal { D }$ where each sample $( { \\pmb x } , y )$ consists of an input image $\\pmb { x } \\in \\mathbb { R } ^ { C \\times H \\times W }$ , and a ground-truth label $y \\in \\mathbb N$ . Here $C$ , $H$ and $W$ respectively denote the number of channels, and the height and width of the input image. Training a deep CNN classifier thus minimizes the following loss function with an optimization method based on SGD: ",
+        "bbox": [
+            173,
+            215,
+            823,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba387637b2844c447c53fdaaf0835e282b411fc4f80adafd8164f175ff8f4f5c.jpg",
+        "text": "$$\n\\mathcal { L } ( \\pmb { \\theta } ) = \\mathbb { E } _ { ( \\pmb { x } , \\pmb { y } ) \\sim \\mathcal { D } } [ \\mathcal { L } ^ { \\mathrm { C E } } ( f ( \\pmb { x } , \\pmb { \\theta } ) , \\pmb { y } ) + \\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) + \\lambda \\| \\pmb { \\theta } \\| _ { 2 } ^ { 2 } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            284,
+            687,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\theta }$ comprises all parameters of the model, the loss $\\mathcal { L } ^ { \\mathrm { C E } } ( f ( \\pmb { x } , \\pmb { \\theta } ) , y )$ denotes the crossentropy loss between the CNN output $f ( { \\pmb x } , { \\pmb \\theta } )$ and the label $y$ . The regularizer $\\mathcal { R } ( \\pmb \\theta , \\pmb x )$ is often used to reduce the risk of overfitting. In conventional training, $\\mathcal { R } ( \\pmb \\theta , \\pmb x ) = 0$ . Finally, we impose a $L ^ { 2 }$ penalty on $\\pmb { \\theta }$ , where $\\left. \\ z \\right. _ { 2 }$ represents the $L ^ { 2 }$ -norm of $_ z$ across all its elements. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We assume that $f ( { \\pmb x } , { \\pmb \\theta } )$ is a feed-forward CNN composed of $N$ ConvBN layers for feature extraction, $f _ { l } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } )$ with $l \\in L = \\{ 1 , 2 , \\ldots , N \\}$ , and a final fully-connected layer for classification, $g ( \\pmb { x } _ { N } , \\pmb { \\theta } _ { g } )$ . Here, for the $l ^ { \\mathrm { t h } }$ layer, ${ \\bf { \\Delta } } x _ { l - 1 }$ is the input to the layer, with ${ \\boldsymbol { \\mathbf { \\mathit { x } } } } _ { 0 }$ indicating $_ { x }$ , and $\\theta _ { l }$ is the layer’s parameters. Therefore, the $l ^ { \\mathrm { t h } }$ layer is defined as: ",
+        "bbox": [
+            173,
+            372,
+            825,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbe6d8041f8d822121737b144f991384922c2fe0e64a90b3447d2db9b21236cc.jpg",
+        "text": "$$\n\\pmb { x } _ { l } = f _ { l } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } ) = \\mathrm { r e l u } ( \\gamma _ { l } \\cdot \\mathrm { n o r m } ( \\mathrm { c o n v } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } ) ) + \\beta _ { l } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            439,
+            696,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { x } _ { l } \\in \\mathbb { R } ^ { C _ { l } \\times H _ { l } \\times W _ { l } }$ contains $C _ { l }$ feature maps of the layer, each with a $H _ { l }$ height and $W _ { l }$ width. The function $\\mathrm { c o n v } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } )$ is a convolution that takes ${ \\bf { \\Delta } } x _ { l - 1 }$ as input and uses trainable parameters $\\theta _ { l }$ , and $\\operatorname { n o r m } ( z )$ performs batch normalization. Finally, $\\gamma _ { l } , \\beta _ { l } \\in \\mathbb { R } ^ { C _ { l } }$ are trainable vectors, the multiplications (·) and additions $( + )$ are channel-wise, and $\\mathrm { r e l u } ( z ) = \\mathrm { m a x } ( z , 0 )$ stands for the ReLU activation. Although we use the feed-forward classifier above for simplicity, it can be easily modified to contain additional structures such as residual connections (He et al., 2016) and computations for object detection (Ren et al., 2015). ",
+        "bbox": [
+            173,
+            462,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During transfer learning, as we fine-tune the network with a different task, the final layer $g ( \\pmb { x } _ { N } , \\pmb { \\theta } _ { g } )$ is generally replaced with a new randomly-initialized one $h ( \\pmb { x } _ { N } , \\pmb { \\theta } _ { h } )$ . To prevent overfitting, additional terms are used during transfer learning, for instance, $L ^ { z }$ - $S P$ (Li et al., 2018) further constrains the parameters $\\pmb { \\theta } _ { l }$ to explore around their initial values $\\pmb { \\theta } _ { l } ^ { \\star }$ : ",
+        "bbox": [
+            174,
+            580,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2c2a57943e748e913fcc265d73457c101a3979cd704f514ac7a1828f36cae6d.jpg",
+        "text": "$$\n\\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) = \\lambda _ { \\mathrm { S P } } \\sum _ { l \\in L } \\lVert \\pmb { \\theta } _ { l } - \\pmb { \\theta } _ { l } ^ { \\star } \\rVert _ { 2 } ^ { 2 } + \\lambda _ { \\mathrm { L 2 } } \\lVert \\pmb { \\theta } \\rVert _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            647,
+            643,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instead of regularizing parameters, methods based on knowledge distillation (Hinton et al., 2014) encourages the model to mimic the behavior of the original while learning the target task. Learning without Forgetting (LwF) (Li $\\&$ Hoiem, 2018) uses the following regularizer to mimic the response from the original classifiers: ",
+        "bbox": [
+            173,
+            695,
+            825,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f87ff63501b5fdd656cda787c73ecd8c3038e30ae6a5d03f25f388d2f0428e07.jpg",
+        "text": "$$\n\\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) = \\lambda _ { \\mathrm { L w F } } \\mathcal { L } ^ { \\mathrm { C E } } ( g ^ { \\star } ( f _ { L } ( \\pmb { x } , \\pmb { \\theta } _ { L } ) , \\pmb { \\theta } _ { g } ^ { \\star } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            760,
+            642,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { L } ( \\pmb { x } , \\pmb { \\theta } _ { L } )$ indicates the first $N$ layers, and $g ^ { \\star }$ and $\\theta _ { g } ^ { \\star }$ respectively denote the original fully-connected (FC) layer and its associated parameters, and generally $\\lambda _ { \\mathrm { L w F } } ~ = ~ 1$ . Zagoruyko $\\&$ Komodakis (2017), Yim et al. (2017) and Li et al. (2019) chose to regularize feature maps in some intermediate layers $L ^ { \\prime } \\subseteq L$ . We assume that $\\mathbf { \\boldsymbol { x } } _ { l } ^ { \\star }$ is the $l ^ { \\mathrm { t h } }$ layer output of the original model with weights $\\theta ^ { \\star }$ when the input $_ { x }$ is shown to the model, and $r$ is a method-dependent function that constrains the relationship between $\\mathbf { \\boldsymbol { x } } _ { l } ^ { \\star }$ and $\\mathbf { \\Delta } x _ { l }$ . The regularizer can then be defined as follows: ",
+        "bbox": [
+            173,
+            786,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df794cdf3fb7f2baa635092c0dafb2d35613afccee1a2ef32dde076481934b8f.jpg",
+        "text": "$$\n\\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) = \\lambda _ { \\mathrm { K D } } \\sum _ { l \\in L ^ { \\prime } } r ( \\pmb { x } _ { l } ^ { \\star } , \\pmb { x } _ { l } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            895,
+            602,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Attentive Feature Distillation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            482,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A simple way to extend Equation (5) is to constrain the $L ^ { 2 }$ -norm-distance between $\\mathbf { \\boldsymbol { x } } _ { l } ^ { \\star }$ and $\\mathbf { \\Delta } x _ { l }$ , and thus pushing the target model to learn the feature map responses of the source: ",
+        "bbox": [
+            171,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3db9b080b85a5cf55e7e2337ee2a6f32952cc25d04f51fd74d7879e61f65481d.jpg",
+        "text": "$$\n\\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) = \\lambda _ { \\mathrm { F D } } \\sum _ { l \\in L ^ { \\prime } } \\| \\pmb { x } _ { l } ^ { \\star } - \\pmb { x } _ { l } \\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            165,
+            607,
+            198
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The above formulation, however, places equal weight to each channel neurons of the feature maps. As we discussed earlier, the importance of channel neurons varies drastically when different input images are shown. it is thus desirable to enforce a different penalty for each channel depending on the input $_ { x }$ . For this purpose, we design the regularizer: ",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4fe5dfe74d8dd6a710f23e7520aa76334bf74c4188524731f0211c038beea22.jpg",
+        "text": "$$\n\\mathcal { R } ( \\pmb { \\theta } , \\pmb { x } ) = \\lambda _ { \\mathrm { A F D } } \\sum _ { l \\in L ^ { \\prime } } \\sum _ { c \\in C _ { l } } \\pmb { \\rho } _ { l } ^ { [ c ] } ( \\pmb { x } _ { l } ^ { \\star } ) \\| ( \\pmb { x } _ { l } ^ { \\star } - \\pmb { x } _ { l } ) ^ { [ c ] } \\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            268,
+            671,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that in Equation (7), for any tensor $_ z$ , the term $z ^ { [ c ] }$ denotes the $c ^ { \\mathrm { t h } }$ slice of the tensor. The transfer importance predictor ${ \\pmb \\rho } _ { l } : \\mathbb { R } ^ { C _ { l } \\times H _ { l } \\times W _ { l } }  \\mathbb { R } ^ { C _ { l } }$ computes for each channel the importance of the source activation maps, which governs the strength of the $L ^ { 2 }$ regularization for each channel. The predictor function is trainable and is defined as a small network with two FC layers: ",
+        "bbox": [
+            173,
+            310,
+            825,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eccfd1a15b286765ae3c5f26219a8a25866219189d5330fef1e309a6e4169ea2.jpg",
+        "text": "$$\n\\rho _ { l } ^ { [ c ] } ( { \\pmb x } _ { l } ^ { \\star } ) = \\mathrm { s o f t m a x } ( \\mathrm { r e l u } ( { \\sf b } ( { \\pmb x } _ { l } ^ { \\star } ) { \\pmb \\varphi } _ { l } + { \\pmb \\nu } _ { l } ) { \\pmb \\varphi } _ { l } ^ { \\prime } + { \\pmb \\nu } _ { l } ^ { \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            380,
+            668,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The function $\\flat : \\mathbb { R } ^ { C \\times H \\times W }  \\mathbb { R } ^ { C \\times H W }$ flattens the spatial dimensions in a channel-wise fashion; The parameters $\\varphi _ { l } \\in \\mathbb { R } ^ { H W \\times H }$ , $\\pmb { \\nu } _ { l } \\in \\mathbb { R } ^ { 1 \\times H }$ , $\\varphi _ { l } ^ { \\prime } \\in \\mathbb { R } ^ { H }$ and $\\pmb { \\nu } _ { l } ^ { \\prime } \\in \\mathbb { R } ^ { C }$ can thus be trained to adjust the importance of each channel dynamically; finally, the softmax activation is borrowed from attention mechanism (Vaswani et al., 2017) to normalize the importance values. In our experiments, $\\varphi _ { l }$ and $\\varphi _ { l } ^ { \\prime }$ use He et al. (2015)’s initialization, $\\pmb { \\nu } _ { l }$ and $\\nu _ { l } ^ { \\prime }$ are both initialized to $\\mathbf { 0 }$ . ",
+        "bbox": [
+            173,
+            402,
+            825,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Attentive Feature Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            505,
+            462,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In a fashion similar to feature boosting and suppression (FBS) (Gao et al., 2019), AFS modifies the ConvBN layers from Equation (2): ",
+        "bbox": [
+            171,
+            530,
+            823,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9eeaefb5c4e7f6573525c45ae3478a8e5517c5c12d2f5e9e1d4be97ccb75587d.jpg",
+        "text": "$$\n\\hat { f } _ { l } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } ) = \\mathrm { r e l u } ( \\pi _ { l } ( \\pmb { x } _ { l - 1 } ) \\cdot \\mathrm { n o r m } ( \\mathrm { c o n v } ( \\pmb { x } _ { l - 1 } , \\pmb { \\theta } _ { l } ) ) + \\beta _ { l } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            568,
+            700,
+            585
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where the predictor function takes as input the activation maps of the previous layer, i.e. : $\\mathbb { R } ^ { C _ { l - 1 } \\times H _ { l - 1 } \\times W _ { l - 1 } } \\to \\mathbb { R } ^ { C }$ , is used to replace the vector $\\gamma _ { l }$ . This function dynamically predicts the importance of each channel, and suppresses certain unimportant channels by setting them to zero. The expensive conv function can hence be accelerated by skipping the disabled output channels. The predictor function is defined as below: ",
+        "bbox": [
+            173,
+            592,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c4df1efc51a8043d47b03685b7efa9c4e5d3bb152b02a581db215b3a7af585c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pi _ { l } ( \\pmb { x } _ { l - 1 } ) = \\pmb { \\mathrm { m } } _ { l } \\cdot \\ b { q } _ { l } ( \\pmb { x } _ { l - 1 } ) , \\mathrm { ~ w h e r e ~ } \\pmb { q } _ { l } ( \\pmb { x } _ { l - 1 } ) = \\mathrm { w t a } _ { \\lceil d C _ { l } \\rceil } ( \\mathbf { s } _ { l } \\cdot h _ { l } ( \\pmb { x } _ { l - 1 } ) + ( 1 - \\mathbf { s } _ { l } ) \\cdot \\gamma _ { l } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            670,
+            769,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { m } _ { l } , \\mathbf { s } _ { l } \\in \\{ 0 , 1 \\} ^ { C _ { l } }$ are both constant masks that take binary values: $\\mathbf { I I I }$ prunes output channels by permanently setting them to zeros, and $\\mathbf { s } _ { l }$ decides for each channel whether the output of $h _ { l } ( \\pmb { x } _ { l - 1 } )$ or $\\gamma _ { l }$ should be used. It is clear that when ${ \\bf m } _ { l } = { \\bf 1 }$ , no channel neurons are removed from the network. In Section 3.5, we explain how $\\mathbf { I I I }$ and $\\gamma _ { l }$ can be determined during the fine-tuning process. The winner-take-all function w $\\tan _ { [ d C _ { l } ] } ( z )$ preserves the $\\lceil d C _ { l } \\rceil$ most salient values in $_ { z }$ , and suppresses the remaining ones by setting them to zeros. The density value $0 < d \\leq 1$ is a constant that controls the number of channels to preserve during inference, with 1 preserving all $C _ { l }$ channels. The smaller $d$ gets, the more channels can be skipped, which in turn accelerates the model. Finally, the function $h _ { l } : \\mathbb { R } ^ { C _ { l - 1 } \\times H \\times W }  \\mathbb { R } ^ { C _ { l } }$ is a small network that is used to predict the importance of each channel. It is composed of a global average pool followed by a FC layer, where pool : $: \\mathbb { R } ^ { C _ { l - 1 } \\times H \\times W }  \\mathbb { R } ^ { C _ { l - 1 } }$ computes the average across the spatial dimensions for each channel: ",
+        "bbox": [
+            173,
+            695,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b59705e350c4ce81b0fd94243ab277b9e8b5afb9c73baa12d0456f52a22833a8.jpg",
+        "text": "$$\nh ( \\pmb { x } _ { l - 1 } ) = \\mathrm { r e l u } ( \\mathrm { p o o l } ( \\pmb { x } _ { l - 1 } ) \\pmb { \\varphi } _ { l } ^ { \\prime \\prime } + \\pmb { \\nu } _ { l } ^ { \\prime \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            871,
+            629,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the initialization of the FC parameters, we apply He et al. (2015)’s method on the trainable weights $\\varphi _ { l } ^ { \\prime \\prime } \\in \\mathbb { R } ^ { C _ { l - 1 } \\times C _ { l } }$ and $\\pmb { \\nu } _ { l } ^ { \\prime \\prime } \\in \\mathbb { R } ^ { C _ { l } }$ is initialized to zeros. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 Training Procedure ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            387,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the pipeline of AFDS for transferring knowledge from a source model to a new model by fine-tuning on target dataset. The detailed algorithm can be found in Appendix A. ",
+        "bbox": [
+            176,
+            130,
+            821,
+            171
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Initially, we have a pre-trained model $f$ with parameters $\\theta ^ { \\star }$ for the source dataset (e.g. ImageNet). To ensure better accuracies on compressed target models, All ConvBN layers $f _ { l }$ in $f$ are extended with AFS as discussed in Section 3.4, with $d$ initially set to 1, which means that all output channels in a convolutional layer are evaluated during inference, i.e. no acceleration. The pre-trained model is then fine-tuned on the target training dataset $\\mathcal { D }$ with the AFD regularization proposed in Section 3.3. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Empirically we found that in residual networks with greater depths, AFS could become notably challenging to train to high accuracies. To mitigate this, for each output channel of a layer $\\it l$ we update $\\mathbf { s } _ { l }$ according to the variance of $h _ { l } ( \\pmb { x } _ { l - 1 } )$ observed on the target dataset. For each channel if the variance is smaller than a threshold $\\delta _ { s }$ , then we set the entry in $\\mathbf { s } _ { l }$ to zero for that particular channel. This action replaces the output of $h _ { l } ( \\pmb { x } _ { l - 1 } )$ with $\\gamma _ { l }$ , which is a trainable parameter initialized to the mean of $h _ { l } ( \\pmb { x } _ { l - 1 } )$ . We compute the mean and variance statistics using Welford (1962)’s online algorithm which can efficiently compute the statistics in a single-pass with $O ( 1 )$ storage. In our experiments, $\\delta _ { \\mathrm { s } }$ is set to a value such that $5 0 \\%$ of the channel neurons use the predictor function $h _ { l }$ . ",
+        "bbox": [
+            174,
+            270,
+            825,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we discovered that many of the channel neurons are rarely activated in a AFSbased network. We further propose to remove the channel neurons that are activated with a low frequency. In each layer $\\it l$ , the mask $\\mathbf { m } _ { l }$ is used to disable certain channels from the network by setting their output to a constant $\\mathbf { 0 }$ , if the probability of a channel neuron being active is lower than $\\delta _ { \\mathrm { m } }$ . Zeroed-out channels can thus be permanently removed when the model is used in inference. ",
+        "bbox": [
+            174,
+            401,
+            823,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            331,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide an extensive empirical study of the joint methods of transfer learning and channel pruning. We evaluate the methods with 6 different benchmark datasets: Caltech-256 (Griffin et al., 2007) of 256 general object categories; Stanford Dogs 120 (Khosla et al., 2011) specializes to images containing dogs; MIT Indoors 67 (Quattoni & Torralba, 2009) for indoor scene classification; Caltech-UCSD Birds-200-2011 (CUB-200-2011) (Wah et al., 2011) for classifying birds; and Food-101 (Bossard et al., 2014) for food categories. We refer to Li et al. (2018) and Li et al. (2019), for a detailed description of the benchmark datasets. For Caltech-256, we randomly sample either 30 or 60 images from the training set for each category to produce Caltech-256-30 and - $6 0$ training datasets. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the ResNet-101 from torchvision1 pre-trained on ImageNet as the network for experiments. For ResNet-101 equipped with AFS, we start by extending the pre-trained model and replacing each batch normalization with a randomly initialized AFS, and fine-tune the resulting model on ImageNet for 90 epochs with a learning rate of 0.01 decaying by a factor of 10 every 30 epochs. The resulting model matches its original baseline accuracy. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For each benchmark dataset, the final FC layer of the network is replaced with a new FC randomly initialized with He et al. (2015)’s method to match the number of output categories accordingly. We then perform transfer learning with 4 different methods: $L ^ { 2 }$ (fine-tuning without additional regularization), $L ^ { 2 }$ -SP (Li et al., 2018), learning without forgetting (LwF) (Li & Hoiem, 2018), and finally AFD for models using AFS. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To accelerate the resulting fine-tuned models, we continue fine-tuning the model while gradually pruning away channels used during inference. For this, we separately examine 3 pruning strategies: network slimming (NS) (Liu et al., 2017), soft filter pruning (SFP) (He et al., 2018) and finally AFS for models transfer learned with AFD. Note that NS prunes channels by sorting them globally, while SFP does so in a layer-wise manner with identical prune ratios. During this procedure, we start with an unpruned model and incrementally remove $1 0 \\%$ of the channels used in inference, i.e. preserving $9 0 \\%$ , $8 0 \\%$ , and etc., down to $1 0 \\%$ of all channels for the accelerated models. At each step, we fine-tune each model using 4500 steps of SGD with a batch size of 48, at a learning rate of 0.01, before fine-tuning for a further 4500 steps at a learning rate of 0.001. AFS additionally updates the $\\mathbf { m }$ and s masks between the two fine-tuning runs. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            895
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/66bd87a574c039fc1e92c2e6b51d9e5d416c389eebebac6f71b112eb03ceaf6b.jpg",
+        "table_caption": [
+            "Table 1: Top-1 accuracy ( $\\%$ ) comparisons of NS, SFP and AFDS on 6 datasets fine-tuned with their respective best transfer learning methods under various speed-up constraints. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">MACs reduction</td><td>NS</td><td>SFP</td><td>AFDS</td></tr><tr><td rowspan=\"3\">MIT Indoors 67</td><td>2×</td><td>81.83 ± 0.35</td><td>79.43± 0.50</td><td>82.05 ± 0.43</td></tr><tr><td>5×</td><td>69.38 ± 0.27</td><td>60.43 ± 0.31</td><td>69.93 ± 0.52</td></tr><tr><td>10×</td><td>1.50 ± 0.30</td><td>58.49 ± 0.34</td><td>66.72 ± 0.53</td></tr><tr><td rowspan=\"3\">Stanford Dogs 120</td><td>2×</td><td>87.21 ± 0.58</td><td>81.74 ± 0.26</td><td>87.41 ± 0.56</td></tr><tr><td>5×</td><td>73.44 ± 0.27</td><td>61.20 ± 0.31</td><td>75.14 ± 0.52</td></tr><tr><td>10×</td><td>1.33 ± 0.50</td><td>59.63 ± 0.23</td><td>70.70 ± 0.33</td></tr><tr><td rowspan=\"3\">Caltech-256-30</td><td>2×</td><td>85.87 ± 0.38</td><td>77.26 ± 0.28</td><td>85.15 ± 0.75</td></tr><tr><td>5×</td><td>66.57 ± 0.23</td><td>64.27 ± 0.31</td><td>66.64 ± 0.32</td></tr><tr><td>10×</td><td>0.39 ±0.04</td><td>57.11 ± 0.54</td><td>61.45 ± 0.43</td></tr><tr><td rowspan=\"3\">Caltech-256-60</td><td>2×</td><td>88.02 ± 0.45</td><td>84.59 ± 0.28</td><td>87.15 ± 0.75</td></tr><tr><td>5×</td><td>73.95 ± 0.27</td><td>68.38 ± 0.59</td><td>74.46 ± 0.52</td></tr><tr><td>10×</td><td>5.05 ± 0.11</td><td>61.27 ± 0.49</td><td>70.16 ± 0.53</td></tr><tr><td rowspan=\"3\">CUB-200-2011</td><td>2×</td><td>78.88± 0.65</td><td>75.65± 0.26</td><td>78.03 ± 0.45</td></tr><tr><td>5×</td><td>73.44 ± 0.27</td><td>61.50 ± 0.31</td><td>73.35 ± 0.52</td></tr><tr><td>10×</td><td>0.52 ± 0.50</td><td>57.88 ± 0.23</td><td>69.07 ± 0.43</td></tr><tr><td rowspan=\"3\">Food-101</td><td>2×</td><td>83.78 ± 0.61</td><td>75.65 ± 0.26</td><td>84.21 ± 0.65</td></tr><tr><td>5×</td><td>73.36 ± 0.45</td><td>17.10 ± 0.17</td><td>79.12 ± 0.52</td></tr><tr><td>10×</td><td>0.99 ± 0.04</td><td>3.85 ± 0.09</td><td>76.95 ± 0.49</td></tr></table>",
+        "bbox": [
+            276,
+            247,
+            722,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/74c057eb6f34220ce0d0fb0115c55c7983f7ab6851818529dd2fdec087504d17.jpg",
+        "table_caption": [
+            "Table 2: Top-1 accuracy ( $\\%$ ) comparisons of $L ^ { 2 }$ , $L ^ { 2 }$ -SP, LwF, AFDS on 6 datasets fine-tuned with their respective best pruning methods under various speed-up constraints. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">MACs reduction</td><td>L²</td><td>L²-SP</td><td>LwF</td><td>AFDS</td></tr><tr><td rowspan=\"3\">MIT Indoors 67</td><td>2×</td><td>79.13 ± 0.16</td><td>78.09 ± 0.56</td><td>81.83 ± 0.35</td><td>82.05 ± 0.43</td></tr><tr><td>5×</td><td>64.02 ± 0.21</td><td>62.00 ± 0.31</td><td>69.38 ± 0.27</td><td>69.93 ± 0.52</td></tr><tr><td>10×</td><td>58.04 ± 0.38</td><td>58.49 ± 0.34</td><td>48.09 ± 0.52</td><td>66.72 ± 0.53</td></tr><tr><td rowspan=\"3\">Stanford Dogs 120</td><td>2×</td><td>85.38 ± 0.67</td><td>87.21 ± 0.58</td><td>87.07 ± 0.35</td><td>87.41 ± 0.56</td></tr><tr><td>5×</td><td>70.20 ± 0.37</td><td>67.10 ± 0.31</td><td>73.44 ± 0.27</td><td>75.14 ± 0.52</td></tr><tr><td>10×</td><td>59.63 ± 0.23</td><td>42.89 ± 0.48</td><td>17.79 ± 0.50</td><td>70.70 ± 0.33</td></tr><tr><td rowspan=\"3\">Caltech-256-30</td><td>2×</td><td>83.83 ± 0.62</td><td>83.67 ± 0.53</td><td>85.87 ± 0.38</td><td>85.15 ± 0.75</td></tr><tr><td>5×</td><td>61.45 ± 0.17</td><td>60.03 ± 0.21</td><td>66.57 ± 0.23</td><td>66.64 ± 0.32</td></tr><tr><td>10×</td><td>57.11 ± 0.54</td><td>56.12 ± 0.31</td><td>40.32 ± 0.34</td><td>61.45 ± 0.43</td></tr><tr><td rowspan=\"3\">Caltech-256-60</td><td>2×</td><td>86.27 ± 0.47</td><td>85.84 ± 0.51</td><td>88.02 ± 0.45</td><td>87.15 ± 0.75</td></tr><tr><td>5×</td><td>71.02 ± 0.37</td><td>69.9 ± 0.31</td><td>73.95 ± 0.27</td><td>74.46 ± 0.52</td></tr><tr><td>10×</td><td>61.27 ± 0.49</td><td>39.41 ± 0.71</td><td>26.75 ± 0.50</td><td>70.16 ± 0.53</td></tr><tr><td rowspan=\"3\">CUB-200-2011</td><td>2×</td><td>76.27 ± 0.37</td><td>75.58 ± 0.46</td><td>78.88 ± 0.65</td><td>78.03 ± 0.45</td></tr><tr><td>5×</td><td>66.48 ± 0.37</td><td>64.49 ± 0.31</td><td>73.44 ± 0.27</td><td>73.35 ± 0.52</td></tr><tr><td>10×</td><td>57.88 ± 0.23</td><td>57.13 ± 0.38</td><td>29.57 ± 0.31</td><td>69.07 ± 0.43</td></tr><tr><td rowspan=\"3\">Food-101</td><td>2×</td><td>83.78 ± 0.61</td><td>82.27 ± 0.23</td><td>82.38 ± 0.85</td><td>84.21 ± 0.65</td></tr><tr><td>5×</td><td>73.36 ± 0.33</td><td>70.12 ± 0.71</td><td>73.05 ± 0.64</td><td>79.12 ± 0.52</td></tr><tr><td>10×</td><td>1.6 ± 0.04</td><td>3.56 ± 0.08</td><td>3.85 ± 0.09</td><td>76.95 ± 0.49</td></tr></table>",
+        "bbox": [
+            232,
+            535,
+            764,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For each pruned model, we can compute the number of multiply-accumulate operations (MACs) required to perform inference on an image. For each accelerated convolution, the required number of MACs is $k ^ { 2 } H W C _ { \\mathrm { i n } } C _ { \\mathrm { o u t } }$ , where $C _ { \\mathrm { i n } }$ and $C _ { \\mathrm { o u t } }$ are the number of input and output channels that are not pruned, respectively. We compute the total number of MACs by summing up the MACs in all convolutions, residual connections, and the final pooling and FC layers. For AFS as we dynamically select which channels to evaluate during inference, we additionally add the overhead of the importance predictor layers to the number of total MACs. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd6a2e27c56394e4a566acb3707a5e988496f320dea7be611014fb42b464da28.jpg",
+        "table_caption": [
+            "Table 3: Comparison to related transfer learning methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Method</td><td>Model</td><td>Accuracy</td><td>MACs</td></tr><tr><td rowspan=\"4\">CUB-200-2011</td><td rowspan=\"2\">Zagoruyko &amp; Komodakis (2017)</td><td>ResNet-34</td><td>73.5</td><td>3.6G</td></tr><tr><td>ResNet-18</td><td>73.0</td><td>1.8G</td></tr><tr><td rowspan=\"2\">Jang et al. (2019)</td><td>ResNet-18</td><td>65.05</td><td>1.8G</td></tr><tr><td>ResNet-101</td><td>76.34</td><td>2.4G</td></tr><tr><td rowspan=\"4\">MIT Indoors 67</td><td rowspan=\"2\">AFDS</td><td>ResNet-101</td><td>73.35</td><td>1.9G</td></tr><tr><td>ResNet-34</td><td>74.0</td><td>3.6G</td></tr><tr><td rowspan=\"2\">Zagoruyko &amp; Komodakis (2017) Jang et al. (2019)</td><td>ResNet-18</td><td>72.9</td><td>1.8G</td></tr><tr><td>ResNet-18</td><td>64.85</td><td>1.8G</td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\">AFDS</td><td>ResNet-101</td><td>78.09</td><td>2.4G</td></tr><tr><td>ResNet-101</td><td>74.57</td><td>1.9G</td></tr></table>",
+        "bbox": [
+            236,
+            126,
+            761,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/54d449f402811faa6fb736dad205decbb6120fc9757ea4d3388ed2ebe0b04cb2.jpg",
+        "image_caption": [
+            "Figure 3: MACs and accuracy $\\%$ ) trade-off comparisons among different joint methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            299,
+            785,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3, we present the trade-off relationship between the number of vs. the target dataset accuracies for Stanford Dogs and Caltech-256-60. It is clear that AFDS (ours) exceeds various combinations of pruning methods (NS, SFP) and transfer learning methods ( $L ^ { 2 }$ , $L ^ { 2 }$ -SP, LwF). The results for the remaining datasets can be found in Appendix B. The trade-off curves show that AFDS minimizes accuracy degradation even if 47% of the total MACs are removed from the original model, AFDS resulted in only $1 . 8 3 \\%$ drop in accuracy for the model trained on Stanford Dogs. In extreme cases where we permit only $\\textstyle { \\frac { 1 } { 1 0 } }$ of the original computations, our method can still manage abstantially better when compared to other pruning algorithm $7 0 . 7 0 \\%$ accuracrops to ch is and $1 . 3 3 \\%$ SFP only has $5 9 . 6 3 \\%$ . ",
+        "bbox": [
+            174,
+            532,
+            825,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1 provide numerical comparisons of different pruning methods against AFS under various speed-up constraints. Table 2 similarly compares transfer learning strategies against AFD. Under most acceleration requirements, the combined method, AFDS, achieves the best accuracies on the target datasets. Finally, Table 3 compares AFDS against other literatures that performs transfer learning. AFDS can achieve state-of-the-art accuracies when compared to methods that produce models with similar number of MACs. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            320,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced attentive feature distillation and selection (AFDS), a dualattention method that aims to reap the advantages of transfer learning and channel pruning methods. By applying AFDS during fine-tuning, we can not only learn a new model with a higher target task accuracy, but also further accelerates it by computing a subset of channel neurons in each convolutional layers. Under a wide range of datasets, we demonstrated the smallest drop in validation accuracies under the same speed-up constraints when compared to traditional compression methods such as network slimming (Liu et al., 2017) and soft filter pruning (He et al., 2018). ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            369,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is supported in part by National Key R&D Program of China (No. 2019YFB2102100), Science and Technology Development Fund of Macao S.A.R (FDCT) under number 0015/2019/AKP, Shenzhen Discipline Construction Project for Urban Computing and Data Intelligence, the National Natural Science Foundation of China (Nos. 61806192, 61802387), Shenzhen Science and Technology Innovation Commission (No. JCYJ2017081853518789, JCYJ20190812160003719), the Guangdong Science and Technology Plan Guangdong-Hong Kong Cooperation Innovation Platform (No. 2018B050502009), and China’s Post-doctoral Science Fund (No. 2019M663183). ",
+        "bbox": [
+            174,
+            133,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            266,
+            289,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 2270–2278. 2016. ",
+        "bbox": [
+            176,
+            290,
+            821,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hossein Azizpour, Ali Sharif Razavian, Josephine Sullivan, Atsuto Maki, and Stefan Carlsson. From generic to specific deep representations for visual recognition. In Proceedings of the 2015 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’15, pp. 36–45, 2015. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tolga Bolukbasi, Joseph Wang, Ofer Dekel, and Venkatesh Saligrama. Adaptive neural networks for efficient inference. In Proceedings of the 34th International Conference on Machine Learning (ICML), pp. 527–536, 2017. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101 – mining discriminative components with random forests. In European Conference on Computer Vision, 2014. ",
+        "bbox": [
+            171,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhaowei Cai and Nuno Vasconcelos. Cascade R-CNN: Delving into high quality object detection. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 6154–6162, 2018. ",
+        "bbox": [
+            174,
+            503,
+            821,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yves Chauvin. A back-propagation algorithm with optimal use of hidden units. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 1, pp. 519–526. Morgan-Kaufmann, 1989. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A largescale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, June 2009. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A deep convolutional activation feature for generic visual recognition. In Eric P. Xing and Tony Jebara (eds.), Proceedings of the 31st International Conference on Machine Learning, volume 32 of Proceedings of Machine Learning Research, pp. 647–655, Bejing, China, 22–24 Jun 2014. PMLR. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xin Dong, Shangyu Chen, and Sinno Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 4857–4867. Curran Associates, Inc., 2017a. ",
+        "bbox": [
+            173,
+            747,
+            825,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong, Junshi Huang, Yi Yang, and Shuicheng Yan. More is less: A more complicated network with less inference complexity. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017b. ",
+        "bbox": [
+            174,
+            814,
+            823,
+            857
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Figurnov, Maxwell D. Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xitong Gao, Yiren Zhao, Lukasz Dudziak, Robert Mullins, and Cheng-zhong Xu. Dynamic channel pruning: Feature boosting and suppression. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. Technical report, 2007. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient DNNs. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            193,
+            821,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi, David G. Stork, and Gregory Wolff. Optimal brain surgeon: Extensions and performance comparisons. In J. D. Cowan, G. Tesauro, and J. Alspector (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 263–270. 1994. ",
+        "bbox": [
+            176,
+            231,
+            821,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 1026– 1034, Washington, DC, USA, 2015. IEEE Computer Society. ISBN 978-1-4673-8391-2. doi: 10.1109/ICCV.2015.123. ",
+        "bbox": [
+            173,
+            282,
+            825,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            362,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In International Joint Conference on Artificial Intelligence (IJCAI), pp. 2234–2240, 2018. ",
+        "bbox": [
+            174,
+            415,
+            823,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017. ",
+        "bbox": [
+            171,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. Advances in neural information processing systems 2014, Deep Learning Workshop, 2014. ",
+        "bbox": [
+            173,
+            503,
+            821,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 448–456. JMLR.org, 2015. URL http://dl.acm.org/citation.cfm?id=3045118.3045167. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunhun Jang, Hankook Lee, Sung Ju Hwang, and Jinwoo Shin. Learning what and where to transfer. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 3030–3039, Long Beach, California, USA, 09–15 Jun 2019. PMLR. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Khosla, Nityananda Jayadevaprakash, Bangpeng Yao, and Li Fei-Fei. Novel dataset for fine-grained image categorization. In First Workshop on Fine-Grained Visual Categorization, IEEE Conference on Computer Vision and Pattern Recognition, Colorado Springs, CO, June 2011. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems (NIPS), pp. 598–605. 1990. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, and Jun Huan. DELTA: Deep learning transfer using feature map with attention for convolutional networks. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuhong Li, Yves Grandvalet, and Franck Davoine. Explicit inductive bias for transfer learning with convolutional networks. Thirty-fifth International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, Dec 2018. ISSN 0162-8828. doi: 10.1109/TPAMI.2017.2773081. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ji Lin, Yongming Rao, Jiwen Lu, and Jie Zhou. Runtime neural pruning. In Advances in Neural Information Processing Systems (NIPS), pp. 2181–2191. 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            179,
+            142,
+            820,
+            186
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. ThiNet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision, pp. 5058–5066, 2017. ",
+        "bbox": [
+            176,
+            196,
+            823,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 1, pp. 107–115. Morgan-Kaufmann, 1989. ",
+        "bbox": [
+            173,
+            251,
+            823,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009. ",
+        "bbox": [
+            171,
+            304,
+            823,
+            334
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 413–420, June 2009. doi: 10.1109/CVPR.2009.5206537. ",
+        "bbox": [
+            174,
+            343,
+            823,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features off-the-shelf: An astounding baseline for recognition. In Proceedings of the 2014 IEEE Conference on Computer Vision and Pattern Recognition Workshops, CVPRW ’14, pp. 512–519, Washington, DC, USA, 2014. IEEE Computer Society. ISBN 978-1-4799- 4308-1. doi: 10.1109/CVPRW.2014.131. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "R. Reed. Pruning algorithms–a survey. IEEE Transactions on Neural Networks, 4(5):740– 747, Sep. 1993. doi: 10.1109/72.248452. ",
+        "bbox": [
+            171,
+            478,
+            823,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Andrei Pokrovsky, Bin Yang, and Raquel Urtasun. SBNet: Sparse blocks network for fast inference. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            171,
+            518,
+            825,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards realtime object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-ofexperts layer. 2017. ",
+        "bbox": [
+            174,
+            626,
+            821,
+            670
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan and Quoc Le. EfficientNet: Rethinking model scaling for convolutional neural networks. In International Conference on Machine Learning, pp. 6105–6114, 2019. ",
+        "bbox": [
+            171,
+            679,
+            823,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            719,
+            823,
+            763
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011. ",
+        "bbox": [
+            174,
+            773,
+            823,
+            816
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B. P. Welford. Note on a method for calculating corrected sums of squares and products. Technometrics, 4(3):419–420, 1962. ISSN 00401706. URL http://www.jstor.org/ stable/1266577. ",
+        "bbox": [
+            173,
+            827,
+            821,
+            869
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2074–2082. 2016. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zuxuan Wu, Tushar Nagarajan, Abhishek Kumar, Steven Rennie, Larry S. Davis, Kristen Grauman, and Rogerio Feris. BlockDrop: Dynamic inference paths in residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-lessinformative assumption in channel pruning of convolution layers. 2018. ",
+        "bbox": [
+            173,
+            167,
+            821,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7130–7138, July 2017. doi: 10.1109/CVPR.2017.754. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 3320–3328. Curran Associates, Inc., 2014. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            378
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. ICNet for realtime semantic segmentation on high-resolution images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 405–420, 2018. ",
+        "bbox": [
+            176,
+            386,
+            825,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhuangwei Zhuang, Mingkui Tan, Bohan Zhuang, Jing Liu, Yong Guo, Qingyao Wu, Junzhou Huang, and Jinhui Zhu. Discrimination-aware channel pruning for deep neural networks. In Advances in Neural Information Processing Systems, pp. 875–886, 2018. ",
+        "bbox": [
+            176,
+            436,
+            825,
+            479
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A The Overall Training Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            550,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Algorithm 1 we illustrate the complete training procedure described above. Here, the function takes as input the target training dataset $\\mathcal { D }$ , the source model $f$ and its parameters $\\theta ^ { \\star }$ , the total number of steps to fine-tune $S$ , the initial learning rate $\\alpha$ , and the threshold hyperparameters $\\delta _ { \\mathrm { s } }$ and $\\delta _ { \\mathrm { m } }$ respectively for $\\mathbf { s } _ { l }$ and $\\mathbf { I I I }$ . The function returns the optimized parameters $\\pmb { \\theta }$ for the target dataset, and both constant masks for all layers $\\mathbf { s } = ( \\mathbf { s } _ { 1 } , \\mathbf { s } _ { 2 } , \\ldots , \\mathbf { s } _ { L } )$ and $\\mathbf { m } = \\left( \\mathbf { m } _ { 1 } , \\mathbf { m } _ { 2 } , \\ldots , \\mathbf { m } _ { L } \\right)$ . The function SGD then fine-tunes the model parameters. For each layer $\\it { \\Delta } l$ , we compute the mean $\\pmb { \\mu } _ { l }$ and variance $\\sigma _ { \\mathit { l } }$ statistics of $q _ { l } ( \\pmb { x } _ { l - 1 } )$ , and use it to compute $\\mathbf { s } _ { l }$ . ",
+        "bbox": [
+            173,
+            535,
+            825,
+            647
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d1c9d0707dd3601122d3d99b4e0949b4ab5d360b7212af049bfe1baaff9ff6d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 1 Training Procedure</td></tr><tr><td>1: function AFDS(D,f,0*,S,α,δs,δm)</td></tr><tr><td>2: forl∈L:st←1</td></tr><tr><td>3: forl∈L:m ←1</td></tr><tr><td>4: 0 ← SGD(D,f,0*,s,m,「],a,R) 5: forl∈Ldo</td></tr><tr><td>6: μ ←E(x,y)~D[q(xl-1)]</td></tr><tr><td>7: σ²←E(,y)~D[(q(xl-1）-μt)²]</td></tr><tr><td>8: Pl ←E(χ,y)~D[πt(xl-1) &gt;0]</td></tr><tr><td>9: st←σ²&gt;δs</td></tr><tr><td>10:</td></tr><tr><td>Y←μ 11: m ←p&gt;δm</td></tr><tr><td>end for</td></tr><tr><td>12:</td></tr><tr><td>13: 0 ← SGD(D,f,0,s,m,「2],1,R)</td></tr><tr><td>14: return 0,s,m</td></tr><tr><td>15: :end function</td></tr></table>",
+        "bbox": [
+            336,
+            676,
+            656,
+            914
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/197b538790b49855ed0dac130f6f7382640fe64ee680053e799e991fa6266aa0.jpg",
+        "image_caption": [
+            "Figure 4: MACs and accuracy $\\%$ ) trade-off comparisons among different joint methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            137,
+            789,
+            497
+        ],
+        "page_idx": 13
+    }
+]