Add files using upload-large-folder tool

parse/train/Bke6vTVYwH/Bke6vTVYwH.md

@@ -0,0 +1,291 @@
+# GRAPH CONVOLUTIONAL NETWORKS FOR LEARNING WITH FEW CLEAN AND MANY NOISY LABELS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In this work we consider the problem of learning a classifier from noisy labels when a few clean labeled examples are given. The structure of clean and noisy data is modeled by a graph per class and Graph Convolutional Networks (GCN) are used to predict class relevance of noisy examples. For each class, the GCN is treated as a binary classifier learning to discriminate clean from noisy examples using a weighted binary cross-entropy loss function, and then the GCN-inferred “clean” probability is exploited as a relevance measure. Each noisy example is weighted by its relevance when learning a classifier for the end task. We evaluate our method on an extended version of a few-shot learning problem, where the few clean examples of novel classes are supplemented with additional noisy data. Experimental results show that our GCN-based cleaning process significantly improves the classification accuracy over not cleaning the noisy data and standard few-shot classification where only few clean examples are used. The proposed GCN-based method outperforms the transductive approach (Douze et al., 2018) that is using the same additional data without labels.
+
+# 1 INTRODUCTION
+
+State-of-the-art deep learning methods require a large amount of manually labeled data. The need for supervision may be reduced by decoupling representation learning from the end task and/or using additional training data that are unlabeled, weakly labeled (with noisy labels), or belong to different domains or classes. Example approaches are transfer learning (Wang & Gupta, 2015), unsupervised representation learning (Wang & Gupta, 2015), semi-supervised learning (Weston et al., 2008), learning from noisy labels (Joulin et al., 2016) and few-shot learning (Snell et al., 2017).
+
+Learning from noisy labels allows using large-scale data and labels from the web without human annotation effort. Most work focuses on learning the representation jointly with the end task, assuming there is still a considerable amount of clean labeled data (Patrini et al., 2017; Lee et al., 2018; Li et al., 2017). However, for a number of classes only very few or even no clean labeled examples might be available at the representation learning stage. Few-shot learning limits the labeled data to very few on the end task, while the representation is learned on a large training set of different classes (Hariharan & Girshick, 2017; Snell et al., 2017; Vinyals et al., 2016). Nevertheless, in many situations, more data with noisy labels are available or can be acquired for the end task.
+
+One interesting mix of few-shot learning with additional large-scale data is the work of Douze et al. (2018), where labels are propagated from few clean labeled examples to a large-scale collection. This collection is unlabeled and actually contains data of many more classes than the end task. Their method overall improves the classification accuracy, but at an additional computational cost; it is a transductive method, i.e., instead of learning a parametric classifier, the large-scale collection is still necessary at inference.
+
+In this work, we learn a classifier from few clean labeled examples and additional weakly labeled data, while the representation is learned on different classes, as in few-shot learning. We assume the class names are known, and we use them to search an existing large collection of images with textual description. The result is a set of images with potentially relevant, but noisy labels. As shown in Figure 1, we clean this data using a graph convolutional network (GCN) (Kipf & Welling, 2017), which learns to predict a class relevance score per image based on the source (clean vs. noisy) of its connections in the graph. Both the clean and the noisy images are then used to learn a classifier, where the noisy examples are weighted by relevance. Unlike most existing work, our method operates independently per class and applies when clean labeled examples are few or even one per class.
+
+![](images/7eed9d45df54f8a4f9857ca30afe31d8710a4404ec6cdacce1d0af912c397be2.jpg)  
+Figure 1: Overview of our cleaning approach for 1-shot learning with noisy examples. We use the class name admiral to crawl noisy images from web and create an adjacency graph based on visual similarity. We then assign a relevance score to each noisy example with a graph convolutional network (GCN). Relevance scores are displayed next to the images.
+
+We make the following contributions:
+
+• We learn a classifier on a large-scale weakly-labeled collection jointly with only few clean labeled examples.   
+• To our knowledge, we are the first to use a GCN to clean noisy data: we cast a GCN as a binary classifier learning to discriminate clean from noisy data, and we use its inferred probabilities for the “clean” class as a relevance score per example.   
+We apply our method to a few-shot learning benchmark and show significant improvement in accuracy, while outperforming the method by Douze et al. (2018) using the same large-scale collection of data.
+
+# 2 RELATED WORK
+
+Learning with noisy labels is often concerned with estimating or learning a transition matrix (Natarajan et al., 2013; Patrini et al., 2017; Sukhbaatar et al., 2014) or knowledge graph (Li et al., 2017) between labels and correcting the loss function, which does not apply in our case since the classes in the noisy data are unknown. Most recent work on learning from large-scale weakly-labeled data focuses on learning the representation e.g. by metric learning (Lee et al., 2018; Wang et al., 2018a), bootstrapping (Reed et al., 2015), or distillation (Li et al., 2017). In our case however, since the clean labeled examples are few, we need to keep the representation mostly fixed.
+
+Dealing with the noise, e.g. by thresholding (Lee et al., 2018), outlier detection (Wang et al., 2018a) or reweighting (Liu & Tao, 2015), is applicable while the representation is learned, based e.g. on the gradient of the loss (Ren et al., 2018b). In contrast, the relatively-shallow GCN that we propose effectively decouples reweighting from both representation learning and classifier learning. Learning to clean the noisy labels (Veit et al., 2017) typically assumes adequate human verified labels for training, which again is not the case in this work.
+
+Few-shot learning. Meta-learning (Vilalta & Drissi, 2002) refers to learning at two levels, where generic knowledge is acquired before adapting to more specific tasks. In few-shot learning, this translates to learning on a set of base classes how to learn from few examples on a distinct set of novel classes without overfitting. For instance, optimization meta-learning (Finn et al., 2017; 2018; Ravi & Larochelle, 2017) amounts to learning a model that is easy to fine-tune in few steps. In our work, we study an extension of few-shot learning where more data are available on novel classes, reducing the risk of overfitting when fine-tuning the model. Metric learning approaches learn how to compare queries for instance to few examples (Vinyals et al., 2016) or to the corresponding class prototypes (Snell et al., 2017). Hariharan & Girshick (2017) and Wang et al. (2018b) learn how to generate novel-class examples, which is not needed when more data are actually available.
+
+Gidaris & Komodakis (2018) learn on base classes a simpler cosine similarity-based parametric classifier, or simply cosine classifier, without meta-learning. The same classifier has been introduced independently by Qi et al. (2018), who further fine-tune the network, assuming access to the base class training set. A recent survey (Chen et al., 2019) confirms the superiority of the cosine classifier to previous work including meta-learning (Finn et al., 2017). We use the cosine classifier in this work, both for base and novel classes. All of the above use only the few labeled examples of the novel classes.
+
+Making use of unlabeled data has been little explored in few-shot learning until recently. Ren et al. (2018a) introduce a semi-supervised few-shot classification task, where some labels are unknown. Liu et al. (2019) follow the same semi-supervised setup, but use graph-based label propagation (LP) (Zhou et al., 2003a) for classification and consider jointly all test images. These methods assume a meta-learning scenario, where only small-scale data is available at each training episode; arguably, such a small amount of data limits the representation adaptation and generalization to unseen data. Similarly, Rohrbach et al. (2013) use label propagation in a transductive setting, but at a larger scale assuming that all examples come from a set of known classes. Douze et al. (2018) extend to even larger scale, leveraging 100M unlabeled images in a graph without using additional text information. We focus on the latter large-scale scenario using the same 100M dataset. However, we filter by text to obtain noisy labels and follow an inductive approach by training a classifier for novel classes, such that the 100M collection is not needed at inference.
+
+Graph neural networks are generalizations of convolutional networks to non-Euclidean spaces (Bronstein et al., 2017). Early spectral methods (Bruna et al., 2014; Henaff et al., 2015) have been succeeded by Chebyshev polynomial approximations (Defferrard et al., 2016), which avoid the high computational cost of computing eigenvectors. Graph convolutional networks (GCN) (Kipf & Welling, 2017) provide a further simplification by a first-order approximation of graph filtering and are applied to semi-supervised (Kipf & Welling, 2017) and subsequently to few-shot learning (Garcia & Bruna, 2018). In Kipf & Welling (2017), the loss function is applied to labeled examples to make predictions on unlabeled ones. Similarly in Garcia & Bruna (2018), GCNs make predictions on novel class examples. Gidaris & Komodakis (2019) use Graph Neural Networks as denoising autoencoders to generate class weights for novel classes. In contrast, we cast GCNs as binary classifiers discriminating clean from noisy examples: we apply a loss function to all examples, and then use the inferred probabilities as a class relevance measure, effectively cleaning the data.
+
+Our counter-intuitive objective of treating all noisy examples as negative can be compared to treating each example as a different class in instance-level discrimination (Wu et al., 2018). In fact, our loss function is similar to noise-contrastive estimation (NCE) (Gutmann & Hyvärinen, 2010) used in that work. According to our experiments, our GCN-based classifier outperforms classical LP (Zhou et al., 2003a) used for a similar purpose by Rohrbach et al. (2013).
+
+# 3 PROBLEM FORMULATION
+
+We consider a space $\mathcal { X }$ of examples. We are given a set $X _ { \mathcal { L } } \subset \mathcal { X }$ of examples, each having a clean (manually verified) label in a set $C _ { \mathcal { L } }$ of classes with $| C _ { \mathcal { L } } | = K _ { \mathcal { L } }$ . For any set $X \subset { \mathcal { X } }$ , we denote by $X ^ { c }$ its subset of examples having a label in class $c$ . We assume that the number $| X _ { \mathcal { L } } ^ { c } |$ of examples labeled in each class $c \in C _ { \mathcal { L } }$ is only $k$ , typically in $\{ 1 , 2 , 5 , 1 0 , 2 0 \}$ . We are also given an additional set $X _ { \mathcal { Z } } ^ { c }$ of examples, each with a set of noisy labels in $C _ { \mathcal { L } }$ . The extended set of examples for class $c$ is now $X _ { \mathcal { E } } ^ { c } = X _ { \mathcal { L } } ^ { c } \cup X _ { \mathcal { Z } } ^ { c }$ . Examples or sets of examples having clean (noisy) labels are referred to as clean (noisy) as well. The goal is to train a classifier, using the additional noisy set in order to improve the accuracy compared to only using the small clean set.
+
+We assume that we are given a feature extractor $g _ { \theta } : \mathcal { X }  \mathbb { R } ^ { d }$ , mapping an example to a $d .$ -dimensional vector. For instance, when examples are images, the feature extractor is typically a convolutional neural network (CNN) and $\theta$ are the parameters of all layers.
+
+In this work, we assume that the noisy set $X z$ is collected via web crawling with examples that are images accompanied with free-form text description and/or user tags originating from community photo collections. To make use of text data, we assume that the names of classes in $C _ { \mathcal { L } }$ are given. An example in $X z$ is given a label in class $c \in C _ { \mathcal { L } }$ if its textual information contains the name of class $c$ ; it may then have none, one or more labels. In this way, we automatically infer labels for $X z$ without human effort, which are however noisy.
+
+We perform cleaning by predicting a class relevance measure for each noisy example in $X _ { \mathcal { Z } } ^ { c }$ , independently per class $c \in C _ { \mathcal { L } }$ . To simplify notation, we drop superscript $c$ where possible in this subsection and we denote $X _ { \mathcal { E } } ^ { c }$ by $\left\{ x _ { 1 } , \ldots , x _ { k } , x _ { k + 1 } , \ldots , x _ { N } \right\}$ , where $X _ { \mathcal { L } } ^ { c } ~ = ~ \{ \bar { x _ { 1 } } , \ldots , x _ { k } \}$ and $X _ { \mathcal { Z } } ^ { c } = \{ x _ { k + 1 } , \ldots , x _ { N } \}$ . The features of these examples are similarly represented by matrix $V = [ \ b { \mathrm { v } } _ { 1 } , \ b { \mathrm { ~ . ~ . ~ . ~ } } , \ b { \mathrm { v } } _ { k } , \ b { \mathrm { v } } _ { k + 1 } , \ b { \mathrm { ~ . ~ . ~ . ~ } } , \ b { \mathrm { v } } _ { N } ] \in \mathbb { R } ^ { d \times N }$ , where $\mathbf { v } _ { i } = g _ { \theta } ( x _ { i } )$ for $i = 1 , \ldots , N$ .
+
+We construct an affinity matrix $A \in \mathbb { R } ^ { N \times N }$ with elements $a _ { i j } = [ \mathbf { v } _ { i } ^ { \top } \mathbf { v } _ { j } ] _ { + }$ if examples $\mathbf { v } _ { i }$ and $\mathbf { v } _ { j }$ are reciprocal nearest neighbors in $X _ { \mathcal { E } } ^ { c }$ and 0 otherwise. Matrix $A$ has zero diagonal, but self-connections are added and then $A$ is normalized as $\tilde { A } = D ^ { - 1 } ( A + I )$ with $D = \mathrm { d i a g } ( ( A + I ) \mathbf { 1 } )$ being the degree matrix of $A + I$ and 1 the all-ones vector.
+
+Graph convolutional networks (GCNs) (Kipf & Welling, 2017) are formed by a sequence of layers. Each layer is a function $f _ { \Theta } : \mathbb { R } ^ { \hat { N } \times N } \times \mathbb { R } ^ { l \times \hat { N } }  \mathbb { R } ^ { n \times \hat { N } }$ of the form
+
+$$
+f _ { \Theta } ( \tilde { A } , Z ) = h ( \Theta ^ { \top } Z \tilde { A } ) ,
+$$
+
+where $Z \in \mathbb { R } ^ { l \times N }$ represents the input features, $\boldsymbol { \Theta } \in \mathbb { R } ^ { l \times n }$ holds the parameters of the layer to be learned, and $h$ is a nonlinear activation function. Function $f _ { \Theta }$ maps $l$ -dimensional input features to $n$ -dimensional output features.
+
+In this work we consider a two layer GCN with a scalar output per example. This network is a function $F _ { \Theta } : \mathbb { R } ^ { N \times N } \times \mathbb { R } ^ { d \times N }  \bar { \mathbb { R } } ^ { N }$ given by
+
+$$
+F _ { \Theta } ( \tilde { A } , V ) = \sigma ( \Theta _ { 2 } ^ { \top } [ \Theta _ { 1 } ^ { \top } V \tilde { A } ] _ { + } \tilde { A } ) ,
+$$
+
+where $\Theta = \{ \Theta _ { 1 } , \Theta _ { 2 } \}$ , $\Theta _ { 1 } \in \mathbb { R } ^ { d \times m }$ , $\Theta _ { 2 } \in \mathbb { R } ^ { m \times 1 }$ , $[ \cdot ] _ { + }$ is the positive part or ReLU function (Nair & Hinton, 2010) and $\bar { \sigma ( } x ) = ( 1 + e ^ { - x } ) ^ { - 1 }$ for $x \in \mathbb { R }$ is the sigmoid function. Function $F _ { \Theta }$ performs feature propagation through the affinity matrix in an analogy to classical graph-based propagation methods for classification (Zhou et al., 2003a) or search (Zhou et al., 2003b).
+
+The output $F _ { \Theta } ( \tilde { A } , V )$ is a vector of length $N$ , with element $F _ { \Theta } ( { \tilde { A } } , V ) _ { i }$ in $[ 0 , 1 ]$ representing a relevance value of example $x _ { i }$ for class $c$ . To learn the parameters $\Theta$ , we treat the GCN as a binary classifier where target output 1 corresponds to clean examples and 0 to noisy. In particular, we minimize the loss function
+
+$$
+L _ { \mathcal { G } } ( V , \tilde { A } ; \Theta ) = - \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \log \left( F _ { \Theta } ( \tilde { A } , V ) _ { i } \right) - \frac { \lambda } { N - k } \sum _ { i = k + 1 } ^ { N } \log \left( 1 - F _ { \Theta } ( \tilde { A } , V ) _ { i } \right) .
+$$
+
+This is a binary cross-entropy loss function where noisy examples are given an importance weight $\lambda$ . Given the propagation on the nearest neighbor graph, and depending on the relative importance $\lambda$ of the second term, noisy examples that are strongly connected to clean ones are still expected to receive high class relevance, while noisy examples that are not relevant to the current class are expected to get a class relevance near zero.
+
+The impact of parameter $\lambda$ is validated in Section 6, where we show that the fewer the available clean images are (smaller $k$ ) the smaller the importance weight should be. As is standard practice for GCNs in classification (Kipf & Welling, 2017), training is performed in batches of size $N$ , that is the entire set of features.
+
+Figure 2 shows examples of clean images, corresponding noisy ones and the predicted relevance. Thanks to the visual similarity to the clean image, we can use relevance to resolve cases of polysemy, e.g. black widow (spider) vs. black widow (superhero), or cases like pineapple vs. pineapple juice.
+
+Discussion. Loss function (3) is similar to noise-contrastive estimation (NCE) (Gutmann & Hyvärinen, 2010) as used by Wu et al. (2018) for instance-level discrimination, whereas we discriminate clean from noisy examples. The semi-supervised learning setup of GCNs (Kipf & Welling, 2017) uses a loss function that applies only to the labeled examples, and makes discrete predictions on unlabeled examples. In our case, all examples contribute to the loss but with different importance, while we infer real-valued class relevance for the noisy examples, to be used for subsequent learning.
+
+Function $F _ { \Theta }$ in (2) reduces to a Multi-Layer Perceptron (MLP) when the affinity matrix $A$ is zero, in which case all examples are disconnected. Using an MLP to perform cleaning would take each example into account independently of the others, while the GCN considers the collection of examples as a whole. MLP training is performed identically to GCN by minimizing (3). We compare the two alternatives in our experiments.
+
+![](images/d562245fb1728f832564e87b5ff05688b13eb6f98c403180ec263fd140ddad27.jpg)  
+Figure 2: Examples of clean images (left) for 1-shot classification, cumulative histogram of the predicted relevance for noisy images (middle), and representative noisy images (right), each having its position in the (descending) ranked list according to relevance and relevance value reported below. Test accuracy without and with additional data using class prototypes (6) is shown next to class names.
+
+# 5 LEARNING A CLASSIFIER WITH FEW CLEAN AND MANY NOISY EXAMPLES
+
+Our cleaning process applies when the clean labeled examples are few, but assumes a feature extractor $g _ { \theta }$ . That is, representation learning, label cleaning and classifier learning are decoupled. We follow few-shot learning in that we learn the representation by supervised classification on a set of base classes, obtaining $g _ { \theta }$ , and then solving new classification tasks on a distinct set of novel classes. In these new tasks, we assume few clean and many noisy labels as specified in Section 3, perform GCN-based cleaning as described in Section 4, and learn a classifier by weighing examples according to class relevance. Representation and classifier learning are described below.
+
+# 5.1 COSINE-SIMILARITY BASED CLASSIFIER
+
+We use a cosine-similarity based classifier (Gidaris & Komodakis, 2018; Qi et al., 2018), or cosine classifier for short. Given classes $C$ with $| C | = K$ , each class $c \in C$ is represented by a learnable parameter $\mathbf { w } _ { c } \in \mathbb { R } ^ { d }$ . The prediction of example $x \in \mathcal { X }$ is the class $c$ of maximum cosine similarity $\hat { \mathbf { w } } _ { c } ^ { \top } \hat { g } _ { \boldsymbol { \theta } } ( x ) ^ { 1 }$
+
+$$
+\pi _ { \boldsymbol { \theta } , W } ( x ) = \arg \operatorname* { m a x } _ { c } \hat { \mathbf { w } } _ { c } ^ { \top } \hat { g } _ { \boldsymbol { \theta } } ( x ) ,
+$$
+
+where $W = [ \mathbf { w } _ { 1 } , \ j . . . , \mathbf { w } _ { K } ] \in \mathbb { R } ^ { d \times K }$ .
+
+# 5.2 REPRESENTATION LEARNING: BASE CLASSES
+
+We are given a set $X _ { B } \subset { \mathcal { X } }$ of examples, each having a clean label in a set of base classes $C _ { B }$ with $| C _ { B } | = K _ { B }$ . These data are used to learn a feature representation, i.e. a feature extractor $g _ { \theta }$ , by learning a $K _ { B }$ -way base-class classifier for unseen data in $\mathcal { X }$ . The parameters $\theta$ of the feature extractor and $W _ { B }$ of the classifier are jointly learned by minimizing the cross entropy loss
+
+$$
+{ \cal L } _ { \mathcal B } ( C _ { \mathcal B } , X _ { \mathcal B } ; \boldsymbol { \theta } , W _ { \mathcal B } ) = - \sum _ { c \in C _ { \mathcal B } } \frac { 1 } { | X _ { \mathcal B } ^ { c } | } \sum _ { x \in X _ { \mathcal B } ^ { c } } \log ( \sigma ( s \hat { W } _ { \mathcal B } ^ { \top } \hat { g } _ { \boldsymbol \theta } ( x ) ) _ { c } ) ,
+$$
+
+where $\sigma : \mathbb { R } ^ { K }  \mathbb { R } ^ { K }$ is the softmax function with $\pmb { \sigma } ( \mathbf { a } ) _ { c } = e ^ { a _ { c } } / \sum _ { j \in C } e ^ { a _ { j } }$ for $\mathbf { a } \in \mathbb { R } ^ { K }$ , $s$ is a learnable scale parameter and $\hat { W } _ { \mathcal { B } } = [ \hat { \mathbf { w } } _ { 1 } , \hdots , \hat { \mathbf { w } } _ { K _ { \mathcal { B } } } ] \in \mathbb { R } ^ { d \times K _ { \mathcal { B } } }$ . Learning and inference are
+
+performed on base classes by $L _ { B } ( C _ { B } , X _ { B } ; \theta , W _ { B } )$ (5) and $\pi _ { \boldsymbol { \theta } , W _ { B } }$ (4), respectively. As a result, learned feature extractor parameters $\theta$ are used for base or novel classes, while the classifier parameters $W _ { B }$ can be used for base class or all-class classification, as discussed below.
+
+# 5.3 NEW CLASSIFICATION TASKS: NOVEL OR ALL CLASSES
+
+Each new task is related to a set of novel classes $C _ { \mathcal { L } }$ , disjoint from $C _ { B }$ . The goal is to learn a $K _ { \mathcal { L } }$ -way novel-class classifier or a $K _ { A }$ -way classifier on all classes $C _ { A } = C _ { B } \cup C _ { \mathcal { L } }$ for unseen data in $\mathcal { X }$ , where $K _ { \mathcal { A } } = K _ { B } + K _ { \mathcal { L } }$ . Unlike the typical few-shot learning task, each novel class contains few clean and many noise examples.
+
+Prior to learning classifiers for novel classes, training examples $x _ { i } \in X _ { \mathcal { Z } } ^ { c }$ are weighted by their relevance $r ( x _ { i } )$ to class $c$ . For a noisy example $x _ { i } \in X _ { \mathcal { E } } ^ { c }$ , we define $r ( x _ { i } ) = F _ { \Theta } ( \tilde { A } , V ) _ { i }$ where $F _ { \Theta } ( \tilde { A } , V )$ is the output vector of the GCN, while for a clean example $x _ { i } \in X _ { \mathcal { L } } ^ { c }$ we fix $r ( x _ { i } ) = 1$ Note that optimizing (3) does not guarantee $F _ { \Theta } ( \tilde { A } , V ) _ { i } = 1$ for clean examples $x _ { i } \in X _ { \mathcal { L } } ^ { c }$ . We define $\textstyle r ( X ) = \sum _ { x \in X } r ( x )$ for any set $X \subset { \mathcal { X } }$ .
+
+We first assume that we no longer have access to examples of base classes in new classification tasks and consider two different classifiers, class prototypes and cosine-similarity based classifier. Then, this assumption is dropped and the classifier and feature representation are learned jointly by fine-tuning the entire network.
+
+Class prototypes. For each novel class $c \in C _ { \mathcal { L } }$ , we define prototype ${ \bf w } _ { c }$ by
+
+$$
+\mathbf { w } _ { c } = \frac { 1 } { r ( X _ { \mathcal { E } } ^ { c } ) } \sum _ { x \in X _ { \mathcal { E } } ^ { c } } r ( x ) g _ { \theta } ( x ) .
+$$
+
+Prototypes are fixed vectors, not learnable parameters. Collecting them into matrix $\begin{array} { r l } { W _ { \mathcal { L } } } & { { } = } \end{array}$ $[ \mathbf { w } _ { 1 } , \dots , \mathbf { w } _ { K _ { \mathcal { L } } } ] \in \mathbb { R } ^ { d \times K _ { \mathcal { L } } }$ , $K _ { \mathcal { L } }$ -way prediction on novel classes is made by classifier $\pi _ { \boldsymbol { \theta } , W _ { \mathcal { L } } }$ (4), while $K _ { A }$ -way prediction on all (base and novel) classes by $\pi _ { \boldsymbol { \theta } , W _ { A } }$ , where $W _ { \mathcal { A } } = [ W _ { B } , W _ { \mathcal { L } } ]$ and $W _ { B }$ is learned according to $L _ { B } ( C _ { B } , X _ { B } ; \theta , W _ { B } )$ (5) and then kept fixed.
+
+Cosine classifier learning. Similarly to Section 5.2, given clean and noisy novel-class examples $X _ { \mathcal { E } }$ , we learn a parametric cosine classifier with parameters $W _ { \mathcal { L } } = [ \mathbf { w } _ { 1 } , \dots , \mathbf { w } _ { K _ { \mathcal { L } } } ] \in \mathbb { R } ^ { d \times K _ { \mathcal { L } } }$ by minimizing the weighted cross entropy loss $L _ { \mathcal { L } } ( C _ { \mathcal { L } } , X _ { \mathcal { E } } ; \theta , W _ { \mathcal { L } } )$ over $W _ { \mathcal { L } }$ , where
+
+$$
+L _ { \mathcal { L } } ( C _ { \mathcal { L } } , X _ { \mathcal { E } } ; \theta , W _ { \mathcal { L } } ) = - \sum _ { c \in C _ { \mathcal { L } } } \frac { 1 } { r ( X _ { \mathcal { E } } ^ { c } ) } \sum _ { x \in X _ { \mathcal { E } } ^ { c } } r ( x ) \log ( \sigma ( s \hat { W } _ { \mathcal { L } } ^ { \top } \hat { g } _ { \theta } ( x ) ) _ { c } ) ,
+$$
+
+while the parameters $\theta$ of the feature extractor are fixed. The scale parameter $s$ is also fixed to the value obtained during base class learning. Prediction on novel only or all classes is then made as in the previous case.
+
+Deep network fine-tuning. We now drop the assumption that base class examples are not accessible and, given all examples $X _ { \mathcal { A } } = X _ { \mathcal { B } } \cup X _ { \mathcal { E } }$ , we jointly learn the parameters $\theta$ of the feature extractor and $W _ { \mathcal { A } } = ( W _ { B } , W _ { \mathcal { L } } )$ of the $K _ { A }$ -way cosine classifier for all classes by minimizing loss function
+
+$$
+L _ { A } ( C _ { A } , X _ { A } ; \theta , W _ { A } ) = L _ { B } ( C _ { B } , X _ { B } ; \theta , W _ { B } ) + L _ { \mathcal { L } } ( C _ { \mathcal { L } } , X _ { \mathcal { E } } ; \theta , W _ { \mathcal { L } } ) .
+$$
+
+Note that, due to overfitting on the few available examples, such learning is avoided in a few-shot learning setup. In a few cases, it takes the form of fine-tuning including all base class data (Qi et al., 2018), or only lasts for a few iterations when the base class data is not accessible (Finn et al., 2017).
+
+# 6 EXPERIMENTS
+
+# 6.1 EXPERIMENTAL SETUP
+
+Datasets and task setup. We extend the Low-Shot ImageNet benchmark introduced by Hariharan & Girshick (2017) by assuming many noisy examples for novel classes, in addition to the few clean ones. In this benchmark, the 1000 ImageNet classes (Russakovsky et al., 2015) are split into 389 base classes and 611 novel classes. The validation set contains 193 base and 300 novel classes, and the test set the remaining 196 base and 311 novel classes. The standard benchmark includes $k$ -shot classification, i.e. classification on $k$ clean examples per class, which we extend to $k$ clean and many noisy examples per class, with $k \in \{ 1 , 2 , 5 , 1 0 , 2 0 \}$ . Similar to Hariharan & Girshick (2017) we perform 5 tasks, each drawing a subset of $k$ clean examples per class. We report the average top-5 accuracy over the 5 tasks on novel or all classes of the test set.
+
+We use the YFCC100M dataset (Thomee et al., 2016) as a source for additional data with noisy labels. It contains approximatively 100M images collected from Flickr. Each image comes with a text description obtained from the user title and caption. We use the text description to obtain images with noisy labels. as discussed in Section 3. This process results in very different numbers of additional examples per class, with a minimum of zero for classes maillot and missile, and a maximum of 620,142 for class church/church building.
+
+Representation and classifier learning. In most experiments, we use ResNet-10 (He et al., 2016) as feature extractor as in Gidaris & Komodakis (2018). Classification for novel classes is performed with class prototypes (6), cosine classifier learning (7) or deep network fine-tuning (8). Hyper-parameters such as batch size and number of epochs, are tuned on the validation set. Possible values are 2048, 4096, and 8192 for batchsize and 10, 30 and 50 for number of epochs. The learning rate starts from 0.1 and is reduced to 0.001 at the end of training with cosine annealing (Loshchilov & Hutter, 2017).
+
+We handle the imbalance of the noisy set by normalizing by $r ( X _ { c } )$ in (7). Prototypes (6) are used to initialize $W _ { \mathcal { L } }$ of cosine classifier in (7), and the learned $W _ { \mathcal { L } }$ is used to initialize the corresponding part of $W _ { A }$ when fine-tuning the network by (8). In the latter case, we train all layers for 10 epochs with learning rate 0.01. We ignore examples $x _ { i }$ with relevance $r ( x _ { i } ) < 0 . 1$ to reduce the complexity when fine-tuning the network.
+
+We also report results with ResNet-50 as feature extractor, using the model trained on base classes by Hariharan & Girshick (2017). Following Douze et al. (2018), we apply PCA to the features to reduce their dimensionality to 256. Base classes are represented by class prototypes (6) in this case.
+
+GCN training is performed with Adam optimizer and a learning rate of 0.1 for 100 iterations. We use dropout with probability 0.5. The dimensionality of the input descriptors is $d = 5 1 2$ for ResNet-10 and $d = 2 5 6$ for ResNet-50 (after PCA). Dimensionality of the internal representation in (1) is $m = 1 6$ . The affinity matrix is constructed with reciprocal top-50 nearest neighbors.
+
+Baselines. We implement and evaluate several baseline methods. $\beta$ -cleaning assigns $r ( x _ { i } ) = \beta$ to all additional examples. We report results for $\beta = 1 . 0$ (unit relevance score) and $\beta ^ { * }$ , the optimal $\beta$ for all $k$ obtained on the validation set. $M L P$ , discussed in Section 4, learns a nonlinear mapping to assign relevance, but does not propagate over the graph. Label Propagation (LP) (Zhou et al., 2003a) propagates information by a linear operation. It solves the linear system $( I - \alpha D ^ { - 1 / 2 } A D ^ { - 1 / 2 } ) \mathbf { r } _ { c } =$ $\mathbf { y } _ { c }$ (Iscen et al., 2017) for each class $c$ , where $D$ is the degree matrix of $A$ , $\alpha = 0 . 9$ and $\mathbf { y } _ { c } \in \mathbb { R } ^ { N }$ is a $k$ -hot binary vector indicating the labeled examples of class $c$ . Relevance $r ( x _ { i } )$ is then the $i$ -th element $( \mathbf { r } _ { c } ) _ { i }$ of the solution.
+
+# 6.2 EXPERIMENTAL RESULTS
+
+The impact of importance weight $\lambda$ is measured on the validation set and the best performing value is used on the test set for each value of $k$ . Results are shown in Appendix A. The larger the value of $\lambda$ , the more the loss encourages noisy examples to be classified as negatives. As a consequence, large (small) $\lambda$ results in smaller (larger) relevance, on average, for noisy examples. The optimal $\lambda$ per value of $k$ suggests that the fewer the clean examples the larger the need for additional ones.
+
+Comparison with baselines using additional data is presented in Table 1. The use of additional data is mostly harmful for $\beta$ -weighting except for 1 and 2-shot. MLP offers improvements in most cases, implying that it manages to appropriately downweigh irrelevant examples. The consistent improvement of our method compared to MLP, especially large for small $k$ , suggests that it is beneficial to incorporate relations, with the affinity matrix $A$ modeling the structure of the feature space. LP is a classic approach that also uses $A$ but is a linear operation with no parameters, and is inferior to our method. The gain of cleaning ( $\beta = 1$ vs. ours) ranges from $11 \%$ to $20 \%$ .
+
+Table 1: Comparison with baselines using noisy examples. We report top-5 accuracy on novel classes with classification by class prototypes (6).   
+
+<table><tr><td>Method</td><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td></tr><tr><td colspan="6">FEW CLEAN EXAMPLES</td></tr><tr><td>Class proto.Gidaris &amp; Komodakis (2018)</td><td>45.3±0.65</td><td>57.1±0.37</td><td>69.3±0.32</td><td>74.8±0.20</td><td>77.8±0.24</td></tr><tr><td colspan="6">FEW CLEAN &amp; MANY NOISY EXAMPLES</td></tr><tr><td>β-weighting,β=1</td><td>56.1±0.06</td><td>56.4±0.08</td><td>57.1±0.05</td><td>57.7±0.08</td><td>58.7±0.06</td></tr><tr><td>β-weighting,β*</td><td>55.6±0.24</td><td>58.3±0.14</td><td>63.4±0.25</td><td>67.5±0.34</td><td>71.0±0.22</td></tr><tr><td>Label Propagation Zhou et al. (2003a)</td><td>62.6±0.35</td><td>67.0±0.41</td><td>74.6±0.30</td><td>76.3±0.23</td><td>77.7±0.18</td></tr><tr><td>MLP</td><td>63.6±0.41</td><td>68.8±0.42</td><td>73.9±0.25</td><td>75.6±0.21</td><td>77.6±0.21</td></tr><tr><td>Ours</td><td>67.8±0.10</td><td>70.9±0.30</td><td>73.7±0.17</td><td>76.1±0.12</td><td>78.2±0.14</td></tr></table>
+
+<table><tr><td>METHOD</td><td colspan="4">NoVEL CLASSES</td><td colspan="5">ALL CLASSES</td></tr><tr><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td></tr><tr><td colspan="10">RESNET-10 -FEW CLEAN EXAMPLES</td></tr><tr><td>Proto.-Nets (Snell et al., 2017)</td><td>39.3</td><td>54.4 66.3</td><td>71.2</td><td>73.9</td><td>49.5</td><td>61.0</td><td>69.7</td><td>72.9</td><td>74.6</td></tr><tr><td>Logistic reg.w/H(Wang et al.,2018b)</td><td>40.7</td><td>50.8 62.0</td><td>69.3</td><td>76.5</td><td>52.2</td><td>59.4</td><td>67.6</td><td>72.8</td><td>76.9</td></tr><tr><td>PMN w/H(Wang et al., 2018b)</td><td>45.8</td><td>57.8 69.0</td><td>74.3</td><td>77.4</td><td>57.6</td><td>64.7</td><td>71.9</td><td>75.2</td><td>77.5</td></tr><tr><td>Class proto.(Gidaris &amp; Komodakis,2018)</td><td></td><td></td><td>45.3±0.6557.1±0.37 69.3±0.32 74.8±0.20 77.8±0.24</td><td></td><td></td><td></td><td></td><td></td><td>57.0±0.3664.7±0.1672.5±0.1875.8±0.1677.4±0.19 58.1±0.4865.2±0.15 72.9±0.25 76.6±0.18 78.8±0.16</td></tr><tr><td colspan="10">Class proto.w/At.(Gidaris&amp; Komodakis,2018) 45.8±0.74 57.4±0.38 69.6±0.27 75.0±0.29 78.2±0.23</td></tr><tr><td></td><td></td><td></td><td>RESNET-1O -FEW CLEAN&amp; MANY NOISY EXAMPLES</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Ours -class proto.(6) Ours-cosine (7)</td><td></td><td></td><td>67.8±0.10 70.9±0.30 73.7±0.20 76.1±0.16 78.2±0.14</td><td></td><td></td><td></td><td></td><td></td><td>70.3±0.05 72.1±0.18 74.1±0.12 75.6±0.13 76.9±0.09</td></tr><tr><td>Ours - fine-tune (8)</td><td></td><td>73.2±0.14 75.3±0.25 75.6±0.24 78.5±0.32 80.7±0.26 74.6±0.13 76.6±0.26 78.2±0.23 80.9±0.34 82.9±0.20</td><td></td><td></td><td></td><td></td><td></td><td></td><td>71.9±0.0774.0±0.2376.5±0.1678.3±0.2380.2±0.18 76.0±0.1077.3±0.1378.7±0.1980.7±0.2582.2±0.14</td></tr><tr><td colspan="10">RESNET-50 - FEW CLEAN EXAMPLES</td></tr><tr><td>Proto.-Nets (Snell et al., 2017)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PMN w/H(Wang et al.,2018b)</td><td>49.6 64.0 54.7 66.8</td><td>74.4 77.4</td><td>78.1 81.4</td><td>80.0 83.8</td><td>61.4 65.7</td><td>71.4 73.5</td><td>78.0 80.2</td><td>80.0 82.8</td><td>81.1 84.5</td></tr><tr><td colspan="10">RESNET-5O-FEW CLEAN&amp;MANYUNLABELED EXAMPLES</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Diffusion (Douze et al., 2018) Diffusion -logistic (Douze et al.,2018)</td><td></td><td></td><td>63.6±0.61 69.5±0.60 75.2±0.40 78.5±0.34 80.8±0.18</td><td></td><td></td><td>=</td><td>-</td><td></td><td></td></tr><tr><td colspan="10">64.0±0.7071.1±0.82 79.7±0.3883.9±0.10 86.3±0.17 RESNET-5O-FEWCLEAN&amp;MANY NOISY EXAMPLES</td></tr><tr><td>Ours - class proto.(6)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Ours - cosine (7)</td><td></td><td>78.0±0.38 80.2±0.3380.9±0.17 83.7±0.1985.7±0.11</td><td>69.7±0.44 73.7±0.56 77.0±0.20 79.9±0.30 81.9±0.29</td><td></td><td></td><td>77.6±0.26 79.1±0.20 79.9±0.09 82.1±0.22 83.8±0.11</td><td></td><td></td><td>73.8±0.33 76.6±0.36 78.9±0.19 80.8±0.21 82.2±0.14</td></tr><tr><td>Ours - fine-tune (8)</td><td>80.8±0.25 83.0±0.23 83.8±0.39 86.4±0.23 88.5±0.20</td><td></td><td></td><td></td><td></td><td>81.6±0.20 83.2±0.16 84.3±0.23 86.2±0.17 87.8±0.03</td><td></td><td></td><td></td></tr></table>
+
+Table 2: Comparison to the state of the art on the Low-shot ImageNet benchmark. We report top-5 accuracy on novel and all classes. We use class prototypes (6), cosine classifier learning (7) and deep network fine-tuning (8) for classification with our GCN-based data addition method.
+
+Comparison with the state of the art is presented in Table 2. We significantly improve the performance by using additional data and cleaning compared to a number of different approaches, including the work by Gidaris & Komodakis (2018), which is our starting point. As expected, the gain is more pronounced for small $k$ , reaching more than $20 \%$ improvement for 1-shot novel accuracy.
+
+Closest to ours is the work of Douze et al. (2018), who use the same experimental setup and the same additional data, but without filtering by text and using noisy labels. We outperform their approach in all cases, while requiring much less computation: offline, we construct a separate small graph per class rather than a single graph over the entire 100M collection; online, we perform inference by cosine similarity to one prototype per class or a learned classifier rather than iterative diffusion on the entire collection. Note that by ignoring examples that are not given any noisy label, we are only using a tiny fraction of the 100M collection: in particular, only 3,744,994 images for the 311-class test split of the Low-shot ImageNet benchmark. In contrast to Douze et al. (2018), additional data brings improvement even at 20-shot with classifier learning or network fine-tuning. Most importantly, our approach does not require the entire 100M collection at inference.
+
+# 7 CONCLUSIONS
+
+In this paper we have introduced a new method for assigning class relevance to noisy images obtained by textual queries with class names. Our approach leverages one or a few labeled images per class and relies on a graph convolutional network (GCN) to propagate visual information from the labeled images to the noisy ones. The GCN is a binary classifier discriminating clean from noisy examples using a weighted binary cross-entropy loss function and inferring “clean” probability as a relevance measure for that class. Experimental results show that using noisy images weighted by this relevance measure significantly improves the classification accuracy.
+
+# REFERENCES
+
+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.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann Lecun. Spectral networks and locally connected networks on graphs. In ICLR, 2014.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. ICLR, 2019.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NeurIPS, 2016.
+
+Matthijs Douze, Arthur Szlam, Bharath Hariharan, and Hervé Jégou. Low-shot learning with large-scale diffusion. In CVPR, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In NeurIPS, 2018.
+
+Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. In ICLR, 2018.
+
+Spyros Gidaris and Nikos Komodakis. Dynamic few-shot visual learning without forgetting. In CVPR, 2018.
+
+Spyros Gidaris and Nikos Komodakis. Generating classification weights with gnn denoising autoencoders for few-shot learning. In CVPR, 2019.
+
+Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In International Conference on Artificial Intelligence and Statistics, 2010.
+
+Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In CVPR, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Ahmet Iscen, Giorgos Tolias, Yannis Avrithis, Teddy Furon, and Ondrej Chum. Efficient diffusion on region manifolds: Recovering small objects with compact cnn representations. In CVPR, 2017.
+
+Armand Joulin, Laurens van der Maaten, Allan Jabri, and Nicolas Vasilache. Learning visual features from large weakly supervised data. In ECCV, 2016.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Kuang-Huei Lee, Xiaodong He, Lei Zhang, and Linjun Yang. CleanNet: Transfer learning for scalable image classifier training with label noise. In CVPR, 2018.
+
+Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In ICCV, 2017.
+
+Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Trans. PAMI, 38(3), 2015.
+
+Yanbin Liu, Juho Lee, Minseop Park, Saehoon Kim, Eunho Yang, Sung Ju Hwang, and Yi Yang. Learning to propagate labels: Transductive propagation network for few-shot learning. In ICLR, 2019.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. ICLR, 2017.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with noisy labels. In NeurIPS, 2013.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017.
+
+Hang Qi, Matthew Brown, and David G. Lowe. Low-shot learning with imprinted weights. In CVPR, June 2018.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017.
+
+Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. ICLR, 2015.
+
+Mengye Ren, Sachin Ravi, Eleni Triantafillou, Jake Snell, Kevin Swersky, Josh B. Tenenbaum, Hugo Larochelle, and Richard S. Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018a.
+
+Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to reweight examples for robust deep learning. In ICML, 2018b.
+
+Marcus Rohrbach, Sandra Ebert, and Bernt Schiele. Transfer learning in a transductive setting. In NeurIPS, 2013.
+
+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. IJCV, 115(3), 2015.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017.
+
+Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. arXiv preprint arXiv:1406.2080, 2014.
+
+Bart Thomee, David A. Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland, Damian Borth, and Li-Jia Li. Yfcc $1 0 0 \mathrm { m }$ : The new data in multimedia research. Commun. ACM, 59(2), 2016.
+
+Andreas Veit, Neil Alldrin, Gal Chechik, Ivan Krasin, Abhinav Gupta, and Serge Belongie. Learning from noisy large-scale datasets with minimal supervision. In CVPR, July 2017.
+
+Ricardo Vilalta and Youssef Drissi. A perspective view and survey of meta-learning. Artificial intelligence review, 18(2):77–95, 2002.
+
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In NeurIPS, 2016.
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In CVPR, 2015.
+
+Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. In CVPR, 2018a.
+
+Yu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In CVPR, 2018b.
+
+Jason Weston, Frédéric Ratle, and Ronan Collobert. Deep learning via semi-supervised embedding. In ICML, 2008.
+
+Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance-level discrimination. CVPR, 2018.
+
+Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. In NeurIPS, 2003a.
+
+Dengyong Zhou, Jason Weston, Arthur Gretton, Olivier Bousquet, and Bernhard Schölkopf. Ranking on data manifolds. In NeurIPS, 2003b.
+
+![](images/d75584f0f38734e1f60b1588c31cd97d99ef2d5781c2f1c3f7deaf0d2182f12d.jpg)  
+Figure 3: (a) Number of additional images per class $c$ sampled from YFCC-100M for all novel classes of Low-Shot ImageNet. (b) Number of classes per group, when $| X _ { \mathcal { Z } } ^ { c } |$ is sampled logarithmically into groups. (c) Accuracy improvement $\Delta$ Acc (difference of accuracy between our method with noisy examples and the baseline without noisy examples) for prototype classifier, for same groups as in (b).
+
+# A APPENDIX
+
+Noisy data statistics. We present statistics about the noisy examples of novel classes and the improvements of our method per class. Figure 3 (a) shows that the noisy examples for novel classes are long tailed (in log scale). There is a significant number of classes where we end up with less than 1000 extra examples, but we improve nevertheless; see Figure 3 (c). A small exception is 4 very rare classes out of 311, with around 3 additional images per class (leftmost bin in Figure 3 (b) and (c)). Note that in real world applications, one could use more resources like web queries for additional data.
+
+Impact of importance weight $\lambda ,$ . We present the impact of $\lambda$ (3) for different values of $k$ in the validation set of the extended Low-shot ImageNet benchmark in Figure 4.
+
+![](images/75723f011baed9f80d3665089fcfcb5e9cf2105defc23b6659f2c9df36dc3084.jpg)  
+Figure 4: Impact of $\lambda$ on the validation set of the extended Low-shot ImageNet benchmark with YFCC-100M for noisy examples using class prototypes (6).

parse/train/Bke6vTVYwH/Bke6vTVYwH_content_list.json

@@ -0,0 +1,1575 @@
+[
+    {
+        "type": "text",
+        "text": "GRAPH CONVOLUTIONAL NETWORKS FOR LEARNING WITH FEW CLEAN AND MANY NOISY LABELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider the problem of learning a classifier from noisy labels when a few clean labeled examples are given. The structure of clean and noisy data is modeled by a graph per class and Graph Convolutional Networks (GCN) are used to predict class relevance of noisy examples. For each class, the GCN is treated as a binary classifier learning to discriminate clean from noisy examples using a weighted binary cross-entropy loss function, and then the GCN-inferred “clean” probability is exploited as a relevance measure. Each noisy example is weighted by its relevance when learning a classifier for the end task. We evaluate our method on an extended version of a few-shot learning problem, where the few clean examples of novel classes are supplemented with additional noisy data. Experimental results show that our GCN-based cleaning process significantly improves the classification accuracy over not cleaning the noisy data and standard few-shot classification where only few clean examples are used. The proposed GCN-based method outperforms the transductive approach (Douze et al., 2018) that is using the same additional data without labels. ",
+        "bbox": [
+            233,
+            263,
+            766,
+            472
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            336,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "State-of-the-art deep learning methods require a large amount of manually labeled data. The need for supervision may be reduced by decoupling representation learning from the end task and/or using additional training data that are unlabeled, weakly labeled (with noisy labels), or belong to different domains or classes. Example approaches are transfer learning (Wang & Gupta, 2015), unsupervised representation learning (Wang & Gupta, 2015), semi-supervised learning (Weston et al., 2008), learning from noisy labels (Joulin et al., 2016) and few-shot learning (Snell et al., 2017). ",
+        "bbox": [
+            174,
+            526,
+            825,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning from noisy labels allows using large-scale data and labels from the web without human annotation effort. Most work focuses on learning the representation jointly with the end task, assuming there is still a considerable amount of clean labeled data (Patrini et al., 2017; Lee et al., 2018; Li et al., 2017). However, for a number of classes only very few or even no clean labeled examples might be available at the representation learning stage. Few-shot learning limits the labeled data to very few on the end task, while the representation is learned on a large training set of different classes (Hariharan & Girshick, 2017; Snell et al., 2017; Vinyals et al., 2016). Nevertheless, in many situations, more data with noisy labels are available or can be acquired for the end task. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One interesting mix of few-shot learning with additional large-scale data is the work of Douze et al. (2018), where labels are propagated from few clean labeled examples to a large-scale collection. This collection is unlabeled and actually contains data of many more classes than the end task. Their method overall improves the classification accuracy, but at an additional computational cost; it is a transductive method, i.e., instead of learning a parametric classifier, the large-scale collection is still necessary at inference. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we learn a classifier from few clean labeled examples and additional weakly labeled data, while the representation is learned on different classes, as in few-shot learning. We assume the class names are known, and we use them to search an existing large collection of images with textual description. The result is a set of images with potentially relevant, but noisy labels. As shown in Figure 1, we clean this data using a graph convolutional network (GCN) (Kipf & Welling, 2017), which learns to predict a class relevance score per image based on the source (clean vs. noisy) of its connections in the graph. Both the clean and the noisy images are then used to learn a classifier, where the noisy examples are weighted by relevance. Unlike most existing work, our method operates independently per class and applies when clean labeled examples are few or even one per class. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eed9d45df54f8a4f9857ca30afe31d8710a4404ec6cdacce1d0af912c397be2.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our cleaning approach for 1-shot learning with noisy examples. We use the class name admiral to crawl noisy images from web and create an adjacency graph based on visual similarity. We then assign a relevance score to each noisy example with a graph convolutional network (GCN). Relevance scores are displayed next to the images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            87,
+            782,
+            228
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            311,
+            821,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We make the following contributions: ",
+        "bbox": [
+            176,
+            347,
+            419,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We learn a classifier on a large-scale weakly-labeled collection jointly with only few clean labeled examples.   \n• To our knowledge, we are the first to use a GCN to clean noisy data: we cast a GCN as a binary classifier learning to discriminate clean from noisy data, and we use its inferred probabilities for the “clean” class as a relevance score per example.   \nWe apply our method to a few-shot learning benchmark and show significant improvement in accuracy, while outperforming the method by Douze et al. (2018) using the same large-scale collection of data. ",
+        "bbox": [
+            215,
+            367,
+            825,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            341,
+            516
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning with noisy labels is often concerned with estimating or learning a transition matrix (Natarajan et al., 2013; Patrini et al., 2017; Sukhbaatar et al., 2014) or knowledge graph (Li et al., 2017) between labels and correcting the loss function, which does not apply in our case since the classes in the noisy data are unknown. Most recent work on learning from large-scale weakly-labeled data focuses on learning the representation e.g. by metric learning (Lee et al., 2018; Wang et al., 2018a), bootstrapping (Reed et al., 2015), or distillation (Li et al., 2017). In our case however, since the clean labeled examples are few, we need to keep the representation mostly fixed. ",
+        "bbox": [
+            173,
+            536,
+            826,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dealing with the noise, e.g. by thresholding (Lee et al., 2018), outlier detection (Wang et al., 2018a) or reweighting (Liu & Tao, 2015), is applicable while the representation is learned, based e.g. on the gradient of the loss (Ren et al., 2018b). In contrast, the relatively-shallow GCN that we propose effectively decouples reweighting from both representation learning and classifier learning. Learning to clean the noisy labels (Veit et al., 2017) typically assumes adequate human verified labels for training, which again is not the case in this work. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Few-shot learning. Meta-learning (Vilalta & Drissi, 2002) refers to learning at two levels, where generic knowledge is acquired before adapting to more specific tasks. In few-shot learning, this translates to learning on a set of base classes how to learn from few examples on a distinct set of novel classes without overfitting. For instance, optimization meta-learning (Finn et al., 2017; 2018; Ravi & Larochelle, 2017) amounts to learning a model that is easy to fine-tune in few steps. In our work, we study an extension of few-shot learning where more data are available on novel classes, reducing the risk of overfitting when fine-tuning the model. Metric learning approaches learn how to compare queries for instance to few examples (Vinyals et al., 2016) or to the corresponding class prototypes (Snell et al., 2017). Hariharan & Girshick (2017) and Wang et al. (2018b) learn how to generate novel-class examples, which is not needed when more data are actually available. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Gidaris & Komodakis (2018) learn on base classes a simpler cosine similarity-based parametric classifier, or simply cosine classifier, without meta-learning. The same classifier has been introduced independently by Qi et al. (2018), who further fine-tune the network, assuming access to the base class training set. A recent survey (Chen et al., 2019) confirms the superiority of the cosine classifier to previous work including meta-learning (Finn et al., 2017). We use the cosine classifier in this work, both for base and novel classes. All of the above use only the few labeled examples of the novel classes. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Making use of unlabeled data has been little explored in few-shot learning until recently. Ren et al. (2018a) introduce a semi-supervised few-shot classification task, where some labels are unknown. Liu et al. (2019) follow the same semi-supervised setup, but use graph-based label propagation (LP) (Zhou et al., 2003a) for classification and consider jointly all test images. These methods assume a meta-learning scenario, where only small-scale data is available at each training episode; arguably, such a small amount of data limits the representation adaptation and generalization to unseen data. Similarly, Rohrbach et al. (2013) use label propagation in a transductive setting, but at a larger scale assuming that all examples come from a set of known classes. Douze et al. (2018) extend to even larger scale, leveraging 100M unlabeled images in a graph without using additional text information. We focus on the latter large-scale scenario using the same 100M dataset. However, we filter by text to obtain noisy labels and follow an inductive approach by training a classifier for novel classes, such that the 100M collection is not needed at inference. ",
+        "bbox": [
+            173,
+            166,
+            826,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks are generalizations of convolutional networks to non-Euclidean spaces (Bronstein et al., 2017). Early spectral methods (Bruna et al., 2014; Henaff et al., 2015) have been succeeded by Chebyshev polynomial approximations (Defferrard et al., 2016), which avoid the high computational cost of computing eigenvectors. Graph convolutional networks (GCN) (Kipf & Welling, 2017) provide a further simplification by a first-order approximation of graph filtering and are applied to semi-supervised (Kipf & Welling, 2017) and subsequently to few-shot learning (Garcia & Bruna, 2018). In Kipf & Welling (2017), the loss function is applied to labeled examples to make predictions on unlabeled ones. Similarly in Garcia & Bruna (2018), GCNs make predictions on novel class examples. Gidaris & Komodakis (2019) use Graph Neural Networks as denoising autoencoders to generate class weights for novel classes. In contrast, we cast GCNs as binary classifiers discriminating clean from noisy examples: we apply a loss function to all examples, and then use the inferred probabilities as a class relevance measure, effectively cleaning the data. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            517
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our counter-intuitive objective of treating all noisy examples as negative can be compared to treating each example as a different class in instance-level discrimination (Wu et al., 2018). In fact, our loss function is similar to noise-contrastive estimation (NCE) (Gutmann & Hyvärinen, 2010) used in that work. According to our experiments, our GCN-based classifier outperforms classical LP (Zhou et al., 2003a) used for a similar purpose by Rohrbach et al. (2013). ",
+        "bbox": [
+            174,
+            525,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            415,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider a space $\\mathcal { X }$ of examples. We are given a set $X _ { \\mathcal { L } } \\subset \\mathcal { X }$ of examples, each having a clean (manually verified) label in a set $C _ { \\mathcal { L } }$ of classes with $| C _ { \\mathcal { L } } | = K _ { \\mathcal { L } }$ . For any set $X \\subset { \\mathcal { X } }$ , we denote by $X ^ { c }$ its subset of examples having a label in class $c$ . We assume that the number $| X _ { \\mathcal { L } } ^ { c } |$ of examples labeled in each class $c \\in C _ { \\mathcal { L } }$ is only $k$ , typically in $\\{ 1 , 2 , 5 , 1 0 , 2 0 \\}$ . We are also given an additional set $X _ { \\mathcal { Z } } ^ { c }$ of examples, each with a set of noisy labels in $C _ { \\mathcal { L } }$ . The extended set of examples for class $c$ is now $X _ { \\mathcal { E } } ^ { c } = X _ { \\mathcal { L } } ^ { c } \\cup X _ { \\mathcal { Z } } ^ { c }$ . Examples or sets of examples having clean (noisy) labels are referred to as clean (noisy) as well. The goal is to train a classifier, using the additional noisy set in order to improve the accuracy compared to only using the small clean set. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume that we are given a feature extractor $g _ { \\theta } : \\mathcal { X }  \\mathbb { R } ^ { d }$ , mapping an example to a $d .$ -dimensional vector. For instance, when examples are images, the feature extractor is typically a convolutional neural network (CNN) and $\\theta$ are the parameters of all layers. ",
+        "bbox": [
+            176,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we assume that the noisy set $X z$ is collected via web crawling with examples that are images accompanied with free-form text description and/or user tags originating from community photo collections. To make use of text data, we assume that the names of classes in $C _ { \\mathcal { L } }$ are given. An example in $X z$ is given a label in class $c \\in C _ { \\mathcal { L } }$ if its textual information contains the name of class $c$ ; it may then have none, one or more labels. In this way, we automatically infer labels for $X z$ without human effort, which are however noisy. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We perform cleaning by predicting a class relevance measure for each noisy example in $X _ { \\mathcal { Z } } ^ { c }$ , independently per class $c \\in C _ { \\mathcal { L } }$ . To simplify notation, we drop superscript $c$ where possible in this subsection and we denote $X _ { \\mathcal { E } } ^ { c }$ by $\\left\\{ x _ { 1 } , \\ldots , x _ { k } , x _ { k + 1 } , \\ldots , x _ { N } \\right\\}$ , where $X _ { \\mathcal { L } } ^ { c } ~ = ~ \\{ \\bar { x _ { 1 } } , \\ldots , x _ { k } \\}$ and $X _ { \\mathcal { Z } } ^ { c } = \\{ x _ { k + 1 } , \\ldots , x _ { N } \\}$ . The features of these examples are similarly represented by matrix $V = [ \\ b { \\mathrm { v } } _ { 1 } , \\ b { \\mathrm { ~ . ~ . ~ . ~ } } , \\ b { \\mathrm { v } } _ { k } , \\ b { \\mathrm { v } } _ { k + 1 } , \\ b { \\mathrm { ~ . ~ . ~ . ~ } } , \\ b { \\mathrm { v } } _ { N } ] \\in \\mathbb { R } ^ { d \\times N }$ , where $\\mathbf { v } _ { i } = g _ { \\theta } ( x _ { i } )$ for $i = 1 , \\ldots , N$ . ",
+        "bbox": [
+            174,
+            132,
+            825,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We construct an affinity matrix $A \\in \\mathbb { R } ^ { N \\times N }$ with elements $a _ { i j } = [ \\mathbf { v } _ { i } ^ { \\top } \\mathbf { v } _ { j } ] _ { + }$ if examples $\\mathbf { v } _ { i }$ and $\\mathbf { v } _ { j }$ are reciprocal nearest neighbors in $X _ { \\mathcal { E } } ^ { c }$ and 0 otherwise. Matrix $A$ has zero diagonal, but self-connections are added and then $A$ is normalized as $\\tilde { A } = D ^ { - 1 } ( A + I )$ with $D = \\mathrm { d i a g } ( ( A + I ) \\mathbf { 1 } )$ being the degree matrix of $A + I$ and 1 the all-ones vector. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph convolutional networks (GCNs) (Kipf & Welling, 2017) are formed by a sequence of layers. Each layer is a function $f _ { \\Theta } : \\mathbb { R } ^ { \\hat { N } \\times N } \\times \\mathbb { R } ^ { l \\times \\hat { N } }  \\mathbb { R } ^ { n \\times \\hat { N } }$ of the form ",
+        "bbox": [
+            171,
+            276,
+            825,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/13b3539b42a92529ba0733c4bb034de201e83b06236457e097f398a2fd35d52b.jpg",
+        "text": "$$\nf _ { \\Theta } ( \\tilde { A } , Z ) = h ( \\Theta ^ { \\top } Z \\tilde { A } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            310,
+            578,
+            329
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Z \\in \\mathbb { R } ^ { l \\times N }$ represents the input features, $\\boldsymbol { \\Theta } \\in \\mathbb { R } ^ { l \\times n }$ holds the parameters of the layer to be learned, and $h$ is a nonlinear activation function. Function $f _ { \\Theta }$ maps $l$ -dimensional input features to $n$ -dimensional output features. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider a two layer GCN with a scalar output per example. This network is a function $F _ { \\Theta } : \\mathbb { R } ^ { N \\times N } \\times \\mathbb { R } ^ { d \\times N }  \\bar { \\mathbb { R } } ^ { N }$ given by ",
+        "bbox": [
+            176,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa8f3059c25a8e88d03f34ad4a60198132485042f75fe3825f0e8940f8ab17b9.jpg",
+        "text": "$$\nF _ { \\Theta } ( \\tilde { A } , V ) = \\sigma ( \\Theta _ { 2 } ^ { \\top } [ \\Theta _ { 1 } ^ { \\top } V \\tilde { A } ] _ { + } \\tilde { A } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            416,
+            611,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\Theta = \\{ \\Theta _ { 1 } , \\Theta _ { 2 } \\}$ , $\\Theta _ { 1 } \\in \\mathbb { R } ^ { d \\times m }$ , $\\Theta _ { 2 } \\in \\mathbb { R } ^ { m \\times 1 }$ , $[ \\cdot ] _ { + }$ is the positive part or ReLU function (Nair & Hinton, 2010) and $\\bar { \\sigma ( } x ) = ( 1 + e ^ { - x } ) ^ { - 1 }$ for $x \\in \\mathbb { R }$ is the sigmoid function. Function $F _ { \\Theta }$ performs feature propagation through the affinity matrix in an analogy to classical graph-based propagation methods for classification (Zhou et al., 2003a) or search (Zhou et al., 2003b). ",
+        "bbox": [
+            174,
+            440,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The output $F _ { \\Theta } ( \\tilde { A } , V )$ is a vector of length $N$ , with element $F _ { \\Theta } ( { \\tilde { A } } , V ) _ { i }$ in $[ 0 , 1 ]$ representing a relevance value of example $x _ { i }$ for class $c$ . To learn the parameters $\\Theta$ , we treat the GCN as a binary classifier where target output 1 corresponds to clean examples and 0 to noisy. In particular, we minimize the loss function ",
+        "bbox": [
+            174,
+            503,
+            825,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d837015149b4cf45be34663d466e1cbfb336b844aff7679816550bc5ca1f8182.jpg",
+        "text": "$$\nL _ { \\mathcal { G } } ( V , \\tilde { A } ; \\Theta ) = - \\frac { 1 } { k } \\sum _ { i = 1 } ^ { k } \\log \\left( F _ { \\Theta } ( \\tilde { A } , V ) _ { i } \\right) - \\frac { \\lambda } { N - k } \\sum _ { i = k + 1 } ^ { N } \\log \\left( 1 - F _ { \\Theta } ( \\tilde { A } , V ) _ { i } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            563,
+            767,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This is a binary cross-entropy loss function where noisy examples are given an importance weight $\\lambda$ . Given the propagation on the nearest neighbor graph, and depending on the relative importance $\\lambda$ of the second term, noisy examples that are strongly connected to clean ones are still expected to receive high class relevance, while noisy examples that are not relevant to the current class are expected to get a class relevance near zero. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The impact of parameter $\\lambda$ is validated in Section 6, where we show that the fewer the available clean images are (smaller $k$ ) the smaller the importance weight should be. As is standard practice for GCNs in classification (Kipf & Welling, 2017), training is performed in batches of size $N$ , that is the entire set of features. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows examples of clean images, corresponding noisy ones and the predicted relevance. Thanks to the visual similarity to the clean image, we can use relevance to resolve cases of polysemy, e.g. black widow (spider) vs. black widow (superhero), or cases like pineapple vs. pineapple juice. ",
+        "bbox": [
+            176,
+            752,
+            823,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Discussion. Loss function (3) is similar to noise-contrastive estimation (NCE) (Gutmann & Hyvärinen, 2010) as used by Wu et al. (2018) for instance-level discrimination, whereas we discriminate clean from noisy examples. The semi-supervised learning setup of GCNs (Kipf & Welling, 2017) uses a loss function that applies only to the labeled examples, and makes discrete predictions on unlabeled examples. In our case, all examples contribute to the loss but with different importance, while we infer real-valued class relevance for the noisy examples, to be used for subsequent learning. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Function $F _ { \\Theta }$ in (2) reduces to a Multi-Layer Perceptron (MLP) when the affinity matrix $A$ is zero, in which case all examples are disconnected. Using an MLP to perform cleaning would take each example into account independently of the others, while the GCN considers the collection of examples as a whole. MLP training is performed identically to GCN by minimizing (3). We compare the two alternatives in our experiments. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d562245fb1728f832564e87b5ff05688b13eb6f98c403180ec263fd140ddad27.jpg",
+        "image_caption": [
+            "Figure 2: Examples of clean images (left) for 1-shot classification, cumulative histogram of the predicted relevance for noisy images (middle), and representative noisy images (right), each having its position in the (descending) ranked list according to relevance and relevance value reported below. Test accuracy without and with additional data using class prototypes (6) is shown next to class names. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            94,
+            790,
+            309
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            383,
+            825,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 LEARNING A CLASSIFIER WITH FEW CLEAN AND MANY NOISY EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            173,
+            446,
+            820,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our cleaning process applies when the clean labeled examples are few, but assumes a feature extractor $g _ { \\theta }$ . That is, representation learning, label cleaning and classifier learning are decoupled. We follow few-shot learning in that we learn the representation by supervised classification on a set of base classes, obtaining $g _ { \\theta }$ , and then solving new classification tasks on a distinct set of novel classes. In these new tasks, we assume few clean and many noisy labels as specified in Section 3, perform GCN-based cleaning as described in Section 4, and learn a classifier by weighing examples according to class relevance. Representation and classifier learning are described below. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 COSINE-SIMILARITY BASED CLASSIFIER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            493,
+            606
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use a cosine-similarity based classifier (Gidaris & Komodakis, 2018; Qi et al., 2018), or cosine classifier for short. Given classes $C$ with $| C | = K$ , each class $c \\in C$ is represented by a learnable parameter $\\mathbf { w } _ { c } \\in \\mathbb { R } ^ { d }$ . The prediction of example $x \\in \\mathcal { X }$ is the class $c$ of maximum cosine similarity $\\hat { \\mathbf { w } } _ { c } ^ { \\top } \\hat { g } _ { \\boldsymbol { \\theta } } ( x ) ^ { 1 }$ ",
+        "bbox": [
+            173,
+            616,
+            825,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40e6a0f31bb15db55ac4c34edda9ebe293e0f22aac7359518e37b8c95fccd4b7.jpg",
+        "text": "$$\n\\pi _ { \\boldsymbol { \\theta } , W } ( x ) = \\arg \\operatorname* { m a x } _ { c } \\hat { \\mathbf { w } } _ { c } ^ { \\top } \\hat { g } _ { \\boldsymbol { \\theta } } ( x ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            671,
+            601,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W = [ \\mathbf { w } _ { 1 } , \\ j . . . , \\mathbf { w } _ { K } ] \\in \\mathbb { R } ^ { d \\times K }$ . ",
+        "bbox": [
+            174,
+            699,
+            416,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.2 REPRESENTATION LEARNING: BASE CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            731,
+            529,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We are given a set $X _ { B } \\subset { \\mathcal { X } }$ of examples, each having a clean label in a set of base classes $C _ { B }$ with $| C _ { B } | = K _ { B }$ . These data are used to learn a feature representation, i.e. a feature extractor $g _ { \\theta }$ , by learning a $K _ { B }$ -way base-class classifier for unseen data in $\\mathcal { X }$ . The parameters $\\theta$ of the feature extractor and $W _ { B }$ of the classifier are jointly learned by minimizing the cross entropy loss ",
+        "bbox": [
+            174,
+            756,
+            826,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae61401e91b7b7148fa78affb508b0916a0836a3c71827c7dbf2006dd9558870.jpg",
+        "text": "$$\n{ \\cal L } _ { \\mathcal B } ( C _ { \\mathcal B } , X _ { \\mathcal B } ; \\boldsymbol { \\theta } , W _ { \\mathcal B } ) = - \\sum _ { c \\in C _ { \\mathcal B } } \\frac { 1 } { | X _ { \\mathcal B } ^ { c } | } \\sum _ { x \\in X _ { \\mathcal B } ^ { c } } \\log ( \\sigma ( s \\hat { W } _ { \\mathcal B } ^ { \\top } \\hat { g } _ { \\boldsymbol \\theta } ( x ) ) _ { c } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            818,
+            712,
+            858
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma : \\mathbb { R } ^ { K }  \\mathbb { R } ^ { K }$ is the softmax function with $\\pmb { \\sigma } ( \\mathbf { a } ) _ { c } = e ^ { a _ { c } } / \\sum _ { j \\in C } e ^ { a _ { j } }$ for $\\mathbf { a } \\in \\mathbb { R } ^ { K }$ , $s$ is a learnable scale parameter and $\\hat { W } _ { \\mathcal { B } } = [ \\hat { \\mathbf { w } } _ { 1 } , \\hdots , \\hat { \\mathbf { w } } _ { K _ { \\mathcal { B } } } ] \\in \\mathbb { R } ^ { d \\times K _ { \\mathcal { B } } }$ . Learning and inference are ",
+        "bbox": [
+            174,
+            864,
+            825,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "performed on base classes by $L _ { B } ( C _ { B } , X _ { B } ; \\theta , W _ { B } )$ (5) and $\\pi _ { \\boldsymbol { \\theta } , W _ { B } }$ (4), respectively. As a result, learned feature extractor parameters $\\theta$ are used for base or novel classes, while the classifier parameters $W _ { B }$ can be used for base class or all-class classification, as discussed below. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 NEW CLASSIFICATION TASKS: NOVEL OR ALL CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            162,
+            596,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Each new task is related to a set of novel classes $C _ { \\mathcal { L } }$ , disjoint from $C _ { B }$ . The goal is to learn a $K _ { \\mathcal { L } }$ -way novel-class classifier or a $K _ { A }$ -way classifier on all classes $C _ { A } = C _ { B } \\cup C _ { \\mathcal { L } }$ for unseen data in $\\mathcal { X }$ , where $K _ { \\mathcal { A } } = K _ { B } + K _ { \\mathcal { L } }$ . Unlike the typical few-shot learning task, each novel class contains few clean and many noise examples. ",
+        "bbox": [
+            174,
+            188,
+            826,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Prior to learning classifiers for novel classes, training examples $x _ { i } \\in X _ { \\mathcal { Z } } ^ { c }$ are weighted by their relevance $r ( x _ { i } )$ to class $c$ . For a noisy example $x _ { i } \\in X _ { \\mathcal { E } } ^ { c }$ , we define $r ( x _ { i } ) = F _ { \\Theta } ( \\tilde { A } , V ) _ { i }$ where $F _ { \\Theta } ( \\tilde { A } , V )$ is the output vector of the GCN, while for a clean example $x _ { i } \\in X _ { \\mathcal { L } } ^ { c }$ we fix $r ( x _ { i } ) = 1$ Note that optimizing (3) does not guarantee $F _ { \\Theta } ( \\tilde { A } , V ) _ { i } = 1$ for clean examples $x _ { i } \\in X _ { \\mathcal { L } } ^ { c }$ . We define $\\textstyle r ( X ) = \\sum _ { x \\in X } r ( x )$ for any set $X \\subset { \\mathcal { X } }$ . ",
+        "bbox": [
+            173,
+            251,
+            825,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first assume that we no longer have access to examples of base classes in new classification tasks and consider two different classifiers, class prototypes and cosine-similarity based classifier. Then, this assumption is dropped and the classifier and feature representation are learned jointly by fine-tuning the entire network. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Class prototypes. For each novel class $c \\in C _ { \\mathcal { L } }$ , we define prototype ${ \\bf w } _ { c }$ by ",
+        "bbox": [
+            173,
+            401,
+            666,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d641c429881b24c6da69fdf3b5c2603b24182d5a2b4595d7fba7984967050ee.jpg",
+        "text": "$$\n\\mathbf { w } _ { c } = \\frac { 1 } { r ( X _ { \\mathcal { E } } ^ { c } ) } \\sum _ { x \\in X _ { \\mathcal { E } } ^ { c } } r ( x ) g _ { \\theta } ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            424,
+            601,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Prototypes are fixed vectors, not learnable parameters. Collecting them into matrix $\\begin{array} { r l } { W _ { \\mathcal { L } } } & { { } = } \\end{array}$ $[ \\mathbf { w } _ { 1 } , \\dots , \\mathbf { w } _ { K _ { \\mathcal { L } } } ] \\in \\mathbb { R } ^ { d \\times K _ { \\mathcal { L } } }$ , $K _ { \\mathcal { L } }$ -way prediction on novel classes is made by classifier $\\pi _ { \\boldsymbol { \\theta } , W _ { \\mathcal { L } } }$ (4), while $K _ { A }$ -way prediction on all (base and novel) classes by $\\pi _ { \\boldsymbol { \\theta } , W _ { A } }$ , where $W _ { \\mathcal { A } } = [ W _ { B } , W _ { \\mathcal { L } } ]$ and $W _ { B }$ is learned according to $L _ { B } ( C _ { B } , X _ { B } ; \\theta , W _ { B } )$ (5) and then kept fixed. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Cosine classifier learning. Similarly to Section 5.2, given clean and noisy novel-class examples $X _ { \\mathcal { E } }$ , we learn a parametric cosine classifier with parameters $W _ { \\mathcal { L } } = [ \\mathbf { w } _ { 1 } , \\dots , \\mathbf { w } _ { K _ { \\mathcal { L } } } ] \\in \\mathbb { R } ^ { d \\times K _ { \\mathcal { L } } }$ by minimizing the weighted cross entropy loss $L _ { \\mathcal { L } } ( C _ { \\mathcal { L } } , X _ { \\mathcal { E } } ; \\theta , W _ { \\mathcal { L } } )$ over $W _ { \\mathcal { L } }$ , where ",
+        "bbox": [
+            174,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d9cc6a68fc31b95d6d72f3677cd4daa097ce6fca886266a36bbf086a956fc14.jpg",
+        "text": "$$\nL _ { \\mathcal { L } } ( C _ { \\mathcal { L } } , X _ { \\mathcal { E } } ; \\theta , W _ { \\mathcal { L } } ) = - \\sum _ { c \\in C _ { \\mathcal { L } } } \\frac { 1 } { r ( X _ { \\mathcal { E } } ^ { c } ) } \\sum _ { x \\in X _ { \\mathcal { E } } ^ { c } } r ( x ) \\log ( \\sigma ( s \\hat { W } _ { \\mathcal { L } } ^ { \\top } \\hat { g } _ { \\theta } ( x ) ) _ { c } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            585,
+            735,
+            626
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "while the parameters $\\theta$ of the feature extractor are fixed. The scale parameter $s$ is also fixed to the value obtained during base class learning. Prediction on novel only or all classes is then made as in the previous case. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Deep network fine-tuning. We now drop the assumption that base class examples are not accessible and, given all examples $X _ { \\mathcal { A } } = X _ { \\mathcal { B } } \\cup X _ { \\mathcal { E } }$ , we jointly learn the parameters $\\theta$ of the feature extractor and $W _ { \\mathcal { A } } = ( W _ { B } , W _ { \\mathcal { L } } )$ of the $K _ { A }$ -way cosine classifier for all classes by minimizing loss function ",
+        "bbox": [
+            173,
+            684,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/379610d627fb0113437714afc09f9e9a7331a93b4bb191ea3d1aaf2e77db7ced.jpg",
+        "text": "$$\nL _ { A } ( C _ { A } , X _ { A } ; \\theta , W _ { A } ) = L _ { B } ( C _ { B } , X _ { B } ; \\theta , W _ { B } ) + L _ { \\mathcal { L } } ( C _ { \\mathcal { L } } , X _ { \\mathcal { E } } ; \\theta , W _ { \\mathcal { L } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            733,
+            725,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that, due to overfitting on the few available examples, such learning is avoided in a few-shot learning setup. In a few cases, it takes the form of fine-tuning including all base class data (Qi et al., 2018), or only lasts for a few iterations when the base class data is not accessible (Finn et al., 2017). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            800
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            820,
+            326,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            852,
+            374,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets and task setup. We extend the Low-Shot ImageNet benchmark introduced by Hariharan & Girshick (2017) by assuming many noisy examples for novel classes, in addition to the few clean ones. In this benchmark, the 1000 ImageNet classes (Russakovsky et al., 2015) are split into 389 base classes and 611 novel classes. The validation set contains 193 base and 300 novel classes, and the test set the remaining 196 base and 311 novel classes. The standard benchmark includes $k$ -shot classification, i.e. classification on $k$ clean examples per class, which we extend to $k$ clean and many noisy examples per class, with $k \\in \\{ 1 , 2 , 5 , 1 0 , 2 0 \\}$ . Similar to Hariharan & Girshick (2017) we perform 5 tasks, each drawing a subset of $k$ clean examples per class. We report the average top-5 accuracy over the 5 tasks on novel or all classes of the test set. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the YFCC100M dataset (Thomee et al., 2016) as a source for additional data with noisy labels. It contains approximatively 100M images collected from Flickr. Each image comes with a text description obtained from the user title and caption. We use the text description to obtain images with noisy labels. as discussed in Section 3. This process results in very different numbers of additional examples per class, with a minimum of zero for classes maillot and missile, and a maximum of 620,142 for class church/church building. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Representation and classifier learning. In most experiments, we use ResNet-10 (He et al., 2016) as feature extractor as in Gidaris & Komodakis (2018). Classification for novel classes is performed with class prototypes (6), cosine classifier learning (7) or deep network fine-tuning (8). Hyper-parameters such as batch size and number of epochs, are tuned on the validation set. Possible values are 2048, 4096, and 8192 for batchsize and 10, 30 and 50 for number of epochs. The learning rate starts from 0.1 and is reduced to 0.001 at the end of training with cosine annealing (Loshchilov & Hutter, 2017). ",
+        "bbox": [
+            174,
+            290,
+            825,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We handle the imbalance of the noisy set by normalizing by $r ( X _ { c } )$ in (7). Prototypes (6) are used to initialize $W _ { \\mathcal { L } }$ of cosine classifier in (7), and the learned $W _ { \\mathcal { L } }$ is used to initialize the corresponding part of $W _ { A }$ when fine-tuning the network by (8). In the latter case, we train all layers for 10 epochs with learning rate 0.01. We ignore examples $x _ { i }$ with relevance $r ( x _ { i } ) < 0 . 1$ to reduce the complexity when fine-tuning the network. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also report results with ResNet-50 as feature extractor, using the model trained on base classes by Hariharan & Girshick (2017). Following Douze et al. (2018), we apply PCA to the features to reduce their dimensionality to 256. Base classes are represented by class prototypes (6) in this case. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GCN training is performed with Adam optimizer and a learning rate of 0.1 for 100 iterations. We use dropout with probability 0.5. The dimensionality of the input descriptors is $d = 5 1 2$ for ResNet-10 and $d = 2 5 6$ for ResNet-50 (after PCA). Dimensionality of the internal representation in (1) is $m = 1 6$ . The affinity matrix is constructed with reciprocal top-50 nearest neighbors. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We implement and evaluate several baseline methods. $\\beta$ -cleaning assigns $r ( x _ { i } ) = \\beta$ to all additional examples. We report results for $\\beta = 1 . 0$ (unit relevance score) and $\\beta ^ { * }$ , the optimal $\\beta$ for all $k$ obtained on the validation set. $M L P$ , discussed in Section 4, learns a nonlinear mapping to assign relevance, but does not propagate over the graph. Label Propagation (LP) (Zhou et al., 2003a) propagates information by a linear operation. It solves the linear system $( I - \\alpha D ^ { - 1 / 2 } A D ^ { - 1 / 2 } ) \\mathbf { r } _ { c } =$ $\\mathbf { y } _ { c }$ (Iscen et al., 2017) for each class $c$ , where $D$ is the degree matrix of $A$ , $\\alpha = 0 . 9$ and $\\mathbf { y } _ { c } \\in \\mathbb { R } ^ { N }$ is a $k$ -hot binary vector indicating the labeled examples of class $c$ . Relevance $r ( x _ { i } )$ is then the $i$ -th element $( \\mathbf { r } _ { c } ) _ { i }$ of the solution. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            689
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            390,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The impact of importance weight $\\lambda$ is measured on the validation set and the best performing value is used on the test set for each value of $k$ . Results are shown in Appendix A. The larger the value of $\\lambda$ , the more the loss encourages noisy examples to be classified as negatives. As a consequence, large (small) $\\lambda$ results in smaller (larger) relevance, on average, for noisy examples. The optimal $\\lambda$ per value of $k$ suggests that the fewer the clean examples the larger the need for additional ones. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            814
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison with baselines using additional data is presented in Table 1. The use of additional data is mostly harmful for $\\beta$ -weighting except for 1 and 2-shot. MLP offers improvements in most cases, implying that it manages to appropriately downweigh irrelevant examples. The consistent improvement of our method compared to MLP, especially large for small $k$ , suggests that it is beneficial to incorporate relations, with the affinity matrix $A$ modeling the structure of the feature space. LP is a classic approach that also uses $A$ but is a linear operation with no parameters, and is inferior to our method. The gain of cleaning ( $\\beta = 1$ vs. ours) ranges from $11 \\%$ to $20 \\%$ . ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a459708462385f825bec2f32d3a41cf64b24997f7906997386decb7226e7f454.jpg",
+        "table_caption": [
+            "Table 1: Comparison with baselines using noisy examples. We report top-5 accuracy on novel classes with classification by class prototypes (6). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td></tr><tr><td colspan=\"6\">FEW CLEAN EXAMPLES</td></tr><tr><td>Class proto.Gidaris &amp; Komodakis (2018)</td><td>45.3±0.65</td><td>57.1±0.37</td><td>69.3±0.32</td><td>74.8±0.20</td><td>77.8±0.24</td></tr><tr><td colspan=\"6\">FEW CLEAN &amp; MANY NOISY EXAMPLES</td></tr><tr><td>β-weighting,β=1</td><td>56.1±0.06</td><td>56.4±0.08</td><td>57.1±0.05</td><td>57.7±0.08</td><td>58.7±0.06</td></tr><tr><td>β-weighting,β*</td><td>55.6±0.24</td><td>58.3±0.14</td><td>63.4±0.25</td><td>67.5±0.34</td><td>71.0±0.22</td></tr><tr><td>Label Propagation Zhou et al. (2003a)</td><td>62.6±0.35</td><td>67.0±0.41</td><td>74.6±0.30</td><td>76.3±0.23</td><td>77.7±0.18</td></tr><tr><td>MLP</td><td>63.6±0.41</td><td>68.8±0.42</td><td>73.9±0.25</td><td>75.6±0.21</td><td>77.6±0.21</td></tr><tr><td>Ours</td><td>67.8±0.10</td><td>70.9±0.30</td><td>73.7±0.17</td><td>76.1±0.12</td><td>78.2±0.14</td></tr></table>",
+        "bbox": [
+            225,
+            101,
+            761,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b93b35a59e17c23022787514572c2915798f4e6c89bd4a24615df6a04cefb60.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td colspan=\"4\">NoVEL CLASSES</td><td colspan=\"5\">ALL CLASSES</td></tr><tr><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td><td>k=1</td><td>2</td><td>5</td><td>10</td><td>20</td></tr><tr><td colspan=\"10\">RESNET-10 -FEW CLEAN EXAMPLES</td></tr><tr><td>Proto.-Nets (Snell et al., 2017)</td><td>39.3</td><td>54.4 66.3</td><td>71.2</td><td>73.9</td><td>49.5</td><td>61.0</td><td>69.7</td><td>72.9</td><td>74.6</td></tr><tr><td>Logistic reg.w/H(Wang et al.,2018b)</td><td>40.7</td><td>50.8 62.0</td><td>69.3</td><td>76.5</td><td>52.2</td><td>59.4</td><td>67.6</td><td>72.8</td><td>76.9</td></tr><tr><td>PMN w/H(Wang et al., 2018b)</td><td>45.8</td><td>57.8 69.0</td><td>74.3</td><td>77.4</td><td>57.6</td><td>64.7</td><td>71.9</td><td>75.2</td><td>77.5</td></tr><tr><td>Class proto.(Gidaris &amp; Komodakis,2018)</td><td></td><td></td><td>45.3±0.6557.1±0.37 69.3±0.32 74.8±0.20 77.8±0.24</td><td></td><td></td><td></td><td></td><td></td><td>57.0±0.3664.7±0.1672.5±0.1875.8±0.1677.4±0.19 58.1±0.4865.2±0.15 72.9±0.25 76.6±0.18 78.8±0.16</td></tr><tr><td colspan=\"10\">Class proto.w/At.(Gidaris&amp; Komodakis,2018) 45.8±0.74 57.4±0.38 69.6±0.27 75.0±0.29 78.2±0.23</td></tr><tr><td></td><td></td><td></td><td>RESNET-1O -FEW CLEAN&amp; MANY NOISY EXAMPLES</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Ours -class proto.(6) Ours-cosine (7)</td><td></td><td></td><td>67.8±0.10 70.9±0.30 73.7±0.20 76.1±0.16 78.2±0.14</td><td></td><td></td><td></td><td></td><td></td><td>70.3±0.05 72.1±0.18 74.1±0.12 75.6±0.13 76.9±0.09</td></tr><tr><td>Ours - fine-tune (8)</td><td></td><td>73.2±0.14 75.3±0.25 75.6±0.24 78.5±0.32 80.7±0.26 74.6±0.13 76.6±0.26 78.2±0.23 80.9±0.34 82.9±0.20</td><td></td><td></td><td></td><td></td><td></td><td></td><td>71.9±0.0774.0±0.2376.5±0.1678.3±0.2380.2±0.18 76.0±0.1077.3±0.1378.7±0.1980.7±0.2582.2±0.14</td></tr><tr><td colspan=\"10\">RESNET-50 - FEW CLEAN EXAMPLES</td></tr><tr><td>Proto.-Nets (Snell et al., 2017)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PMN w/H(Wang et al.,2018b)</td><td>49.6 64.0 54.7 66.8</td><td>74.4 77.4</td><td>78.1 81.4</td><td>80.0 83.8</td><td>61.4 65.7</td><td>71.4 73.5</td><td>78.0 80.2</td><td>80.0 82.8</td><td>81.1 84.5</td></tr><tr><td colspan=\"10\">RESNET-5O-FEW CLEAN&amp;MANYUNLABELED EXAMPLES</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Diffusion (Douze et al., 2018) Diffusion -logistic (Douze et al.,2018)</td><td></td><td></td><td>63.6±0.61 69.5±0.60 75.2±0.40 78.5±0.34 80.8±0.18</td><td></td><td></td><td>=</td><td>-</td><td></td><td></td></tr><tr><td colspan=\"10\">64.0±0.7071.1±0.82 79.7±0.3883.9±0.10 86.3±0.17 RESNET-5O-FEWCLEAN&amp;MANY NOISY EXAMPLES</td></tr><tr><td>Ours - class proto.(6)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Ours - cosine (7)</td><td></td><td>78.0±0.38 80.2±0.3380.9±0.17 83.7±0.1985.7±0.11</td><td>69.7±0.44 73.7±0.56 77.0±0.20 79.9±0.30 81.9±0.29</td><td></td><td></td><td>77.6±0.26 79.1±0.20 79.9±0.09 82.1±0.22 83.8±0.11</td><td></td><td></td><td>73.8±0.33 76.6±0.36 78.9±0.19 80.8±0.21 82.2±0.14</td></tr><tr><td>Ours - fine-tune (8)</td><td>80.8±0.25 83.0±0.23 83.8±0.39 86.4±0.23 88.5±0.20</td><td></td><td></td><td></td><td></td><td>81.6±0.20 83.2±0.16 84.3±0.23 86.2±0.17 87.8±0.03</td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            178,
+            262,
+            820,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison to the state of the art on the Low-shot ImageNet benchmark. We report top-5 accuracy on novel and all classes. We use class prototypes (6), cosine classifier learning (7) and deep network fine-tuning (8) for classification with our GCN-based data addition method. ",
+        "bbox": [
+            176,
+            517,
+            821,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison with the state of the art is presented in Table 2. We significantly improve the performance by using additional data and cleaning compared to a number of different approaches, including the work by Gidaris & Komodakis (2018), which is our starting point. As expected, the gain is more pronounced for small $k$ , reaching more than $20 \\%$ improvement for 1-shot novel accuracy. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Closest to ours is the work of Douze et al. (2018), who use the same experimental setup and the same additional data, but without filtering by text and using noisy labels. We outperform their approach in all cases, while requiring much less computation: offline, we construct a separate small graph per class rather than a single graph over the entire 100M collection; online, we perform inference by cosine similarity to one prototype per class or a learned classifier rather than iterative diffusion on the entire collection. Note that by ignoring examples that are not given any noisy label, we are only using a tiny fraction of the 100M collection: in particular, only 3,744,994 images for the 311-class test split of the Low-shot ImageNet benchmark. In contrast to Douze et al. (2018), additional data brings improvement even at 20-shot with classifier learning or network fine-tuning. Most importantly, our approach does not require the entire 100M collection at inference. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            328,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have introduced a new method for assigning class relevance to noisy images obtained by textual queries with class names. Our approach leverages one or a few labeled images per class and relies on a graph convolutional network (GCN) to propagate visual information from the labeled images to the noisy ones. The GCN is a binary classifier discriminating clean from noisy examples using a weighted binary cross-entropy loss function and inferring “clean” probability as a relevance measure for that class. Experimental results show that using noisy images weighted by this relevance measure significantly improves the classification accuracy. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "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": [
+            174,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann Lecun. Spectral networks and locally connected networks on graphs. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            160,
+            821,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. ICLR, 2019. ",
+        "bbox": [
+            173,
+            195,
+            820,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NeurIPS, 2016. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthijs Douze, Arthur Szlam, Bharath Hariharan, and Hervé Jégou. Low-shot learning with large-scale diffusion. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, 2017. ",
+        "bbox": [
+            174,
+            303,
+            821,
+            330
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In NeurIPS, 2018. ",
+        "bbox": [
+            174,
+            338,
+            816,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. In ICLR, 2018. ",
+        "bbox": [
+            178,
+            362,
+            735,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Spyros Gidaris and Nikos Komodakis. Dynamic few-shot visual learning without forgetting. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            385,
+            816,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Spyros Gidaris and Nikos Komodakis. Generating classification weights with gnn denoising autoencoders for few-shot learning. In CVPR, 2019. ",
+        "bbox": [
+            174,
+            409,
+            821,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In International Conference on Artificial Intelligence and Statistics, 2010. ",
+        "bbox": [
+            173,
+            444,
+            823,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            515,
+            823,
+            544
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ahmet Iscen, Giorgos Tolias, Yannis Avrithis, Teddy Furon, and Ondrej Chum. Efficient diffusion on region manifolds: Recovering small objects with compact cnn representations. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Laurens van der Maaten, Allan Jabri, and Nicolas Vasilache. Learning visual features from large weakly supervised data. In ECCV, 2016. ",
+        "bbox": [
+            174,
+            623,
+            823,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            686
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kuang-Huei Lee, Xiaodong He, Lei Zhang, and Linjun Yang. CleanNet: Transfer learning for scalable image classifier training with label noise. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            694,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            731,
+            823,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Trans. PAMI, 38(3), 2015. ",
+        "bbox": [
+            174,
+            766,
+            823,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yanbin Liu, Juho Lee, Minseop Park, Saehoon Kim, Eunho Yang, Sung Ju Hwang, and Yi Yang. Learning to propagate labels: Transductive propagation network for few-shot learning. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            801,
+            823,
+            829
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. ICLR, 2017. ",
+        "bbox": [
+            176,
+            838,
+            772,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            176,
+            861,
+            823,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with noisy labels. In NeurIPS, 2013. ",
+        "bbox": [
+            174,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hang Qi, Matthew Brown, and David G. Lowe. Low-shot learning with imprinted weights. In CVPR, June 2018. ",
+        "bbox": [
+            171,
+            143,
+            823,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            172,
+            754,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. ICLR, 2015. ",
+        "bbox": [
+            176,
+            200,
+            828,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Sachin Ravi, Eleni Triantafillou, Jake Snell, Kevin Swersky, Josh B. Tenenbaum, Hugo Larochelle, and Richard S. Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018a. ",
+        "bbox": [
+            173,
+            241,
+            825,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to reweight examples for robust deep learning. In ICML, 2018b. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marcus Rohrbach, Sandra Ebert, and Bernt Schiele. Transfer learning in a transductive setting. In NeurIPS, 2013. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "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. IJCV, 115(3), 2015. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. arXiv preprint arXiv:1406.2080, 2014. ",
+        "bbox": [
+            174,
+            444,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bart Thomee, David A. Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland, Damian Borth, and Li-Jia Li. Yfcc $1 0 0 \\mathrm { m }$ : The new data in multimedia research. Commun. ACM, 59(2), 2016. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Veit, Neil Alldrin, Gal Chechik, Ivan Krasin, Abhinav Gupta, and Serge Belongie. Learning from noisy large-scale datasets with minimal supervision. In CVPR, July 2017. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ricardo Vilalta and Youssef Drissi. A perspective view and survey of meta-learning. Artificial intelligence review, 18(2):77–95, 2002. ",
+        "bbox": [
+            173,
+            564,
+            823,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In NeurIPS, 2016. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. In CVPR, 2018a. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In CVPR, 2018b. ",
+        "bbox": [
+            171,
+            727,
+            825,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Frédéric Ratle, and Ronan Collobert. Deep learning via semi-supervised embedding. In ICML, 2008. ",
+        "bbox": [
+            171,
+            767,
+            825,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance-level discrimination. CVPR, 2018. ",
+        "bbox": [
+            173,
+            808,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. In NeurIPS, 2003a. ",
+        "bbox": [
+            173,
+            848,
+            823,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Jason Weston, Arthur Gretton, Olivier Bousquet, and Bernhard Schölkopf. Ranking on data manifolds. In NeurIPS, 2003b. ",
+        "bbox": [
+            171,
+            888,
+            823,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/d75584f0f38734e1f60b1588c31cd97d99ef2d5781c2f1c3f7deaf0d2182f12d.jpg",
+        "image_caption": [
+            "Figure 3: (a) Number of additional images per class $c$ sampled from YFCC-100M for all novel classes of Low-Shot ImageNet. (b) Number of classes per group, when $| X _ { \\mathcal { Z } } ^ { c } |$ is sampled logarithmically into groups. (c) Accuracy improvement $\\Delta$ Acc (difference of accuracy between our method with noisy examples and the baseline without noisy examples) for prototype classifier, for same groups as in (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            828,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            297,
+            357
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noisy data statistics. We present statistics about the noisy examples of novel classes and the improvements of our method per class. Figure 3 (a) shows that the noisy examples for novel classes are long tailed (in log scale). There is a significant number of classes where we end up with less than 1000 extra examples, but we improve nevertheless; see Figure 3 (c). A small exception is 4 very rare classes out of 311, with around 3 additional images per class (leftmost bin in Figure 3 (b) and (c)). Note that in real world applications, one could use more resources like web queries for additional data. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Impact of importance weight $\\lambda ,$ . We present the impact of $\\lambda$ (3) for different values of $k$ in the validation set of the extended Low-shot ImageNet benchmark in Figure 4. ",
+        "bbox": [
+            171,
+            497,
+            825,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/75723f011baed9f80d3665089fcfcb5e9cf2105defc23b6659f2c9df36dc3084.jpg",
+        "image_caption": [
+            "Figure 4: Impact of $\\lambda$ on the validation set of the extended Low-shot ImageNet benchmark with YFCC-100M for noisy examples using class prototypes (6). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            554,
+            676,
+            656
+        ],
+        "page_idx": 10
+    }
+]

parse/train/Hk2aImxAb/Hk2aImxAb.md

@@ -0,0 +1,241 @@
+# MULTI-SCALE DENSE NETWORKS FOR RESOURCE EFFICIENT IMAGE CLASSIFICATION
+
+Gao Huang Cornell University
+
+Danlu Chen Fudan University
+
+Tianhong Li Tsinghua University
+
+Felix Wu Cornell University
+
+Laurens van der Maaten Facebook AI Research
+
+Kilian Weinberger Cornell University
+
+# ABSTRACT
+
+In this paper we investigate image classification with computational resource limits at test time. Two such settings are: 1. anytime classification, where the network’s prediction for a test example is progressively updated, facilitating the output of a prediction at any time; and 2. budgeted batch classification, where a fixed amount of computation is available to classify a set of examples that can be spent unevenly across “easier” and “harder” inputs. In contrast to most prior work, such as the popular Viola and Jones algorithm, our approach is based on convolutional neural networks. We train multiple classifiers with varying resource demands, which we adaptively apply during test time. To maximally re-use computation between the classifiers, we incorporate them as early-exits into a single deep convolutional neural network and inter-connect them with dense connectivity. To facilitate high quality classification early on, we use a two-dimensional multi-scale network architecture that maintains coarse and fine level features all-throughout the network. Experiments on three image-classification tasks demonstrate that our framework substantially improves the existing state-of-the-art in both settings.
+
+# 1 INTRODUCTION
+
+Recent years have witnessed a surge in demand for applications of visual object recognition, for instance, in self-driving cars (Bojarski et al., 2016) and content-based image search (Wan et al., 2014). This demand has in part been fueled through the promise generated by the astonishing progress of convolutional networks (CNNs) on visual object recognition benchmark competition datasets, such as ILSVRC (Deng et al., 2009) and COCO (Lin et al., 2014), where state-of-the-art models may have even surpassed human-level performance (He et al., 2015; 2016).
+
+However, the requirements of such competitions differ from realworld applications, which tend to incentivize resource-hungry models with high computational demands at inference time. For example, the COCO 2016 competition was won by a large ensemble of computationally intensive $\mathrm { \dot { C } N N s ^ { 1 } }$ — a model likely far too computationally expensive for any resource-aware application. Although much smaller models would also obtain decent error, very large, computationally intensive models seem necessary to correctly classify the hard examples that make up the bulk of the remaining misclassifications of modern algorithms. To illustrate this point, Figure 1 shows two images of horses. The left image depicts a horse in canonical pose and is easy to classify, whereas the right image is taken from a rare viewpoint and is likely in the tail of the data distribution. Computationally intensive models are needed to classify such tail examples correctly, but are wasteful when applied to canonical images such as the left one.
+
+![](images/2e2e080304ad2c7be1e5890d21d32ed57f0cf575c439df5f869a545d4f732d05.jpg)  
+Figure 1: Two images containing a horse. The left image is canonical and easy to detect even with a small model, whereas the right image requires a computationally more expensive network architecture. (Copyright Pixel Addict and Doyle (CC BY-ND 2.0).)
+
+In real-world applications, computation directly translates into power consumption, which should be minimized for environmental and economical reasons, and is a scarce commodity on mobile devices. This begs the question: why do we choose between either wasting computational resources by applying an unnecessarily computationally expensive model to easy images, or making mistakes by using an efficient model that fails to recognize difficult images? Ideally, our systems should automatically use small networks when test images are easy or computational resources limited, and use big networks when test images are hard or computation is abundant.
+
+Such systems would be beneficial in at least two settings with computational constraints at testtime: anytime prediction, where the network can be forced to output a prediction at any given point in time; and budgeted batch classification, where a fixed computational budget is shared across a large set of examples which can be spent unevenly across “easy” and “hard” examples. A practical use-case of anytime prediction is in mobile apps on Android devices: in 2015, there existed 24, 093 distinct Android devices2, each with its own distinct computational limitations. It is infeasible to train a different network that processes video frame-by-frame at a fixed framerate for each of these devices. Instead, you would like to train a single network that maximizes accuracy on all these devices, within the computational constraints of that device. The budget batch classification setting is ubiquitous in large-scale machine learning applications. Search engines, social media companies, on-line advertising agencies, all must process large volumes of data on limited hardware resources. For example, as of 2010, Google Image Search had over 10 Billion images indexed3, which has likely grown to over 1 Trillion since. Even if a new model to process these images is only 1/10s slower per image, this additional cost would add 3170 years of CPU time. In the budget batch classification setting, companies can improve the average accuracy by reducing the amount of computation spent on “easy” cases to save up computation for “hard” cases.
+
+Motivated by prior work in computer vision on resource-efficient recognition (Viola & Jones, 2001), we aim to develop CNNs that “slice” the computation and process these slices one-by-one, stopping the evaluation once the CPU time is depleted or the classification sufficiently certain (through “early exits”). Unfortunately, the architecture of CNNs is inherently at odds with the introduction of early exits. CNNs learn the data representation and the classifier jointly, which leads to two problems with early exits: 1. The features in the last layer are extracted directly to be used by the classifier, whereas earlier features are not. The inherent dilemma is that different kinds of features need to be extracted depending on how many layers are left until the classification. 2. The features in different layers of the network may have different scale. Typically, the first layers of a deep nets operate on a fine scale (to extract low-level features), whereas later layers transition (through pooling or strided convolution) to coarse scales that allow global context to enter the classifier. Both scales are needed but happen at different places in the network.
+
+We propose a novel network architecture that addresses both of these problems through careful design changes, allowing for resource-efficient image classification. Our network uses a cascade of intermediate classifiers throughout the network. The first problem, of classifiers altering the internal representation, is addressed through the introduction of dense connectivity (Huang et al., 2017). By connecting all layers to all classifiers, features are no longer dominated by the most imminent earlyexit and the trade-off between early or later classification can be performed elegantly as part of the loss function. The second problem, the lack of coarse-scale features in early layers, is addressed by adopting a multi-scale network structure. At each layer we produce features of all scales (fine-tocoarse), which facilitates good classification early on but also extracts low-level features that only become useful after several more layers of processing. Our network architecture is illustrated in Figure 2, and we refer to it as Multi-Scale DenseNet (MSDNet).
+
+We evaluate MSDNets on three image-classification datasets. In the anytime classification setting, we show that it is possible to provide the ability to output a prediction at any time while maintain high accuracies throughout. In the budget batch classification setting we show that MSDNets can be effectively used to adapt the amount of computation to the difficulty of the example to be classified, which allows us to reduce the computational requirements of our models drastically whilst performing on par with state-of-the-art CNNs in terms of overall classification accuracy. To our knowledge this is the first deep learning architecture of its kind that allows dynamic resource adaptation with a single model and obtains competitive results throughout.
+
+![](images/393456a645a070145e34d48f149ac9a7ed180043707a693bf4407c8f3be79371.jpg)  
+Figure 2: Illustration of the first four layers of an MSDNet with three scales. The horizontal direction corresponds to the layer direction (depth) of the network. The vertical direction corresponds to the scale of the feature maps. Horizontal arrows indicate a regular convolution operation, whereas diagonal and vertical arrows indicate a strided convolution operation. Classifiers only operate on feature maps at the coarsest scale. Connections across more than one layer are not drawn explicitly: they are implicit through recursive concatenations.
+
+# 2 RELATED WORK
+
+We briefly review related prior work on computation-efficient networks, memory-efficient networks, and resource-sensitive machine learning, from which our network architecture draws inspiration.
+
+Computation-efficient networks. Most prior work on (convolutional) networks that are computationally efficient at test time focuses on reducing model size after training. In particular, many studies propose to prune weights (LeCun et al., 1989; Hassibi et al., 1993; Li et al., 2017) or quantize weights (Hubara et al., 2016; Rastegari et al., 2016) during or after training. These approaches are generally effective because deep networks often have a substantial number of redundant weights that can be pruned or quantized without sacrificing (and sometimes even improving) performance. Prior work also studies approaches that directly learn compact models with less parameter redundancy. For example, the knowledge-distillation method (Bucilua et al., 2006; Hinton et al., 2014) trains small student networks to reproduce the output of a much larger teacher network or ensemble. Our work differs from those approaches in that we train a single model that trades off computation for accuracy at test time without any re-training or finetuning. Indeed, weight pruning and knowledge distillation can be used in combination with our approach, and may lead to further improvements.
+
+Resource-efficient machine learning. Various prior studies explore computationally efficient variants of traditional machine-learning models (Viola & Jones, 2001; Grubb & Bagnell, 2012; Karayev et al., 2014; Trapeznikov & Saligrama, 2013; Xu et al., 2012; 2013; Nan et al., 2015; Wang et al., 2015). Most of these studies focus on how to incorporate the computational requirements of computing particular features in the training of machine-learning models such as (gradient-boosted) decision trees. Whilst our study is certainly inspired by these results, the architecture we explore differs substantially: most prior work exploits characteristics of machine-learning models (such as decision trees) that do not apply to deep networks. Our work is possibly most closely related to recent work on FractalNets (Larsson et al., 2017), which can perform anytime prediction by progressively evaluating subnetworks of the full network. FractalNets differ from our work in that they are not explicitly optimized for computation efficiency and consequently our experiments show that MSDNets substantially outperform FractalNets. Our dynamic evaluation strategy for reducing batch computational cost is closely related to the the adaptive computation time approach (Graves, 2016; Figurnov et al., 2016), and the recently proposed method of adaptively evaluating neural networks (Bolukbasi et al., 2017). Different from these works, our method adopts a specially designed network with multiple classifiers, which are jointly optimized during training and can directly output confidence scores to control the evaluation process for each test example. The adaptive computation time method (Graves, 2016) and its extension (Figurnov et al., 2016) also perform adaptive evaluation on test examples to save batch computational cost, but focus on skipping units rather than layers. In (Odena et al., 2017), a “composer”model is trained to construct the evaluation network from a set of sub-modules for each test example. By contrast, our work uses a single CNN with multiple intermediate classifiers that is trained end-to-end. The Feedback Networks (Zamir et al., 2016) enable early predictions by making predictions in a recurrent fashion, which heavily shares parameters among classifiers, but is less efficient in sharing computation.
+
+Related network architectures. Our network architecture borrows elements from neural fabrics (Saxena & Verbeek, 2016) and others (Zhou et al., 2015; Jacobsen et al., 2017; Ke et al., 2016)
+
+![](images/6c59242daaab86116b0562f24208342d867eb57b7d0db805e434894dcf77ee2c.jpg)  
+Figure 3: Relative accuracy of the intermediate classifier (left) and the final classifier (right) when introducing a single intermediate classifier at different layers in a ResNet, DenseNet and MSDNet. All experiments were performed on the CIFAR-100 dataset. Higher is better.
+
+to rapidly construct a low-resolution feature map that is amenable to classification, whilst also maintaining feature maps of higher resolution that are essential for obtaining high classification accuracy. Our design differs from the neural fabrics (Saxena & Verbeek, 2016) substantially in that MSDNets have a reduced number of scales and no sparse channel connectivity or up-sampling paths. MSDNets are at least one order of magnitude more efficient and typically more accurate — for example, an MSDNet with less than 1 million parameters obtains a test error below $7 . 0 \%$ on CIFAR-10 (Krizhevsky & Hinton, 2009), whereas Saxena & Verbeek (2016) report $7 . 4 3 \%$ with over 20 million parameters. We use the same feature-concatenation approach as DenseNets (Huang et al., 2017), which allows us to bypass features optimized for early classifiers in later layers of the network. Our architecture is related to deeply supervised networks (Lee et al., 2015) in that it incorporates classifiers at multiple layers throughout the network. In contrast to all these prior architectures, our network is specifically designed to operate in resource-aware settings.
+
+# 3 PROBLEM SETUP
+
+We consider two settings that impose computational constraints at prediction time.
+
+Anytime prediction. In the anytime prediction setting (Grubb & Bagnell, 2012), there is a finite computational budget $B > 0$ available for each test example $\mathbf { x }$ . The computational budget is nondeterministic, and varies per test instance. It is determined by the occurrence of an event that requires the model to output a prediction immediately. We assume that the budget is drawn from some joint distribution $P ( \mathbf { x } , B )$ . In some applications $P ( B )$ may be independent of $P ( \mathbf { x } )$ and can be estimated. For example, if the event is governed by a Poisson process, $P ( B )$ is an exponential distribution. We denote the loss of a model $f ( \mathbf { x } )$ that has to produce a prediction for instance $\mathbf { x }$ within budget $B$ by $L ( f ( \mathbf { x } ) , B )$ . The goal of an anytime learner is to minimize the expected loss under the budget distribution: $L ( f ) = \mathbb { E } \left[ L ( f ( \mathbf { x } ) , B ) \right] _ { P ( \mathbf { x } , B ) } .$ Here, $L ( \cdot )$ denotes a suitable loss function. As is common in the empirical risk minimization framework, the expectation under $P ( \mathbf { x } , B )$ may be estimated by an average over samples from $P ( \mathbf { x } , B )$ .
+
+Budgeted batch classification. In the budgeted batch classification setting, the model needs to classify a set of examples $\mathcal { D } _ { t e s t } = \{ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { M } \}$ within a finite computational budget $B > 0$ that is known in advance. The learner aims to minimize the loss across all examples in $\mathcal { D } _ { t e s t }$ within a cumulative cost bounded by $B$ , which we denote by $L ( f ( \mathcal { D } _ { t e s t } ) , B )$ for some suitable loss function $L ( \cdot )$ . It can potentially do so by spending less than BM computation on classifying an “easy” example whilst using more than $\textstyle { \frac { B } { M } }$ computation on classifying a “difficult” example. Therefore, the budget considered here is a soft constraint when we have a large batch of testing samples.
+
+# 4 MULTI-SCALE DENSE CONVOLUTIONAL NETWORKS
+
+A straightforward solution to the two problems introduced in Section 3 is to train multiple networks of increasing capacity, and sequentially evaluate them at test time (as in Bolukbasi et al. (2017)). In the anytime setting the evaluation can be stopped at any point and the most recent prediction is returned. In the batch setting, the evaluation is stopped prematurely the moment a network classifies the test sample with sufficient confidence. When the resources are so limited that the execution is terminated after the first network, this approach is optimal because the first network is trained for exactly this computational budget without compromises. However, in both settings, this scenario is rare. In the more common scenario where some test samples can require more processing time than others the approach is far from optimal because previously learned features are never re-used across the different networks.
+
+An alternative solution is to build a deep network with a cascade of classifiers operating on the features of internal layers: in such a network features computed for an earlier classifier can be re-used by later classifiers. However, na¨ıvely attaching intermediate early-exit classifiers to a stateof-the-art deep network leads to poor performance.
+
+There are two reasons why intermediate early-exit classifiers hurt the performance of deep neural networks: early classifiers lack coarse-level features and classifiers throughout interfere with the feature generation process. In this section we investigate these effects empirically (see Figure 3) and, in response to our findings, propose the MSDNet architecture illustrated in Figure 2.
+
+Problem: The lack of coarse-level features. Traditional neural networks learn features of fine scale in early layers and coarse scale in later layers (through repeated convolution, pooling, and strided convolution). Coarse scale features in the final layers are important to classify the content of the whole image into a single class. Early layers lack coarse-level features and early-exit classifiers attached to these layers will likely yield unsatisfactory high error rates. To illustrate this point, we attached4 intermediate classifiers to varying layers of a ResNet (He et al., 2016) and a DenseNet (Huang et al., 2017) on the CIFAR-100 dataset (Krizhevsky & Hinton, 2009). The blue and red dashed lines in the left plot of Figure 3 show the relative accuracies of these classifiers. All three plots gives rise to a clear trend: the accuracy of a classifier is highly correlated with its position within the network. Particularly in the case of the ResNet (blue line), one can observe a visible “staircase” pattern, with big improvements after the 2nd and 4th classifiers — located right after pooling layers.
+
+Solution: Multi-scale feature maps. To address this issue, MSDNets maintain a feature representation at multiple scales throughout the network, and all the classifiers only use the coarse-level features. The feature maps at a particular layer5 and scale are computed by concatenating the results of one or two convolutions: 1. the result of a regular convolution applied on the same-scale features from the previous layer (horizontal connections) and, if possible, 2. the result of a strided convolution applied on the finer-scale feature map from the previous layer (diagonal connections). The horizontal connections preserve and progress high-resolution information, which facilitates the construction of high-quality coarse features in later layers. The vertical connections produce coarse features throughout that are amenable to classification. The dashed black line in Figure 3 shows that MSDNets substantially increase the accuracy of early classifiers.
+
+Problem: Early classifiers interfere with later classifiers. The right plot of Figure 3 shows the accuracies of the final classifier as a function of the location of a single intermediate classifier, relative to the accuracy of a network without intermediate classifiers. The results show that the introduction of an intermediate classifier harms the final ResNet classifier (blue line), reducing its accuracy by up to $7 \%$ . We postulate that this accuracy degradation in the ResNet may be caused by the intermediate classifier influencing the early features to be optimized for the short-term and not for the final layers. This improves the accuracy of the immediate classifier but collapses information required to generate high quality features in later layers. This effect becomes more pronounced when the first classifier is attached to an earlier layer.
+
+Solution: Dense connectivity. By contrast, the DenseNet (red line) suffers much less from this effect. Dense connectivity (Huang et al., 2017) connects each layer with all subsequent layers and allows later layers to bypass features optimized for the short-term, to maintain the high accuracy of the final classifier. If an earlier layer collapses information to generate short-term features, the lost information can be recovered through the direct connection to its preceding layer. The final classifier’s performance becomes (more or less) independent of the location of the intermediate classifier. As far as we know, this is the first paper that discovers that dense connectivity is an important element to early-exit classifiers in deep networks, and we make it an integral design choice in MSDNets.
+
+![](images/8de8c69d9d36a341a0373469c5e2695c92df31ad7bca8cfbfd76709c742d677e.jpg)  
+Figure 4: The output $\mathbf { x } _ { \ell } ^ { s }$ of layer $\ell$ at the $s ^ { \mathrm { t h } }$ scale in a MSDNet. Herein, [. . . ] denotes the concatenation operator, $h _ { \ell } ^ { s } ( \cdot )$ a regular convolution transformation, and $\tilde { h } _ { \ell } ^ { s } ( \cdot )$ a strided convolutional. Note that the outputs of $h _ { \ell } ^ { s }$ and $\tilde { h } _ { \ell } ^ { s }$ have the same feature map size; their outputs are concatenated along the channel dimension.
+
+# 4.1 THE MSDNET ARCHITECTURE
+
+The MSDNet architecture is illustrated in Figure 2. We present its main components below. Additional details on the architecture are presented in Appendix A.
+
+First layer. The first layer $\ell = 1 $ ) is unique as it includes vertical connections in Figure 2. Its main purpose is to “seed” representations on all $S$ scales. One could view its vertical layout as a miniature “S-layers” convolutional network $S { = } 3$ in Figure 2). Let us denote the output feature maps at layer $\ell$ and scale $s$ as $\mathbf { x } _ { \ell } ^ { s }$ and the original input image as $\mathbf { x } _ { 0 } ^ { 1 }$ . Feature maps at coarser scales are obtained via down-sampling. The output $\mathbf { x } _ { 1 } ^ { s }$ of the first layer is formally given in the top row of Figure 4.
+
+Subsequent layers. Following Huang et al. (2017), the output feature maps $\mathbf { x } _ { \ell } ^ { s }$ produced at subsequent layers, $\ell > 1$ , and scales, $s$ , are a concatenation of transformed feature maps from all previous feature maps of scale $s$ and $s - 1$ (if $s > 1$ ). Formally, the $\ell \cdot$ -th layer of our network outputs a set of features at $S$ scales $\big \{ \mathbf { x } _ { \ell } ^ { 1 } , \dots , \mathbf { x } _ { \ell } ^ { S } \big \}$ , given in the last row of Figure 4.
+
+Classifiers. The classifiers in MSDNets also follow the dense connectivity pattern within the coarsest scale, $S$ , i.e., the classifier at layer $\ell$ uses all the features $\left[ \mathbf { x } _ { 1 } ^ { S } , \ldots , \mathbf { x } _ { \ell } ^ { S } \right]$ . Each classifier consists of two convolutional layers, followed by one average pooling layer and one linear layer. In practice, we only attach classifiers to some of the intermediate layers, and we let $f _ { k } ( \cdot )$ denote the $k ^ { \mathrm { { t h } } }$ classifier. During testing in the anytime setting we propagate the input through the network until the budget is exhausted and output the most recent prediction. In the batch budget setting at test time, an example traverses the network and exits after classifier $f _ { k }$ if its prediction confidence (we use the maximum value of the softmax probability as a confidence measure) exceeds a pre-determined threshold $\theta _ { k }$ . Before training, we compute the computational cost, $C _ { k }$ , required to process the network up to the $k ^ { \mathrm { { t h } } }$ classifier. We denote by $0 < q \le 1$ a fixed exit probability that a sample that reaches a classifier will obtain a classification with sufficient confidence to exit. We assume that $q$ is constant across all layers, which allows us to compute the probability that a sample exits at classifier $k$ as: $q _ { k } = z ( 1 - q ) ^ { \bar { k ^ { - 1 } } q }$ , where $z$ is a normalizing constant that ensures that $\begin{array} { r } { \sum _ { k } p ( q _ { k } ) = 1 } \end{array}$ . At test time, we need to ensure that the overall cost of classifying all samples in $\mathcal { D } _ { t e s t }$ does not exceed our budget $B$ (in expectation). This gives rise to the constraint $\begin{array} { r } { \left| \mathcal { D } _ { t e s t } \right| \sum _ { k } q _ { k } C _ { k } \le B } \end{array}$ . We can solve this constraint for $q$ and determine the thresholds $\theta _ { k }$ on a validation set in such a way that approximately $| \mathcal { D } _ { t e s t } | q _ { k }$ validation samples exit at the $k ^ { \mathrm { { t h } } }$ classifier.
+
+Loss functions. During training we use cross entropy loss functions $L ( f _ { k } )$ for all classifiers and minimize a weighted cumulative loss: $\begin{array} { r } { \frac { 1 } { | \mathcal { D } | } \sum _ { ( \mathbf { x } , y ) \in \mathcal { D } } \mathbf { \tilde { \sum } } _ { k } w _ { k } L ( f _ { k } ) } \end{array}$ . Herein, $\mathcal { D }$ denotes the training set and $w _ { k } \ge 0$ the weight of the $k$ -th classifier. If the budget distribution $P ( B )$ is known, we can use the weights $w _ { k }$ to incorporate our prior knowledge about the budget $B$ in the learning. Empirically, we find that using the same weight for all loss functions (i.e., setting $\forall k : w _ { k } = 1$ ) works well in practice.
+
+Network reduction and lazy evaluation. There are two straightforward ways to further reduce the computational requirements of MSDNets. First, it is inefficient to maintain all the finer scales until the last layer of the network. One simple strategy to reduce the size of the network is by splitting it into $S$ blocks along the depth dimension, and only keeping the coarsest $( S - i + 1 )$ scales in the $i ^ { \mathrm { t h } }$ block (a schematic layout of this structure is shown in Figure 9). This reduces computational cost for both training and testing. Every time a scale is removed from the network, we add a transition layer between the two blocks that merges the concatenated features using a $1 \times 1$ convolution and cuts the number of channels in half before feeding the fine-scale features into the coarser scale via a strided convolution (this is similar to the DenseNet-BC architecture of Huang et al. (2017)). Second, since a classifier at layer $\ell$ only uses features from the coarsest scale, the finer feature maps in layer $\ell$ (and some of the finer feature maps in the previous $S - 2$ layers) do not influence the prediction of that classifier. Therefore, we group the computation in “diagonal blocks” such that we only propagate the example along paths that are required for the evaluation of the next classifier. This minimizes unnecessary computations when we need to stop because the computational budget is exhausted. We call this strategy lazy evaluation.
+
+# 5 EXPERIMENTS
+
+We evaluate the effectiveness of our approach on three image classification datasets, i.e., the CIFAR10, CIFAR-100 (Krizhevsky & Hinton, 2009) and ILSVRC 2012 (ImageNet; Deng et al. (2009)) datasets. Code to reproduce all results is available at https://anonymous-url. Details on architectural configurations of MSDNets are described in Appendix A.
+
+Datasets. The two CIFAR datasets contain 50, 000 training and 10, 000 test images of $3 2 \times 3 2$ pixels; we hold out 5, 000 training images as a validation set. The datasets comprise 10 and 100 classes, respectively. We follow He et al. (2016) and apply standard data-augmentation techniques to the training images: images are zero-padded with 4 pixels on each side, and then randomly cropped to produce $3 2 \times 3 2$ images. Images are flipped horizontally with probability 0.5, and normalized by subtracting channel means and dividing by channel standard deviations. The ImageNet dataset comprises 1, 000 classes, with a total of 1.2 million training images and 50,000 validation images. We hold out 50,000 images from the training set to estimate the confidence threshold for classifiers in MSDNet. We adopt the data augmentation scheme of He et al. (2016) at training time; at test time, we classify a $2 2 4 \times 2 2 4$ center crop of images that were resized to $2 5 6 \times 2 5 6$ pixels.
+
+Training Details. We train all models using the framework of Gross & Wilber (2016). On the two CIFAR datasets, all models (including all baselines) are trained using stochastic gradient descent (SGD) with mini-batch size 64. We use Nesterov momentum with a momentum weight of 0.9 without dampening, and a weight decay of $1 0 ^ { - 4 }$ . All models are trained for 300 epochs, with an initial learning rate of 0.1, which is divided by a factor 10 after 150 and 225 epochs. We apply the same optimization scheme to the ImageNet dataset, except that we increase the mini-batch size to 256, and all the models are trained for 90 epochs with learning rate drops after 30 and 60 epochs.
+
+# 5.1 ANYTIME PREDICTION
+
+In the anytime prediction setting, the model maintains a progressively updated distribution over classes, and it can be forced to output its most up-to-date prediction at an arbitrary time.
+
+Baselines. There exist several baseline approaches for anytime prediction: FractalNets (Larsson et al., 2017), deeply supervised networks (Lee et al., 2015), and ensembles of deep networks of varying or identical sizes. FractalNets allow for multiple evaluation paths during inference time, which vary in computation time. In the anytime setting, paths are evaluated in order of increasing computation. In our result figures, we replicate the FractalNet results reported in the original paper (Larsson et al., 2017) for reference. Deeply supervised networks introduce multiple early-exit classifiers throughout a network, which are applied on the features of the particular layer they are attached to. Instead of using the original model proposed in Lee et al. (2015), we use the more competitive ResNet and DenseNet architectures (referred to as DenseNet- $B C$ in Huang et al. (2017)) as the base networks in our experiments with deeply supervised networks. We refer to these as $R e s N e t ^ { M C }$ and DenseNetMC, where $M C$ stands for multiple classifiers. Both networks require about $1 . 3 \times 1 0 ^ { 8 }$ FLOPs when fully evaluated; the detailed network configurations are presented in the supplementary material. In addition, we include ensembles of ResNets and DenseNets of varying or identical sizes. At test time, the networks are evaluated sequentially (in ascending order of network size) to obtain predictions for the test data. All predictions are averaged over the evaluated classifiers. On
+
+![](images/0e595351824a020ac424bb128829df21d92c0ecca2b1cea17c58c737e1308b61.jpg)  
+Figure 5: Accuracy (top-1) of anytime prediction models as a function of computational budget on the ImageNet (left) and CIFAR-100 (right) datasets. Higher is better.
+
+ImageNet, we compare MSDNet against a highly competitive ensemble of ResNets and DenseNets, with depth varying from 10 layers to 50 layers, and 36 layers to 121 layers, respectively.
+
+Anytime prediction results are presented in Figure 5. The left plot shows the top-1 classification accuracy on the ImageNet validation set. Here, for all budgets in our evaluation, the accuracy of MSDNet substantially outperforms the ResNets and DenseNets ensemble. In particular, when the budget ranges from $0 . 1 \times \bar { 1 0 } ^ { 1 0 }$ to $0 . 3 \times 1 0 ^ { 1 0 }$ FLOPs, MSDNet achieves $\sim 4 \% - 8 \%$ higher accuracy.
+
+We evaluate more baselines on CIFAR-100 (and CIFAR-10; see supplementary materials). We observe that MSDNet substantially outperforms ResNetsMC and DenseNetsMC at any computational budget within our range. This is due to the fact that after just a few layers, MSDNets have produced low-resolution feature maps that are much more suitable for classification than the high-resolution feature maps in the early layers of ResNets or DenseNets. MSDNet also outperforms the other baselines for nearly all computational budgets, although it performs on par with ensembles when the budget is very small. In the extremely low-budget regime, ensembles have an advantage because their predictions are performed by the first (small) network, which is optimized exclusively for the low budget. However, the accuracy of ensembles does not increase nearly as fast when the budget is increased. The MSDNet outperforms the ensemble as soon as the latter needs to evaluate a second model: unlike MSDNets, this forces the ensemble to repeat the computation of similar low-level features repeatedly. Ensemble accuracies saturate rapidly when all networks are shallow.
+
+# 5.2 BUDGETED BATCH CLASSIFICATION
+
+In budgeted batch classification setting, the predictive model receives a batch of $M$ instances and a computational budget $B$ for classifying all $M$ instances. In this setting, we use dynamic evaluation: we perform early-exiting of “easy” examples at early classifiers whilst propagating “hard” examples through the entire network, using the procedure described in Section 4.
+
+Baselines. On ImageNet, we compare the dynamically evaluated MSDNet with five ResNets (He et al., 2016) and five DenseNets (Huang et al., 2017), AlexNet (Krizhevsky et al., 2012), and GoogleLeNet (Szegedy et al., 2015); see the supplementary material for details. We also evaluate an ensemble of the five ResNets that uses exactly the same dynamic-evaluation procedure as MSDNets at test time: “easy” images are only propagated through the smallest ResNet-10, whereas “hard” images are classified by all five ResNet models (predictions are averaged across all evaluated networks in the ensemble). We classify batches of $M = 1 2 8$ images.
+
+On CIFAR-100, we compare MSDNet with several highly competitive baselines, including ResNets (He et al., 2016), DenseNets (Huang et al., 2017) of varying sizes, Stochastic Depth Networks (Huang et al., 2016), Wide ResNets (Zagoruyko & Komodakis, 2016) and FractalNets (Larsson et al., 2017). We also compare MSDNet to the $\mathrm { R e s N e t ^ { M C } }$ and DenseNetMC models that were used in Section 5.1, using dynamic evaluation at test time. We denote these baselines as $R e s N e t ^ { M C }$ / DenseNetMC with early-exits. To prevent the result plots from becoming too cluttered, we present CIFAR-100 results with dynamically evaluated ensembles in the supplementary material. We classify batches of $M = 2 5 6$ images at test time.
+
+Budgeted batch classification results on ImageNet are shown in the left panel of Figure 7. We trained three MSDNets with different depths, each of which covers a different range of computational budgets. We plot the performance of each MSDNet as a gray curve; we select the best model for each budget based on its accuracy on the validation set, and plot the corresponding accuracy as a black curve. The plot shows that the predictions of MSDNets with dynamic evaluation are substantially more accurate than those of ResNets and DenseNets that use the same amount of computation. For instance, with an average budget of $1 . 7 \times 1 0 ^ { 9 }$ FLOPs, MSDNet achieves a top-1 accuracy of ${ \sim } 7 5 \%$ , which is ${ \sim } 6 \%$ higher than that achieved by a ResNet with the same number of FLOPs. Compared to the computationally efficient DenseNets, MSDNet uses $\sim 2 - 3 \times$ times fewer FLOPs to achieve the same classification accuracy. Moreover, MSDNet with dynamic evaluation allows for very precise tuning of the computational budget that is consumed, which is not possible with individual ResNet or DenseNet models. The ensemble of ResNets or DenseNets with dynamic evaluation performs on par with or worse than their individual counterparts (but they do allow for setting the computational budget very precisely).
+
+![](images/047b8902b777ad1edf01cc1798508fdcb86d98ce8b5ec9a2971efe96719d19ec.jpg)  
+Figure 7: Accuracy (top-1) of budgeted batch classification models as a function of average computational budget per image the on ImageNet (left) and CIFAR-100 (right) datasets. Higher is better.
+
+The right panel of Figure 7 shows our results on CIFAR-100. The results show that MSDNets consistently outperform all baselines across all budgets. Notably, MSDNet performs on par with a 110- layer ResNet using only 1/10th of the computational budget and it is up to $\sim 5$ times more efficient than DenseNets, Stochastic Depth Networks, Wide ResNets, and FractalNets. Similar to results in the anytime-prediction setting, MSDNet substantially outperform ResNetsMC and DenseNets $_ { M C }$ with multiple intermediate classifiers, which provides further evidence that the coarse features in the MSDNet are important for high performance in earlier layers.
+
+Visualization. To illustrate the ability of our approach to reduce the computational requirements for classifying “easy” examples, we show twelve randomly sampled test images from two ImageNet classes in Figure 6. The top row shows “easy” examples that were correctly classified and exited by the first classifier. The bottom row shows “hard” examples that would have been incorrectly classified by the first classifier but were passed on because its uncertainty was too high. The figure suggests that early classifiers recognize prototypical class examples, whereas the last classifier recognizes non-typical images.
+
+![](images/105e212787f02ba3ad81fe470cd4782e898e2825cb6b2147833e9bbcf9aa8bfb.jpg)  
+Figure 6: Sampled images from the ImageNet classes Red wine and Volcano. Top row: images exited from the first classifier of a MSDNet with correct prediction; Bottom row: images failed to be correctly classified at the first classifier but were correctly predicted and exited at the last layer.
+
+# 5.3 MORE COMPUTATIONALLY EFFICIENT DENSENETS
+
+Here, we discuss an interesting finding during our exploration of the MSDNet architecture. We found that following the DenseNet structure to design our network, i.e., by keeping the number of output channels (or growth rate) the same at all scales, did not lead to optimal results in terms of the accuracy-speed trade-off. The main reason for this is that compared to network architectures like ResNets, the DenseNet structure tends to apply more filters on the high-resolution feature maps in the network. This helps to reduce the number of parameters in the model, but at the same time, it greatly increases the computational cost. We tried to modify DenseNets by doubling the growth rate after each transition layer, so that more filters are applied to low-resolution feature maps. It turns out that the resulting network, which we denote as DenseNet\*, significantly outperform the original DenseNet in terms of computational efficiency.
+
+![](images/f82f1fa9b6ae7df691196495c61b67a76cd3e63f7fdf3cb3be3f5fd5bc49b88b.jpg)  
+Figure 8: Test accuracy of DenseNet\* on CIFAR-100 under the anytime learning setting (left) and the budgeted batch setting (right).
+
+We experimented with DenseNet\* in our two settings with test time budget constraints. The left panel of Figure 8 shows the anytime prediction performance of an ensemble of DenseNets\* of varying depths. It outperforms the ensemble of original DenseNets of varying depth by a large margin, but is still slightly worse than MSDNets. In the budgeted batch budget setting, DenseNet\* also leads to significantly higher accuracy over its counterpart under all budgets, but is still substantially outperformed by MSDNets.
+
+# 6 CONCLUSION
+
+We presented the MSDNet, a novel convolutional network architecture, optimized to incorporate CPU budgets at test-time. Our design is based on two high-level design principles, to generate and maintain coarse level features throughout the network and to inter-connect the layers with dense connectivity. The former allows us to introduce intermediate classifiers even at early layers and the latter ensures that these classifiers do not interfere with each other. The final design is a two dimensional array of horizontal and vertical layers, which decouples depth and feature coarseness. Whereas in traditional convolutional networks features only become coarser with increasing depth, the MSDNet generates features of all resolutions from the first layer on and maintains them throughout. The result is an architecture with an unprecedented range of efficiency. A single network can outperform all competitive baselines on an impressive range of computational budgets ranging from highly limited CPU constraints to almost unconstrained settings.
+
+As future work we plan to investigate the use of resource-aware deep architectures beyond object classification, e.g. image segmentation (Long et al., 2015). Further, we intend to explore approaches that combine MSDNets with model compression (Chen et al., 2015; Han et al., 2015), spatially adaptive computation (Figurnov et al., 2016) and more efficient convolution operations (Chollet, 2016; Howard et al., 2017) to further improve computational efficiency.
+
+# ACKNOWLEDGMENTS
+
+The authors are supported in part by grants from the National Science Foundation ( III-1525919, IIS-1550179, IIS-1618134, S&AS 1724282, and CCF-1740822), the Office of Naval Research DOD (N00014-17-1-2175), and the Bill and Melinda Gates Foundation.
+
+# REFERENCES
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+Tolga Bolukbasi, Joseph Wang, Ofer Dekel, and Venkatesh Saligrama. Adaptive neural networks for fast test-time prediction. arXiv preprint arXiv:1702.07811, 2017.   
+Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ACM SIGKDD, pp. 535–541. ACM, 2006.   
+Wenlin Chen, James T Wilson, Stephen Tyree, Kilian Q Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In ICML, pp. 2285–2294, 2015.   
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255, 2009.   
+Michael Figurnov, Maxwell D Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. arXiv preprint arXiv:1612.02297, 2016.   
+Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.   
+Sam Gross and Michael Wilber. Training and investigating residual nets. 2016. URL http: //torch.ch/blog/2016/02/04/resnets.html.   
+Alexander Grubb and Drew Bagnell. Speedboost: Anytime prediction with uniform near-optimality. In AISTATS, volume 15, pp. 458–466, 2012.   
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2015.   
+Babak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. In IJCNN, pp. 293–299, 1993.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In ICCV, pp. 1026–1034, 2015.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.   
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NIPS Deep Learning Workshop, 2014.   
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.   
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, pp. 646–661. Springer, 2016.   
+Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017.   
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In NIPS, pp. 4107–4115, 2016.   
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pp. 770–778, 2015.   
+Jorn-Henrik Jacobsen, Edouard Oyallon, St ¨ ephane Mallat, and Arnold WM Smeulders. Multiscale ´ hierarchical convolutional networks. arXiv preprint arXiv:1703.04140, 2017.   
+Sergey Karayev, Mario Fritz, and Trevor Darrell. Anytime recognition of objects and scenes. In CVPR, pp. 572–579, 2014.   
+Tsung-Wei Ke, Michael Maire, and Stella X. Yu. Neural multigrid. CoRR, abs/1611.07661, 2016. URL http://arxiv.org/abs/1611.07661.   
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Tech Report, 2009.   
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pp. 1097–1105, 2012.   
+Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. In ICLR, 2017.   
+Yann LeCun, John S Denker, Sara A Solla, Richard E Howard, and Lawrence D Jackel. Optimal brain damage. In NIPS, volume 2, pp. 598–605, 1989.   
+Chen-Yu Lee, Saining Xie, Patrick W Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. In AISTATS, volume 2, pp. 5, 2015.   
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.   
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ ECCV, pp. 740–755. Springer, 2014.   
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, pp. 3431–3440, 2015.   
+Feng Nan, Joseph Wang, and Venkatesh Saligrama. Feature-budgeted random forest. In ICML, pp. 1983–1991, 2015.   
+Augustus Odena, Dieterich Lawson, and Christopher Olah. Changing model behavior at test-time using reinforcement learning. arXiv preprint arXiv:1702.07780, 2017.   
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, pp. 525–542. Springer, 2016.   
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In NIPS, pp. 4053–4061, 2016.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015.   
+Kirill Trapeznikov and Venkatesh Saligrama. Supervised sequential classification under budget constraints. In AI-STATS, pp. 581–589, 2013.   
+Paul Viola and Michael Jones. Robust real-time object detection. International Journal of Computer Vision, 4(34–47), 2001.   
+Ji Wan, Dayong Wang, Steven Chu Hong Hoi, Pengcheng Wu, Jianke Zhu, Yongdong Zhang, and Jintao Li. Deep learning for content-based image retrieval: A comprehensive study. In ACM Multimedia, pp. 157–166, 2014.   
+Joseph Wang, Kirill Trapeznikov, and Venkatesh Saligrama. Efficient learning by directed acyclic graph for resource constrained prediction. In NIPS, pp. 2152–2160. 2015.   
+Zhixiang Xu, Olivier Chapelle, and Kilian Q. Weinberger. The greedy miser: Learning under testtime budgets. In ICML, pp. 1175–1182, 2012.   
+Zhixiang Xu, Matt Kusner, Minmin Chen, and Kilian Q. Weinberger. Cost-sensitive tree of classifiers. In ICML, volume 28, pp. 133–141, 2013.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   
+A. R. Zamir, T.-L. Wu, L. Sun, W. Shen, B. E. Shi, J. Malik, and S. Savarese. Feedback Networks. ArXiv e-prints, December 2016.   
+Yisu Zhou, Xiaolin Hu, and Bo Zhang. Interlinked convolutional neural networks for face parsing. In International Symposium on Neural Networks, pp. 222–231. Springer, 2015.
+
+# A DETAILS OF MSDNET ARCHITECTURE AND BASELINE NETWORKS
+
+We use MSDNet with three scales on the CIFAR datasets, and the network reduction method introduced in 4.1 is applied. Figure 9 gives an illustration of the reduced network. The convolutional layer functions in the first layer, $h _ { 1 } ^ { s }$ , denote a sequence of $3 { \times } 3$ convolutions (Conv), batch normalization (BN; Ioffe & Szegedy (2015)), and rectified linear unit (ReLU) activation. In the computation of $\tilde { h } _ { 1 } ^ { s }$ , down-sampling is performed by applying convolutions using strides that are powers of two. For subsequent feature layers, the transformations $h _ { \ell } ^ { s }$ and $\tilde { h } _ { \ell } ^ { s }$ are defined following the design in DenseNets (Huang et al., 2017): Conv $( 1 \times 1 )$ -BN-ReLU-Conv $\left( 3 \times 3 \right)$ -BN-ReLU. We set the number of output channels of the three scales to 6, 12, and 24, respectively. Each classifier has two down-sampling convolutional layers with 128 dimensional $3 \times 3$ filters, followed by a $2 \times 2$ average pooling layer and a linear layer.
+
+The MSDNet used for ImageNet has four scales, respectively producing 16, 32, 64, and 64 feature maps at each layer. The network reduction is also applied to reduce computational cost. The original images are first transformed by a $7 \times 7$ convolution and a $3 \times 3$ max pooling (both with stride 2), before entering the first layer of MSDNets. The classifiers have the same structure as those used for the CIFAR datasets, except that the number of output channels of each convolutional layer is set to be equal to the number of its input channels.
+
+![](images/d0de6b68dce803aca2a16de6affb943796e7f0bf1bb1eac9cef6c06e5c471db7.jpg)  
+Figure 9: Illustration of an MSDNet with network reduction. The network has $S = 3$ scales, and it is divided into three blocks, which maintain a decreasing number of scales. A transition layer is placed between two contiguous blocks.
+
+Network architecture for anytime prediction. The MSDNet used in our anytime-prediction experiments has 24 layers (each layer corresponds to a column in Fig. 1 of the main paper), using the reduced network with transition layers as described in Section 4. The classifiers operate on the output of the $2 \times ( i { + } 1 ) ^ { \mathrm { t h } }$ layers, with $i = 1 , \ldots , 1 1$ . On ImageNet, we use MSDNets with four scales, and the $i ^ { \mathrm { { t h } } }$ classifier operates on the $( k \times i + 3 ) ^ { \mathrm { t h } }$ layer (with $i = 1 , \ldots , 5$ ), where $k = 4 , 6$ and 7. For simplicity, the losses of all the classifiers are weighted equally during training.
+
+Network architecture for budgeted batch setting. The MSDNets used here for the two CIFAR datasets have depths ranging from 10 to 36 layers, using the reduced network with transition layers as described in Section 4. The $k ^ { \mathrm { { t h } } }$ classifier is attached to the $( \sum _ { i = 1 } ^ { k } i ) ^ { \mathrm { t h } }$ layer. The MSDNets used for ImageNet are the same as those described for the anytime learning setting.
+
+$\mathbf { R e s N e t } ^ { \mathbf { M C } }$ and DenseNetMC. The ResNetMC has 62 layers, with 10 residual blocks at each spatial resolution (for three resolutions): we train early-exit classifiers on the output of the $4 ^ { \mathrm { t h } }$ and $8 ^ { \mathrm { t h } }$ residual blocks at each resolution, producing a total of 6 intermediate classifiers (plus the final classification layer). The DenseNetMC consists of 52 layers with three dense blocks and each of them has 16 layers. The six intermediate classifiers are attached to the $6 ^ { \mathrm { { t h } } }$ and $1 2 ^ { \mathrm { t h } }$ layer in each block, also with dense connections to all previous layers in that block.
+
+# B ADDITIONAL RESULTS
+
+# B.1 ABLATION STUDY
+
+We perform additional experiments to shed light on the contributions of the three main components of MSDNet, viz., multi-scale feature maps, dense connectivity, and intermediate classifiers.
+
+We start from an MSDNet with six intermediate classifiers and remove the three main components one at a time. To make our comparisons fair, we keep the computational costs of the full networks similar, at around $3 . 0 \times 1 0 ^ { 8 }$ FLOPs, by adapting the network width, i.e., number of output channels at each layer. After removing all the three components in an MSDNet, we obtain a regular VGG-like convolutional network. We show the classification accuracy of all classifiers in a model in the left panel of Figure 10. Several observations can be made: 1. the dense connectivity is crucial for the performance of MSDNet and removing it hurts the overall accuracy drastically (orange vs. black curve); 2. removing multi-scale convolution hurts the accuracy only in the lower budget regions, which is consistent with our mo
+
+![](images/36de99964e9e6ab4f6f1967fffee5d8d4816d0686cfae2751a7e8cef27def4c9.jpg)  
+Figure 10: Ablation study (on CIFAR-100) of MSDNets that shows the effect of dense connectivity, multi-scale features, and intermediate classifiers. Higher is better.
+
+tivation that the multi-scale design introduces discriminative features early on; 3. the final canonical CNN (star) performs similarly as MSDNet under the specific budget that matches its evaluation cost exactly, but it is unsuited for varying budget constraints. The final CNN performs substantially better at its particular budget region than the model without dense connectivity (orange curve). This suggests that dense connectivity is particularly important in combination with multiple classifiers.
+
+# B.2 RESULTS ON CIFAR-10
+
+For the CIFAR-10 dataset, we use the same MSDNets and baseline models as we used for CIFAR100, except that the networks used here have a 10-way fully connected layer at the end. The results under the anytime learning setting and the batch computational budget setting are shown in the left and right panel of Figure 11, respectively. Similar to what we have observed from the results on CIFAR-100 and ImageNet, MSDNets outperform all the baselines by a significant margin in both settings. As in the experiments presented in the main paper, ResNet and DenseNet models with multiple intermediate classifiers perform relatively poorly.
+
+![](images/adf6b406c38b10a1e3fedffbeafa7e030553b2ab7ceb4700cb0a1fb272d4ff92.jpg)  
+Figure 11: Classification accuracies on the CIFAR-10 dataset in the anytime-prediction setting (left) and the budgeted batch setting (right).

parse/train/Hk2aImxAb/Hk2aImxAb_content_list.json

@@ -0,0 +1,1186 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-SCALE DENSE NETWORKS FOR RESOURCE EFFICIENT IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            794,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang Cornell University ",
+        "bbox": [
+            184,
+            170,
+            305,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Danlu Chen Fudan University ",
+        "bbox": [
+            351,
+            170,
+            465,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianhong Li Tsinghua University ",
+        "bbox": [
+            511,
+            171,
+            647,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu Cornell University ",
+        "bbox": [
+            689,
+            170,
+            813,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten Facebook AI Research ",
+        "bbox": [
+            183,
+            219,
+            357,
+            248
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kilian Weinberger Cornell University ",
+        "bbox": [
+            529,
+            219,
+            660,
+            248
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            285,
+            544,
+            299
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we investigate image classification with computational resource limits at test time. Two such settings are: 1. anytime classification, where the network’s prediction for a test example is progressively updated, facilitating the output of a prediction at any time; and 2. budgeted batch classification, where a fixed amount of computation is available to classify a set of examples that can be spent unevenly across “easier” and “harder” inputs. In contrast to most prior work, such as the popular Viola and Jones algorithm, our approach is based on convolutional neural networks. We train multiple classifiers with varying resource demands, which we adaptively apply during test time. To maximally re-use computation between the classifiers, we incorporate them as early-exits into a single deep convolutional neural network and inter-connect them with dense connectivity. To facilitate high quality classification early on, we use a two-dimensional multi-scale network architecture that maintains coarse and fine level features all-throughout the network. Experiments on three image-classification tasks demonstrate that our framework substantially improves the existing state-of-the-art in both settings. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            336,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have witnessed a surge in demand for applications of visual object recognition, for instance, in self-driving cars (Bojarski et al., 2016) and content-based image search (Wan et al., 2014). This demand has in part been fueled through the promise generated by the astonishing progress of convolutional networks (CNNs) on visual object recognition benchmark competition datasets, such as ILSVRC (Deng et al., 2009) and COCO (Lin et al., 2014), where state-of-the-art models may have even surpassed human-level performance (He et al., 2015; 2016). ",
+        "bbox": [
+            174,
+            566,
+            825,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the requirements of such competitions differ from realworld applications, which tend to incentivize resource-hungry models with high computational demands at inference time. For example, the COCO 2016 competition was won by a large ensemble of computationally intensive $\\mathrm { \\dot { C } N N s ^ { 1 } }$ — a model likely far too computationally expensive for any resource-aware application. Although much smaller models would also obtain decent error, very large, computationally intensive models seem necessary to correctly classify the hard examples that make up the bulk of the remaining misclassifications of modern algorithms. To illustrate this point, Figure 1 shows two images of horses. The left image depicts a horse in canonical pose and is easy to classify, whereas the right image is taken from a rare viewpoint and is likely in the tail of the data distribution. Computationally intensive models are needed to classify such tail examples correctly, but are wasteful when applied to canonical images such as the left one. ",
+        "bbox": [
+            174,
+            659,
+            612,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e2e080304ad2c7be1e5890d21d32ed57f0cf575c439df5f869a545d4f732d05.jpg",
+        "image_caption": [
+            "Figure 1: Two images containing a horse. The left image is canonical and easy to detect even with a small model, whereas the right image requires a computationally more expensive network architecture. (Copyright Pixel Addict and Doyle (CC BY-ND 2.0).) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            664,
+            823,
+            732
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            852,
+            823,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In real-world applications, computation directly translates into power consumption, which should be minimized for environmental and economical reasons, and is a scarce commodity on mobile devices. This begs the question: why do we choose between either wasting computational resources by applying an unnecessarily computationally expensive model to easy images, or making mistakes by using an efficient model that fails to recognize difficult images? Ideally, our systems should automatically use small networks when test images are easy or computational resources limited, and use big networks when test images are hard or computation is abundant. ",
+        "bbox": [
+            178,
+            873,
+            820,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Such systems would be beneficial in at least two settings with computational constraints at testtime: anytime prediction, where the network can be forced to output a prediction at any given point in time; and budgeted batch classification, where a fixed computational budget is shared across a large set of examples which can be spent unevenly across “easy” and “hard” examples. A practical use-case of anytime prediction is in mobile apps on Android devices: in 2015, there existed 24, 093 distinct Android devices2, each with its own distinct computational limitations. It is infeasible to train a different network that processes video frame-by-frame at a fixed framerate for each of these devices. Instead, you would like to train a single network that maximizes accuracy on all these devices, within the computational constraints of that device. The budget batch classification setting is ubiquitous in large-scale machine learning applications. Search engines, social media companies, on-line advertising agencies, all must process large volumes of data on limited hardware resources. For example, as of 2010, Google Image Search had over 10 Billion images indexed3, which has likely grown to over 1 Trillion since. Even if a new model to process these images is only 1/10s slower per image, this additional cost would add 3170 years of CPU time. In the budget batch classification setting, companies can improve the average accuracy by reducing the amount of computation spent on “easy” cases to save up computation for “hard” cases. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Motivated by prior work in computer vision on resource-efficient recognition (Viola & Jones, 2001), we aim to develop CNNs that “slice” the computation and process these slices one-by-one, stopping the evaluation once the CPU time is depleted or the classification sufficiently certain (through “early exits”). Unfortunately, the architecture of CNNs is inherently at odds with the introduction of early exits. CNNs learn the data representation and the classifier jointly, which leads to two problems with early exits: 1. The features in the last layer are extracted directly to be used by the classifier, whereas earlier features are not. The inherent dilemma is that different kinds of features need to be extracted depending on how many layers are left until the classification. 2. The features in different layers of the network may have different scale. Typically, the first layers of a deep nets operate on a fine scale (to extract low-level features), whereas later layers transition (through pooling or strided convolution) to coarse scales that allow global context to enter the classifier. Both scales are needed but happen at different places in the network. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel network architecture that addresses both of these problems through careful design changes, allowing for resource-efficient image classification. Our network uses a cascade of intermediate classifiers throughout the network. The first problem, of classifiers altering the internal representation, is addressed through the introduction of dense connectivity (Huang et al., 2017). By connecting all layers to all classifiers, features are no longer dominated by the most imminent earlyexit and the trade-off between early or later classification can be performed elegantly as part of the loss function. The second problem, the lack of coarse-scale features in early layers, is addressed by adopting a multi-scale network structure. At each layer we produce features of all scales (fine-tocoarse), which facilitates good classification early on but also extracts low-level features that only become useful after several more layers of processing. Our network architecture is illustrated in Figure 2, and we refer to it as Multi-Scale DenseNet (MSDNet). ",
+        "bbox": [
+            174,
+            583,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate MSDNets on three image-classification datasets. In the anytime classification setting, we show that it is possible to provide the ability to output a prediction at any time while maintain high accuracies throughout. In the budget batch classification setting we show that MSDNets can be effectively used to adapt the amount of computation to the difficulty of the example to be classified, which allows us to reduce the computational requirements of our models drastically whilst performing on par with state-of-the-art CNNs in terms of overall classification accuracy. To our knowledge this is the first deep learning architecture of its kind that allows dynamic resource adaptation with a single model and obtains competitive results throughout. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/393456a645a070145e34d48f149ac9a7ed180043707a693bf4407c8f3be79371.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of the first four layers of an MSDNet with three scales. The horizontal direction corresponds to the layer direction (depth) of the network. The vertical direction corresponds to the scale of the feature maps. Horizontal arrows indicate a regular convolution operation, whereas diagonal and vertical arrows indicate a strided convolution operation. Classifiers only operate on feature maps at the coarsest scale. Connections across more than one layer are not drawn explicitly: they are implicit through recursive concatenations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            83,
+            826,
+            213
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            318,
+            344,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We briefly review related prior work on computation-efficient networks, memory-efficient networks, and resource-sensitive machine learning, from which our network architecture draws inspiration. ",
+        "bbox": [
+            176,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Computation-efficient networks. Most prior work on (convolutional) networks that are computationally efficient at test time focuses on reducing model size after training. In particular, many studies propose to prune weights (LeCun et al., 1989; Hassibi et al., 1993; Li et al., 2017) or quantize weights (Hubara et al., 2016; Rastegari et al., 2016) during or after training. These approaches are generally effective because deep networks often have a substantial number of redundant weights that can be pruned or quantized without sacrificing (and sometimes even improving) performance. Prior work also studies approaches that directly learn compact models with less parameter redundancy. For example, the knowledge-distillation method (Bucilua et al., 2006; Hinton et al., 2014) trains small student networks to reproduce the output of a much larger teacher network or ensemble. Our work differs from those approaches in that we train a single model that trades off computation for accuracy at test time without any re-training or finetuning. Indeed, weight pruning and knowledge distillation can be used in combination with our approach, and may lead to further improvements. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            549
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Resource-efficient machine learning. Various prior studies explore computationally efficient variants of traditional machine-learning models (Viola & Jones, 2001; Grubb & Bagnell, 2012; Karayev et al., 2014; Trapeznikov & Saligrama, 2013; Xu et al., 2012; 2013; Nan et al., 2015; Wang et al., 2015). Most of these studies focus on how to incorporate the computational requirements of computing particular features in the training of machine-learning models such as (gradient-boosted) decision trees. Whilst our study is certainly inspired by these results, the architecture we explore differs substantially: most prior work exploits characteristics of machine-learning models (such as decision trees) that do not apply to deep networks. Our work is possibly most closely related to recent work on FractalNets (Larsson et al., 2017), which can perform anytime prediction by progressively evaluating subnetworks of the full network. FractalNets differ from our work in that they are not explicitly optimized for computation efficiency and consequently our experiments show that MSDNets substantially outperform FractalNets. Our dynamic evaluation strategy for reducing batch computational cost is closely related to the the adaptive computation time approach (Graves, 2016; Figurnov et al., 2016), and the recently proposed method of adaptively evaluating neural networks (Bolukbasi et al., 2017). Different from these works, our method adopts a specially designed network with multiple classifiers, which are jointly optimized during training and can directly output confidence scores to control the evaluation process for each test example. The adaptive computation time method (Graves, 2016) and its extension (Figurnov et al., 2016) also perform adaptive evaluation on test examples to save batch computational cost, but focus on skipping units rather than layers. In (Odena et al., 2017), a “composer”model is trained to construct the evaluation network from a set of sub-modules for each test example. By contrast, our work uses a single CNN with multiple intermediate classifiers that is trained end-to-end. The Feedback Networks (Zamir et al., 2016) enable early predictions by making predictions in a recurrent fashion, which heavily shares parameters among classifiers, but is less efficient in sharing computation. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related network architectures. Our network architecture borrows elements from neural fabrics (Saxena & Verbeek, 2016) and others (Zhou et al., 2015; Jacobsen et al., 2017; Ke et al., 2016) ",
+        "bbox": [
+            173,
+            896,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c59242daaab86116b0562f24208342d867eb57b7d0db805e434894dcf77ee2c.jpg",
+        "image_caption": [
+            "Figure 3: Relative accuracy of the intermediate classifier (left) and the final classifier (right) when introducing a single intermediate classifier at different layers in a ResNet, DenseNet and MSDNet. All experiments were performed on the CIFAR-100 dataset. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            93,
+            792,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "to rapidly construct a low-resolution feature map that is amenable to classification, whilst also maintaining feature maps of higher resolution that are essential for obtaining high classification accuracy. Our design differs from the neural fabrics (Saxena & Verbeek, 2016) substantially in that MSDNets have a reduced number of scales and no sparse channel connectivity or up-sampling paths. MSDNets are at least one order of magnitude more efficient and typically more accurate — for example, an MSDNet with less than 1 million parameters obtains a test error below $7 . 0 \\%$ on CIFAR-10 (Krizhevsky & Hinton, 2009), whereas Saxena & Verbeek (2016) report $7 . 4 3 \\%$ with over 20 million parameters. We use the same feature-concatenation approach as DenseNets (Huang et al., 2017), which allows us to bypass features optimized for early classifiers in later layers of the network. Our architecture is related to deeply supervised networks (Lee et al., 2015) in that it incorporates classifiers at multiple layers throughout the network. In contrast to all these prior architectures, our network is specifically designed to operate in resource-aware settings. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            348,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider two settings that impose computational constraints at prediction time. ",
+        "bbox": [
+            176,
+            539,
+            710,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Anytime prediction. In the anytime prediction setting (Grubb & Bagnell, 2012), there is a finite computational budget $B > 0$ available for each test example $\\mathbf { x }$ . The computational budget is nondeterministic, and varies per test instance. It is determined by the occurrence of an event that requires the model to output a prediction immediately. We assume that the budget is drawn from some joint distribution $P ( \\mathbf { x } , B )$ . In some applications $P ( B )$ may be independent of $P ( \\mathbf { x } )$ and can be estimated. For example, if the event is governed by a Poisson process, $P ( B )$ is an exponential distribution. We denote the loss of a model $f ( \\mathbf { x } )$ that has to produce a prediction for instance $\\mathbf { x }$ within budget $B$ by $L ( f ( \\mathbf { x } ) , B )$ . The goal of an anytime learner is to minimize the expected loss under the budget distribution: $L ( f ) = \\mathbb { E } \\left[ L ( f ( \\mathbf { x } ) , B ) \\right] _ { P ( \\mathbf { x } , B ) } .$ Here, $L ( \\cdot )$ denotes a suitable loss function. As is common in the empirical risk minimization framework, the expectation under $P ( \\mathbf { x } , B )$ may be estimated by an average over samples from $P ( \\mathbf { x } , B )$ . ",
+        "bbox": [
+            173,
+            560,
+            825,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Budgeted batch classification. In the budgeted batch classification setting, the model needs to classify a set of examples $\\mathcal { D } _ { t e s t } = \\{ \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { M } \\}$ within a finite computational budget $B > 0$ that is known in advance. The learner aims to minimize the loss across all examples in $\\mathcal { D } _ { t e s t }$ within a cumulative cost bounded by $B$ , which we denote by $L ( f ( \\mathcal { D } _ { t e s t } ) , B )$ for some suitable loss function $L ( \\cdot )$ . It can potentially do so by spending less than BM computation on classifying an “easy” example whilst using more than $\\textstyle { \\frac { B } { M } }$ computation on classifying a “difficult” example. Therefore, the budget considered here is a soft constraint when we have a large batch of testing samples. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 MULTI-SCALE DENSE CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            643,
+            857
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A straightforward solution to the two problems introduced in Section 3 is to train multiple networks of increasing capacity, and sequentially evaluate them at test time (as in Bolukbasi et al. (2017)). In the anytime setting the evaluation can be stopped at any point and the most recent prediction is returned. In the batch setting, the evaluation is stopped prematurely the moment a network classifies the test sample with sufficient confidence. When the resources are so limited that the execution is terminated after the first network, this approach is optimal because the first network is trained for exactly this computational budget without compromises. However, in both settings, this scenario is rare. In the more common scenario where some test samples can require more processing time than others the approach is far from optimal because previously learned features are never re-used across the different networks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An alternative solution is to build a deep network with a cascade of classifiers operating on the features of internal layers: in such a network features computed for an earlier classifier can be re-used by later classifiers. However, na¨ıvely attaching intermediate early-exit classifiers to a stateof-the-art deep network leads to poor performance. ",
+        "bbox": [
+            174,
+            194,
+            823,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are two reasons why intermediate early-exit classifiers hurt the performance of deep neural networks: early classifiers lack coarse-level features and classifiers throughout interfere with the feature generation process. In this section we investigate these effects empirically (see Figure 3) and, in response to our findings, propose the MSDNet architecture illustrated in Figure 2. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Problem: The lack of coarse-level features. Traditional neural networks learn features of fine scale in early layers and coarse scale in later layers (through repeated convolution, pooling, and strided convolution). Coarse scale features in the final layers are important to classify the content of the whole image into a single class. Early layers lack coarse-level features and early-exit classifiers attached to these layers will likely yield unsatisfactory high error rates. To illustrate this point, we attached4 intermediate classifiers to varying layers of a ResNet (He et al., 2016) and a DenseNet (Huang et al., 2017) on the CIFAR-100 dataset (Krizhevsky & Hinton, 2009). The blue and red dashed lines in the left plot of Figure 3 show the relative accuracies of these classifiers. All three plots gives rise to a clear trend: the accuracy of a classifier is highly correlated with its position within the network. Particularly in the case of the ResNet (blue line), one can observe a visible “staircase” pattern, with big improvements after the 2nd and 4th classifiers — located right after pooling layers. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Solution: Multi-scale feature maps. To address this issue, MSDNets maintain a feature representation at multiple scales throughout the network, and all the classifiers only use the coarse-level features. The feature maps at a particular layer5 and scale are computed by concatenating the results of one or two convolutions: 1. the result of a regular convolution applied on the same-scale features from the previous layer (horizontal connections) and, if possible, 2. the result of a strided convolution applied on the finer-scale feature map from the previous layer (diagonal connections). The horizontal connections preserve and progress high-resolution information, which facilitates the construction of high-quality coarse features in later layers. The vertical connections produce coarse features throughout that are amenable to classification. The dashed black line in Figure 3 shows that MSDNets substantially increase the accuracy of early classifiers. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Problem: Early classifiers interfere with later classifiers. The right plot of Figure 3 shows the accuracies of the final classifier as a function of the location of a single intermediate classifier, relative to the accuracy of a network without intermediate classifiers. The results show that the introduction of an intermediate classifier harms the final ResNet classifier (blue line), reducing its accuracy by up to $7 \\%$ . We postulate that this accuracy degradation in the ResNet may be caused by the intermediate classifier influencing the early features to be optimized for the short-term and not for the final layers. This improves the accuracy of the immediate classifier but collapses information required to generate high quality features in later layers. This effect becomes more pronounced when the first classifier is attached to an earlier layer. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Solution: Dense connectivity. By contrast, the DenseNet (red line) suffers much less from this effect. Dense connectivity (Huang et al., 2017) connects each layer with all subsequent layers and allows later layers to bypass features optimized for the short-term, to maintain the high accuracy of the final classifier. If an earlier layer collapses information to generate short-term features, the lost information can be recovered through the direct connection to its preceding layer. The final classifier’s performance becomes (more or less) independent of the location of the intermediate classifier. As far as we know, this is the first paper that discovers that dense connectivity is an important element to early-exit classifiers in deep networks, and we make it an integral design choice in MSDNets. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8de8c69d9d36a341a0373469c5e2695c92df31ad7bca8cfbfd76709c742d677e.jpg",
+        "image_caption": [
+            "Figure 4: The output $\\mathbf { x } _ { \\ell } ^ { s }$ of layer $\\ell$ at the $s ^ { \\mathrm { t h } }$ scale in a MSDNet. Herein, [. . . ] denotes the concatenation operator, $h _ { \\ell } ^ { s } ( \\cdot )$ a regular convolution transformation, and $\\tilde { h } _ { \\ell } ^ { s } ( \\cdot )$ a strided convolutional. Note that the outputs of $h _ { \\ell } ^ { s }$ and $\\tilde { h } _ { \\ell } ^ { s }$ have the same feature map size; their outputs are concatenated along the channel dimension. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            826,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            295,
+            825,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE MSDNET ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            418,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The MSDNet architecture is illustrated in Figure 2. We present its main components below. Additional details on the architecture are presented in Appendix A. ",
+        "bbox": [
+            174,
+            383,
+            820,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First layer. The first layer $\\ell = 1 $ ) is unique as it includes vertical connections in Figure 2. Its main purpose is to “seed” representations on all $S$ scales. One could view its vertical layout as a miniature “S-layers” convolutional network $S { = } 3$ in Figure 2). Let us denote the output feature maps at layer $\\ell$ and scale $s$ as $\\mathbf { x } _ { \\ell } ^ { s }$ and the original input image as $\\mathbf { x } _ { 0 } ^ { 1 }$ . Feature maps at coarser scales are obtained via down-sampling. The output $\\mathbf { x } _ { 1 } ^ { s }$ of the first layer is formally given in the top row of Figure 4. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Subsequent layers. Following Huang et al. (2017), the output feature maps $\\mathbf { x } _ { \\ell } ^ { s }$ produced at subsequent layers, $\\ell > 1$ , and scales, $s$ , are a concatenation of transformed feature maps from all previous feature maps of scale $s$ and $s - 1$ (if $s > 1$ ). Formally, the $\\ell \\cdot$ -th layer of our network outputs a set of features at $S$ scales $\\big \\{ \\mathbf { x } _ { \\ell } ^ { 1 } , \\dots , \\mathbf { x } _ { \\ell } ^ { S } \\big \\}$ , given in the last row of Figure 4. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Classifiers. The classifiers in MSDNets also follow the dense connectivity pattern within the coarsest scale, $S$ , i.e., the classifier at layer $\\ell$ uses all the features $\\left[ \\mathbf { x } _ { 1 } ^ { S } , \\ldots , \\mathbf { x } _ { \\ell } ^ { S } \\right]$ . Each classifier consists of two convolutional layers, followed by one average pooling layer and one linear layer. In practice, we only attach classifiers to some of the intermediate layers, and we let $f _ { k } ( \\cdot )$ denote the $k ^ { \\mathrm { { t h } } }$ classifier. During testing in the anytime setting we propagate the input through the network until the budget is exhausted and output the most recent prediction. In the batch budget setting at test time, an example traverses the network and exits after classifier $f _ { k }$ if its prediction confidence (we use the maximum value of the softmax probability as a confidence measure) exceeds a pre-determined threshold $\\theta _ { k }$ . Before training, we compute the computational cost, $C _ { k }$ , required to process the network up to the $k ^ { \\mathrm { { t h } } }$ classifier. We denote by $0 < q \\le 1$ a fixed exit probability that a sample that reaches a classifier will obtain a classification with sufficient confidence to exit. We assume that $q$ is constant across all layers, which allows us to compute the probability that a sample exits at classifier $k$ as: $q _ { k } = z ( 1 - q ) ^ { \\bar { k ^ { - 1 } } q }$ , where $z$ is a normalizing constant that ensures that $\\begin{array} { r } { \\sum _ { k } p ( q _ { k } ) = 1 } \\end{array}$ . At test time, we need to ensure that the overall cost of classifying all samples in $\\mathcal { D } _ { t e s t }$ does not exceed our budget $B$ (in expectation). This gives rise to the constraint $\\begin{array} { r } { \\left| \\mathcal { D } _ { t e s t } \\right| \\sum _ { k } q _ { k } C _ { k } \\le B } \\end{array}$ . We can solve this constraint for $q$ and determine the thresholds $\\theta _ { k }$ on a validation set in such a way that approximately $| \\mathcal { D } _ { t e s t } | q _ { k }$ validation samples exit at the $k ^ { \\mathrm { { t h } } }$ classifier. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Loss functions. During training we use cross entropy loss functions $L ( f _ { k } )$ for all classifiers and minimize a weighted cumulative loss: $\\begin{array} { r } { \\frac { 1 } { | \\mathcal { D } | } \\sum _ { ( \\mathbf { x } , y ) \\in \\mathcal { D } } \\mathbf { \\tilde { \\sum } } _ { k } w _ { k } L ( f _ { k } ) } \\end{array}$ . Herein, $\\mathcal { D }$ denotes the training set and $w _ { k } \\ge 0$ the weight of the $k$ -th classifier. If the budget distribution $P ( B )$ is known, we can use the weights $w _ { k }$ to incorporate our prior knowledge about the budget $B$ in the learning. Empirically, we find that using the same weight for all loss functions (i.e., setting $\\forall k : w _ { k } = 1$ ) works well in practice. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Network reduction and lazy evaluation. There are two straightforward ways to further reduce the computational requirements of MSDNets. First, it is inefficient to maintain all the finer scales until the last layer of the network. One simple strategy to reduce the size of the network is by splitting it into $S$ blocks along the depth dimension, and only keeping the coarsest $( S - i + 1 )$ scales in the $i ^ { \\mathrm { t h } }$ block (a schematic layout of this structure is shown in Figure 9). This reduces computational cost for both training and testing. Every time a scale is removed from the network, we add a transition layer between the two blocks that merges the concatenated features using a $1 \\times 1$ convolution and cuts the number of channels in half before feeding the fine-scale features into the coarser scale via a strided convolution (this is similar to the DenseNet-BC architecture of Huang et al. (2017)). Second, since a classifier at layer $\\ell$ only uses features from the coarsest scale, the finer feature maps in layer $\\ell$ (and some of the finer feature maps in the previous $S - 2$ layers) do not influence the prediction of that classifier. Therefore, we group the computation in “diagonal blocks” such that we only propagate the example along paths that are required for the evaluation of the next classifier. This minimizes unnecessary computations when we need to stop because the computational budget is exhausted. We call this strategy lazy evaluation. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            326,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness of our approach on three image classification datasets, i.e., the CIFAR10, CIFAR-100 (Krizhevsky & Hinton, 2009) and ILSVRC 2012 (ImageNet; Deng et al. (2009)) datasets. Code to reproduce all results is available at https://anonymous-url. Details on architectural configurations of MSDNets are described in Appendix A. ",
+        "bbox": [
+            174,
+            334,
+            823,
+            390
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. The two CIFAR datasets contain 50, 000 training and 10, 000 test images of $3 2 \\times 3 2$ pixels; we hold out 5, 000 training images as a validation set. The datasets comprise 10 and 100 classes, respectively. We follow He et al. (2016) and apply standard data-augmentation techniques to the training images: images are zero-padded with 4 pixels on each side, and then randomly cropped to produce $3 2 \\times 3 2$ images. Images are flipped horizontally with probability 0.5, and normalized by subtracting channel means and dividing by channel standard deviations. The ImageNet dataset comprises 1, 000 classes, with a total of 1.2 million training images and 50,000 validation images. We hold out 50,000 images from the training set to estimate the confidence threshold for classifiers in MSDNet. We adopt the data augmentation scheme of He et al. (2016) at training time; at test time, we classify a $2 2 4 \\times 2 2 4$ center crop of images that were resized to $2 5 6 \\times 2 5 6$ pixels. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            532
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training Details. We train all models using the framework of Gross & Wilber (2016). On the two CIFAR datasets, all models (including all baselines) are trained using stochastic gradient descent (SGD) with mini-batch size 64. We use Nesterov momentum with a momentum weight of 0.9 without dampening, and a weight decay of $1 0 ^ { - 4 }$ . All models are trained for 300 epochs, with an initial learning rate of 0.1, which is divided by a factor 10 after 150 and 225 epochs. We apply the same optimization scheme to the ImageNet dataset, except that we increase the mini-batch size to 256, and all the models are trained for 90 epochs with learning rate drops after 30 and 60 epochs. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            635
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 ANYTIME PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            374,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the anytime prediction setting, the model maintains a progressively updated distribution over classes, and it can be forced to output its most up-to-date prediction at an arbitrary time. ",
+        "bbox": [
+            173,
+            680,
+            821,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. There exist several baseline approaches for anytime prediction: FractalNets (Larsson et al., 2017), deeply supervised networks (Lee et al., 2015), and ensembles of deep networks of varying or identical sizes. FractalNets allow for multiple evaluation paths during inference time, which vary in computation time. In the anytime setting, paths are evaluated in order of increasing computation. In our result figures, we replicate the FractalNet results reported in the original paper (Larsson et al., 2017) for reference. Deeply supervised networks introduce multiple early-exit classifiers throughout a network, which are applied on the features of the particular layer they are attached to. Instead of using the original model proposed in Lee et al. (2015), we use the more competitive ResNet and DenseNet architectures (referred to as DenseNet- $B C$ in Huang et al. (2017)) as the base networks in our experiments with deeply supervised networks. We refer to these as $R e s N e t ^ { M C }$ and DenseNetMC, where $M C$ stands for multiple classifiers. Both networks require about $1 . 3 \\times 1 0 ^ { 8 }$ FLOPs when fully evaluated; the detailed network configurations are presented in the supplementary material. In addition, we include ensembles of ResNets and DenseNets of varying or identical sizes. At test time, the networks are evaluated sequentially (in ascending order of network size) to obtain predictions for the test data. All predictions are averaged over the evaluated classifiers. On ",
+        "bbox": [
+            174,
+            715,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e595351824a020ac424bb128829df21d92c0ecca2b1cea17c58c737e1308b61.jpg",
+        "image_caption": [
+            "Figure 5: Accuracy (top-1) of anytime prediction models as a function of computational budget on the ImageNet (left) and CIFAR-100 (right) datasets. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            92,
+            810,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ImageNet, we compare MSDNet against a highly competitive ensemble of ResNets and DenseNets, with depth varying from 10 layers to 50 layers, and 36 layers to 121 layers, respectively. ",
+        "bbox": [
+            173,
+            314,
+            821,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Anytime prediction results are presented in Figure 5. The left plot shows the top-1 classification accuracy on the ImageNet validation set. Here, for all budgets in our evaluation, the accuracy of MSDNet substantially outperforms the ResNets and DenseNets ensemble. In particular, when the budget ranges from $0 . 1 \\times \\bar { 1 0 } ^ { 1 0 }$ to $0 . 3 \\times 1 0 ^ { 1 0 }$ FLOPs, MSDNet achieves $\\sim 4 \\% - 8 \\%$ higher accuracy. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate more baselines on CIFAR-100 (and CIFAR-10; see supplementary materials). We observe that MSDNet substantially outperforms ResNetsMC and DenseNetsMC at any computational budget within our range. This is due to the fact that after just a few layers, MSDNets have produced low-resolution feature maps that are much more suitable for classification than the high-resolution feature maps in the early layers of ResNets or DenseNets. MSDNet also outperforms the other baselines for nearly all computational budgets, although it performs on par with ensembles when the budget is very small. In the extremely low-budget regime, ensembles have an advantage because their predictions are performed by the first (small) network, which is optimized exclusively for the low budget. However, the accuracy of ensembles does not increase nearly as fast when the budget is increased. The MSDNet outperforms the ensemble as soon as the latter needs to evaluate a second model: unlike MSDNets, this forces the ensemble to repeat the computation of similar low-level features repeatedly. Ensemble accuracies saturate rapidly when all networks are shallow. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 BUDGETED BATCH CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            590,
+            462,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In budgeted batch classification setting, the predictive model receives a batch of $M$ instances and a computational budget $B$ for classifying all $M$ instances. In this setting, we use dynamic evaluation: we perform early-exiting of “easy” examples at early classifiers whilst propagating “hard” examples through the entire network, using the procedure described in Section 4. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines. On ImageNet, we compare the dynamically evaluated MSDNet with five ResNets (He et al., 2016) and five DenseNets (Huang et al., 2017), AlexNet (Krizhevsky et al., 2012), and GoogleLeNet (Szegedy et al., 2015); see the supplementary material for details. We also evaluate an ensemble of the five ResNets that uses exactly the same dynamic-evaluation procedure as MSDNets at test time: “easy” images are only propagated through the smallest ResNet-10, whereas “hard” images are classified by all five ResNet models (predictions are averaged across all evaluated networks in the ensemble). We classify batches of $M = 1 2 8$ images. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On CIFAR-100, we compare MSDNet with several highly competitive baselines, including ResNets (He et al., 2016), DenseNets (Huang et al., 2017) of varying sizes, Stochastic Depth Networks (Huang et al., 2016), Wide ResNets (Zagoruyko & Komodakis, 2016) and FractalNets (Larsson et al., 2017). We also compare MSDNet to the $\\mathrm { R e s N e t ^ { M C } }$ and DenseNetMC models that were used in Section 5.1, using dynamic evaluation at test time. We denote these baselines as $R e s N e t ^ { M C }$ / DenseNetMC with early-exits. To prevent the result plots from becoming too cluttered, we present CIFAR-100 results with dynamically evaluated ensembles in the supplementary material. We classify batches of $M = 2 5 6$ images at test time. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Budgeted batch classification results on ImageNet are shown in the left panel of Figure 7. We trained three MSDNets with different depths, each of which covers a different range of computational budgets. We plot the performance of each MSDNet as a gray curve; we select the best model for each budget based on its accuracy on the validation set, and plot the corresponding accuracy as a black curve. The plot shows that the predictions of MSDNets with dynamic evaluation are substantially more accurate than those of ResNets and DenseNets that use the same amount of computation. For instance, with an average budget of $1 . 7 \\times 1 0 ^ { 9 }$ FLOPs, MSDNet achieves a top-1 accuracy of ${ \\sim } 7 5 \\%$ , which is ${ \\sim } 6 \\%$ higher than that achieved by a ResNet with the same number of FLOPs. Compared to the computationally efficient DenseNets, MSDNet uses $\\sim 2 - 3 \\times$ times fewer FLOPs to achieve the same classification accuracy. Moreover, MSDNet with dynamic evaluation allows for very precise tuning of the computational budget that is consumed, which is not possible with individual ResNet or DenseNet models. The ensemble of ResNets or DenseNets with dynamic evaluation performs on par with or worse than their individual counterparts (but they do allow for setting the computational budget very precisely). ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/047b8902b777ad1edf01cc1798508fdcb86d98ce8b5ec9a2971efe96719d19ec.jpg",
+        "image_caption": [
+            "Figure 7: Accuracy (top-1) of budgeted batch classification models as a function of average computational budget per image the on ImageNet (left) and CIFAR-100 (right) datasets. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            93,
+            807,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            320,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The right panel of Figure 7 shows our results on CIFAR-100. The results show that MSDNets consistently outperform all baselines across all budgets. Notably, MSDNet performs on par with a 110- layer ResNet using only 1/10th of the computational budget and it is up to $\\sim 5$ times more efficient than DenseNets, Stochastic Depth Networks, Wide ResNets, and FractalNets. Similar to results in the anytime-prediction setting, MSDNet substantially outperform ResNetsMC and DenseNets $_ { M C }$ with multiple intermediate classifiers, which provides further evidence that the coarse features in the MSDNet are important for high performance in earlier layers. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Visualization. To illustrate the ability of our approach to reduce the computational requirements for classifying “easy” examples, we show twelve randomly sampled test images from two ImageNet classes in Figure 6. The top row shows “easy” examples that were correctly classified and exited by the first classifier. The bottom row shows “hard” examples that would have been incorrectly classified by the first classifier but were passed on because its uncertainty was too high. The figure suggests that early classifiers recognize prototypical class examples, whereas the last classifier recognizes non-typical images. ",
+        "bbox": [
+            174,
+            599,
+            496,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/105e212787f02ba3ad81fe470cd4782e898e2825cb6b2147833e9bbcf9aa8bfb.jpg",
+        "image_caption": [
+            "Figure 6: Sampled images from the ImageNet classes Red wine and Volcano. Top row: images exited from the first classifier of a MSDNet with correct prediction; Bottom row: images failed to be correctly classified at the first classifier but were correctly predicted and exited at the last layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            604,
+            821,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 MORE COMPUTATIONALLY EFFICIENT DENSENETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            570,
+            814
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here, we discuss an interesting finding during our exploration of the MSDNet architecture. We found that following the DenseNet structure to design our network, i.e., by keeping the number of output channels (or growth rate) the same at all scales, did not lead to optimal results in terms of the accuracy-speed trade-off. The main reason for this is that compared to network architectures like ResNets, the DenseNet structure tends to apply more filters on the high-resolution feature maps in the network. This helps to reduce the number of parameters in the model, but at the same time, it greatly increases the computational cost. We tried to modify DenseNets by doubling the growth rate after each transition layer, so that more filters are applied to low-resolution feature maps. It turns out that the resulting network, which we denote as DenseNet\\*, significantly outperform the original DenseNet in terms of computational efficiency. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f82f1fa9b6ae7df691196495c61b67a76cd3e63f7fdf3cb3be3f5fd5bc49b88b.jpg",
+        "image_caption": [
+            "Figure 8: Test accuracy of DenseNet\\* on CIFAR-100 under the anytime learning setting (left) and the budgeted batch setting (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            104,
+            808,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            344,
+            825,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We experimented with DenseNet\\* in our two settings with test time budget constraints. The left panel of Figure 8 shows the anytime prediction performance of an ensemble of DenseNets\\* of varying depths. It outperforms the ensemble of original DenseNets of varying depth by a large margin, but is still slightly worse than MSDNets. In the budgeted batch budget setting, DenseNet\\* also leads to significantly higher accuracy over its counterpart under all budgets, but is still substantially outperformed by MSDNets. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            318,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented the MSDNet, a novel convolutional network architecture, optimized to incorporate CPU budgets at test-time. Our design is based on two high-level design principles, to generate and maintain coarse level features throughout the network and to inter-connect the layers with dense connectivity. The former allows us to introduce intermediate classifiers even at early layers and the latter ensures that these classifiers do not interfere with each other. The final design is a two dimensional array of horizontal and vertical layers, which decouples depth and feature coarseness. Whereas in traditional convolutional networks features only become coarser with increasing depth, the MSDNet generates features of all resolutions from the first layer on and maintains them throughout. The result is an architecture with an unprecedented range of efficiency. A single network can outperform all competitive baselines on an impressive range of computational budgets ranging from highly limited CPU constraints to almost unconstrained settings. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As future work we plan to investigate the use of resource-aware deep architectures beyond object classification, e.g. image segmentation (Long et al., 2015). Further, we intend to explore approaches that combine MSDNets with model compression (Chen et al., 2015; Han et al., 2015), spatially adaptive computation (Figurnov et al., 2016) and more efficient convolution operations (Chollet, 2016; Howard et al., 2017) to further improve computational efficiency. ",
+        "bbox": [
+            174,
+            676,
+            823,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            326,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors are supported in part by grants from the National Science Foundation ( III-1525919, IIS-1550179, IIS-1618134, S&AS 1724282, and CCF-1740822), the Office of Naval Research DOD (N00014-17-1-2175), and the Bill and Melinda Gates Foundation. ",
+        "bbox": [
+            176,
+            790,
+            821,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            285,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tolga Bolukbasi, Joseph Wang, Ofer Dekel, and Venkatesh Saligrama. Adaptive neural networks for fast test-time prediction. arXiv preprint arXiv:1702.07811, 2017.   \nCristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ACM SIGKDD, pp. 535–541. ACM, 2006.   \nWenlin Chen, James T Wilson, Stephen Tyree, Kilian Q Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In ICML, pp. 2285–2294, 2015.   \nFranc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.   \nJia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255, 2009.   \nMichael Figurnov, Maxwell D Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. arXiv preprint arXiv:1612.02297, 2016.   \nAlex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.   \nSam Gross and Michael Wilber. Training and investigating residual nets. 2016. URL http: //torch.ch/blog/2016/02/04/resnets.html.   \nAlexander Grubb and Drew Bagnell. Speedboost: Anytime prediction with uniform near-optimality. In AISTATS, volume 15, pp. 458–466, 2012.   \nSong Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2015.   \nBabak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. In IJCNN, pp. 293–299, 1993.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In ICCV, pp. 1026–1034, 2015.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.   \nGeoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NIPS Deep Learning Workshop, 2014.   \nAndrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.   \nGao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, pp. 646–661. Springer, 2016.   \nGao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017.   \nItay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In NIPS, pp. 4107–4115, 2016.   \nSergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pp. 770–778, 2015.   \nJorn-Henrik Jacobsen, Edouard Oyallon, St ¨ ephane Mallat, and Arnold WM Smeulders. Multiscale ´ hierarchical convolutional networks. arXiv preprint arXiv:1703.04140, 2017.   \nSergey Karayev, Mario Fritz, and Trevor Darrell. Anytime recognition of objects and scenes. In CVPR, pp. 572–579, 2014.   \nTsung-Wei Ke, Michael Maire, and Stella X. Yu. Neural multigrid. CoRR, abs/1611.07661, 2016. URL http://arxiv.org/abs/1611.07661.   \nAlex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Tech Report, 2009.   \nAlex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pp. 1097–1105, 2012.   \nGustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. In ICLR, 2017.   \nYann LeCun, John S Denker, Sara A Solla, Richard E Howard, and Lawrence D Jackel. Optimal brain damage. In NIPS, volume 2, pp. 598–605, 1989.   \nChen-Yu Lee, Saining Xie, Patrick W Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. In AISTATS, volume 2, pp. 5, 2015.   \nHao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.   \nTsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ ECCV, pp. 740–755. Springer, 2014.   \nJonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, pp. 3431–3440, 2015.   \nFeng Nan, Joseph Wang, and Venkatesh Saligrama. Feature-budgeted random forest. In ICML, pp. 1983–1991, 2015.   \nAugustus Odena, Dieterich Lawson, and Christopher Olah. Changing model behavior at test-time using reinforcement learning. arXiv preprint arXiv:1702.07780, 2017.   \nMohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, pp. 525–542. Springer, 2016.   \nShreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In NIPS, pp. 4053–4061, 2016.   \nChristian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015.   \nKirill Trapeznikov and Venkatesh Saligrama. Supervised sequential classification under budget constraints. In AI-STATS, pp. 581–589, 2013.   \nPaul Viola and Michael Jones. Robust real-time object detection. International Journal of Computer Vision, 4(34–47), 2001.   \nJi Wan, Dayong Wang, Steven Chu Hong Hoi, Pengcheng Wu, Jianke Zhu, Yongdong Zhang, and Jintao Li. Deep learning for content-based image retrieval: A comprehensive study. In ACM Multimedia, pp. 157–166, 2014.   \nJoseph Wang, Kirill Trapeznikov, and Venkatesh Saligrama. Efficient learning by directed acyclic graph for resource constrained prediction. In NIPS, pp. 2152–2160. 2015.   \nZhixiang Xu, Olivier Chapelle, and Kilian Q. Weinberger. The greedy miser: Learning under testtime budgets. In ICML, pp. 1175–1182, 2012.   \nZhixiang Xu, Matt Kusner, Minmin Chen, and Kilian Q. Weinberger. Cost-sensitive tree of classifiers. In ICML, volume 28, pp. 133–141, 2013.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   \nA. R. Zamir, T.-L. Wu, L. Sun, W. Shen, B. E. Shi, J. Malik, and S. Savarese. Feedback Networks. ArXiv e-prints, December 2016.   \nYisu Zhou, Xiaolin Hu, and Bo Zhang. Interlinked convolutional neural networks for face parsing. In International Symposium on Neural Networks, pp. 222–231. Springer, 2015. ",
+        "bbox": [
+            171,
+            58,
+            828,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            78,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS OF MSDNET ARCHITECTURE AND BASELINE NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            769,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use MSDNet with three scales on the CIFAR datasets, and the network reduction method introduced in 4.1 is applied. Figure 9 gives an illustration of the reduced network. The convolutional layer functions in the first layer, $h _ { 1 } ^ { s }$ , denote a sequence of $3 { \\times } 3$ convolutions (Conv), batch normalization (BN; Ioffe & Szegedy (2015)), and rectified linear unit (ReLU) activation. In the computation of $\\tilde { h } _ { 1 } ^ { s }$ , down-sampling is performed by applying convolutions using strides that are powers of two. For subsequent feature layers, the transformations $h _ { \\ell } ^ { s }$ and $\\tilde { h } _ { \\ell } ^ { s }$ are defined following the design in DenseNets (Huang et al., 2017): Conv $( 1 \\times 1 )$ -BN-ReLU-Conv $\\left( 3 \\times 3 \\right)$ -BN-ReLU. We set the number of output channels of the three scales to 6, 12, and 24, respectively. Each classifier has two down-sampling convolutional layers with 128 dimensional $3 \\times 3$ filters, followed by a $2 \\times 2$ average pooling layer and a linear layer. ",
+        "bbox": [
+            173,
+            135,
+            825,
+            279
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The MSDNet used for ImageNet has four scales, respectively producing 16, 32, 64, and 64 feature maps at each layer. The network reduction is also applied to reduce computational cost. The original images are first transformed by a $7 \\times 7$ convolution and a $3 \\times 3$ max pooling (both with stride 2), before entering the first layer of MSDNets. The classifiers have the same structure as those used for the CIFAR datasets, except that the number of output channels of each convolutional layer is set to be equal to the number of its input channels. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            369
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0de6b68dce803aca2a16de6affb943796e7f0bf1bb1eac9cef6c06e5c471db7.jpg",
+        "image_caption": [
+            "Figure 9: Illustration of an MSDNet with network reduction. The network has $S = 3$ scales, and it is divided into three blocks, which maintain a decreasing number of scales. A transition layer is placed between two contiguous blocks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            388,
+            743,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Network architecture for anytime prediction. The MSDNet used in our anytime-prediction experiments has 24 layers (each layer corresponds to a column in Fig. 1 of the main paper), using the reduced network with transition layers as described in Section 4. The classifiers operate on the output of the $2 \\times ( i { + } 1 ) ^ { \\mathrm { t h } }$ layers, with $i = 1 , \\ldots , 1 1$ . On ImageNet, we use MSDNets with four scales, and the $i ^ { \\mathrm { { t h } } }$ classifier operates on the $( k \\times i + 3 ) ^ { \\mathrm { t h } }$ layer (with $i = 1 , \\ldots , 5$ ), where $k = 4 , 6$ and 7. For simplicity, the losses of all the classifiers are weighted equally during training. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Network architecture for budgeted batch setting. The MSDNets used here for the two CIFAR datasets have depths ranging from 10 to 36 layers, using the reduced network with transition layers as described in Section 4. The $k ^ { \\mathrm { { t h } } }$ classifier is attached to the $( \\sum _ { i = 1 } ^ { k } i ) ^ { \\mathrm { t h } }$ layer. The MSDNets used for ImageNet are the same as those described for the anytime learning setting. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { R e s N e t } ^ { \\mathbf { M C } }$ and DenseNetMC. The ResNetMC has 62 layers, with 10 residual blocks at each spatial resolution (for three resolutions): we train early-exit classifiers on the output of the $4 ^ { \\mathrm { t h } }$ and $8 ^ { \\mathrm { t h } }$ residual blocks at each resolution, producing a total of 6 intermediate classifiers (plus the final classification layer). The DenseNetMC consists of 52 layers with three dense blocks and each of them has 16 layers. The six intermediate classifiers are attached to the $6 ^ { \\mathrm { { t h } } }$ and $1 2 ^ { \\mathrm { t h } }$ layer in each block, also with dense connections to all previous layers in that block. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            832,
+            398,
+            847
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            866,
+            341,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We perform additional experiments to shed light on the contributions of the three main components of MSDNet, viz., multi-scale feature maps, dense connectivity, and intermediate classifiers. ",
+        "bbox": [
+            173,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We start from an MSDNet with six intermediate classifiers and remove the three main components one at a time. To make our comparisons fair, we keep the computational costs of the full networks similar, at around $3 . 0 \\times 1 0 ^ { 8 }$ FLOPs, by adapting the network width, i.e., number of output channels at each layer. After removing all the three components in an MSDNet, we obtain a regular VGG-like convolutional network. We show the classification accuracy of all classifiers in a model in the left panel of Figure 10. Several observations can be made: 1. the dense connectivity is crucial for the performance of MSDNet and removing it hurts the overall accuracy drastically (orange vs. black curve); 2. removing multi-scale convolution hurts the accuracy only in the lower budget regions, which is consistent with our mo",
+        "bbox": [
+            174,
+            104,
+            496,
+            338
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/36de99964e9e6ab4f6f1967fffee5d8d4816d0686cfae2751a7e8cef27def4c9.jpg",
+        "image_caption": [
+            "Figure 10: Ablation study (on CIFAR-100) of MSDNets that shows the effect of dense connectivity, multi-scale features, and intermediate classifiers. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            516,
+            104,
+            818,
+            267
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "tivation that the multi-scale design introduces discriminative features early on; 3. the final canonical CNN (star) performs similarly as MSDNet under the specific budget that matches its evaluation cost exactly, but it is unsuited for varying budget constraints. The final CNN performs substantially better at its particular budget region than the model without dense connectivity (orange curve). This suggests that dense connectivity is particularly important in combination with multiple classifiers. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            409
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.2 RESULTS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            385,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the CIFAR-10 dataset, we use the same MSDNets and baseline models as we used for CIFAR100, except that the networks used here have a 10-way fully connected layer at the end. The results under the anytime learning setting and the batch computational budget setting are shown in the left and right panel of Figure 11, respectively. Similar to what we have observed from the results on CIFAR-100 and ImageNet, MSDNets outperform all the baselines by a significant margin in both settings. As in the experiments presented in the main paper, ResNet and DenseNet models with multiple intermediate classifiers perform relatively poorly. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            549
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/adf6b406c38b10a1e3fedffbeafa7e030553b2ab7ceb4700cb0a1fb272d4ff92.jpg",
+        "image_caption": [
+            "Figure 11: Classification accuracies on the CIFAR-10 dataset in the anytime-prediction setting (left) and the budgeted batch setting (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            564,
+            810,
+            734
+        ],
+        "page_idx": 13
+    }
+]

parse/train/HyeaSkrYPH/HyeaSkrYPH.md

@@ -0,0 +1,356 @@
+# CERTIFIED DEFENSES FOR ADVERSARIAL PATCHES∗
+
+Ping-yeh Chiang†, Renkun Ni†, Ahmed Abdelkader, Chen Zhu University of Maryland, College Park {pchiang,rn9zm,akader,chenzhu}@cs.umd.edu
+
+Christoph Studer Cornell University studer@cornell.edu
+
+Tom Goldstein   
+University of Maryland, College Park   
+tomg@cs.umd.edu
+
+# ABSTRACT
+
+Adversarial patch attacks are among one of the most practical threat models against real-world computer vision systems. This paper studies certified and empirical defenses against patch attacks. We begin with a set of experiments showing that most existing defenses, which work by pre-processing input images to mitigate adversarial patches, are easily broken by simple white-box adversaries. Motivated by this finding, we propose the first certified defense against patch attacks, and propose faster methods for its training. Furthermore, we experiment with different patch shapes for testing, obtaining surprisingly good robustness transfer across shapes, and present preliminary results on certified defense against sparse attacks. Our complete implementation can be found on: https://github.com/Ping-C/certifiedpatchdefense.
+
+# 1 INTRODUCTION
+
+Despite the great success of neural networks for vision problems, they are easily fooled by adversarial attacks in which the input to a machine learning model is modified with the goal of manipulating its output. Research in this area is largely focused on norm-bounded attack (Madry et al., 2017; Tramer\` & Boneh, 2019; Shafahi et al., 2019), where the adversary is allowed to perturb all pixels in an image provided that the $\ell _ { p }$ -norm of the perturbation is within prescribed bounds. Other adversarial models were also proposed, such as functional (Laidlaw & Feizi, 2019), rotation/translation (Engstrom et al., 2017), and Wasserstein (Wong et al., 2019), all of which allow modification to all pixels.
+
+Whole-image perturbations are unrealistic for modeling ”physical-world” attacks, in which a realworld object is modified to evade detection. A physical adversary usually modifies an object using stickers or paint. Because this object may only occupy a small portion of an image, the adversary can only manipulate a limited number of pixels. As such, the more practical patch attack model was proposed (Brown et al., 2017). In a patch attack, the adversary may only change the pixels in a confined region, but is otherwise free to choose the values yielding the strongest attack. The threat to real-world computer vision systems is well-demonstrated in recent literature where carefully crafted patches can fool a classifier with high reliability (Brown et al., 2017; Karmon et al., 2018), make objects invisible to an object detector (Wu et al., 2019; Lee & Kolter, 2019), or fool a face recognition system (Sharif et al., 2017). In light of such effective physical-world patch attacks, very few defenses are known to date.
+
+In this paper, we study principled defenses against patch attacks. We begin by looking at existing defenses in the literature that claim to be effective against patch attacks, including Local Gradient Smoothing (LGS) (Naseer et al., 2019) and Digital Watermarking (DW) (Hayes, 2018). Similar to what has been observed for whole-image attacks by (Athalye et al., 2018), we show that these patch defenses are easily broken by stronger adversaries. Concretely, we demonstrate successful white-box attacks, where the adversary designs an attack against a known model, including any pre-processing steps. To cope with such potentially stronger adversaries, we train a robust model that produces a lower-bound on adversarial accuracy. In particular, we propose the first certifiable defense against patch attacks by extending interval bound propagation (IBP) defenses (Gowal et al., 2018; Mirman et al., 2018). We also propose modifications to IBP training to make it faster in the patch setting. Furthermore, we study the generalization of certified patch defenses to patches of different shapes, and observe that robustness transfers well across different patch types. We also present preliminary results on certified defense against the stronger sparse attack model, where a fixed number of possibly non-adjacent pixels can be arbitrarily modified (Modas et al., 2019).
+
+# 2 PROBLEM SETUP
+
+We consider a white-box adversary that is allowed to choose the location of the patch (chosen from a set $\mathbb { L }$ of possible locations) and can modify pixels within the particular patch (chosen from the set $\mathbb { P }$ ) similar to (Karmon et al., 2018). An attack is successful if the adversary changes the classification of the network to a wrong label. In this paper, we are primarily interested in the patch attack robust accuracy (adversarial accuracy for short) as defined by
+
+$$
+\underset { x \sim X } { \mathbb { E } } \operatorname* { m i n } _ { p \in \mathbb { P } , l \in \mathbb { L } } \mathcal { X } [ f ( A ( x , p , l ) ; \theta ) = y ] ,
+$$
+
+where the operator $A$ places the adversarial patch p on a given image $\mathbf { X }$ at location $l$ , f is a neural network with parameter $\theta$ , $X$ is a distribution of images, and $\mathcal { X }$ is a characteristic function that takes value 1 if its argument is true, and 0 otherwise.
+
+In this model, the strength of the adversary can vary depending on the set of possible patches allowed, and the type of perturbation allowed within the patch. In what follows, we assume the standard setup in which the adversary is allowed any perturbation that maintains pixel intensities in the range $[ 0 , 1 ]$ . Unless otherwise noted, we also assume the patch is restricted to a square of prescribed size. We consider two different options for the set $\mathbb { L }$ of possible patch locations. First, we consider a weak adversary that can only place patches at the corner of an image. We find that even this weak model is enough to break existing patch defenses. Then, we consider a stronger adversary with no restrictions on patch location, and use this model to evaluate our proposed defenses. Note that an adversary, when restricted to modify only a square patch at location $l$ in the image, has the freedom to modify any non-square subset of these pixels. In other words, a certified defense against square patch attacks also provably subverts any non-square patch attack that fits inside a small enough square.
+
+In general, calculating the adversarial accuracy (1) is intractable due to non-convexity. Common approaches try to approximate it by solving the inner minimization using a gradient-based method. However, in Section 3, we show that depending on how the minimization is solved, the upper bound could be very loose: a model may appear to be very robust, but fail when faced with a stronger attack. To side-step the arms race between attacks and defenses, in Section 4, we extend the work of (Gowal et al., 2018) and (Mirman et al., 2018) to train a network that produces a lower bound on adversarial accuracy. We will refer to approximations of the upper bound as empirical adversarial accuracy and the lower bound as certified accuracy.
+
+# 3 VULNERABILITY OF EXISTING DEFENSES
+
+We start by examining existing defense strategies that claim to be effective against patch attacks. Similar to what has been observed for whole-image attacks by Athalye et al. (2018), we show that these patch defenses can easily be broken by white-box attacks, where the adversary optimizes against a given model including any pre-processing steps.
+
+# 3.1 EXISTING DEFENSES
+
+Under our threat model, two defenses have been proposed that each use input transformations to detect and remove adversarial patches.
+
+The first defense is based on the observation that the gradient of the loss with respect to the input image often exhibits large values near the perturbed pixels. In (Hayes, 2018), the proposed digital watermarking (DW) approach exploits this behavior to detect unusually dense regions of large gradient entries using saliency maps, before masking them out in the image. Despite a $1 2 \%$ drop in accuracy on clean (non-adversarial) images, this defense method supposedly achieves an empirical adversarial accuracy of $6 3 \%$ for non-targeted patch attacks of size $4 2 \times 4 2$ ( $\dot { 2 } \%$ of the image pixels), using 400 randomly picked images from ImageNet (Deng et al., 2009) on VGG19 (Simonyan & Zisserman, 2014).
+
+Table 1: Empirical adversarial accuracy of ImageNet classifiers defended with Local Gradient Smoothing and Digital Watermarking. We consider two types of adversaries, one that takes the defense into account during backpropagation and one that does not   
+
+<table><tr><td colspan="2"></td><td colspan="3">Patch Size</td></tr><tr><td>Attack</td><td>Defense</td><td>42 × 42</td><td>52 × 52</td><td>60 ×60</td></tr><tr><td>IFGSM</td><td>LGS</td><td>78%</td><td>75%</td><td>71%</td></tr><tr><td>IFGSM+LGS</td><td>LGS</td><td>14%</td><td>5%</td><td>3%</td></tr><tr><td>IFGSM</td><td>DW</td><td>56%</td><td>49%</td><td>45%</td></tr><tr><td>IFGSM+DW</td><td>DW</td><td>13%</td><td>8%</td><td>5%</td></tr></table>
+
+The second defense, Local Gradient Smoothing (LGS) by Naseer et al. (2019) is based on the empirical observation that pixel values tend to change sharply within these adversarial patches. In other words, the image gradients tend to be large within these adversarial patches. Note that the image gradient here differs from the gradient in Hayes (2018), the former is with respect the changes of adjacent pixel values and the later is with respect to the classification loss. Naseer et al. (2019) propose suppressing this adversarial noise by multiplying each pixel with one minus its image gradient as in (2). To make their methods more effective, Naseer et al. (2019) also pre-process the image gradient with a normalization and a thresholding step.
+
+$$
+{ \hat { x } } = x \odot ( 1 - \lambda g ( x ) ) .
+$$
+
+The $\lambda$ here is a smoothing hyper-parameter. Naseer et al. (2019) claim the best adversarial accuracy on ImageNet with respect to patch attacks among all of the defenses we studied. They also claim that their defense is resilient to Backward Pass Differential Approximation (BPDA) from Athalye et al. (2018), one of the most effective methods to attack models that include a non-differentiable operator as a pre-processing step.
+
+# 3.2 BREAKING EXISTING DEFENSES
+
+Using a similar setup as in (Hayes, 2018; Naseer et al., 2019), we are able to mostly replicate the reported empirical adversarial accuracy for Iterative Fast Gradient Sign Method (IFGSM), a common gradient based attack, but we show that when the pre-processing step is taken into account, the empirical adversarial accuracy on ImageNet quickly drops from $\bar { \sim } 7 0 \% ( \sim 5 0 \% )$ for LGS(DW) to levels around $\sim 1 0 \%$ as shown in Table 1.
+
+Specifically, we break DW (Hayes, 2018) by applying BPDA, in which the non-differentiable operator is approximated with an identity mapping during the backward pass. We break LGS (Naseer et al., 2019) by directly incorporating the smoothing step during backpropagation. Even though the windowing and thresholding steps are non-differentiable, the smoothing operator provides enough gradient information for the attack to be effective.
+
+To make sure that our evaluation is fair, we used the exact same models as Hayes (2018) (VGG19) and Szegedy et al. (2016) (Inception V3). We also consider a weaker set of attackers that can only attack the corners, the same as their setting. Further, we ensure that we were able to replicate their reported result under similar setting.
+
+# 4 CERTIFIED DEFENSES
+
+Given the ease with which these supposedly strong defenses are broken, it is natural to seek methods that can rigorously guarantee robustness of a given model to patch attacks. With such certifiable guarantees in hand, we need not worry about an adversary with a stronger optimizer, or a more clever algorithm for choosing patch locations.
+
+# 4.1 BACKGROUND ON CERTIFIED DEFENSES
+
+Certified defenses have been intensely studied with respect to norm-bounded attacks (Cohen et al., 2019; Wong & Kolter, 2017; Gowal et al., 2018; Mirman et al., 2018; Zhang et al., 2019b). In all of these methods, in addition to the prediction model, there is also a verifier. Given a model and an input, the verifier outputs a certificate if it is guaranteed that the image can not be adversarially perturbed. This is done by checking whether there exists any nearby image (within a prescribed $\ell _ { p }$ distance) with a different label than the image being classified. While theoretical bounds exist on the size of this distance that hold for any classifier (Shafahi et al., 2018), exactly computing bounds for a specific classifier and test image is hard. Alternatively, the verifier may output a lower bound on the distance to the nearest image of a different label. This latter distance is referred to as the certifiable radius. Most of these verifiers provide a rather loose bound on the certifiable radius. However, if the verifier is differentiable, then the network can be trained with a loss that promotes tightness of this bound. We use the term certificate training to refer to the process of training with a loss that promotes strong certificates. Interval bound propagation (IBP) (Mirman et al., 2018; Gowal et al., 2018) is a very simple verifier that uses layer-wise interval arithmetic to produce a certificate. Even though the IBP certificate is generally loose, after certificate training, it yields state-of-the-art certifiably-robust models for $l _ { \infty }$ -norm bounded attacks (Gowal et al., 2018; Zhang et al., 2019b). In this paper, we extend IBP to train certifiably-robust networks resilient to patch attacks. We first introduce some notation and basic algorithms for IBP training.
+
+Notation We represent a neural network with a series of transformations $h ^ { ( k ) }$ for each of its $k$ layers. We use $z ^ { ( k ) } \in \bar { \mathbb { R } } ^ { n _ { k } }$ to denote the output of layer $k$ , where $n _ { k }$ is the number of units in the $k ^ { t h }$ layer and $z ^ { ( 0 ) }$ stands for the input. Specifically, the network computes
+
+$$
+z ^ { ( k ) } = h ^ { ( k - 1 ) } ( z ^ { ( k - 1 ) } ) \forall k = 1 , \dots , K .
+$$
+
+Certification Problem To produce a certificate for an input $x _ { 0 }$ , we want to verify that the following condition is true with respect to all possible labels $y$ :
+
+$$
+( e _ { y _ { t r u e } } - e _ { y } ) ^ { T } z ^ { ( K ) } = { \bf m } _ { y } \geq 0 \qquad \forall z ^ { ( 0 ) } \in \mathbb { B } ( x _ { 0 } ) \qquad \forall y .
+$$
+
+Here, $e _ { i }$ is the $i ^ { t h }$ basis vector, and $\mathbf { m } _ { y }$ is called the margin following Wong & Kolter (2017). Note that $\mathbf { m } _ { y _ { t r u e } }$ is always equal to 0. The vector $\mathbf { m }$ contains all margins corresponding to all labels. $\mathbb { B } ( x _ { 0 } )$ is the constraint set over which the adversarial input image may range. In a conventional setting, this is an $\ell _ { \infty }$ ball around $x _ { 0 }$ . In the case of patch attack, the constraint set contains all images formed by applying a patch to $x _ { 0 }$ ;
+
+$$
+\mathbb { B } ( x _ { 0 } ) = \{ A ( x _ { 0 } , p , l ) | p \in \mathbb { P } { \mathrm { ~ a n d ~ } } l \in \mathbb { L } \} .
+$$
+
+The Basics of Interval Bound Propagation (IBP) We now describe how to produce certificates using interval bound propagation as in (Gowal et al., 2018). Suppose that for each component in $z ^ { ( k - \bar { 1 } ) }$ we have an interval containing all the values which this component reaches as $z ^ { ( 0 ) }$ ranges over the ball $\mathbb { B } ( x _ { 0 } )$ . If $z ^ { ( k ) } = h ^ { ( k ) } ( z ^ { \top } )$ is a linear (or convolutional) layer of the form ${ z } ^ { ( k ) ^ { - } } =$ $W ^ { ( k ) } z ^ { ( k - 1 ) } + b ^ { ( k ) }$ , then we can get an outer approximation of the reachable interval range of activations by the next layer $z ^ { ( k ) }$ using the formulas below
+
+$$
+\begin{array} { r l } & { \overline { { z } } ^ { ( k ) } = W ^ { ( k ) } \frac { \overline { { z } } ^ { ( k - 1 ) } + \underline { { z } } ^ { ( k - 1 ) } } { 2 } + | W ^ { ( k ) } | \frac { \overline { { z } } ^ { ( k - 1 ) } - \underline { { z } } ^ { ( k - 1 ) } } { 2 } + b ^ { ( k ) } , } \\ & { \underline { { z } } ^ { ( k ) } = W ^ { ( k ) } \frac { \overline { { z } } ^ { ( k - 1 ) } + \underline { { z } } ^ { ( k - 1 ) } } { 2 } - | W ^ { ( k ) } | \frac { \overline { { z } } ^ { ( k - 1 ) } - \underline { { z } } ^ { ( k - 1 ) } } { 2 } + b ^ { ( k ) } . } \end{array}
+$$
+
+Here $\overline { { z } } ^ { ( k - 1 ) }$ denotes the upper bound of each interval, $\underline { z } ^ { ( k - 1 ) }$ the lower bound, and $| W ^ { ( k ) } |$ the element-wise absolute value. Alternatively, if $h ^ { ( k ) } ( z ^ { ( k - 1 ) } )$ is an element-wise monotonic activation (e.g., a ReLU), then we can calculate the outer approximation of the reachable interval range of the next layer using the formulas below.
+
+$$
+\begin{array} { r } { \overline { z } ^ { ( k ) } = h ^ { ( k ) } ( \overline { z } ^ { ( k - 1 ) } ) } \\ { \underline { z } ^ { ( k ) } = h ^ { ( k ) } ( \underline { z } ^ { ( k - 1 ) } ) . } \end{array}
+$$
+
+When the feasible set $\mathbb { B } ( x _ { 0 } )$ represents a simple $\ell _ { \infty }$ attack, the range of possible $z ^ { ( 0 ) }$ values is trivially characterized by an interval bound $\overline { { z } } ^ { ( 0 ) }$ and $\underline { z } ^ { ( 0 ) }$ . Then, by iteratively applying the above rules, we can propagate intervals through the network and eventually get $\overline { { z } } ^ { ( K ) }$ and $\smash { \mathcal { Z } ^ { ( K ) } }$ . A certificate can then be given if we can show that (3) is always true for outputs in the range $\overline { { z } } ^ { ( K ) }$ and $\smash { \boldsymbol { \mathcal { Z } } ^ { ( K ) } }$ with respect to all possible labels. More specifically, we can check that the following holds for all $y$
+
+$$
+\begin{array} { r } { \underline { { \mathbf { m } } } _ { y } = e _ { y _ { t r u e } } ^ { T } \underline { { z } } ^ { ( K ) } - e _ { y } ^ { T } \overline { { z } } ^ { ( K ) } = \underline { { z } } _ { y _ { t r u e } } ^ { ( K ) } - \overline { { z } } _ { y } ^ { ( K ) } \geq 0 \quad \forall y . } \end{array}
+$$
+
+Training for Interval Bound Propagation To train a network to produce accurate interval bounds, we simply replace standard logits with the $- \mathbf { m }$ vector in (3). Note that all elements of $\mathbf { m }$ need to be larger than zero to satisfy the conditions in (3), and mytrue is always equal to zero. Put simply, we would like mytrue to be the least of all margins. We can promote this condition by training with the loss function
+
+$$
+\mathrm { C e r t i f i c a t e \ L o s s } = \mathrm { C r o s s \ E n t r o p y \ L o s s } ( - \mathbf { m } , y ) .
+$$
+
+Unlike regular neural network training, stochastic gradient descent for minimizing equation 10 is unstable, and a range of tricks are necessary to stabilize IBP training (Gowal et al., 2018). The first trick is merging the last linear weight matrix with $( e _ { y } - e _ { y _ { t r u e } } )$ before calculating $- { \underline { { \mathbf { m } } } } _ { y }$ . This allows a tighter characterization of the interval bound that noticeably improves results. The second trick uses an “epsilon schedule” in which training begins with a perturbation radius of zero, and this radius is slowly increased over time until a sentinel value is reached. Finally, a mixed loss function containing both a standard natural loss and an IBP loss is used.
+
+In all of our experiments, we use the merging technique and the epsilon schedule, but we do not use a mixed loss function containing a natural loss as it does not increase our certificate performance.
+
+# 4.2 CERTIFYING AGAINST PATCH ATTACKS
+
+We can now describe the extension of IBP to patches. If we specify the patch location, one can represent the feasible set of images with a simple interval bound: for pixels within the patch, the upper and lower bound is equal to 1 and 0. For pixels outside of the patch, the upper and lower bounds are both equal to the original pixel value. By passing this bound through the network, we would be able to get msingle location and verify that they satisfy the conditions in (3).
+
+However, we have to consider not just a single location, but all possible locations $\mathbb { L }$ to give a certificate. To adapt the bound to all possible location, we pass each of the possible patches through the network, and take the worst case margin. More specifically,
+
+$$
+\mathbf { m } ^ { \mathrm { e s } } ( \mathbb { L } ) _ { y } = \operatorname* { m i n } _ { l \in \mathbb { L } } \mathbf { m } ^ { \mathrm { s i n g l e ~ p a t c h } } ( l ) _ { y } \forall y .
+$$
+
+Similar to regular IBP training, we simply use $\underline { { \mathbf { m } } } ^ { \mathrm { e s } } ( \mathbb { L } )$ to calculate the cross entropy loss for training and backpropagation,
+
+$$
+\operatorname { C e r t i f i c a t e \operatorname { L o s s } } = \operatorname { C r o s s \operatorname { E n t r o p y \operatorname { L o s s } } } ( - \underline { { \mathbf { m } } } ^ { \mathrm { e s } } ( \mathbb { L } ) , y ) .
+$$
+
+Unfortunately, the cost of producing this na¨ıve certificate increases quadratically with image size. Consider that a CIFAR-10 image is of size $3 2 \times 3 2$ , requiring over a thousand interval bounds, one for each possible patch location. To alleviate this problem, we propose two certificate training methods: Random Patch and Guided Patch, so that the number of forward passes does not scale with the dimension of the inputs.
+
+Random Patch Certificate Training In this method, we simply select a random set of patches out of the possible patches and pass them forward. A level of robustness is achieved even though a very small number of random patches are selected compared to the total number of possible patches
+
+$$
+\underline { { \mathbf { m } } } ^ { \mathrm { r a n d o m \ p a t c h e s } } ( \mathbb { L } ) _ { y } = \underline { { \mathbf { m } } } ^ { \mathrm { e s } } ( S ) _ { y }
+$$
+
+where $S$ is a random subset of $\mathbb { L }$ . Similarly, the random patch certificate loss is calculated as below.
+
+$$
+\mathrm { R a n d o m ~ P a t c h ~ C e r t i f i c a t e ~ L o s s } = \mathrm { C r o s s ~ E n t r o p y ~ L o s s } ( - \underline { { \mathbf { m } } } ^ { \mathrm { r a n d o m ~ p a t c h e s } } ( \mathbb { L } ) , y )
+$$
+
+Guided Patch Certificate Training In this method, we propose using a U-net (Ronneberger et al., 2015) to predict msingle patch, and then randomly select a couple of locations based on the predicted $\mathbf { m } ^ { \mathrm { s i n g l e } \mathrm { p a t c h } }$ so that fewer patches need to be passed forward.
+
+Note that very few patches contribute to the worst case bound $\underline { { \mathbf { m } } } ^ { \mathrm { e s } }$ in (11). In fact, the number of patches that yield the worst case margins will be no more than the number of labels. If we know the worst-case patches beforehand, then we can simply select the few worst-case patches during training.
+
+We propose to use U-net as the number of locations and margins is very large. For a square patch of size $n \times n$ and an image of size $m \times m$ , the total number of possible locations is $( m - n + \mathbf { \hat { 1 } } ) ^ { 2 }$ , and for each location the number of margins is equal to the number of possible labels.
+
+$$
+\begin{array} { l } { { \bf { m } } ^ { \mathrm { { p r e d } } } = { \bf { U } } { \mathrm { - n e t } } ( \mathrm { i m a g e } ) } \\ { { \bf { d i m } } ( { \bf { m } } ^ { \mathrm { { p r e d } } } ) = ( m - n + 1 , m - n + 1 , \# \mathrm { o f } \mathrm { l a b e l s } ) . } \end{array}
+$$
+
+Given the U-net prediction of $\underline { { \mathbf { m } } } ^ { \mathrm { p r e d } }$ , we then randomly select a single patch for each label based on the softmax of the predicted $\underline { { \mathbf { m } } } ^ { \mathrm { p r e d } }$ . The number of selected patches is equal to the number of labels. After these patches are passed forward, the U-net is then updated with a mean-squared-error loss between the predicted margins $\underline { { \mathbf { m } } } ^ { \mathrm { p r e d } }$ and the actual margins $\underline { { \mathbf { m } } } ^ { \mathrm { a c t u a l } }$ . Note that only a few patches are selected at a time, so that the mean-squared-error only passes through the selected patches.
+
+$$
+\mathrm { U } \mathrm { - n e t } \mathrm { L o s s } = \mathbf { M } \mathrm { S E } ( \mathbf { \underline { { m } } } ^ { \mathrm { p r e d } } , \mathbf { \underline { { m } } } ^ { \mathrm { a c t u a l } } ) .
+$$
+
+The network is trained with the following loss:
+
+Guided Patch Certificate $\operatorname { L o s s } = \operatorname { C r o s s } \operatorname { E n t r o p y } \operatorname { L o s s } ( - \underline { { \mathbf { m } } } ^ { \mathrm { g u i d e d } \mathrm { p a t c h e s } } ( \mathbb { L } ) , y ) .$
+
+Certification Process In all our experiments, we check that equation (3) is satisfied by iterating over all possible patches and forward-passing the interval bounds generated for each patch; this overhead is tolerable at evaluation time.
+
+# 4.3 CERTIFYING AGAINST SPARSE ATTACKS
+
+IBP can also be adapted to defend against sparse attack where the attacker is allowed to modify a fixed number $( k )$ of pixels that may not be adjacent to each other (Modas et al., 2019). The only modification is that we have to change the bound calculated from the first layer to
+
+$$
+\overline { { { z } } } _ { i } ^ { ( 1 ) } = W _ { i , : } ^ { ( 1 ) } z ^ { ( 0 ) } + | W _ { i , : } ^ { ( 1 ) } | _ { t o p _ { k } } ~ z _ { i } ^ { ( 1 ) } = W _ { i , : } ^ { ( 1 ) } z ^ { ( 0 ) } - | W _ { i , : } ^ { ( 1 ) } | _ { t o p _ { k } } ~ \forall i
+$$
+
+and apply equation (5) and (6) for the subsequent layers. Here, $( . ) _ { t o p _ { k } }$ is the sum of the largest $k$ elements in the vector.
+
+# 5 EXPERIMENTS
+
+In this section, we compare our certified defenses with exiting algorithms on two datasets and three model architectures of varying complexity. We consider a strong attack setting in which adversarial patches can appear anywhere in the image. Different training strategies for the certified defense are also compared, which shows a trade-off between performance and training efficiency. Furthermore, we evaluate the transferability of a model trained using square patches to other adversarial shapes, including shapes that do not fit in any certified square. The training and architectural details can be found in Appendix A.1. We also present preliminary results on certified defense against sparse attacks.
+
+# 5.1 COMPARISON AGAINST EXISTING DEFENSES
+
+In this section, we study the effectiveness of our proposed IBP certified models against an adversary that is allowed to place patches anywhere in the image, even on top of the salient object. If the patch is sufficiently small, and does not cover a large portion of the salient object, then the model should still classify correctly, and defense against the perturbation should be possible.
+
+In the best case, our IBP certified model is able to achieve $9 1 . 6 \%$ certified (Table 2) with respect to a $2 \times 2$ patch $( \sim . 5 \%$ of image pixels) adversary on MNIST. For more challenging cases, such as a 5 $\times 5$ ( $\sim 2 . 5 \%$ of image pixels) patch adversary on CIFAR-10, the certified adversarial accuracy is only $2 4 . 9 \%$ (Table 2). Even though these existing defenses appear to achieve better or comparable adversarial accuracy as our IBP certified model when faced with a weak adversary, when faced with a stronger adversary their adversarial accuracy dropped to levels below our certified accuracy for all cases that we analyzed.
+
+When evaluating existing defenses, we only report cases where non-trivial adversarial accuracy is achieved against a weaker adversary. We do not explore cases where LGS and DW perform so poorly that no meaningful comparison can be done. LGS and DW are highly dependent on hyperparameters to work effectively against naive attacks, and yet neither Naseer et al. (2019) nor Hayes (2018) proposed a way to learn these hyperparameters. By trial and error, we were able to increase the adversarial accuracy against a weaker adversary for some settings, but not all. In addition, we also notice a peculiar feature of DW: when we increase the adversarial accuracy, the clean accuracy degrades, sometimes so much that it is even lower than the empirical adversarial accuracy. This happens because DW always removes a patch from the prediction. When an adversarial patch is detected, it is likely to be removed, enabling correct prediction. On the other hand, when there are no adversarial patches, DW removes actual salient information, resulting in lower clean accuracy.
+
+Here we did not compare our results with adversarial training, because even though it produces some of the most adversarially robust models, it does not offer any guarantees on the empirical robust accuracy, and could still be decreased further with stronger attacks. For example, Wang et al. (2019) proposed a stronger attack that could find $47 \%$ more adversarial examples compared to gradient based method. Further, adversarial training on all possible patches would be even more expensive compared to certificate training, and is slightly beyond our computational budget.
+
+Compared to state-of-the-art certified models for CIFAR with $L _ { \infty }$ -perturbation, where Zhang et al. (2019a) proposed a deterministic algorithm that achieves clean accuracy of $3 4 . 0 \%$ , our clean accuracy for our most robust CIFAR $5 \times 5$ model is $4 7 . 8 \%$ when using a large model (Table 2).
+
+Table 2: Comparison of our IBP certified patch defense against existing defenses. Empirical adversarial accuracy is calculated for 400 random images in both datasets. All results are averaged over three different models.   
+
+<table><tr><td>Dataset</td><td>Patch Size</td><td>Adversary</td><td>Defense</td><td>Clean Accuracy</td><td>Accuracy</td><td>Empirical Certified Adversarial Accuracy</td></tr><tr><td rowspan="5">MNIST</td><td>2×2</td><td>IFGSM</td><td>None</td><td>98.4%</td><td>80.1%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>LGS</td><td>97.4%</td><td>90.0%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+LGS</td><td>LGS</td><td>97.4%</td><td>60.7%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>IBP</td><td>98.5%</td><td>93.9%</td><td>91.6%</td></tr><tr><td>5×5</td><td>IFGSM</td><td>None</td><td>98.5%</td><td>3.3%</td><td></td></tr><tr><td rowspan="10">CIFAR</td><td>5×5</td><td>IFGSM</td><td>IBP</td><td>92.9%</td><td>66.1%</td><td>62.0%</td></tr><tr><td>2×2</td><td>IFGSM</td><td>None</td><td>66.3%</td><td>25.4%</td><td>1</td></tr><tr><td>2×2</td><td>IFGSM</td><td>LGS</td><td>64.9%</td><td>31.3%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+LGS</td><td>LGS</td><td>64.9%</td><td>24.2%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>DW</td><td>47.1%</td><td>43.3%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+DW</td><td>DW</td><td>47.1%</td><td>20.2%</td><td>=</td></tr><tr><td>2×2</td><td>IFGSM</td><td>IBP</td><td>48.6%</td><td>45.2%</td><td>41.6%</td></tr><tr><td>5×5</td><td>IFGSM</td><td>None</td><td>66.5%</td><td>0.4%</td><td></td></tr><tr><td>5×5</td><td>IFGSM</td><td>LGS</td><td>51.2% 51.2%</td><td>22.11%</td><td></td></tr><tr><td>5×5</td><td>IFGSM +LGS</td><td>LGS DW</td><td>45.3%</td><td>0.5% 59.3%</td><td></td></tr><tr><td>5×5</td><td></td><td>IFGSM</td><td></td><td></td><td></td></tr><tr><td>5×5</td><td>IFGSM+DW</td><td>DW</td><td>45.3%</td><td>15.6%</td><td></td></tr><tr><td>5×5</td><td>IFGSM</td><td>IBP</td><td>33.9%</td><td>29.1%</td><td>24.9%</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+# 5.2 COMPARISON OF TRAINING STRATEGIES
+
+We find that given a fixed architecture all-patch certificate training achieves the best certified accuracy. However, given a fixed computational budget, random and guided training significantly outperform all-patch training. Finally, guided-patch certificate training consistently outperforms random-patch certificate training by a slim margin, indicating that the U-net is learning how to predict the minimum margin m.
+
+In Table 3, we see that given a fixed architecture all-patch certificate training significantly outperforms both random-patch certificate training and guided-patch certificate training in terms of certified accuracy, outperforming the second best certified defenses in each task by $2 . 6 \%$ (MNIST, $2 \times 2$ ), $7 . 3 \%$ (MNIST, $5 \times 5$ ), $3 . 9 \%$ (CIFAR-10, $2 \times 2 )$ ), and $3 . 4 \%$ (CIFAR-10, $5 \times 5$ ). However, all-patch certificate training is very expensive, taking on average 4 to 15 times longer than guided-patch certificate training and over 30 to 70 times longer than random-patch certificate training.
+
+On the other hand, given a limited computational budget, random-patch and guided-patch training significantly outperforms all-patch training. Due to the efficiency of random-patch and guided-patch training, they scale much better to large architectures. By switching to a large architecture (5 layer wide convolutional network), we are able to boost the certified accuracy by over $10 \%$ compared to the best performing all-patch small model (Table 2). Note that we are unable to all-patch train the same architecture as it will take almost 15 days to complete, and is out of our computational budget.
+
+Guided-patch certificate training is slightly more expensive compared to random patch, due to overhead from the U-net architecture. However, given the 10 patches picked, guided-patch certificate training consistently outperforms random-patch certificate training, indicating that the U-net is learning how to predict the minimum margin m.
+
+Table 3: Trade-off between certified accuracy and training time for different strategies. The numbers next to training strategies indicate the number of patches used for estimating the lower bound during training. Most training times are measured on a single 2080Ti GPU, with the exception of all-patch training which is run on four 2080Ti GPUs. For that specific case, the training time is multiplied by 4 for fair comparison. See Appendix A.6 for more detailed statistics. \*indicates the performance of the best performing large model trained with either random or guided patch. Detailed performance of the large models can be found in Appendix A.5   
+
+<table><tr><td colspan="2"></td><td colspan="3">2×2</td><td colspan="3">5×5</td></tr><tr><td>Dataset</td><td>Training Strategy</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td></tr><tr><td rowspan="4">MNIST</td><td>AllPatch</td><td>98.5%</td><td>91.5%</td><td>9.3</td><td>92.0%</td><td>60.4%</td><td>8.4</td></tr><tr><td>Random(1)</td><td>98.5%</td><td>82.9%</td><td>0.2</td><td>96.9%</td><td>24.1%</td><td>0.4</td></tr><tr><td>Random(5)</td><td>98.6%</td><td>86.6%</td><td>0.3</td><td>95.8%</td><td>42.1%</td><td>0.3</td></tr><tr><td>Random(10)</td><td>98.6%</td><td>87.7%</td><td>0.3</td><td>95.6%</td><td>49.6%</td><td>0.3</td></tr><tr><td rowspan="6">CIFAR</td><td>Guided(10) All Patch</td><td>98.6% 50.9%</td><td>88.9% 39.9%</td><td>2.2 56.4</td><td>95.0% 33.5%</td><td>53.1% 22.0%</td><td>2.6 45.8</td></tr><tr><td>Random(1)</td><td>53.6%</td><td>21.6%</td><td>0.6</td><td>43.6%</td><td>6.1%</td><td>0.6</td></tr><tr><td>Random(5)</td><td>52.9%</td><td>32.3%</td><td>0.7</td><td>39.0%</td><td>14.6%</td><td>0.7</td></tr><tr><td>Random(10)</td><td>51.9%</td><td>35.6%</td><td>0.8</td><td>38.8%</td><td>18.6%</td><td></td></tr><tr><td>Guided(10)</td><td>52.4%</td><td>36.0%</td><td>3.7</td><td>37.9%</td><td>18.8%</td><td>0.8 3.7</td></tr><tr><td>Large Model*</td><td>65.8%</td><td>51.9%</td><td>22.4</td><td>47.8%</td><td>30.3%</td><td>15.4</td></tr></table>
+
+# 5.3 EFFECTIVENESS AGAINST SPARSE ATTACK
+
+The IBP based method can also be used to defend against sparse attack, see Section 4.3. Its performance is reasonable compared to patch defense (e.g. $9 1 . 5 \%$ certified accuracy for $2 \times 2$ patch vs $9 0 . 8 \%$ for $\mathrm { k } { = } 4$ ), even though the sparse attack model is much stronger. For convolutional networks, we increase the size of the first convolutional layer (i.e. from $3 \times 3$ to $1 1 \times 1 1$ ) so the interval bounds calculated are tighter. However, despite the change, fully-connected network still performs much better. For example, the certified accuracy drops from $2 5 . 6 \%$ to $1 3 . 8 \%$ when we switch from fully-connected to convolutional network for CIFAR10 and drops from $9 0 . 8 \%$ to $7 5 . 9 \%$ for MNIST respectively. Detailed results are shown in the Appendix A.4 Table 7.
+
+Table 4 compares our approach with the state-of-the-art certified sparse defense (Random Ablation) Levine & Feizi (2019). We use their best model with the largest medium radii to certify against various levels of sparsity. As shown in the table, our method achieves higher certified accuracy on the MNIST dataset over all the sparse radii, but lower on CIFAR-10. It is worth noting that we are using a much smaller and simpler model (a fully-connected network) compared to Random Ablation, which uses ResNet-50.
+
+Table 4: Certified accuracy for sparse defenses with IBP and Random Ablation.   
+
+<table><tr><td>Dataset</td><td>Sparsity (k)</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td></tr><tr><td rowspan="6">MNIST</td><td>1</td><td>IBP-sparse</td><td>98.4%</td><td>96.0%</td></tr><tr><td>4</td><td>IBP-sparse</td><td>97.8%</td><td>90.8%</td></tr><tr><td>10</td><td>IBP-sparse</td><td>95.2%</td><td>86.8%</td></tr><tr><td>1</td><td>Random Ablation</td><td>96.7%</td><td>90.3%</td></tr><tr><td>4</td><td>Random Ablation</td><td>96.7%</td><td>79.1%</td></tr><tr><td>10</td><td>Random Ablation</td><td>96.7%</td><td>29.2%</td></tr><tr><td rowspan="6">CIFAR</td><td>1</td><td>IBP-sparse</td><td>48.4%</td><td>40.0%</td></tr><tr><td>4</td><td>IBP-sparse</td><td>42.2%</td><td>31.2%</td></tr><tr><td>10</td><td>IBP-sparse</td><td>37.0%</td><td>25.6%</td></tr><tr><td>1</td><td>Random Ablation</td><td>78.3%</td><td>68.6%</td></tr><tr><td>4</td><td>Random Ablation</td><td>78.3%</td><td>61.3%</td></tr><tr><td>10</td><td>Random Ablation</td><td>78.3%</td><td>45.0%</td></tr></table>
+
+# 5.4 TRANSFERABILITY TO PATCHES OF DIFFERENT SHAPES
+
+Since real-world adversarial patches may not always be square, the robust transferability of the model to shapes other than the square is important.
+
+Therefore, we evaluate the robustness of the square-patch-trained model to adversarial patches of different shapes while fixing the number of pixels. In all these experiments, we evaluate the certified accuracy for our largest model, on both MNIST and CIFAR datasets. We evaluate the transferability to various shapes including rectangle, line, parallelogram, and diamond. With the exception of rectangles, all the shapes have the exact same pixel count as the patches used for training. For rectangles, we use multiple choices of width and length, obtaining some combinations with slightly more pixels, and the worst accuracy is reported in Table 5. The exact shapes used can be found in Appendix A.2.
+
+The certified accuracy of our models generalize surprisingly well to other shapes, losing no more than than $5 \%$ in most cases for MNIST and no more than $6 \%$ for CIFAR-10 (Table 5). The largest degradation of accuracy happens for rectangles and lines, and it is mostly because the rectangle considered has more pixels compared to the square, and the line has less overlaps. However, it is still interesting that the certificate even generalizes to a straight line, even though the model was never trained to be robust to lines. In the case of MNIST with small patch size, the certified accuracy even improves when transferred to lines.
+
+Table 5: Certified accuracy for square-patch trained model for different shapes   
+
+<table><tr><td>Dataset</td><td>Pixel Count</td><td>Square</td><td>Rectangle</td><td>Line</td><td>Diamond</td><td>Parallelogram</td></tr><tr><td>MNIST</td><td>4</td><td>91.6%</td><td>=</td><td>92.5%</td><td>91.6%</td><td>92.3%</td></tr><tr><td rowspan="5">CIFAR</td><td>16</td><td>69.4%</td><td>55.4%</td><td>46.7%</td><td>68.13%</td><td>70.2%</td></tr><tr><td>25</td><td>59.7%</td><td>50.9%</td><td>32.4%</td><td>53.6%</td><td>55.2%</td></tr><tr><td>4</td><td>50.8%</td><td>=</td><td>46.1%</td><td>48.6%</td><td>49.8%</td></tr><tr><td>16</td><td>36.9%</td><td>29.0%</td><td>32.1%</td><td>35.7%</td><td>36.3%</td></tr><tr><td>25</td><td>30.3%</td><td>25.1%</td><td>29.0%</td><td>30.1%</td><td>30.7%</td></tr></table>
+
+# 6 CONCLUSION AND FUTURE WORK
+
+After establishing the weakness of known defenses to patch attacks, we proposed the first certified defense against this model. We demonstrated the effectiveness of our defense on two datasets, and proposed strategies to speed up robust training. Finally, we established the robust transferability of trained certified models to different shapes. In its current form, the proposed certified defense is unlikely to scale to ImageNet, and we hope the presented experiments will encourage further work along this direction.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Tom B Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. arXiv preprint arXiv:1712.09665, 2017.
+
+Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017.
+
+Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018.
+
+Jamie Hayes. On visible adversarial perturbations & digital watermarking. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1597–1604, 2018.
+
+Danny Karmon, Daniel Zoran, and Yoav Goldberg. Lavan: Localized and visible adversarial noise. arXiv preprint arXiv:1801.02608, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Cassidy Laidlaw and Soheil Feizi. Functional adversarial attacks, 2019.
+
+Mark Lee and Zico Kolter. On physical adversarial patches for object detection, 2019.
+
+Alexander Levine and Soheil Feizi. Robustness certificates for sparse adversarial attacks by randomized ablation. arXiv preprint arXiv:1911.09272, 2019.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018.
+
+Apostolos Modas, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Sparsefool: a few pixels make a big difference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9087–9096, 2019.
+
+Muzammal Naseer, Salman Khan, and Fatih Porikli. Local gradients smoothing: Defense against localized adversarial attacks. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 1300–1307. IEEE, 2019.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015.
+
+Ali Shafahi, W Ronny Huang, Christoph Studer, Soheil Feizi, and Tom Goldstein. Are adversarial examples inevitable? arXiv preprint arXiv:1809.02104, 2018.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019.
+
+Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K Reiter. Adversarial generative nets: Neural network attacks on state-of-the-art face recognition. arXiv preprint arXiv:1801.00349, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \` arXiv preprint arXiv:1904.13000, 2019.
+
+Shiqi Wang, Yizheng Chen, Ahmed Abdou, and Suman Jana. Enhancing gradient-based attacks with symbolic intervals, 2019.
+
+Eric Wong and J Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017.
+
+Eric Wong, Frank R Schmidt, and J Zico Kolter. Wasserstein adversarial examples via projected sinkhorn iterations. arXiv preprint arXiv:1902.07906, 2019.
+
+Zuxuan Wu, Ser-Nam Lim, Larry Davis, and Tom Goldstein. Making an invisibility cloak: Real world adversarial attacks on object detectors. arXiv preprint arXiv:1910.14667, 2019.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks, 2019a.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. arXiv preprint arXiv:1906.06316, 2019b.
+
+# A APPENDIX
+
+# A.1 EXPERIMENTAL SETTINGS AND NETWORK STRUCTURE
+
+We evaluate the proposed certified patch defense on three neural networks: a multilayer perceptron (MLP) with one 255-neuron hidden layer, and two convolutional neural networks (CNN) with different depths. The small CNN has two convolutional layers (kernel size 4, stride 2) of 4 and 8 output channels each, and a fully connected layer with 256 neurons. The large CNN has four convolutional layers with kernel size (3, 4, 3, 4), stride (1, 2, 1, 2), output channels (4, 4, 8 ,8), and two fully connected layer with 256 neurons. We run experiments on two datasets, MNIST and CIFAR10, with two different patch sizes $2 \times 2$ and $5 \times 5$ . For all experiments, we are using Adam (Kingma & Ba, 2014) with a learning rate of $5 e - 4$ for MNIST and $1 e - 3$ for CIFAR10, and with no weight decay. We also adopt a warm-up schedule in all experiments like (Zhang et al., 2019b), where the input interval bounds start at zero and grow to [-1,1] after 61/121 epochs for MNIST/CIFAR10 respectively. We train the models for a total of 100/200 epochs for MNIST/CIFAR10, where in the first 61/121 epochs the learning rate is fixed and in the following epochs, we reduce the learning rate by one half every 10 epochs.
+
+In addition, following (Gowal et al., 2018), we further evaluate the CIFAR10 on a larger model which has 5 convolutional layers with kernel size 3 and a fully connected layer with 512 neurons. This deeper and wider model achieves the clean accuracy around $8 9 \%$ , and has 17M parameters in total. Table 8 in Appendix A.5 describes the full certified patch results for this large model.
+
+# A.2 SAMPLE SHAPES FOR GENERALIZATION EXPERIMENTS
+
+We demonstrate generalization to other patch shapes that were not considered in training, obtaining surprisingly good transfer in robust accuracy; see the figure below and the results in Table 5.
+
+![](images/9f216bf62fce941917ea81757e0b262fd04bf16bd11424b98f95987ef90455cd.jpg)  
+Figure 1: Examples of shapes with pixels number 4 and 25. From left to right are square, parallelogram, diamond and rectangle (line) respectively.
+
+# A.3 BOUND POOLING
+
+Besides random-patch certificate training and guided-patch certificate training, we also experimented with the idea of bound pooling. All-patch training is very expensive as bounds generated by each potential patch has to be forward passed through the complete network. Bound pooling partially relieves the problem be pooling the interval bounds in intermediate layers thus reducing the forward pass in subsequent layers.
+
+Specifically, given a set of patches $\mathbb { P }$ , the interval bounds in the ith layer are $\bar { Z } ^ { ( i ) } ( \mathbb { P } ) = \{ \bar { z } ^ { ( i ) } ( p ) : p \in$ $\mathbb { P } \}$ and $\underline { { Z } } ^ { ( i ) } \mathbb { P } = \{ \underline { { z } } ^ { ( i ) } ( p ) : p \in \mathbb { P } \}$ . We can reduce the number of interval bounds by partitioning $\mathbb { P }$ into $n$ subsets $\{ \mathbb { S } ^ { 1 } , . . . , \mathbb { S } ^ { n } \}$ and calculate a new set of bounds $\begin{array} { r } { \bar { Z } _ { p o o l } ^ { ( i ) } ( \mathbb { P } ) = \{ \operatorname* { m a x } _ { p \in \mathbb { S } _ { i } } \bar { z } ^ { ( i ) } ( p ) : i \in [ n ] \} } \end{array}$ and Z(i) ( $\begin{array} { r } { \underline { { Z } } _ { p o o l } ^ { ( i ) } ( \mathbb { P } ) = \{ \operatorname* { m i n } _ { p \in \mathbb { S } _ { i } } \underline { { z } } ^ { ( i ) } ( p ) : i \in [ n ] \} } \end{array}$ . Depending on how $\mathbb { P }$ is partitioned, the bound pooling would work differently. In our experiments, we always select adjacent patches for each $\mathbb { S } _ { i }$ with the assumption that adjacent patches tend to generate similar bounds thus resulting in tighter certificate.
+
+Bound pooling, similar to random- and guided- patch training, trades performance for efficiency compared to all-patch certificate training. However, the trade off is not as favorable compared to random-patch and guided-patch training. For example, in Table 6, Pooling 16 $( 4 \times 4 )$ patches in the first layer reduces training time by $3 5 \%$ while loosing $0 . 7 \%$ in performance (on MNIST $2 \times 2$ ), but a similar level of performance can be achieved with guided-patch training with almost $90 \%$ reduction in training time. The trade off becomes greater when the model becomes larger. Overall, bound pooling is still quite expensive, and cannot scale to larger models like random-patch or guided-patch training.
+
+Table 6: Comparing bound pooling with the guided-patch and random-patch training. Pool 4 means that the adjacent $4 \times 4$ patches (16 patches) are pooled together in the first layer. Pool 2-2 means that the adjacent $2 \times 2$ bounds are pooled together in the first layer and then another $2 \times 2$ bound pooling happens at the second layer. This is similar to $4 \times 4$ pooling except the pooling operation is distributed between the first and second layer. All experiments are performed on a 4-layer convolutional network.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>5×5</td></tr><tr><td rowspan=2 colspan=1>Dataset  TrainingStrategy</td><td rowspan=1 colspan=1>Clean    Certified  Training</td><td rowspan=1 colspan=1>Clean    Certified  Training</td></tr><tr><td rowspan=1 colspan=1>Accuracy  Accuracy  Time(h)</td><td rowspan=1 colspan=1>Accuracy  Accuracy  Time(h)</td></tr><tr><td rowspan=1 colspan=1>MNIST   All Patch</td><td rowspan=1 colspan=1>98.5%     91.6%      20.1</td><td rowspan=1 colspan=1>90.0%    59.7%      16.3</td></tr><tr><td rowspan=6 colspan=1>Pool 2Pool 4Random(1)Random(5)Random(10)Guided(10)</td><td rowspan=1 colspan=1>98.0%     91.1%      15.8</td><td rowspan=1 colspan=1>85.2%     54.2%      11.6</td></tr><tr><td rowspan=1 colspan=1>97.2%     89.9%      13.2</td><td rowspan=1 colspan=1>70.4%     38.3%      10.2</td></tr><tr><td rowspan=1 colspan=1>98.5%     81.9%      0.3</td><td rowspan=1 colspan=1>96.8%     24.8%      0.4</td></tr><tr><td rowspan=1 colspan=1>98.6%     86.5%      0.3</td><td rowspan=1 colspan=1>94.9%     42.0%      0.5</td></tr><tr><td rowspan=1 colspan=1>98.6%     87.5%      0.5</td><td rowspan=1 colspan=1>94.7%     50.4%       0.6</td></tr><tr><td rowspan=1 colspan=1>98.7%     88.9%      2.2</td><td rowspan=1 colspan=1>94.0%    53.2%      3.4</td></tr><tr><td rowspan=1 colspan=1>CIFAR    All Patch</td><td rowspan=1 colspan=1>49.6%     41.6%      22.5</td><td rowspan=1 colspan=1>34.0%     25.0%      18.6</td></tr><tr><td rowspan=2 colspan=1>Pool 2Pool4</td><td rowspan=1 colspan=1>48.1%     39.4%      17.3</td><td rowspan=1 colspan=1>32.4%    24.2%      14.5</td></tr><tr><td rowspan=2 colspan=1>Pool4Pool 2-2</td><td rowspan=1 colspan=1>44.9%     37.1%      16.3</td><td rowspan=1 colspan=1>28.3%     20.6%      13.6</td></tr><tr><td rowspan=1 colspan=1>45.0%     37.4%      16.5</td><td rowspan=1 colspan=1>25.3%     19.1%      13.8</td></tr><tr><td rowspan=1 colspan=1>Random(1)</td><td rowspan=1 colspan=1>53.2%     32.4%      0.6</td><td rowspan=1 colspan=1>42.7%     11.0%      0.6</td></tr><tr><td rowspan=2 colspan=1>Random(5)Random(10)</td><td rowspan=1 colspan=1>52.2%     39.5%      0.9</td><td rowspan=1 colspan=1>37.8%     19.6%      0.9</td></tr><tr><td rowspan=1 colspan=1>50.8%     38.6%       1.0</td><td rowspan=1 colspan=1>38.4%     21.9%       1.0</td></tr><tr><td rowspan=1 colspan=1>Guided(10)</td><td rowspan=1 colspan=1>53.0%     39.8%       4.0</td><td rowspan=1 colspan=1>36.1%     23.0%      3.9</td></tr></table>
+
+# A.4 MULTI-PATCH SPARSE TRAINING
+
+Here we list the detailed certified accuracy for various sparsity levels and model architectures.
+
+Table 7: Certified accuracy for sparse defenses with varying sparsity $k$ and models on both MNIST and CIFAR10, where “Conv $c \times c ^ { \prime \prime }$ represents for the convolutional network with first layer kernel size c.   
+
+<table><tr><td>Dataset</td><td>Sparsity (k)</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td></tr><tr><td rowspan="4">MNIST</td><td>1</td><td>mlp</td><td>98.4%</td><td>96.0%</td></tr><tr><td>4</td><td>mlp</td><td>97.8%</td><td>90.8%</td></tr><tr><td>10</td><td>mlp</td><td>95.2%</td><td>86.8%</td></tr><tr><td>1</td><td>Conv3x3</td><td>97.0%</td><td>88.3%</td></tr><tr><td rowspan="8">CIFAR</td><td>4</td><td>Conv3x3</td><td>92.7%</td><td>75.9%</td></tr><tr><td>1</td><td>mlp</td><td>48.4%</td><td>40.0%</td></tr><tr><td>4</td><td>mlp</td><td>42.2%</td><td>31.2%</td></tr><tr><td>10</td><td>mlp</td><td>37.0%</td><td>25.6%</td></tr><tr><td>1</td><td>Conv11x11</td><td>34.8%</td><td>27.4%</td></tr><tr><td>4</td><td>Conv11x11</td><td>25.1%</td><td>18.3%</td></tr><tr><td>10</td><td>Conv11x11</td><td>17.2%</td><td>13.8%</td></tr><tr><td>1</td><td>Conv13x13</td><td>38.6%</td><td>29.7%</td></tr><tr><td></td><td>4</td><td>Conv13x13</td><td>28.1%</td><td>19.6%</td></tr><tr><td></td><td>10</td><td>Conv13x13</td><td>22.4%</td><td>15.3%</td></tr></table>
+
+# A.5 TRAINING WITH LARGER MODELS
+
+Recall that all-patch training considers all possible patches during training, which can be too expensive for larger models and/or images. The proposed random- and guided-patch training methods aim to reduce the training cost by considering only a subset of patches; please see Section 4.2 for more details.
+
+Table 8: The random and guided training strategy could yield significantly stronger model compared to all-patch training given a fixed computational budget. The random and guided training strategy allows us to train a larger model that would be infeasible to train otherwise. The guided-patch large model is able to boost the certified accuracy by over $10 \%$ compared to the best performing all-patch small model.   
+
+<table><tr><td>Dataset</td><td>Patch Size</td><td>Training Strategy</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td></tr><tr><td rowspan="5">CIFAR</td><td rowspan="5">2×2</td><td>All Patch</td><td>mlp</td><td>50.8%</td><td>35.5%</td><td>9.1</td></tr><tr><td></td><td>2 layer conv</td><td>52.4%</td><td>42.6%</td><td>10.7</td></tr><tr><td></td><td> 4 layer conv</td><td>49.6%</td><td>41.6%</td><td>22.5</td></tr><tr><td></td><td>5 layer conv (wide)</td><td>1</td><td>-</td><td>~360.0</td></tr><tr><td>Random(10) Random(20)</td><td>5 layer conv (wide) 5 layer conv (wide)</td><td>64.7% 64.4%</td><td>49.0%</td><td>9.5</td></tr><tr><td rowspan="6">CIFAR 5×5</td><td>Guided(10)</td><td>5 layer conv (wide)</td><td>66.5%</td><td>50.8% 49.2%</td><td></td><td>15.8 12.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Guided(20) All Patch</td><td>5 layer conv (wide)</td><td>65.8%</td><td>51.9%</td><td></td><td>22.4</td></tr><tr><td></td><td>mlp</td><td></td><td>31.1%</td><td>18.8%</td><td>7.1</td></tr><tr><td></td><td>2 layer conv</td><td>35.5%</td><td></td><td>22.3%</td><td>8.7</td></tr><tr><td></td><td></td><td>4 layer conv.</td><td>34.0%</td><td>25.0%</td><td></td><td>18.6</td></tr><tr><td></td><td></td><td></td><td>5 layer conv (wide)</td><td>1</td><td>、</td><td>~360.0</td></tr><tr><td></td><td></td><td>Random(10) Random(20)</td><td>5 layer conv (wide)</td><td>48.6%</td><td>29.9%</td><td>9.4</td></tr><tr><td></td><td></td><td></td><td>5 layer conv (wide)</td><td>47.8%</td><td>30.3%</td><td>15.4</td></tr><tr><td></td><td>Guided(10)</td><td>5 layer conv (wide)</td><td></td><td>48.4%</td><td>29.0%</td><td>12.4</td></tr><tr><td></td><td></td><td>Guided(20)</td><td>5 layer conv (wide)</td><td>47.6%</td><td>29.6%</td><td>23.8</td></tr></table>
+
+# A.6 DETAILED STATISTICS ON TRAINING STRATEGIES
+
+Here we list the detailed statistics for each training strategies for Table 3
+
+Table 9: Detailed statistics for the comparison of training strategies - $2 \times 2$   
+
+<table><tr><td>Dataset</td><td>Training Strategies</td><td>Model Architecture</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time</td></tr><tr><td>MNIST</td><td>All Patch</td><td>2 layer convolution</td><td>98.63/%</td><td>91.38%</td><td>21.0</td></tr><tr><td rowspan="10"></td><td rowspan="4">Random (1)</td><td>4 layer convolution</td><td>98.48%</td><td>91.63%</td><td>80.3</td></tr><tr><td>fully connected (255,10)</td><td>98.46%</td><td>91.47%</td><td>9.8</td></tr><tr><td>2 layer convolution</td><td>98.69%</td><td>82.57%</td><td>0.2</td></tr><tr><td>4 layer convolution</td><td>98.45%</td><td>81.87%</td><td>0.3</td></tr><tr><td rowspan="3">Random (5)</td><td>fully connected (255,10)</td><td>98.48%</td><td>84.32%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.75%</td><td>85.87%</td><td>0.3</td></tr><tr><td>4 layer convolution</td><td>98.57%</td><td>86.50%</td><td>0.3</td></tr><tr><td rowspan="3">Random (10)</td><td>fully connected (255,10)</td><td>98.62%</td><td>87.32%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.73%</td><td>87.31%</td><td>0.3</td></tr><tr><td>4 layer convolution</td><td>98.63%</td><td>87.54%</td><td>0.5</td></tr><tr><td rowspan="3">Guided (10)</td><td>fully connected (255,10)</td><td>98.49%</td><td>88.13%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.60%</td><td>88.49%</td><td>2.3</td></tr><tr><td>4 layer convolution</td><td>98.70%</td><td>88.85%</td><td>2.2</td></tr><tr><td rowspan="3">CIFAR All Patch</td><td>fully connected (255,10)</td><td>98.63%</td><td>89.44%</td><td>2.2</td></tr><tr><td>2 layer convolution</td><td>52.42%</td><td>42.57%</td><td>42.6</td></tr><tr><td>4 layer convolution</td><td>49.58%</td><td>41.57%</td><td>89.8</td></tr><tr><td rowspan="3">Random (1)</td><td>fully connected (255,10)</td><td>50.83%</td><td>35.49%</td><td>36.6</td></tr><tr><td>2 layer convolution</td><td>54.93%</td><td>29.13%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>53.22%</td><td>32.35%</td><td>0.6</td></tr><tr><td rowspan="3">Random (5)</td><td>fully connected (255,10)</td><td>52.76%</td><td>03.21%</td><td>0.5</td></tr><tr><td>2 layer convolution</td><td>54.15%</td><td>37.30%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>52.19%</td><td>39.45%</td><td>0.9</td></tr><tr><td rowspan="3">Random (10)</td><td>fully connected (255,10)</td><td>52.38%</td><td>20.17%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>53.08%</td><td>39.32%</td><td>0.7</td></tr><tr><td>4 layer convolution</td><td>50.80%</td><td>38.57%</td><td>1.0</td></tr><tr><td rowspan="4">Guided (10)</td><td>fully connected (255,10)</td><td>51.90%</td><td>28.97%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>53.04%</td><td>38.81%</td><td>3.7</td></tr><tr><td>4 layer convolution</td><td>52.97%</td><td>39.84%</td><td>4.0</td></tr><tr><td>fully connected (255,10)</td><td>51.32%</td><td>29.44%</td><td>3.6</td></tr></table>
+
+Table 10: Detailed statistics for the comparison of training strategies - $5 \times 5$   
+
+<table><tr><td>Dataset</td><td>Training Strategies</td><td>Model Architecture</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time</td></tr><tr><td>MNIST</td><td>All Patch</td><td>2 layer convolution</td><td>91.88%</td><td>59.59%</td><td>28.4</td></tr><tr><td rowspan="10"></td><td></td><td>4 layer convolution</td><td>90.03%</td><td>59.72%</td><td>65.2</td></tr><tr><td>Random (1)</td><td>fully connected (255,10)</td><td>93.96%</td><td>61.97%</td><td>7.2</td></tr><tr><td></td><td>2 layer convolution</td><td>96.27%</td><td>18.57%</td><td>0.2</td></tr><tr><td></td><td>4 layer convolution</td><td>96.83%</td><td>24.79%</td><td>0.4</td></tr><tr><td>Random (5)</td><td>fully connected (255,10)</td><td>97.60%</td><td>29.04%</td><td>0.2</td></tr><tr><td></td><td>2 layer convolution</td><td>95.82%</td><td>38.47%</td><td>0.2</td></tr><tr><td></td><td>4 layer convolution</td><td>94.85%</td><td>42.02%</td><td>0.5</td></tr><tr><td>Random (10)</td><td>fully connected (255,10)</td><td>96.73%</td><td>45.89%</td><td>0.2</td></tr><tr><td></td><td>2 layer convolution</td><td>95.55%</td><td>46.13%</td><td>0.3</td></tr><tr><td></td><td>4 layer convolution fully connected (255,10)</td><td>94.76% 96.40%</td><td>50.43% 52.30%</td><td>0.6</td></tr><tr><td>Guided (10)</td><td>2 layer convolution</td><td>95.28%</td><td>50.28%</td><td>0.2 2.3</td></tr><tr><td rowspan="3"></td><td></td><td>93.98%</td><td>53.17%</td><td>3.4</td></tr><tr><td>4 layer convolution</td><td>95.82%</td><td>55.89%</td><td>2.2</td></tr><tr><td>fully connected (255,10)</td><td>35.48%</td><td></td><td></td></tr><tr><td rowspan="3">CIFAR All Patch Random (1)</td><td>2 layer convolution</td><td>33.95%</td><td>22.31% 24.96%</td><td>34.8</td></tr><tr><td>4 layer convolution fully connected (255,10)</td><td>31.05%</td><td>18.78%</td><td>74.4 28.4</td></tr><tr><td></td><td>45.71%</td><td>07.14%</td><td>0.6</td></tr><tr><td rowspan="3"></td><td>2 layer convolution</td><td>42.65%</td><td>10.99%</td><td></td></tr><tr><td>4 layer convolution</td><td>42.34%</td><td></td><td>0.6</td></tr><tr><td>fully connected (255,10)</td><td></td><td>00.10%</td><td>0.5</td></tr><tr><td rowspan="3">Random (5)</td><td>2 layer convolution</td><td>42.85%</td><td>17.29%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>37.80%</td><td>19.63%</td><td>0.9</td></tr><tr><td>fully connected (255,10)</td><td>36.23%</td><td>06.99%</td><td>0.6</td></tr><tr><td rowspan="4">Random (10)</td><td>2 layer convolution</td><td>41.90%</td><td>21.40%</td><td>0.7</td></tr><tr><td>4 layer convolution</td><td>38.41%</td><td>21.90%</td><td>1.0</td></tr><tr><td>fully connected (255,10) Guided (10)</td><td>36.04%</td><td>12.46%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>42.08%</td><td>20.77%</td><td>3.6</td></tr><tr><td></td><td>4 layer convolution fully connected (255,10)</td><td>36.08% 35.51%</td><td>23.01% 12.56%</td><td>3.9 3.5</td></tr></table>

parse/train/HyeaSkrYPH/HyeaSkrYPH_content_list.json

@@ -0,0 +1,1829 @@
+[
+    {
+        "type": "text",
+        "text": "CERTIFIED DEFENSES FOR ADVERSARIAL PATCHES∗ ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            802,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ping-yeh Chiang†, Renkun Ni†, Ahmed Abdelkader, Chen Zhu University of Maryland, College Park {pchiang,rn9zm,akader,chenzhu}@cs.umd.edu ",
+        "bbox": [
+            184,
+            143,
+            607,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Christoph Studer Cornell University studer@cornell.edu ",
+        "bbox": [
+            635,
+            146,
+            813,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein   \nUniversity of Maryland, College Park   \ntomg@cs.umd.edu ",
+        "bbox": [
+            184,
+            209,
+            431,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial patch attacks are among one of the most practical threat models against real-world computer vision systems. This paper studies certified and empirical defenses against patch attacks. We begin with a set of experiments showing that most existing defenses, which work by pre-processing input images to mitigate adversarial patches, are easily broken by simple white-box adversaries. Motivated by this finding, we propose the first certified defense against patch attacks, and propose faster methods for its training. Furthermore, we experiment with different patch shapes for testing, obtaining surprisingly good robustness transfer across shapes, and present preliminary results on certified defense against sparse attacks. Our complete implementation can be found on: https://github.com/Ping-C/certifiedpatchdefense. ",
+        "bbox": [
+            233,
+            318,
+            766,
+            470
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            336,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the great success of neural networks for vision problems, they are easily fooled by adversarial attacks in which the input to a machine learning model is modified with the goal of manipulating its output. Research in this area is largely focused on norm-bounded attack (Madry et al., 2017; Tramer\\` & Boneh, 2019; Shafahi et al., 2019), where the adversary is allowed to perturb all pixels in an image provided that the $\\ell _ { p }$ -norm of the perturbation is within prescribed bounds. Other adversarial models were also proposed, such as functional (Laidlaw & Feizi, 2019), rotation/translation (Engstrom et al., 2017), and Wasserstein (Wong et al., 2019), all of which allow modification to all pixels. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Whole-image perturbations are unrealistic for modeling ”physical-world” attacks, in which a realworld object is modified to evade detection. A physical adversary usually modifies an object using stickers or paint. Because this object may only occupy a small portion of an image, the adversary can only manipulate a limited number of pixels. As such, the more practical patch attack model was proposed (Brown et al., 2017). In a patch attack, the adversary may only change the pixels in a confined region, but is otherwise free to choose the values yielding the strongest attack. The threat to real-world computer vision systems is well-demonstrated in recent literature where carefully crafted patches can fool a classifier with high reliability (Brown et al., 2017; Karmon et al., 2018), make objects invisible to an object detector (Wu et al., 2019; Lee & Kolter, 2019), or fool a face recognition system (Sharif et al., 2017). In light of such effective physical-world patch attacks, very few defenses are known to date. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study principled defenses against patch attacks. We begin by looking at existing defenses in the literature that claim to be effective against patch attacks, including Local Gradient Smoothing (LGS) (Naseer et al., 2019) and Digital Watermarking (DW) (Hayes, 2018). Similar to what has been observed for whole-image attacks by (Athalye et al., 2018), we show that these patch defenses are easily broken by stronger adversaries. Concretely, we demonstrate successful white-box attacks, where the adversary designs an attack against a known model, including any pre-processing steps. To cope with such potentially stronger adversaries, we train a robust model that produces a lower-bound on adversarial accuracy. In particular, we propose the first certifiable defense against patch attacks by extending interval bound propagation (IBP) defenses (Gowal et al., 2018; Mirman et al., 2018). We also propose modifications to IBP training to make it faster in the patch setting. Furthermore, we study the generalization of certified patch defenses to patches of different shapes, and observe that robustness transfers well across different patch types. We also present preliminary results on certified defense against the stronger sparse attack model, where a fixed number of possibly non-adjacent pixels can be arbitrarily modified (Modas et al., 2019). ",
+        "bbox": [
+            174,
+            791,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            348,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a white-box adversary that is allowed to choose the location of the patch (chosen from a set $\\mathbb { L }$ of possible locations) and can modify pixels within the particular patch (chosen from the set $\\mathbb { P }$ ) similar to (Karmon et al., 2018). An attack is successful if the adversary changes the classification of the network to a wrong label. In this paper, we are primarily interested in the patch attack robust accuracy (adversarial accuracy for short) as defined by ",
+        "bbox": [
+            174,
+            266,
+            825,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0c0b8fdaf4c03e2875d72b7ae98100dc0f9e0040781d003defee5ac2d30b80f.jpg",
+        "text": "$$\n\\underset { x \\sim X } { \\mathbb { E } } \\operatorname* { m i n } _ { p \\in \\mathbb { P } , l \\in \\mathbb { L } } \\mathcal { X } [ f ( A ( x , p , l ) ; \\theta ) = y ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            343,
+            619,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the operator $A$ places the adversarial patch p on a given image $\\mathbf { X }$ at location $l$ , f is a neural network with parameter $\\theta$ , $X$ is a distribution of images, and $\\mathcal { X }$ is a characteristic function that takes value 1 if its argument is true, and 0 otherwise. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this model, the strength of the adversary can vary depending on the set of possible patches allowed, and the type of perturbation allowed within the patch. In what follows, we assume the standard setup in which the adversary is allowed any perturbation that maintains pixel intensities in the range $[ 0 , 1 ]$ . Unless otherwise noted, we also assume the patch is restricted to a square of prescribed size. We consider two different options for the set $\\mathbb { L }$ of possible patch locations. First, we consider a weak adversary that can only place patches at the corner of an image. We find that even this weak model is enough to break existing patch defenses. Then, we consider a stronger adversary with no restrictions on patch location, and use this model to evaluate our proposed defenses. Note that an adversary, when restricted to modify only a square patch at location $l$ in the image, has the freedom to modify any non-square subset of these pixels. In other words, a certified defense against square patch attacks also provably subverts any non-square patch attack that fits inside a small enough square. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In general, calculating the adversarial accuracy (1) is intractable due to non-convexity. Common approaches try to approximate it by solving the inner minimization using a gradient-based method. However, in Section 3, we show that depending on how the minimization is solved, the upper bound could be very loose: a model may appear to be very robust, but fail when faced with a stronger attack. To side-step the arms race between attacks and defenses, in Section 4, we extend the work of (Gowal et al., 2018) and (Mirman et al., 2018) to train a network that produces a lower bound on adversarial accuracy. We will refer to approximations of the upper bound as empirical adversarial accuracy and the lower bound as certified accuracy. ",
+        "bbox": [
+            174,
+            583,
+            826,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 VULNERABILITY OF EXISTING DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            715,
+            553,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by examining existing defense strategies that claim to be effective against patch attacks. Similar to what has been observed for whole-image attacks by Athalye et al. (2018), we show that these patch defenses can easily be broken by white-box attacks, where the adversary optimizes against a given model including any pre-processing steps. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXISTING DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            361,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Under our threat model, two defenses have been proposed that each use input transformations to detect and remove adversarial patches. ",
+        "bbox": [
+            176,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first defense is based on the observation that the gradient of the loss with respect to the input image often exhibits large values near the perturbed pixels. In (Hayes, 2018), the proposed digital watermarking (DW) approach exploits this behavior to detect unusually dense regions of large gradient entries using saliency maps, before masking them out in the image. Despite a $1 2 \\%$ drop in accuracy on clean (non-adversarial) images, this defense method supposedly achieves an empirical adversarial accuracy of $6 3 \\%$ for non-targeted patch attacks of size $4 2 \\times 4 2$ ( $\\dot { 2 } \\%$ of the image pixels), using 400 randomly picked images from ImageNet (Deng et al., 2009) on VGG19 (Simonyan & Zisserman, 2014). ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/643c1861bcf8cdebdd5fec558151ec5ffcdf3a16ae36fca9652c576e12ae2e0d.jpg",
+        "table_caption": [
+            "Table 1: Empirical adversarial accuracy of ImageNet classifiers defended with Local Gradient Smoothing and Digital Watermarking. We consider two types of adversaries, one that takes the defense into account during backpropagation and one that does not "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"3\">Patch Size</td></tr><tr><td>Attack</td><td>Defense</td><td>42 × 42</td><td>52 × 52</td><td>60 ×60</td></tr><tr><td>IFGSM</td><td>LGS</td><td>78%</td><td>75%</td><td>71%</td></tr><tr><td>IFGSM+LGS</td><td>LGS</td><td>14%</td><td>5%</td><td>3%</td></tr><tr><td>IFGSM</td><td>DW</td><td>56%</td><td>49%</td><td>45%</td></tr><tr><td>IFGSM+DW</td><td>DW</td><td>13%</td><td>8%</td><td>5%</td></tr></table>",
+        "bbox": [
+            285,
+            156,
+            712,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            270,
+            826,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second defense, Local Gradient Smoothing (LGS) by Naseer et al. (2019) is based on the empirical observation that pixel values tend to change sharply within these adversarial patches. In other words, the image gradients tend to be large within these adversarial patches. Note that the image gradient here differs from the gradient in Hayes (2018), the former is with respect the changes of adjacent pixel values and the later is with respect to the classification loss. Naseer et al. (2019) propose suppressing this adversarial noise by multiplying each pixel with one minus its image gradient as in (2). To make their methods more effective, Naseer et al. (2019) also pre-process the image gradient with a normalization and a thresholding step. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dacb9233c630d057e61b3d43c8d6e60411d85925020064ef1856ce95cb2d16f8.jpg",
+        "text": "$$\n{ \\hat { x } } = x \\odot ( 1 - \\lambda g ( x ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            467,
+            573,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The $\\lambda$ here is a smoothing hyper-parameter. Naseer et al. (2019) claim the best adversarial accuracy on ImageNet with respect to patch attacks among all of the defenses we studied. They also claim that their defense is resilient to Backward Pass Differential Approximation (BPDA) from Athalye et al. (2018), one of the most effective methods to attack models that include a non-differentiable operator as a pre-processing step. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 BREAKING EXISTING DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            578,
+            441,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using a similar setup as in (Hayes, 2018; Naseer et al., 2019), we are able to mostly replicate the reported empirical adversarial accuracy for Iterative Fast Gradient Sign Method (IFGSM), a common gradient based attack, but we show that when the pre-processing step is taken into account, the empirical adversarial accuracy on ImageNet quickly drops from $\\bar { \\sim } 7 0 \\% ( \\sim 5 0 \\% )$ for LGS(DW) to levels around $\\sim 1 0 \\%$ as shown in Table 1. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we break DW (Hayes, 2018) by applying BPDA, in which the non-differentiable operator is approximated with an identity mapping during the backward pass. We break LGS (Naseer et al., 2019) by directly incorporating the smoothing step during backpropagation. Even though the windowing and thresholding steps are non-differentiable, the smoothing operator provides enough gradient information for the attack to be effective. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To make sure that our evaluation is fair, we used the exact same models as Hayes (2018) (VGG19) and Szegedy et al. (2016) (Inception V3). We also consider a weaker set of attackers that can only attack the corners, the same as their setting. Further, we ensure that we were able to replicate their reported result under similar setting. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 CERTIFIED DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            388,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given the ease with which these supposedly strong defenses are broken, it is natural to seek methods that can rigorously guarantee robustness of a given model to patch attacks. With such certifiable guarantees in hand, we need not worry about an adversary with a stronger optimizer, or a more clever algorithm for choosing patch locations. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 BACKGROUND ON CERTIFIED DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            491,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Certified defenses have been intensely studied with respect to norm-bounded attacks (Cohen et al., 2019; Wong & Kolter, 2017; Gowal et al., 2018; Mirman et al., 2018; Zhang et al., 2019b). In all of these methods, in addition to the prediction model, there is also a verifier. Given a model and an input, the verifier outputs a certificate if it is guaranteed that the image can not be adversarially perturbed. This is done by checking whether there exists any nearby image (within a prescribed $\\ell _ { p }$ distance) with a different label than the image being classified. While theoretical bounds exist on the size of this distance that hold for any classifier (Shafahi et al., 2018), exactly computing bounds for a specific classifier and test image is hard. Alternatively, the verifier may output a lower bound on the distance to the nearest image of a different label. This latter distance is referred to as the certifiable radius. Most of these verifiers provide a rather loose bound on the certifiable radius. However, if the verifier is differentiable, then the network can be trained with a loss that promotes tightness of this bound. We use the term certificate training to refer to the process of training with a loss that promotes strong certificates. Interval bound propagation (IBP) (Mirman et al., 2018; Gowal et al., 2018) is a very simple verifier that uses layer-wise interval arithmetic to produce a certificate. Even though the IBP certificate is generally loose, after certificate training, it yields state-of-the-art certifiably-robust models for $l _ { \\infty }$ -norm bounded attacks (Gowal et al., 2018; Zhang et al., 2019b). In this paper, we extend IBP to train certifiably-robust networks resilient to patch attacks. We first introduce some notation and basic algorithms for IBP training. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notation We represent a neural network with a series of transformations $h ^ { ( k ) }$ for each of its $k$ layers. We use $z ^ { ( k ) } \\in \\bar { \\mathbb { R } } ^ { n _ { k } }$ to denote the output of layer $k$ , where $n _ { k }$ is the number of units in the $k ^ { t h }$ layer and $z ^ { ( 0 ) }$ stands for the input. Specifically, the network computes ",
+        "bbox": [
+            174,
+            387,
+            826,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38a6af5bab14c81bc65b7bef9be01f14a5bb4b97642c51ad7f33b7744213b048.jpg",
+        "text": "$$\nz ^ { ( k ) } = h ^ { ( k - 1 ) } ( z ^ { ( k - 1 ) } ) \\forall k = 1 , \\dots , K .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            439,
+            640,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Certification Problem To produce a certificate for an input $x _ { 0 }$ , we want to verify that the following condition is true with respect to all possible labels $y$ : ",
+        "bbox": [
+            173,
+            472,
+            826,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f9d5c8120ecf851be6c3fa5abf5008341345ccf925375410a3fec3f6230774b.jpg",
+        "text": "$$\n( e _ { y _ { t r u e } } - e _ { y } ) ^ { T } z ^ { ( K ) } = { \\bf m } _ { y } \\geq 0 \\qquad \\forall z ^ { ( 0 ) } \\in \\mathbb { B } ( x _ { 0 } ) \\qquad \\forall y .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            507,
+            689,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $e _ { i }$ is the $i ^ { t h }$ basis vector, and $\\mathbf { m } _ { y }$ is called the margin following Wong & Kolter (2017). Note that $\\mathbf { m } _ { y _ { t r u e } }$ is always equal to 0. The vector $\\mathbf { m }$ contains all margins corresponding to all labels. $\\mathbb { B } ( x _ { 0 } )$ is the constraint set over which the adversarial input image may range. In a conventional setting, this is an $\\ell _ { \\infty }$ ball around $x _ { 0 }$ . In the case of patch attack, the constraint set contains all images formed by applying a patch to $x _ { 0 }$ ; ",
+        "bbox": [
+            173,
+            535,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ea4cbd9d09807a5ce309163b0be61414fa8ffa9ac763bf3b36027fab0c675a2.jpg",
+        "text": "$$\n\\mathbb { B } ( x _ { 0 } ) = \\{ A ( x _ { 0 } , p , l ) | p \\in \\mathbb { P } { \\mathrm { ~ a n d ~ } } l \\in \\mathbb { L } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            613,
+            632,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Basics of Interval Bound Propagation (IBP) We now describe how to produce certificates using interval bound propagation as in (Gowal et al., 2018). Suppose that for each component in $z ^ { ( k - \\bar { 1 } ) }$ we have an interval containing all the values which this component reaches as $z ^ { ( 0 ) }$ ranges over the ball $\\mathbb { B } ( x _ { 0 } )$ . If $z ^ { ( k ) } = h ^ { ( k ) } ( z ^ { \\top } )$ is a linear (or convolutional) layer of the form ${ z } ^ { ( k ) ^ { - } } =$ $W ^ { ( k ) } z ^ { ( k - 1 ) } + b ^ { ( k ) }$ , then we can get an outer approximation of the reachable interval range of activations by the next layer $z ^ { ( k ) }$ using the formulas below ",
+        "bbox": [
+            173,
+            643,
+            825,
+            734
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a03423793112af4d36e70a00c1d8a1e7b0b9581ec976adf34c671d6d1020242.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\overline { { z } } ^ { ( k ) } = W ^ { ( k ) } \\frac { \\overline { { z } } ^ { ( k - 1 ) } + \\underline { { z } } ^ { ( k - 1 ) } } { 2 } + | W ^ { ( k ) } | \\frac { \\overline { { z } } ^ { ( k - 1 ) } - \\underline { { z } } ^ { ( k - 1 ) } } { 2 } + b ^ { ( k ) } , } \\\\ & { \\underline { { z } } ^ { ( k ) } = W ^ { ( k ) } \\frac { \\overline { { z } } ^ { ( k - 1 ) } + \\underline { { z } } ^ { ( k - 1 ) } } { 2 } - | W ^ { ( k ) } | \\frac { \\overline { { z } } ^ { ( k - 1 ) } - \\underline { { z } } ^ { ( k - 1 ) } } { 2 } + b ^ { ( k ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            739,
+            710,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\overline { { z } } ^ { ( k - 1 ) }$ denotes the upper bound of each interval, $\\underline { z } ^ { ( k - 1 ) }$ the lower bound, and $| W ^ { ( k ) } |$ the element-wise absolute value. Alternatively, if $h ^ { ( k ) } ( z ^ { ( k - 1 ) } )$ is an element-wise monotonic activation (e.g., a ReLU), then we can calculate the outer approximation of the reachable interval range of the next layer using the formulas below. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc84f47f77535e3848b5ecc1e3a75d1e9012e03c6831c3c6e1882607141dc290.jpg",
+        "text": "$$\n\\begin{array} { r } { \\overline { z } ^ { ( k ) } = h ^ { ( k ) } ( \\overline { z } ^ { ( k - 1 ) } ) } \\\\ { \\underline { z } ^ { ( k ) } = h ^ { ( k ) } ( \\underline { z } ^ { ( k - 1 ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            880,
+            568,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When the feasible set $\\mathbb { B } ( x _ { 0 } )$ represents a simple $\\ell _ { \\infty }$ attack, the range of possible $z ^ { ( 0 ) }$ values is trivially characterized by an interval bound $\\overline { { z } } ^ { ( 0 ) }$ and $\\underline { z } ^ { ( 0 ) }$ . Then, by iteratively applying the above rules, we can propagate intervals through the network and eventually get $\\overline { { z } } ^ { ( K ) }$ and $\\smash { \\mathcal { Z } ^ { ( K ) } }$ . A certificate can then be given if we can show that (3) is always true for outputs in the range $\\overline { { z } } ^ { ( K ) }$ and $\\smash { \\boldsymbol { \\mathcal { Z } } ^ { ( K ) } }$ with respect to all possible labels. More specifically, we can check that the following holds for all $y$ ",
+        "bbox": [
+            173,
+            102,
+            825,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25fc8a53f7effcf2cd2df99ffb77095bfce036a317c1d5ceee2a63e54835de6c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\underline { { \\mathbf { m } } } _ { y } = e _ { y _ { t r u e } } ^ { T } \\underline { { z } } ^ { ( K ) } - e _ { y } ^ { T } \\overline { { z } } ^ { ( K ) } = \\underline { { z } } _ { y _ { t r u e } } ^ { ( K ) } - \\overline { { z } } _ { y } ^ { ( K ) } \\geq 0 \\quad \\forall y . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            185,
+            681,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training for Interval Bound Propagation To train a network to produce accurate interval bounds, we simply replace standard logits with the $- \\mathbf { m }$ vector in (3). Note that all elements of $\\mathbf { m }$ need to be larger than zero to satisfy the conditions in (3), and mytrue is always equal to zero. Put simply, we would like mytrue to be the least of all margins. We can promote this condition by training with the loss function ",
+        "bbox": [
+            173,
+            219,
+            825,
+            289
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72be3c53136bd187f40252a50653129ebf5fd67da8e8f872b8121036efc17f7a.jpg",
+        "text": "$$\n\\mathrm { C e r t i f i c a t e \\ L o s s } = \\mathrm { C r o s s \\ E n t r o p y \\ L o s s } ( - \\mathbf { m } , y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            296,
+            658,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unlike regular neural network training, stochastic gradient descent for minimizing equation 10 is unstable, and a range of tricks are necessary to stabilize IBP training (Gowal et al., 2018). The first trick is merging the last linear weight matrix with $( e _ { y } - e _ { y _ { t r u e } } )$ before calculating $- { \\underline { { \\mathbf { m } } } } _ { y }$ . This allows a tighter characterization of the interval bound that noticeably improves results. The second trick uses an “epsilon schedule” in which training begins with a perturbation radius of zero, and this radius is slowly increased over time until a sentinel value is reached. Finally, a mixed loss function containing both a standard natural loss and an IBP loss is used. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In all of our experiments, we use the merging technique and the epsilon schedule, but we do not use a mixed loss function containing a natural loss as it does not increase our certificate performance. ",
+        "bbox": [
+            173,
+            431,
+            823,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 CERTIFYING AGAINST PATCH ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            482,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can now describe the extension of IBP to patches. If we specify the patch location, one can represent the feasible set of images with a simple interval bound: for pixels within the patch, the upper and lower bound is equal to 1 and 0. For pixels outside of the patch, the upper and lower bounds are both equal to the original pixel value. By passing this bound through the network, we would be able to get msingle location and verify that they satisfy the conditions in (3). ",
+        "bbox": [
+            174,
+            503,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, we have to consider not just a single location, but all possible locations $\\mathbb { L }$ to give a certificate. To adapt the bound to all possible location, we pass each of the possible patches through the network, and take the worst case margin. More specifically, ",
+        "bbox": [
+            174,
+            580,
+            825,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4e469b062571eede31119d89cf7867b9051bdc6b2d1f47c03973309a1cc4ae1.jpg",
+        "text": "$$\n\\mathbf { m } ^ { \\mathrm { e s } } ( \\mathbb { L } ) _ { y } = \\operatorname* { m i n } _ { l \\in \\mathbb { L } } \\mathbf { m } ^ { \\mathrm { s i n g l e ~ p a t c h } } ( l ) _ { y } \\forall y .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            630,
+            619,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to regular IBP training, we simply use $\\underline { { \\mathbf { m } } } ^ { \\mathrm { e s } } ( \\mathbb { L } )$ to calculate the cross entropy loss for training and backpropagation, ",
+        "bbox": [
+            173,
+            661,
+            826,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/badccbe6659e45077e905312268debefca934cb3ec05550287f687b5304211fa.jpg",
+        "text": "$$\n\\operatorname { C e r t i f i c a t e \\operatorname { L o s s } } = \\operatorname { C r o s s \\operatorname { E n t r o p y \\operatorname { L o s s } } } ( - \\underline { { \\mathbf { m } } } ^ { \\mathrm { e s } } ( \\mathbb { L } ) , y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            698,
+            676,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, the cost of producing this na¨ıve certificate increases quadratically with image size. Consider that a CIFAR-10 image is of size $3 2 \\times 3 2$ , requiring over a thousand interval bounds, one for each possible patch location. To alleviate this problem, we propose two certificate training methods: Random Patch and Guided Patch, so that the number of forward passes does not scale with the dimension of the inputs. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Random Patch Certificate Training In this method, we simply select a random set of patches out of the possible patches and pass them forward. A level of robustness is achieved even though a very small number of random patches are selected compared to the total number of possible patches ",
+        "bbox": [
+            174,
+            806,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44945ff3b0611e84f9e7c490e701923833d7e3bd6d9b926f7bcd4dee8156df28.jpg",
+        "text": "$$\n\\underline { { \\mathbf { m } } } ^ { \\mathrm { r a n d o m \\ p a t c h e s } } ( \\mathbb { L } ) _ { y } = \\underline { { \\mathbf { m } } } ^ { \\mathrm { e s } } ( S ) _ { y }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            856,
+            599,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $S$ is a random subset of $\\mathbb { L }$ . Similarly, the random patch certificate loss is calculated as below. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            896
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40631a922fd1252beda45689f839d46b44e018b350319daebbe860eeb763a5e7.jpg",
+        "text": "$$\n\\mathrm { R a n d o m ~ P a t c h ~ C e r t i f i c a t e ~ L o s s } = \\mathrm { C r o s s ~ E n t r o p y ~ L o s s } ( - \\underline { { \\mathbf { m } } } ^ { \\mathrm { r a n d o m ~ p a t c h e s } } ( \\mathbb { L } ) , y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            904,
+            753,
+            921
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Guided Patch Certificate Training In this method, we propose using a U-net (Ronneberger et al., 2015) to predict msingle patch, and then randomly select a couple of locations based on the predicted $\\mathbf { m } ^ { \\mathrm { s i n g l e } \\mathrm { p a t c h } }$ so that fewer patches need to be passed forward. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that very few patches contribute to the worst case bound $\\underline { { \\mathbf { m } } } ^ { \\mathrm { e s } }$ in (11). In fact, the number of patches that yield the worst case margins will be no more than the number of labels. If we know the worst-case patches beforehand, then we can simply select the few worst-case patches during training. ",
+        "bbox": [
+            174,
+            152,
+            823,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We propose to use U-net as the number of locations and margins is very large. For a square patch of size $n \\times n$ and an image of size $m \\times m$ , the total number of possible locations is $( m - n + \\mathbf { \\hat { 1 } } ) ^ { 2 }$ , and for each location the number of margins is equal to the number of possible labels. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e2b722e690020b0cd598c157f790ae7ddb81b815c1fc7d409fbc09cdc855329.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\bf { m } } ^ { \\mathrm { { p r e d } } } = { \\bf { U } } { \\mathrm { - n e t } } ( \\mathrm { i m a g e } ) } \\\\ { { \\bf { d i m } } ( { \\bf { m } } ^ { \\mathrm { { p r e d } } } ) = ( m - n + 1 , m - n + 1 , \\# \\mathrm { o f } \\mathrm { l a b e l s } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            248,
+            671,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the U-net prediction of $\\underline { { \\mathbf { m } } } ^ { \\mathrm { p r e d } }$ , we then randomly select a single patch for each label based on the softmax of the predicted $\\underline { { \\mathbf { m } } } ^ { \\mathrm { p r e d } }$ . The number of selected patches is equal to the number of labels. After these patches are passed forward, the U-net is then updated with a mean-squared-error loss between the predicted margins $\\underline { { \\mathbf { m } } } ^ { \\mathrm { p r e d } }$ and the actual margins $\\underline { { \\mathbf { m } } } ^ { \\mathrm { a c t u a l } }$ . Note that only a few patches are selected at a time, so that the mean-squared-error only passes through the selected patches. ",
+        "bbox": [
+            173,
+            300,
+            826,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2bc1ac4b92bf8f45f0b03b98a291aaf65de753c0cb1dc9cce77eef4b0b12473.jpg",
+        "text": "$$\n\\mathrm { U } \\mathrm { - n e t } \\mathrm { L o s s } = \\mathbf { M } \\mathrm { S E } ( \\mathbf { \\underline { { m } } } ^ { \\mathrm { p r e d } } , \\mathbf { \\underline { { m } } } ^ { \\mathrm { a c t u a l } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            376,
+            616,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The network is trained with the following loss: ",
+        "bbox": [
+            173,
+            398,
+            480,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Guided Patch Certificate $\\operatorname { L o s s } = \\operatorname { C r o s s } \\operatorname { E n t r o p y } \\operatorname { L o s s } ( - \\underline { { \\mathbf { m } } } ^ { \\mathrm { g u i d e d } \\mathrm { p a t c h e s } } ( \\mathbb { L } ) , y ) .$ ",
+        "bbox": [
+            248,
+            419,
+            750,
+            436
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Certification Process In all our experiments, we check that equation (3) is satisfied by iterating over all possible patches and forward-passing the interval bounds generated for each patch; this overhead is tolerable at evaluation time. ",
+        "bbox": [
+            173,
+            440,
+            826,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 CERTIFYING AGAINST SPARSE ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            490,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IBP can also be adapted to defend against sparse attack where the attacker is allowed to modify a fixed number $( k )$ of pixels that may not be adjacent to each other (Modas et al., 2019). The only modification is that we have to change the bound calculated from the first layer to ",
+        "bbox": [
+            174,
+            525,
+            826,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17a421e1da69fa4d200afc0f132582985c1be61c501fb76dbccbf41606d6b64e.jpg",
+        "text": "$$\n\\overline { { { z } } } _ { i } ^ { ( 1 ) } = W _ { i , : } ^ { ( 1 ) } z ^ { ( 0 ) } + | W _ { i , : } ^ { ( 1 ) } | _ { t o p _ { k } } ~ z _ { i } ^ { ( 1 ) } = W _ { i , : } ^ { ( 1 ) } z ^ { ( 0 ) } - | W _ { i , : } ^ { ( 1 ) } | _ { t o p _ { k } } ~ \\forall i\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            571,
+            735,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and apply equation (5) and (6) for the subsequent layers. Here, $( . ) _ { t o p _ { k } }$ is the sum of the largest $k$ elements in the vector. ",
+        "bbox": [
+            174,
+            599,
+            826,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            326,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare our certified defenses with exiting algorithms on two datasets and three model architectures of varying complexity. We consider a strong attack setting in which adversarial patches can appear anywhere in the image. Different training strategies for the certified defense are also compared, which shows a trade-off between performance and training efficiency. Furthermore, we evaluate the transferability of a model trained using square patches to other adversarial shapes, including shapes that do not fit in any certified square. The training and architectural details can be found in Appendix A.1. We also present preliminary results on certified defense against sparse attacks. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMPARISON AGAINST EXISTING DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            522,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study the effectiveness of our proposed IBP certified models against an adversary that is allowed to place patches anywhere in the image, even on top of the salient object. If the patch is sufficiently small, and does not cover a large portion of the salient object, then the model should still classify correctly, and defense against the perturbation should be possible. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the best case, our IBP certified model is able to achieve $9 1 . 6 \\%$ certified (Table 2) with respect to a $2 \\times 2$ patch $( \\sim . 5 \\%$ of image pixels) adversary on MNIST. For more challenging cases, such as a 5 $\\times 5$ ( $\\sim 2 . 5 \\%$ of image pixels) patch adversary on CIFAR-10, the certified adversarial accuracy is only $2 4 . 9 \\%$ (Table 2). Even though these existing defenses appear to achieve better or comparable adversarial accuracy as our IBP certified model when faced with a weak adversary, when faced with a stronger adversary their adversarial accuracy dropped to levels below our certified accuracy for all cases that we analyzed. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When evaluating existing defenses, we only report cases where non-trivial adversarial accuracy is achieved against a weaker adversary. We do not explore cases where LGS and DW perform so poorly that no meaningful comparison can be done. LGS and DW are highly dependent on hyperparameters to work effectively against naive attacks, and yet neither Naseer et al. (2019) nor Hayes (2018) proposed a way to learn these hyperparameters. By trial and error, we were able to increase the adversarial accuracy against a weaker adversary for some settings, but not all. In addition, we also notice a peculiar feature of DW: when we increase the adversarial accuracy, the clean accuracy degrades, sometimes so much that it is even lower than the empirical adversarial accuracy. This happens because DW always removes a patch from the prediction. When an adversarial patch is detected, it is likely to be removed, enabling correct prediction. On the other hand, when there are no adversarial patches, DW removes actual salient information, resulting in lower clean accuracy. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we did not compare our results with adversarial training, because even though it produces some of the most adversarially robust models, it does not offer any guarantees on the empirical robust accuracy, and could still be decreased further with stronger attacks. For example, Wang et al. (2019) proposed a stronger attack that could find $47 \\%$ more adversarial examples compared to gradient based method. Further, adversarial training on all possible patches would be even more expensive compared to certificate training, and is slightly beyond our computational budget. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared to state-of-the-art certified models for CIFAR with $L _ { \\infty }$ -perturbation, where Zhang et al. (2019a) proposed a deterministic algorithm that achieves clean accuracy of $3 4 . 0 \\%$ , our clean accuracy for our most robust CIFAR $5 \\times 5$ model is $4 7 . 8 \\%$ when using a large model (Table 2). ",
+        "bbox": [
+            174,
+            431,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c05cfeed2d4e9f23cc5ab7a5b77dd639884d8719c99778848ff0b07130af40b8.jpg",
+        "table_caption": [
+            "Table 2: Comparison of our IBP certified patch defense against existing defenses. Empirical adversarial accuracy is calculated for 400 random images in both datasets. All results are averaged over three different models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Patch Size</td><td>Adversary</td><td>Defense</td><td>Clean Accuracy</td><td>Accuracy</td><td>Empirical Certified Adversarial Accuracy</td></tr><tr><td rowspan=\"5\">MNIST</td><td>2×2</td><td>IFGSM</td><td>None</td><td>98.4%</td><td>80.1%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>LGS</td><td>97.4%</td><td>90.0%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+LGS</td><td>LGS</td><td>97.4%</td><td>60.7%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>IBP</td><td>98.5%</td><td>93.9%</td><td>91.6%</td></tr><tr><td>5×5</td><td>IFGSM</td><td>None</td><td>98.5%</td><td>3.3%</td><td></td></tr><tr><td rowspan=\"10\">CIFAR</td><td>5×5</td><td>IFGSM</td><td>IBP</td><td>92.9%</td><td>66.1%</td><td>62.0%</td></tr><tr><td>2×2</td><td>IFGSM</td><td>None</td><td>66.3%</td><td>25.4%</td><td>1</td></tr><tr><td>2×2</td><td>IFGSM</td><td>LGS</td><td>64.9%</td><td>31.3%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+LGS</td><td>LGS</td><td>64.9%</td><td>24.2%</td><td></td></tr><tr><td>2×2</td><td>IFGSM</td><td>DW</td><td>47.1%</td><td>43.3%</td><td></td></tr><tr><td>2×2</td><td>IFGSM+DW</td><td>DW</td><td>47.1%</td><td>20.2%</td><td>=</td></tr><tr><td>2×2</td><td>IFGSM</td><td>IBP</td><td>48.6%</td><td>45.2%</td><td>41.6%</td></tr><tr><td>5×5</td><td>IFGSM</td><td>None</td><td>66.5%</td><td>0.4%</td><td></td></tr><tr><td>5×5</td><td>IFGSM</td><td>LGS</td><td>51.2% 51.2%</td><td>22.11%</td><td></td></tr><tr><td>5×5</td><td>IFGSM +LGS</td><td>LGS DW</td><td>45.3%</td><td>0.5% 59.3%</td><td></td></tr><tr><td>5×5</td><td></td><td>IFGSM</td><td></td><td></td><td></td></tr><tr><td>5×5</td><td>IFGSM+DW</td><td>DW</td><td>45.3%</td><td>15.6%</td><td></td></tr><tr><td>5×5</td><td>IFGSM</td><td>IBP</td><td>33.9%</td><td>29.1%</td><td>24.9%</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            197,
+            537,
+            800,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 COMPARISON OF TRAINING STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            493,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that given a fixed architecture all-patch certificate training achieves the best certified accuracy. However, given a fixed computational budget, random and guided training significantly outperform all-patch training. Finally, guided-patch certificate training consistently outperforms random-patch certificate training by a slim margin, indicating that the U-net is learning how to predict the minimum margin m. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we see that given a fixed architecture all-patch certificate training significantly outperforms both random-patch certificate training and guided-patch certificate training in terms of certified accuracy, outperforming the second best certified defenses in each task by $2 . 6 \\%$ (MNIST, $2 \\times 2$ ), $7 . 3 \\%$ (MNIST, $5 \\times 5$ ), $3 . 9 \\%$ (CIFAR-10, $2 \\times 2 )$ ), and $3 . 4 \\%$ (CIFAR-10, $5 \\times 5$ ). However, all-patch certificate training is very expensive, taking on average 4 to 15 times longer than guided-patch certificate training and over 30 to 70 times longer than random-patch certificate training. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, given a limited computational budget, random-patch and guided-patch training significantly outperforms all-patch training. Due to the efficiency of random-patch and guided-patch training, they scale much better to large architectures. By switching to a large architecture (5 layer wide convolutional network), we are able to boost the certified accuracy by over $10 \\%$ compared to the best performing all-patch small model (Table 2). Note that we are unable to all-patch train the same architecture as it will take almost 15 days to complete, and is out of our computational budget. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            313
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Guided-patch certificate training is slightly more expensive compared to random patch, due to overhead from the U-net architecture. However, given the 10 patches picked, guided-patch certificate training consistently outperforms random-patch certificate training, indicating that the U-net is learning how to predict the minimum margin m. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0eb115ffa03813f8cc48e12d421e5fbc40bdd687872b5c2e1df4dfd6b768f92f.jpg",
+        "table_caption": [
+            "Table 3: Trade-off between certified accuracy and training time for different strategies. The numbers next to training strategies indicate the number of patches used for estimating the lower bound during training. Most training times are measured on a single 2080Ti GPU, with the exception of all-patch training which is run on four 2080Ti GPUs. For that specific case, the training time is multiplied by 4 for fair comparison. See Appendix A.6 for more detailed statistics. \\*indicates the performance of the best performing large model trained with either random or guided patch. Detailed performance of the large models can be found in Appendix A.5 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"3\">2×2</td><td colspan=\"3\">5×5</td></tr><tr><td>Dataset</td><td>Training Strategy</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td></tr><tr><td rowspan=\"4\">MNIST</td><td>AllPatch</td><td>98.5%</td><td>91.5%</td><td>9.3</td><td>92.0%</td><td>60.4%</td><td>8.4</td></tr><tr><td>Random(1)</td><td>98.5%</td><td>82.9%</td><td>0.2</td><td>96.9%</td><td>24.1%</td><td>0.4</td></tr><tr><td>Random(5)</td><td>98.6%</td><td>86.6%</td><td>0.3</td><td>95.8%</td><td>42.1%</td><td>0.3</td></tr><tr><td>Random(10)</td><td>98.6%</td><td>87.7%</td><td>0.3</td><td>95.6%</td><td>49.6%</td><td>0.3</td></tr><tr><td rowspan=\"6\">CIFAR</td><td>Guided(10) All Patch</td><td>98.6% 50.9%</td><td>88.9% 39.9%</td><td>2.2 56.4</td><td>95.0% 33.5%</td><td>53.1% 22.0%</td><td>2.6 45.8</td></tr><tr><td>Random(1)</td><td>53.6%</td><td>21.6%</td><td>0.6</td><td>43.6%</td><td>6.1%</td><td>0.6</td></tr><tr><td>Random(5)</td><td>52.9%</td><td>32.3%</td><td>0.7</td><td>39.0%</td><td>14.6%</td><td>0.7</td></tr><tr><td>Random(10)</td><td>51.9%</td><td>35.6%</td><td>0.8</td><td>38.8%</td><td>18.6%</td><td></td></tr><tr><td>Guided(10)</td><td>52.4%</td><td>36.0%</td><td>3.7</td><td>37.9%</td><td>18.8%</td><td>0.8 3.7</td></tr><tr><td>Large Model*</td><td>65.8%</td><td>51.9%</td><td>22.4</td><td>47.8%</td><td>30.3%</td><td>15.4</td></tr></table>",
+        "bbox": [
+            173,
+            501,
+            838,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 EFFECTIVENESS AGAINST SPARSE ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            511,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The IBP based method can also be used to defend against sparse attack, see Section 4.3. Its performance is reasonable compared to patch defense (e.g. $9 1 . 5 \\%$ certified accuracy for $2 \\times 2$ patch vs $9 0 . 8 \\%$ for $\\mathrm { k } { = } 4$ ), even though the sparse attack model is much stronger. For convolutional networks, we increase the size of the first convolutional layer (i.e. from $3 \\times 3$ to $1 1 \\times 1 1$ ) so the interval bounds calculated are tighter. However, despite the change, fully-connected network still performs much better. For example, the certified accuracy drops from $2 5 . 6 \\%$ to $1 3 . 8 \\%$ when we switch from fully-connected to convolutional network for CIFAR10 and drops from $9 0 . 8 \\%$ to $7 5 . 9 \\%$ for MNIST respectively. Detailed results are shown in the Appendix A.4 Table 7. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 compares our approach with the state-of-the-art certified sparse defense (Random Ablation) Levine & Feizi (2019). We use their best model with the largest medium radii to certify against various levels of sparsity. As shown in the table, our method achieves higher certified accuracy on the MNIST dataset over all the sparse radii, but lower on CIFAR-10. It is worth noting that we are using a much smaller and simpler model (a fully-connected network) compared to Random Ablation, which uses ResNet-50. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/db03a2cb6fdb10975ea7bf080ddad1ceeaf16035224cb90629be05a5c6fed02e.jpg",
+        "table_caption": [
+            "Table 4: Certified accuracy for sparse defenses with IBP and Random Ablation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Sparsity (k)</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td></tr><tr><td rowspan=\"6\">MNIST</td><td>1</td><td>IBP-sparse</td><td>98.4%</td><td>96.0%</td></tr><tr><td>4</td><td>IBP-sparse</td><td>97.8%</td><td>90.8%</td></tr><tr><td>10</td><td>IBP-sparse</td><td>95.2%</td><td>86.8%</td></tr><tr><td>1</td><td>Random Ablation</td><td>96.7%</td><td>90.3%</td></tr><tr><td>4</td><td>Random Ablation</td><td>96.7%</td><td>79.1%</td></tr><tr><td>10</td><td>Random Ablation</td><td>96.7%</td><td>29.2%</td></tr><tr><td rowspan=\"6\">CIFAR</td><td>1</td><td>IBP-sparse</td><td>48.4%</td><td>40.0%</td></tr><tr><td>4</td><td>IBP-sparse</td><td>42.2%</td><td>31.2%</td></tr><tr><td>10</td><td>IBP-sparse</td><td>37.0%</td><td>25.6%</td></tr><tr><td>1</td><td>Random Ablation</td><td>78.3%</td><td>68.6%</td></tr><tr><td>4</td><td>Random Ablation</td><td>78.3%</td><td>61.3%</td></tr><tr><td>10</td><td>Random Ablation</td><td>78.3%</td><td>45.0%</td></tr></table>",
+        "bbox": [
+            214,
+            167,
+            785,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 TRANSFERABILITY TO PATCHES OF DIFFERENT SHAPES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            377,
+            596,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since real-world adversarial patches may not always be square, the robust transferability of the model to shapes other than the square is important. ",
+        "bbox": [
+            176,
+            401,
+            823,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we evaluate the robustness of the square-patch-trained model to adversarial patches of different shapes while fixing the number of pixels. In all these experiments, we evaluate the certified accuracy for our largest model, on both MNIST and CIFAR datasets. We evaluate the transferability to various shapes including rectangle, line, parallelogram, and diamond. With the exception of rectangles, all the shapes have the exact same pixel count as the patches used for training. For rectangles, we use multiple choices of width and length, obtaining some combinations with slightly more pixels, and the worst accuracy is reported in Table 5. The exact shapes used can be found in Appendix A.2. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The certified accuracy of our models generalize surprisingly well to other shapes, losing no more than than $5 \\%$ in most cases for MNIST and no more than $6 \\%$ for CIFAR-10 (Table 5). The largest degradation of accuracy happens for rectangles and lines, and it is mostly because the rectangle considered has more pixels compared to the square, and the line has less overlaps. However, it is still interesting that the certificate even generalizes to a straight line, even though the model was never trained to be robust to lines. In the case of MNIST with small patch size, the certified accuracy even improves when transferred to lines. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/5a45d2fb484cb951e71d7c77fd43e0fc10e7fd8eb4c7d8f6baba9438a01d4c7d.jpg",
+        "table_caption": [
+            "Table 5: Certified accuracy for square-patch trained model for different shapes "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Pixel Count</td><td>Square</td><td>Rectangle</td><td>Line</td><td>Diamond</td><td>Parallelogram</td></tr><tr><td>MNIST</td><td>4</td><td>91.6%</td><td>=</td><td>92.5%</td><td>91.6%</td><td>92.3%</td></tr><tr><td rowspan=\"5\">CIFAR</td><td>16</td><td>69.4%</td><td>55.4%</td><td>46.7%</td><td>68.13%</td><td>70.2%</td></tr><tr><td>25</td><td>59.7%</td><td>50.9%</td><td>32.4%</td><td>53.6%</td><td>55.2%</td></tr><tr><td>4</td><td>50.8%</td><td>=</td><td>46.1%</td><td>48.6%</td><td>49.8%</td></tr><tr><td>16</td><td>36.9%</td><td>29.0%</td><td>32.1%</td><td>35.7%</td><td>36.3%</td></tr><tr><td>25</td><td>30.3%</td><td>25.1%</td><td>29.0%</td><td>30.1%</td><td>30.7%</td></tr></table>",
+        "bbox": [
+            210,
+            688,
+            782,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            809,
+            495,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "After establishing the weakness of known defenses to patch attacks, we proposed the first certified defense against this model. We demonstrated the effectiveness of our defense on two datasets, and proposed strategies to speed up robust training. Finally, we established the robust transferability of trained certified models to different shapes. In its current form, the proposed certified defense is unlikely to scale to ImageNet, and we hope the presented experiments will encourage further work along this direction. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            174,
+            126,
+            826,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. arXiv preprint arXiv:1712.09665, 2017. ",
+        "bbox": [
+            171,
+            162,
+            825,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019. ",
+        "bbox": [
+            169,
+            200,
+            825,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jamie Hayes. On visible adversarial perturbations & digital watermarking. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1597–1604, 2018. ",
+        "bbox": [
+            171,
+            395,
+            823,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danny Karmon, Daniel Zoran, and Yoav Goldberg. Lavan: Localized and visible adversarial noise. arXiv preprint arXiv:1801.02608, 2018. ",
+        "bbox": [
+            173,
+            434,
+            823,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cassidy Laidlaw and Soheil Feizi. Functional adversarial attacks, 2019. ",
+        "bbox": [
+            174,
+            510,
+            647,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Lee and Zico Kolter. On physical adversarial patches for object detection, 2019. ",
+        "bbox": [
+            174,
+            535,
+            738,
+            550
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Levine and Soheil Feizi. Robustness certificates for sparse adversarial attacks by randomized ablation. arXiv preprint arXiv:1911.09272, 2019. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            174,
+            595,
+            826,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Apostolos Modas, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Sparsefool: a few pixels make a big difference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9087–9096, 2019. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muzammal Naseer, Salman Khan, and Fatih Porikli. Local gradients smoothing: Defense against localized adversarial attacks. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 1300–1307. IEEE, 2019. ",
+        "bbox": [
+            173,
+            738,
+            823,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, W Ronny Huang, Christoph Studer, Soheil Feizi, and Tom Goldstein. Are adversarial examples inevitable? arXiv preprint arXiv:1809.02104, 2018. ",
+        "bbox": [
+            169,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K Reiter. Adversarial generative nets: Neural network attacks on state-of-the-art face recognition. arXiv preprint arXiv:1801.00349, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \\` arXiv preprint arXiv:1904.13000, 2019. ",
+        "bbox": [
+            169,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shiqi Wang, Yizheng Chen, Ahmed Abdou, and Suman Jana. Enhancing gradient-based attacks with symbolic intervals, 2019. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and J Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Frank R Schmidt, and J Zico Kolter. Wasserstein adversarial examples via projected sinkhorn iterations. arXiv preprint arXiv:1902.07906, 2019. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zuxuan Wu, Ser-Nam Lim, Larry Davis, and Tom Goldstein. Making an invisibility cloak: Real world adversarial attacks on object detectors. arXiv preprint arXiv:1910.14667, 2019. ",
+        "bbox": [
+            174,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks, 2019a. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. arXiv preprint arXiv:1906.06316, 2019b. ",
+        "bbox": [
+            174,
+            470,
+            826,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 EXPERIMENTAL SETTINGS AND NETWORK STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            602,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed certified patch defense on three neural networks: a multilayer perceptron (MLP) with one 255-neuron hidden layer, and two convolutional neural networks (CNN) with different depths. The small CNN has two convolutional layers (kernel size 4, stride 2) of 4 and 8 output channels each, and a fully connected layer with 256 neurons. The large CNN has four convolutional layers with kernel size (3, 4, 3, 4), stride (1, 2, 1, 2), output channels (4, 4, 8 ,8), and two fully connected layer with 256 neurons. We run experiments on two datasets, MNIST and CIFAR10, with two different patch sizes $2 \\times 2$ and $5 \\times 5$ . For all experiments, we are using Adam (Kingma & Ba, 2014) with a learning rate of $5 e - 4$ for MNIST and $1 e - 3$ for CIFAR10, and with no weight decay. We also adopt a warm-up schedule in all experiments like (Zhang et al., 2019b), where the input interval bounds start at zero and grow to [-1,1] after 61/121 epochs for MNIST/CIFAR10 respectively. We train the models for a total of 100/200 epochs for MNIST/CIFAR10, where in the first 61/121 epochs the learning rate is fixed and in the following epochs, we reduce the learning rate by one half every 10 epochs. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In addition, following (Gowal et al., 2018), we further evaluate the CIFAR10 on a larger model which has 5 convolutional layers with kernel size 3 and a fully connected layer with 512 neurons. This deeper and wider model achieves the clean accuracy around $8 9 \\%$ , and has 17M parameters in total. Table 8 in Appendix A.5 describes the full certified patch results for this large model. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            402
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 SAMPLE SHAPES FOR GENERALIZATION EXPERIMENTS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            596,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate generalization to other patch shapes that were not considered in training, obtaining surprisingly good transfer in robust accuracy; see the figure below and the results in Table 5. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f216bf62fce941917ea81757e0b262fd04bf16bd11424b98f95987ef90455cd.jpg",
+        "image_caption": [
+            "Figure 1: Examples of shapes with pixels number 4 and 25. From left to right are square, parallelogram, diamond and rectangle (line) respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            497,
+            689,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 BOUND POOLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            338,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Besides random-patch certificate training and guided-patch certificate training, we also experimented with the idea of bound pooling. All-patch training is very expensive as bounds generated by each potential patch has to be forward passed through the complete network. Bound pooling partially relieves the problem be pooling the interval bounds in intermediate layers thus reducing the forward pass in subsequent layers. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            199
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Specifically, given a set of patches $\\mathbb { P }$ , the interval bounds in the ith layer are $\\bar { Z } ^ { ( i ) } ( \\mathbb { P } ) = \\{ \\bar { z } ^ { ( i ) } ( p ) : p \\in$ $\\mathbb { P } \\}$ and $\\underline { { Z } } ^ { ( i ) } \\mathbb { P } = \\{ \\underline { { z } } ^ { ( i ) } ( p ) : p \\in \\mathbb { P } \\}$ . We can reduce the number of interval bounds by partitioning $\\mathbb { P }$ into $n$ subsets $\\{ \\mathbb { S } ^ { 1 } , . . . , \\mathbb { S } ^ { n } \\}$ and calculate a new set of bounds $\\begin{array} { r } { \\bar { Z } _ { p o o l } ^ { ( i ) } ( \\mathbb { P } ) = \\{ \\operatorname* { m a x } _ { p \\in \\mathbb { S } _ { i } } \\bar { z } ^ { ( i ) } ( p ) : i \\in [ n ] \\} } \\end{array}$ and Z(i) ( $\\begin{array} { r } { \\underline { { Z } } _ { p o o l } ^ { ( i ) } ( \\mathbb { P } ) = \\{ \\operatorname* { m i n } _ { p \\in \\mathbb { S } _ { i } } \\underline { { z } } ^ { ( i ) } ( p ) : i \\in [ n ] \\} } \\end{array}$ . Depending on how $\\mathbb { P }$ is partitioned, the bound pooling would work differently. In our experiments, we always select adjacent patches for each $\\mathbb { S } _ { i }$ with the assumption that adjacent patches tend to generate similar bounds thus resulting in tighter certificate. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            306
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Bound pooling, similar to random- and guided- patch training, trades performance for efficiency compared to all-patch certificate training. However, the trade off is not as favorable compared to random-patch and guided-patch training. For example, in Table 6, Pooling 16 $( 4 \\times 4 )$ patches in the first layer reduces training time by $3 5 \\%$ while loosing $0 . 7 \\%$ in performance (on MNIST $2 \\times 2$ ), but a similar level of performance can be achieved with guided-patch training with almost $90 \\%$ reduction in training time. The trade off becomes greater when the model becomes larger. Overall, bound pooling is still quite expensive, and cannot scale to larger models like random-patch or guided-patch training. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/6cedc241deed68c58913df8996a321dcb92824b0a654c9ed4cb84781332740b1.jpg",
+        "table_caption": [
+            "Table 6: Comparing bound pooling with the guided-patch and random-patch training. Pool 4 means that the adjacent $4 \\times 4$ patches (16 patches) are pooled together in the first layer. Pool 2-2 means that the adjacent $2 \\times 2$ bounds are pooled together in the first layer and then another $2 \\times 2$ bound pooling happens at the second layer. This is similar to $4 \\times 4$ pooling except the pooling operation is distributed between the first and second layer. All experiments are performed on a 4-layer convolutional network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>5×5</td></tr><tr><td rowspan=2 colspan=1>Dataset  TrainingStrategy</td><td rowspan=1 colspan=1>Clean    Certified  Training</td><td rowspan=1 colspan=1>Clean    Certified  Training</td></tr><tr><td rowspan=1 colspan=1>Accuracy  Accuracy  Time(h)</td><td rowspan=1 colspan=1>Accuracy  Accuracy  Time(h)</td></tr><tr><td rowspan=1 colspan=1>MNIST   All Patch</td><td rowspan=1 colspan=1>98.5%     91.6%      20.1</td><td rowspan=1 colspan=1>90.0%    59.7%      16.3</td></tr><tr><td rowspan=6 colspan=1>Pool 2Pool 4Random(1)Random(5)Random(10)Guided(10)</td><td rowspan=1 colspan=1>98.0%     91.1%      15.8</td><td rowspan=1 colspan=1>85.2%     54.2%      11.6</td></tr><tr><td rowspan=1 colspan=1>97.2%     89.9%      13.2</td><td rowspan=1 colspan=1>70.4%     38.3%      10.2</td></tr><tr><td rowspan=1 colspan=1>98.5%     81.9%      0.3</td><td rowspan=1 colspan=1>96.8%     24.8%      0.4</td></tr><tr><td rowspan=1 colspan=1>98.6%     86.5%      0.3</td><td rowspan=1 colspan=1>94.9%     42.0%      0.5</td></tr><tr><td rowspan=1 colspan=1>98.6%     87.5%      0.5</td><td rowspan=1 colspan=1>94.7%     50.4%       0.6</td></tr><tr><td rowspan=1 colspan=1>98.7%     88.9%      2.2</td><td rowspan=1 colspan=1>94.0%    53.2%      3.4</td></tr><tr><td rowspan=1 colspan=1>CIFAR    All Patch</td><td rowspan=1 colspan=1>49.6%     41.6%      22.5</td><td rowspan=1 colspan=1>34.0%     25.0%      18.6</td></tr><tr><td rowspan=2 colspan=1>Pool 2Pool4</td><td rowspan=1 colspan=1>48.1%     39.4%      17.3</td><td rowspan=1 colspan=1>32.4%    24.2%      14.5</td></tr><tr><td rowspan=2 colspan=1>Pool4Pool 2-2</td><td rowspan=1 colspan=1>44.9%     37.1%      16.3</td><td rowspan=1 colspan=1>28.3%     20.6%      13.6</td></tr><tr><td rowspan=1 colspan=1>45.0%     37.4%      16.5</td><td rowspan=1 colspan=1>25.3%     19.1%      13.8</td></tr><tr><td rowspan=1 colspan=1>Random(1)</td><td rowspan=1 colspan=1>53.2%     32.4%      0.6</td><td rowspan=1 colspan=1>42.7%     11.0%      0.6</td></tr><tr><td rowspan=2 colspan=1>Random(5)Random(10)</td><td rowspan=1 colspan=1>52.2%     39.5%      0.9</td><td rowspan=1 colspan=1>37.8%     19.6%      0.9</td></tr><tr><td rowspan=1 colspan=1>50.8%     38.6%       1.0</td><td rowspan=1 colspan=1>38.4%     21.9%       1.0</td></tr><tr><td rowspan=1 colspan=1>Guided(10)</td><td rowspan=1 colspan=1>53.0%     39.8%       4.0</td><td rowspan=1 colspan=1>36.1%     23.0%      3.9</td></tr></table>",
+        "bbox": [
+            173,
+            520,
+            828,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 MULTI-PATCH SPARSE TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            449,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here we list the detailed certified accuracy for various sparsity levels and model architectures. ",
+        "bbox": [
+            173,
+            130,
+            787,
+            145
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4aaae91eba1ccdf0daccfb7c8539b3eb04cd6dcb4465a68c0780caebe05faae.jpg",
+        "table_caption": [
+            "Table 7: Certified accuracy for sparse defenses with varying sparsity $k$ and models on both MNIST and CIFAR10, where “Conv $c \\times c ^ { \\prime \\prime }$ represents for the convolutional network with first layer kernel size c. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Sparsity (k)</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td></tr><tr><td rowspan=\"4\">MNIST</td><td>1</td><td>mlp</td><td>98.4%</td><td>96.0%</td></tr><tr><td>4</td><td>mlp</td><td>97.8%</td><td>90.8%</td></tr><tr><td>10</td><td>mlp</td><td>95.2%</td><td>86.8%</td></tr><tr><td>1</td><td>Conv3x3</td><td>97.0%</td><td>88.3%</td></tr><tr><td rowspan=\"8\">CIFAR</td><td>4</td><td>Conv3x3</td><td>92.7%</td><td>75.9%</td></tr><tr><td>1</td><td>mlp</td><td>48.4%</td><td>40.0%</td></tr><tr><td>4</td><td>mlp</td><td>42.2%</td><td>31.2%</td></tr><tr><td>10</td><td>mlp</td><td>37.0%</td><td>25.6%</td></tr><tr><td>1</td><td>Conv11x11</td><td>34.8%</td><td>27.4%</td></tr><tr><td>4</td><td>Conv11x11</td><td>25.1%</td><td>18.3%</td></tr><tr><td>10</td><td>Conv11x11</td><td>17.2%</td><td>13.8%</td></tr><tr><td>1</td><td>Conv13x13</td><td>38.6%</td><td>29.7%</td></tr><tr><td></td><td>4</td><td>Conv13x13</td><td>28.1%</td><td>19.6%</td></tr><tr><td></td><td>10</td><td>Conv13x13</td><td>22.4%</td><td>15.3%</td></tr></table>",
+        "bbox": [
+            232,
+            210,
+            764,
+            422
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 TRAINING WITH LARGER MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            454,
+            469
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Recall that all-patch training considers all possible patches during training, which can be too expensive for larger models and/or images. The proposed random- and guided-patch training methods aim to reduce the training cost by considering only a subset of patches; please see Section 4.2 for more details. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            536
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/42fc43caae4763d84f07dee1ef9d2252f3eb9def932e7d51cdf8bbff610d1244.jpg",
+        "table_caption": [
+            "Table 8: The random and guided training strategy could yield significantly stronger model compared to all-patch training given a fixed computational budget. The random and guided training strategy allows us to train a larger model that would be infeasible to train otherwise. The guided-patch large model is able to boost the certified accuracy by over $10 \\%$ compared to the best performing all-patch small model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Patch Size</td><td>Training Strategy</td><td>Model</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time(h)</td></tr><tr><td rowspan=\"5\">CIFAR</td><td rowspan=\"5\">2×2</td><td>All Patch</td><td>mlp</td><td>50.8%</td><td>35.5%</td><td>9.1</td></tr><tr><td></td><td>2 layer conv</td><td>52.4%</td><td>42.6%</td><td>10.7</td></tr><tr><td></td><td> 4 layer conv</td><td>49.6%</td><td>41.6%</td><td>22.5</td></tr><tr><td></td><td>5 layer conv (wide)</td><td>1</td><td>-</td><td>~360.0</td></tr><tr><td>Random(10) Random(20)</td><td>5 layer conv (wide) 5 layer conv (wide)</td><td>64.7% 64.4%</td><td>49.0%</td><td>9.5</td></tr><tr><td rowspan=\"6\">CIFAR 5×5</td><td>Guided(10)</td><td>5 layer conv (wide)</td><td>66.5%</td><td>50.8% 49.2%</td><td></td><td>15.8 12.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Guided(20) All Patch</td><td>5 layer conv (wide)</td><td>65.8%</td><td>51.9%</td><td></td><td>22.4</td></tr><tr><td></td><td>mlp</td><td></td><td>31.1%</td><td>18.8%</td><td>7.1</td></tr><tr><td></td><td>2 layer conv</td><td>35.5%</td><td></td><td>22.3%</td><td>8.7</td></tr><tr><td></td><td></td><td>4 layer conv.</td><td>34.0%</td><td>25.0%</td><td></td><td>18.6</td></tr><tr><td></td><td></td><td></td><td>5 layer conv (wide)</td><td>1</td><td>、</td><td>~360.0</td></tr><tr><td></td><td></td><td>Random(10) Random(20)</td><td>5 layer conv (wide)</td><td>48.6%</td><td>29.9%</td><td>9.4</td></tr><tr><td></td><td></td><td></td><td>5 layer conv (wide)</td><td>47.8%</td><td>30.3%</td><td>15.4</td></tr><tr><td></td><td>Guided(10)</td><td>5 layer conv (wide)</td><td></td><td>48.4%</td><td>29.0%</td><td>12.4</td></tr><tr><td></td><td></td><td>Guided(20)</td><td>5 layer conv (wide)</td><td>47.6%</td><td>29.6%</td><td>23.8</td></tr></table>",
+        "bbox": [
+            178,
+            630,
+            820,
+            882
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.6 DETAILED STATISTICS ON TRAINING STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            565,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we list the detailed statistics for each training strategies for Table 3 ",
+        "bbox": [
+            173,
+            128,
+            647,
+            145
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc04836ff4526e02b899ef602f30c5f44a6e919fce529c81f7427fcc1fb2231a.jpg",
+        "table_caption": [
+            "Table 9: Detailed statistics for the comparison of training strategies - $2 \\times 2$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Training Strategies</td><td>Model Architecture</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time</td></tr><tr><td>MNIST</td><td>All Patch</td><td>2 layer convolution</td><td>98.63/%</td><td>91.38%</td><td>21.0</td></tr><tr><td rowspan=\"10\"></td><td rowspan=\"4\">Random (1)</td><td>4 layer convolution</td><td>98.48%</td><td>91.63%</td><td>80.3</td></tr><tr><td>fully connected (255,10)</td><td>98.46%</td><td>91.47%</td><td>9.8</td></tr><tr><td>2 layer convolution</td><td>98.69%</td><td>82.57%</td><td>0.2</td></tr><tr><td>4 layer convolution</td><td>98.45%</td><td>81.87%</td><td>0.3</td></tr><tr><td rowspan=\"3\">Random (5)</td><td>fully connected (255,10)</td><td>98.48%</td><td>84.32%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.75%</td><td>85.87%</td><td>0.3</td></tr><tr><td>4 layer convolution</td><td>98.57%</td><td>86.50%</td><td>0.3</td></tr><tr><td rowspan=\"3\">Random (10)</td><td>fully connected (255,10)</td><td>98.62%</td><td>87.32%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.73%</td><td>87.31%</td><td>0.3</td></tr><tr><td>4 layer convolution</td><td>98.63%</td><td>87.54%</td><td>0.5</td></tr><tr><td rowspan=\"3\">Guided (10)</td><td>fully connected (255,10)</td><td>98.49%</td><td>88.13%</td><td>0.2</td></tr><tr><td>2 layer convolution</td><td>98.60%</td><td>88.49%</td><td>2.3</td></tr><tr><td>4 layer convolution</td><td>98.70%</td><td>88.85%</td><td>2.2</td></tr><tr><td rowspan=\"3\">CIFAR All Patch</td><td>fully connected (255,10)</td><td>98.63%</td><td>89.44%</td><td>2.2</td></tr><tr><td>2 layer convolution</td><td>52.42%</td><td>42.57%</td><td>42.6</td></tr><tr><td>4 layer convolution</td><td>49.58%</td><td>41.57%</td><td>89.8</td></tr><tr><td rowspan=\"3\">Random (1)</td><td>fully connected (255,10)</td><td>50.83%</td><td>35.49%</td><td>36.6</td></tr><tr><td>2 layer convolution</td><td>54.93%</td><td>29.13%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>53.22%</td><td>32.35%</td><td>0.6</td></tr><tr><td rowspan=\"3\">Random (5)</td><td>fully connected (255,10)</td><td>52.76%</td><td>03.21%</td><td>0.5</td></tr><tr><td>2 layer convolution</td><td>54.15%</td><td>37.30%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>52.19%</td><td>39.45%</td><td>0.9</td></tr><tr><td rowspan=\"3\">Random (10)</td><td>fully connected (255,10)</td><td>52.38%</td><td>20.17%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>53.08%</td><td>39.32%</td><td>0.7</td></tr><tr><td>4 layer convolution</td><td>50.80%</td><td>38.57%</td><td>1.0</td></tr><tr><td rowspan=\"4\">Guided (10)</td><td>fully connected (255,10)</td><td>51.90%</td><td>28.97%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>53.04%</td><td>38.81%</td><td>3.7</td></tr><tr><td>4 layer convolution</td><td>52.97%</td><td>39.84%</td><td>4.0</td></tr><tr><td>fully connected (255,10)</td><td>51.32%</td><td>29.44%</td><td>3.6</td></tr></table>",
+        "bbox": [
+            181,
+            152,
+            825,
+            603
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/968fcf41618a93d42b437f4d935589049dd9f94c63cb8390f1d702d87b6949c2.jpg",
+        "table_caption": [
+            "Table 10: Detailed statistics for the comparison of training strategies - $5 \\times 5$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Training Strategies</td><td>Model Architecture</td><td>Clean Accuracy</td><td>Certified Accuracy</td><td>Training Time</td></tr><tr><td>MNIST</td><td>All Patch</td><td>2 layer convolution</td><td>91.88%</td><td>59.59%</td><td>28.4</td></tr><tr><td rowspan=\"10\"></td><td></td><td>4 layer convolution</td><td>90.03%</td><td>59.72%</td><td>65.2</td></tr><tr><td>Random (1)</td><td>fully connected (255,10)</td><td>93.96%</td><td>61.97%</td><td>7.2</td></tr><tr><td></td><td>2 layer convolution</td><td>96.27%</td><td>18.57%</td><td>0.2</td></tr><tr><td></td><td>4 layer convolution</td><td>96.83%</td><td>24.79%</td><td>0.4</td></tr><tr><td>Random (5)</td><td>fully connected (255,10)</td><td>97.60%</td><td>29.04%</td><td>0.2</td></tr><tr><td></td><td>2 layer convolution</td><td>95.82%</td><td>38.47%</td><td>0.2</td></tr><tr><td></td><td>4 layer convolution</td><td>94.85%</td><td>42.02%</td><td>0.5</td></tr><tr><td>Random (10)</td><td>fully connected (255,10)</td><td>96.73%</td><td>45.89%</td><td>0.2</td></tr><tr><td></td><td>2 layer convolution</td><td>95.55%</td><td>46.13%</td><td>0.3</td></tr><tr><td></td><td>4 layer convolution fully connected (255,10)</td><td>94.76% 96.40%</td><td>50.43% 52.30%</td><td>0.6</td></tr><tr><td>Guided (10)</td><td>2 layer convolution</td><td>95.28%</td><td>50.28%</td><td>0.2 2.3</td></tr><tr><td rowspan=\"3\"></td><td></td><td>93.98%</td><td>53.17%</td><td>3.4</td></tr><tr><td>4 layer convolution</td><td>95.82%</td><td>55.89%</td><td>2.2</td></tr><tr><td>fully connected (255,10)</td><td>35.48%</td><td></td><td></td></tr><tr><td rowspan=\"3\">CIFAR All Patch Random (1)</td><td>2 layer convolution</td><td>33.95%</td><td>22.31% 24.96%</td><td>34.8</td></tr><tr><td>4 layer convolution fully connected (255,10)</td><td>31.05%</td><td>18.78%</td><td>74.4 28.4</td></tr><tr><td></td><td>45.71%</td><td>07.14%</td><td>0.6</td></tr><tr><td rowspan=\"3\"></td><td>2 layer convolution</td><td>42.65%</td><td>10.99%</td><td></td></tr><tr><td>4 layer convolution</td><td>42.34%</td><td></td><td>0.6</td></tr><tr><td>fully connected (255,10)</td><td></td><td>00.10%</td><td>0.5</td></tr><tr><td rowspan=\"3\">Random (5)</td><td>2 layer convolution</td><td>42.85%</td><td>17.29%</td><td>0.6</td></tr><tr><td>4 layer convolution</td><td>37.80%</td><td>19.63%</td><td>0.9</td></tr><tr><td>fully connected (255,10)</td><td>36.23%</td><td>06.99%</td><td>0.6</td></tr><tr><td rowspan=\"4\">Random (10)</td><td>2 layer convolution</td><td>41.90%</td><td>21.40%</td><td>0.7</td></tr><tr><td>4 layer convolution</td><td>38.41%</td><td>21.90%</td><td>1.0</td></tr><tr><td>fully connected (255,10) Guided (10)</td><td>36.04%</td><td>12.46%</td><td>0.6</td></tr><tr><td>2 layer convolution</td><td>42.08%</td><td>20.77%</td><td>3.6</td></tr><tr><td></td><td>4 layer convolution fully connected (255,10)</td><td>36.08% 35.51%</td><td>23.01% 12.56%</td><td>3.9 3.5</td></tr></table>",
+        "bbox": [
+            181,
+            98,
+            823,
+            546
+        ],
+        "page_idx": 15
+    }
+]

parse/train/Hyg96gBKPS/Hyg96gBKPS.md

@@ -0,0 +1,334 @@
+# MONOTONIC MULTIHEAD ATTENTION
+
+Xutai $\mathbf { M } \mathbf { a } ^ { 2 }$ ∗, Juan Pino1, James Cross1, Liezl Puzon1, Jiatao $\mathbf { G u } ^ { 1 }$
+
+1Facebook   
+2Johns Hopkins University
+
+xutai ma@jhu.edu, puzon@cs.stanford.edu {juancarabina,jcross,jgu}@fb.com
+
+# ABSTRACT
+
+Simultaneous machine translation models start generating a target sequence before they have encoded the source sequence. Recent approaches for this task either apply a fixed policy on a state-of-the art Transformer model, or a learnable monotonic attention on a weaker recurrent neural network-based structure. In this paper, we propose a new attention mechanism, Monotonic Multihead Attention (MMA), which extends the monotonic attention mechanism to multihead attention. We also introduce two novel and interpretable approaches for latency control that are specifically designed for multiple attention heads. We apply MMA to the simultaneous machine translation task and demonstrate better latency-quality tradeoffs compared to MILk, the previous state-of-the-art approach. We analyze how the latency controls affect the attention span and we study the relationship between the speed of a head and the layer it belongs to. Finally, we motivate the introduction of our model by analyzing the effect of the number of decoder layers and heads on quality and latency.1
+
+# 1 INTRODUCTION
+
+Simultaneous machine translation adds the capability of a live interpreter to machine translation: a simultaneous model starts generating a translation before it has finished reading the entire source sentence. Such models are useful in any situation where translation needs to be done in real time. For example, simultaneous models can translate live video captions or facilitate conversations between people speaking different languages. In a usual translation model, the encoder first reads the entire sentence, then the decoder writes the target sentence. On the other hand, a simultaneous neural machine translation model alternates between reading the input and writing the output using either a fixed or learned policy.
+
+Monotonic attention mechanisms fall into the flexible policy category, in which the policies are automatically learned from data. Recent work exploring monotonic attention variants for simultaneous translation include: hard monotonic attention (Raffel et al., 2017), monotonic chunkwise attention (MoChA) (Chiu & Raffel, 2018) and monotonic infinite lookback attention (MILk) (Arivazhagan et al., 2019). MILk in particular has shown better quality/latency trade-offs than fixed policy approaches, such as wait- $k$ (Ma et al., 2019) or wait-if-\* (Cho & Esipova, 2016) policies. MILk also outperforms hard monotonic attention and MoChA; while the other two monotonic attention mechanisms only consider a fixed window, MILk computes a softmax attention over all previous encoder states, which may be the key to its improved latency-quality tradeoffs. These monotonic attention approaches also provide a closed-form expression for the expected alignment between source and target tokens.
+
+However, monotonic attention-based models, including the state-of-the-art MILk, were built on top of RNN-based models. RNN-based models have been outperformed by the recent state-of-the-art Transformer model (Vaswani et al., 2017), which features multiple encoder-decoder attention layers and multihead attention at each layer.
+
+We thus propose monotonic multihead attention (MMA), which combines the high translation quality from multilayer multihead attention and low latency from monotonic attention. We propose two variants, Hard MMA (MMA-H) and Infinite Lookback MMA (MMA-IL). MMA-H is designed with streaming systems in mind where the attention span must be limited. MMA-IL emphasizes the quality of the translation system. We also propose two novel latency regularization methods. The first encourages the model to be faster by directly minimizing the average latency. The second encourages the attention heads to maintain similar positions, preventing the latency from being dominated by a single or a few heads.
+
+The main contributions of this paper are: (1) A novel monotonic attention mechanism, monotonic multihead attention, which enables the Transformer model to perform online decoding. This model leverages the power of the Transformer and the efficiency of monotonic attention. (2) Better latency/quality tradeoffs compared to the MILk model, the previous state-of-the-art, on two standard translation benchmarks, IWSLT15 English-Vietnamese (En-Vi) and WMT15 German-English (DeEn). (3) Analyses on how our model is able to control the attention span and on the relationship between the speed of a head and the layer it belongs to. We motivate the design of our model with an ablation study on the number of decoder layers and the number of decoder heads.
+
+# 2 MONOTONIC MULTIHEAD ATTENTION MODEL
+
+In this section, we review the monotonic attention-based approaches in RNN-based encoder-decoder models. We then introduce the two types of Monotonic Multihead Attention (MMA) for Transformer models: MMA-H and MMA-IL. Finally, we introduce strategies to control latency and coverage.
+
+# 2.1 MONOTONIC ATTENTION
+
+The hard monotonic attention mechanism (Raffel et al., 2017) was first introduced in order to achieve online linear time decoding for RNN-based encoder-decoder models. We denote the input sequence as $\mathbf { x } = \{ x _ { 1 } , . . . , x _ { T } \}$ , and the corresponding encoder states as $\mathbf { m } = \{ m _ { 1 } , . . . , m _ { T } \}$ , with $T$ being the length of the source sequence. The model generates a target sequence $\mathbf { y } = \{ y _ { 1 } , . . . , y _ { U } \}$ with $U$ being the length of the target sequence. At the $i$ -th decoding step, the decoder only attends to one encoder state $m _ { t _ { i } }$ with $t _ { i } = j$ . When generating a new target token $y _ { i }$ , the decoder chooses whether to move one step forward or to stay at the current position based on a Bernoulli selection probability $p _ { i , j }$ , so that $t _ { i } \ \geq \ t _ { i - 1 }$ . Denoting the decoder state at the $i$ -th position, starting from $j = t _ { i - 1 } , t _ { i - 1 } + 1 , t _ { i - 1 } + 2 , . . . _ $ , this process can be calculated as follows: 2
+
+$$
+\begin{array} { l c l } { e _ { i , j } } & { = } & { \mathrm { M o n o t o n i c E n e r g y } ( s _ { i - 1 } , m _ { j } ) } \\ { p _ { i , j } } & { = } & { \mathrm { S i g m o i d } \left( e _ { i , j } \right) } \\ { z _ { i , j } } & { \sim } & { \mathrm { B e r n o u l l i } ( p _ { i , j } ) } \end{array}
+$$
+
+When $z _ { i , j } = 1$ , we set $t _ { i } = j$ and start generating a target token $y _ { i }$ ; otherwise, we set $t _ { i } = j + 1$ and repeat the process. During training, an expected alignment $_ { \pmb { \alpha } }$ is introduced to replace the softmax attention. It can be calculated in a recurrent manner, shown in Equation 4:
+
+$$
+\begin{array} { l } { \displaystyle \alpha _ { i , j } = p _ { i , j } \sum _ { k = 1 } ^ { j } \left( \alpha _ { i - 1 , k } \prod _ { l = k } ^ { j - 1 } \left( 1 - p _ { i , l } \right) \right) } \\ { \displaystyle = p _ { i , j } \left( \left( 1 - p _ { i , j - 1 } \right) \frac { \alpha _ { i , j - 1 } } { p _ { i , j - 1 } } + \alpha _ { i - 1 , j } \right) } \end{array}
+$$
+
+Raffel et al. (2017) also introduce a closed-form parallel solution for the recurrence relation in Equation 5:
+
+$$
+\alpha _ { i , : } = p _ { i , : } \mathrm { c u m p r o d } ( 1 - p _ { i , : } ) \mathrm { c u m s u m } \left( \frac { \alpha _ { i - 1 , : } } { \mathrm { c u m p r o d } ( 1 - p _ { i , : } ) } \right)
+$$
+
+where $\begin{array} { r } { \mathtt { c u m p r o d } ( x ) = [ 1 , x _ { 1 } , x _ { 1 } x _ { 2 } , . . . , \prod _ { i = 1 } ^ { | x | - 1 } x _ { i } ] } \end{array}$ and $\mathsf { c u m s u m } ( { \pmb x } ) = [ x _ { 1 } , x _ { 1 } + x _ { 2 } , . . . , \sum _ { i = 1 } ^ { | { \pmb x } | } x _ { i } ]$ In practice, the denominator in Equation 5 is clamped into a range of [, 1] to avoid numerical instabilities introduced by cumprod. Although this monotonic attention mechanism achieves online linear time decoding, the decoder can only attend to one encoder state. This limitation can diminish translation quality as there may be insufficient information for reordering.
+
+Moreover, the model lacks a mechanism to adjust latency based on different requirements at decoding time. To address these issues, Chiu & Raffel (2018) introduce Monotonic Chunkwise Attention (MoChA), which allows the decoder to apply softmax attention to a fixed-length subsequence of encoder states. Alternatively, Arivazhagan et al. (2019) introduce Monotonic Infinite Lookback Attention (MILk) which allows the decoder to access encoder states from the beginning of the source sequence. The expected attention for the MILk model is defined in Equation 6.
+
+$$
+\beta _ { i , j } = \sum _ { k = j } ^ { | x | } \left( \frac { \alpha _ { i , k } \exp ( u _ { i , j } ) } { \sum _ { l = 1 } ^ { k } \exp ( u _ { i , l } ) } \right)
+$$
+
+# 2.2 MONOTONIC MULTIHEAD ATTENTION
+
+Previous monotonic attention approaches are based on RNN encoder-decoder models with a single attention and haven’t explored the power of the Transformer model. 3 The Transformer architecture (Vaswani et al., 2017) has recently become the state-of-the-art for machine translation (Barrault et al., 2019). An important feature of the Transformer is the use of a separate multihead attention module at each layer. Thus, we propose a new approach, Monotonic Multihead Attention (MMA), which combines the expressive power of multihead attention and the low latency of monotonic attention.
+
+Multihead attention allows each decoder layer to have multiple heads, where each head can compute a different attention distribution. Given queries $Q$ , keys $K$ and values $V$ , multihead attention MultiHead $( Q , K , V )$ is defined in Equation 7.
+
+$$
+\begin{array} { r } { \begin{array} { l } { \mathrm { M u l t i H e a d } ( Q , K , V ) = \mathrm { C o n c a t } ( \mathrm { h e a d } _ { 1 } , . . . , \mathrm { h e a d } _ { H } ) W ^ { O } } \\ { \mathrm { w h e r e ~ h e a d } _ { h } = \mathrm { A t t e n t i o n } \left( Q W _ { h } ^ { Q } , K W _ { h } ^ { K } , V W _ { h } ^ { V } , \right) } \end{array} } \end{array}
+$$
+
+The attention function is the scaled dot-product attention, defined in Equation 8:
+
+$$
+{ \mathrm { A t t e n t i o n } } ( Q , K , V ) = { \mathrm { S o f t m a x } } \left( { \frac { Q K ^ { T } } { \sqrt { d _ { k } } } } \right) V
+$$
+
+There are three applications of multihead attention in the Transformer model:
+
+1. The Encoder contains self-attention layers where all of the queries, keys and values come from previous layers.   
+2. The Decoder contains self-attention layers that allow each position in the decoder to attend to all positions in the decoder up to and including that position.   
+3. The Encoder-Decoder attention contains multihead attention layers where queries come from the previous decoder layer and the keys and values come from the output of the encoder. Every decoder layer has a separate encoder-decoder attention.
+
+For MMA, we assign each head to operate as a separate monotonic attention in encoder-decoder attention.
+
+For a transformer with $L$ decoder layers and $H$ attention heads per layer, we define the selection process of the $h$ -th head encoder-decoder attention in the $l$ -th decoder layer as
+
+$$
+\begin{array} { l c l } { e _ { i , j } ^ { { l , h } } } & { = } & { \left( \frac { m _ { j } W _ { { l , h } } ^ { K } ( s _ { i - 1 } W _ { { l , h } } ^ { Q } ) ^ { T } } { \sqrt { d _ { k } } } \right) _ { i , j } } \\ { p _ { i , j } ^ { { l , h } } } & { = } & { \mathrm { S i g m o i d } ( e _ { i , j } ) } \\ { z _ { i , j } ^ { { l , h } } } & { \sim } & { \mathrm { B e r n o u l l i } ( p _ { i , j } ) } \end{array}
+$$
+
+![](images/d597335b4efb8a0b81899a74e4bee9cd4514669123bca34eef86fbf7c1b7c310.jpg)  
+Figure 1: Monotonic Attention (Left) versus Monotonic Multihead Attention (Right).
+
+where $W _ { l , h }$ is the input projection matrix, $d _ { k }$ is the dimension of the attention head. We make the selection process independent for each head in each layer. We then investigate two types of MMA, MMA-H(ard) and MMA-IL(infinite lookback). For MMA-H, we use Equation 4 in order to calculate the expected alignment for each layer each head, given $p _ { i , j } ^ { l , h }$ . For MMA-IL, we calculate the softmax energy for each head as follows:
+
+$$
+u _ { i , j } ^ { l , h } = \mathrm { S o f t E n e r g y } = \left( \frac { m _ { j } \hat { W } _ { l , h } ^ { K } ( s _ { i - 1 } \hat { W } _ { l , h } ^ { Q } ) ^ { T } } { \sqrt { d _ { k } } } \right) _ { i , j }
+$$
+
+and then use Equation 6 to calculate the expected attention. Each attention head in MMA-H hardattends to one encoder state. On the other hand, each attention head in MMA-IL can attend to all previous encoder states. Thus, MMA-IL allows the model to leverage more information for translation, but MMA-H may be better suited for streaming systems with stricter efficiency requirements. Finally, our models use unidirectional encoders: the encoder self-attention can only attend to previous states, which is also required for simultaneous translation.
+
+At inference time, our decoding strategy is shown in Algorithm 1. For each $l , h$ , at decoding step $i$ , we apply the sampling processes discussed in subsection 2.1 individually and set the encoder step at $t _ { i } ^ { l , \bar { h } }$ . Then a hard alignment or partial softmax attention from encoder states, shown in Equation 13, will be retrieved to feed into the decoder to generate the $i$ -th token. The model will write a new target token only after all the attentions have decided to write. In other words, the heads that have decided to write must wait until the others have finished reading.
+
+$$
+\begin{array}{c} \begin{array} { r l } & { \qquad c _ { i } ^ { l } = \mathrm { C o n c a t } ( c _ { i } ^ { l , 1 } , c _ { i } ^ { l , 2 } , . . . , c _ { i } ^ { l , H } ) } \\ & { \qquad \mathrm \quad \mathbf { \ " } } \\ & { \qquad \mathbf { \ " } \mathbf { \ " } e _ { i } ^ { l , h } = f _ { \mathrm { c o n t e x t } } ( \boldsymbol { h } , t _ { i } ^ { l , h } ) = \displaystyle \left\{ \sum _ { j = 1 } ^ { m _ { t _ { i } ^ { l , h } } } \frac { \mathrm { e x p } \left( u _ { i , j } ^ { l , h } \right) } { \sum _ { j = 1 } ^ { t _ { i } ^ { l , h } } \mathrm { e x p } \left( u _ { i , j } ^ { l , h } \right) } m _ { j } \quad \mathrm { M M A \mathrm { - } I L } \right.} \end{array}   \end{array}
+$$
+
+Figure 1 illustrates a comparison between our model and the monotonic model with one attention head. Compared with the monotonic model, the MMA model is able to set attention to different positions so that it can still attend to previous states while reading each new token. Each head can adjust its speed on-the-fly. Some heads read new inputs, while the others can stay in the past to retain the source history information. Even with the hard alignment variant (MMA-H), the model is still able to preserve the history information by setting heads to past states. In contrast, the hard monotonic model, which only has one head, loses the previous information at the attention layer.
+
+# 2.3 LATENCY CONTROL
+
+Effective simultaneous machine translation must balance quality and latency. At a high level, latency measures how many source tokens the model has read until a translation is generated. The model we have introduced in subsection 2.2 is not able to control latency on its own. While MMA allows simultaneous translation by having a read or write schedule for each head, the overall latency is determined by the fastest head, i.e. the head that reads the most. It is possible that a head always reads new input without producing output, which would result in the maximum possible latency. Note that the attention behaviors in MMA-H and MMA-IL can be different. In MMA-IL, a head reaching the end of the sentence will provide the model with maximum information about the source sentence. On the other hand, in the case of MMA-H, reaching the end of sentence for a head only
+
+Algorithm 1 MMA monotonic decoding. Because each head is independent, we compute line 3 to 16 in parallel
+
+Input: ${ \bf { \delta } } _ { \bf { \mathcal { X } } } =$ source tokens, $h =$ encoder states, $i = 1 , j = 1 , t _ { 0 } ^ { l , h } = 1 , y _ { 0 } =$ StartOfSequence.
+
+<table><tr><td colspan="3">1:while yi-1 ≠ EndOfSequence do</td></tr><tr><td>2:</td><td>tmax =1</td><td></td></tr><tr><td>3:</td><td>h = empty sequence</td><td></td></tr><tr><td>4:</td><td>forl←1toLdo</td><td></td></tr><tr><td>5:</td><td>forh←1to Hdo</td><td></td></tr><tr><td>6:</td><td>forj←ttoacldo</td><td></td></tr><tr><td>7:</td><td>l,h Pi,j, = Sigmoid (MonotonicEnergy(Si-1,mj ))</td><td></td></tr><tr><td>8:</td><td>ifpi l,h &gt; 0.5 then</td><td></td></tr><tr><td>9:</td><td>=j</td><td></td></tr><tr><td>10:</td><td>l,h =fcontext(h,t,h）</td><td></td></tr><tr><td>11:</td><td>Ci Break</td><td></td></tr><tr><td>12:</td><td>else</td><td></td></tr><tr><td>13:</td><td>if j&gt;tmax then</td><td></td></tr><tr><td>14:</td><td>Read token x j</td><td></td></tr><tr><td>15:</td><td></td><td>Calculate state h j and append to h</td></tr><tr><td>16:</td><td>tmax =j</td><td></td></tr><tr><td>17:</td><td>c = Concat(c,1,</td><td>,cH）</td></tr><tr><td>18:</td><td>s =DecoderLayer&#x27;(s-1,s)</td><td></td></tr><tr><td>19:</td><td>yi = Output(s)</td><td></td></tr><tr><td>20:</td><td></td><td></td></tr></table>
+
+gives a hard alignment to the end-of-sentence token, which provides very little information to the decoder. Furthermore, it is possible that an MMA-H attention head stays at the beginning of sentence without moving forward. Such a head would not cause latency issues but would degrade the model quality since the decoder would not have any information about the input. In addition, this behavior is not suited for streaming systems.
+
+To address these issues, we introduce two latency control methods. The first one is weighted average latency, shown in Equation 14:
+
+$$
+g _ { i } ^ { W } = \frac { \exp ( g _ { i } ^ { l , h } ) } { \sum _ { l = 1 } ^ { L } \sum _ { h = 1 } ^ { H } \exp ( g _ { i } ^ { l , h } ) } g _ { i } ^ { l , h }
+$$
+
+where $\begin{array} { r } { g _ { i } ^ { l , h } = \sum _ { j = 1 } ^ { | x | } j \alpha _ { i , j } } \end{array}$ . Then we calculate the latency loss with a differentiable latency metric $\mathcal { C }$
+
+$$
+\begin{array} { r c l } { { L _ { a v g } } } & { { = } } & { { { \mathcal { C } } \left( g ^ { W } \right) } } \end{array}
+$$
+
+Like Arivazhagan et al. (2019), we use the Differentiable Average Lagging. It is important to note that, unlike the original latency augmented training in Arivazhagan et al. (2019), Equation 15 is not the expected latency metric given $\mathcal { C }$ , but weighted average $\mathcal { C }$ on all the attentions. The real expected latency is $\hat { \pmb g } = \mathrm { m a x } _ { l , h } \left( \pmb g ^ { l , h } \right)$ instead of $\bar { \pmb { g } }$ , but using this directly would only affect the speed of the fastest head. Equation 15 can control every head in a way that the faster heads will be automatically assigned to larger weights and slower heads will also be moderately regularized. For MMA-H models, we found that the latency of are mainly due to outliers that skip almost every token. The weighted average latency loss is not sufficient to control the outliers. We therefore introduce the head divergence loss, the average variance of expected delays at each step, defined in Equation 16:
+
+$$
+\begin{array} { c c l } { { { \cal L } _ { v a r } } } & { { = } } & { { \displaystyle \frac { 1 } { L H } \sum _ { l = 1 } ^ { L } \sum _ { h = 1 } ^ { H } \left( g _ { i } ^ { l , h } - \bar { g } _ { i } \right) ^ { 2 } } } \end{array}
+$$
+
+where $\begin{array} { r } { \bar { g _ { i } } = \frac { 1 } { L H } \sum g _ { i } } \end{array}$ The final objective function is presented in Equation 17:
+
+$$
+L ( \theta ) = - \log ( \pmb { y } \mid \pmb { x } ; \theta ) + \lambda _ { a v g } L _ { a v g } + \lambda _ { v a r } L _ { v a r }
+$$
+
+where $\lambda _ { a v g } , \lambda _ { v a r }$ are hyperparameters that control both losses. Intuitively, while $\lambda _ { a v g }$ controls the overall speed, $\lambda _ { v a r }$ controls the divergence of the heads. Combining these two losses, we are able to dynamically control the range of attention heads so that we can control the latency and the reading buffer. For MMA-IL model, we only use $L _ { a v g }$ ; for MMA-H we only use $L _ { v a r }$ .
+
+# 3 EXPERIMENTAL SETUP
+
+# 3.1 EVALUATION METRICS
+
+We evaluate our model using quality and latency. For translation quality, we use tokenized BLEU 4 for IWSLT15 En-Vi and detokenized BLEU with SacreBLEU (Post, 2018) for WMT15 De-En. For latency, we use three different recent metrics, Average Proportion (AP) (Cho & Esipova, 2016), Average Lagging (AL) (Ma et al., 2019) and Differentiable Average Lagging (DAL) (Arivazhagan et al., 2019) 5. We remind the reader of the metric definitions in Appendix A.2.
+
+# 3.2 DATASETS
+
+Table 1: Number of sentences in each split.   
+
+<table><tr><td>Dataset</td><td>Train</td><td>Validation</td><td>Test</td></tr><tr><td>IWSLT15 En-Vi</td><td>133k</td><td>1268</td><td>1553</td></tr><tr><td>WMT15 De-En</td><td>4.5M</td><td>3000</td><td>2169</td></tr></table>
+
+Table 2: Offline model performance with unidirectional encoder and greedy decoding.   
+
+<table><tr><td>Dataset</td><td>RNN</td><td>Transformer</td></tr><tr><td>IWSLT15 En-Vi</td><td>25.66</td><td>28.7</td></tr><tr><td>WMT15 De-En</td><td>28.4 (Arivazhagan et al., 2019)</td><td>32.3</td></tr></table>
+
+<table><tr><td>Dataset</td><td>Beam Search</td><td>Bidirectional Encoder</td><td>Unidirectional Encoder</td></tr><tr><td rowspan="2">WMT15 De-En</td><td>1</td><td>32.6</td><td>32.3</td></tr><tr><td>4</td><td>33.0</td><td>33.0</td></tr><tr><td rowspan="2">IWSLT15 En-Vi</td><td>1</td><td>28.7</td><td>29.4</td></tr><tr><td>10</td><td>28.8</td><td>29.5</td></tr></table>
+
+Table 3: Effect of using a unidirectional encoder and greedy decoding to BLEU score.
+
+We evaluate our method on two standard machine translation datasets, IWSLT14 En-Vi and WMT15 De-En. Statistics of the datasets can be found in Table 1. For each dataset, we apply tokenization with the Moses (Koehn et al., 2007) tokenizer and preserve casing.
+
+IWSLT15 English-Vietnamese TED talks from IWSLT 2015 Evaluation Campaign (Cettolo et al., 2016). We follow the settings from Luong & Manning (2015) and Raffel et al. (2017). We replace words with frequency less than 5 by $< u n k >$ . We use tst2012 as a validation set tst2013 as a test set.
+
+WMT15 German-English We follow the setting from Arivazhagan et al. (2019). We apply byte pair encoding (BPE) (Sennrich et al., 2016) jointly on the source and target to construct a shared vocabulary with 32K symbols. We use newstest2013 as validation set and newstest2015 as test set.
+
+# 3.3 MODELS
+
+We evaluate MMA-H and MMA-IL models on both datasets. The MILK model we evaluate on IWSLT15 En-Vi is based on Luong et al. (2015) rather than RNMT $^ +$ (Chen et al., 2018). In general, our offline models use unidirectional encoders, i.e. the encoder self-attention can only attend to previous states, and greedy decoding. We report offline model performance in Table 2 and the effect of using unidirectional encoders and greedy decoding in Table 3. For MMA models, we replace the encoder-decoder layers with MMA and keep other hyperparameter settings the same as the offline model. Detailed hyperparameter settings can be found in subsection A.1. We use the Fairseq library (Ott et al., 2019) for our implementation.
+
+# 4 RESULTS
+
+In this section, we present the main results of our model in terms of latency-quality tradeoffs, ablation studies and analyses. In the first study, we analyze the effect of the variance loss on the attention span. Then, we study the effect of the number of decoder layers and decoder heads on quality and latency. We also provide a case study for the behavior of attention heads in an example. Finally, we study the relationship between the rank of an attention head and the layer it belongs to.
+
+![](images/e122b7036362526ca9df24fd1d502cd25f56d35adb6686383751be035f195e06.jpg)  
+Figure 2: Latency-quality tradeoffs for MILk (Arivazhagan et al., 2019) and MMA on IWSLT15 En-Vi and WMT15 De-En. Black dashed line indicates the unidirectional offline transformer model with greedy search.
+
+# 4.1 LATENCY-QUALITY TRADEOFFS
+
+We plot the quality-latency curves for MMA-H and MMA-IL in Figure 2. The BLEU and latency scores on the test sets are generated by setting a latency range and selecting the checkpoint with best BLEU score on the validation set. We use differentiable average lagging (Arivazhagan et al., 2019) when setting the latency range. We find that for a given latency, our models obtain a better translation quality. While MMA-IL tends to have a decrease in quality as the latency decreases, MMA-H has a small gain in quality as latency decreases: a larger latency does not necessarily mean an increase in source information available to the model. In fact, the large latency is from the outlier attention heads, which skip the entire source sentence and point to the end of the sentence. The outliers not only increase the latency but they also do not provide useful information. We introduce the attention variance loss to eliminate the outliers, as such a loss makes the attention heads focus on the current context for translating the new target token.
+
+It is interesting to observe that MMA-H has a better latency-quality tradeoff than $\mathrm { M I L K } ^ { 7 }$ even though each head only attends to only one state. Although MMA-H is not yet able to handle an arbitrarily long input (without resorting to segmenting the input), since both encoder and decoder self-attention have an infinite lookback, that model represents a good step in that direction.
+
+# 4.2 ATTENTION SPAN
+
+In subsection 2.3, we introduced the attention variance loss to MMA-H in order to prevent outlier attention heads from increasing the latency or increasing the attention span. We have already evaluated the effectiveness of this method on latency in subsection 4.1. We also want to measure the difference between the fastest and slowest heads at each decoding step. We define the average
+
+attention span in Equation 18:
+
+$$
+\bar { S } = \frac { 1 } { \vert \pmb { y } \vert } \left( \sum _ { i } ^ { \vert \pmb { y } \vert } \underset { l , h } { \operatorname* { m a x } } t _ { i } ^ { l , h } - \underset { l , h } { \operatorname* { m i n } } t _ { i } ^ { l , h } \right)
+$$
+
+It estimates the reading buffer we need for streaming translation. We show the relation between the average attention span versus $\lambda _ { v a r }$ in Figure 3. As expected, the average attention span is reduced as we increase $\lambda _ { v a r }$ .
+
+![](images/0f751c2faf86a11373cba7cf525d322dc182947f9c6a18f187c49c68d5fad146.jpg)  
+Figure 3: Effect of $\lambda _ { v a r }$ on the average attention span. The variance loss works as intended by reducing the span with higher weights.
+
+# 4.3 EFFECT ON NUMBER OF LAYERS AND NUMBER OF HEADS
+
+One motivation to introduce MMA is to adapt the Transformer, which is the current state-of-the-art model for machine translation, to online decoding. Important features of the Transformer architecture include having a separate attention layer for each decoder layer block and multihead attention. In this section, we test the effect of these two components on the offline, MMA-H, and MMA-IL models from a quality and latency perspective. We report quality as measured by detokenized BLEU and latency as measured by DAL on the WMT13 validation set in Figure 4. We set $\lambda _ { a v g } = 0 . 2$ for MMA-IL and $\lambda _ { v a r } = 0 . 2$ for MMA-H.
+
+The offline model benefits from having more than one decoder layer. In the case of 1 decoder layer, increasing the number of attention heads is beneficial but in the case of 3 and 6 decoder layers, we do not see much benefit from using more than 2 heads. The best performance is obtained for 3 layers and 2 heads (6 effective heads). The MMA-IL model behaves similarly to the offline model, and the best performance is observed with 6 layers and 4 heads (24 effective heads). For MMA-H, with 1 layer, performance improves with more heads. With 3 layers, the single-head setting is the most effective (3 effective heads). Finally, with 6 layers, the best performance is reached with 16 heads (96 effective heads).
+
+The general trend we observe is that performance improves as we increase the number of effective heads, either from multiple layers or multihead attention, up to a certain point, then either plateaus or degrades. This motivates the introduction of the MMA model.
+
+We also note that latency increases with the number of effective attention heads. This is due to having fixed loss weights: when more heads are involved, we should increase $\lambda _ { v a r }$ or $\lambda _ { a v g }$ to better control latency.
+
+# 4.4 ATTENTION BEHAVIORS
+
+We characterize attention behaviors by providing a running example of MMA-H and MMA-IL, shown in Figure 5. Each curve represents the path that an attention head goes through at inference time. For MMA-H, shown in Figure 5a, we found that when the source and target tokens have the same order, the attention heads behave linearly and the distance between fastest head and slowest head is small. For example, this can be observed from partial sentence pair “I also didn’t know that” and target tokens “Tôi cũng không biết rằng”, which have the same order. However, when the source tokens and target tokens have different orders, such as “the second step” and “bước (step) thứ hai (second)”, the model will generate “bước (step)” first and some heads will stay in the past to retain the information for later reordered translation “thứ hai (second)”. We can also see that the attention heads have a near-diagonal trajectory, which is appropriate for streaming inputs.
+
+![](images/587b8944db8cce31706c574a36a9ec6d40a868064c34c383e996803aed29b0b0.jpg)  
+Figure 4: Effect of the number of decoder attention heads and the number of decoder attention layers on quality and latency, reported on the WMT13 validation set.
+
+The behavior of the heads in MMA-IL models is shown in Figure 5b. Notice that we remove the partial softmax alignment in this figure. We don’t expect streaming capability for MMA-IL: some heads stop at early position of the source sentence to retain the history information. Moreover, because MMA-IL has more information when generating a new target token, it tends to produce translations with better quality. In this example, the MMA-IL model has a better translation on “isolate the victim” than MMA-H (“là cô lập nạn nhân” vs “là tách biệt nạn nhân”)
+
+![](images/f9caf5f55023339b16fb95b389bc65cc48ec79600f2fc76d230026679d0627e7.jpg)  
+Figure 5: Running examples on IWSLT15 English-Vietnamese dataset
+
+# 4.5 RANK OF THE HEADS
+
+In Figure 6, we calculate the average and standard deviation of rank of each head when generating every target token. For MMA-IL, we find that heads in lower layers tend to have higher rank and are thus slower. However, in MMA-H, the difference of the average rank are smaller. Furthermore, the standard deviation is very large which means that the order of the heads in MMA-H changes frequently over the inference process.
+
+![](images/945370a5e1d53aa3ee0f21fc5e5f3110a0171fb97a8e1797f201cb0464090bba.jpg)  
+Figure 6: The average rank of attention heads during inference on IWSLT15 En-Vi. Error bars indicate the standard deviation. L indicates the layer number and $\mathrm { H }$ indicates the head number.
+
+# 5 RELATED WORK
+
+Recent work on simultaneous machine translation falls into three categories. In the first one, models use a rule-based policy for reading input and writing output. Cho & Esipova (2016) propose a WaitIf-\* policy to enable an offline model to decode simultaneously. Ma et al. (2019) propose a wait- $k$ policy where the model first reads $k$ tokens, then alternates between read and write actions. Dalvi et al. (2018) propose an incremental decoding method, also based on a rule-based schedule. In the second category, a flexible policy is learnt from data. Grissom II et al. (2014) introduce a Markov chain to phrase-based machine translation models for simultaneous machine translation, in which they apply reinforcement learning to learn the read-write policy based on states. Gu et al. (2017) introduce an agent which learns to make decisions on when to translate from the interaction with a pre-trained offline neural machine translation model. Luo et al. (2017) used continuous rewards policy gradient for online alignments for speech recognition. Lawson et al. (2018) proposed a hard alignment with variational inference for online decoding. Alinejad et al. (2018) propose a new operation ”predict” which predicts future source tokens. Zheng et al. (2019b) introduce a restricted dynamic oracle and restricted imitation learning for simultaneous translation. Zheng et al. (2019a) train the agent with an action sequence from labels that are generated based on the rank of the gold target word given partial input. Models from the last category leverage monotonic attention and replace the softmax attention with an expected attention calculated from a stepwise Bernoulli selection probability. Raffel et al. (2017) first introduce the concept of monotonic attention for online linear time decoding, where the attention only attends to one encoder state at a time. Chiu & Raffel (2018) extended that work to let the model attend to a chunk of encoder state. Arivazhagan et al. (2019) also make use of the monotonic attention but introduce an infinite lookback to improve the translation quality.
+
+# 6 CONCLUSION
+
+In this paper, we propose two variants of the monotonic multihead attention model for simultaneous machine translation. By introducing two new targeted loss terms which allow us to control both latency and attention span, we are able to leverage the power of the Transformer architecture to achieve better quality-latency trade-offs than the previous state-of-the-art model. We also present detailed ablation studies demonstrating the efficacy and rationale of our approach. By introducing these stronger simultaneous sequence-to-sequence models, we hope to facilitate important applications, such as high-quality real-time interpretation between human speakers.
+
+# REFERENCES
+
+Ashkan Alinejad, Maryam Siahbani, and Anoop Sarkar. Prediction improves simultaneous neural machine translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 3022–3027, 2018.
+
+Naveen Arivazhagan, Colin Cherry, Wolfgang Macherey, Chung-Cheng Chiu, Semih Yavuz, Ruoming Pang, Wei Li, and Colin Raffel. Monotonic infinite lookback attention for simultaneous machine translation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 1313–1323, Florence, Italy, July 2019. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P19-1126.
+
+Lo¨ıc Barrault, Ondˇrej Bojar, Marta R. Costa-jussa, Christian Federmann, Mark Fishel, Yvette \` Graham, Barry Haddow, Matthias Huck, Philipp Koehn, Shervin Malmasi, Christof Monz, Mathias Muller, Santanu Pal, Matt Post, and Marcos Zampieri. Findings of the 2019 con- ¨ ference on machine translation (WMT19). In Proceedings of the Fourth Conference on Machine Translation (Volume 2: Shared Task Papers, Day 1), pp. 1–61, Florence, Italy, August 2019. Association for Computational Linguistics. doi: 10.18653/v1/W19-5301. URL https://www.aclweb.org/anthology/W19-5301.
+
+Mauro Cettolo, Niehues Jan, Stuker Sebastian, Luisa Bentivogli, Roldano Cattoni, and Marcello ¨ Federico. The iwslt 2016 evaluation campaign. In International Workshop on Spoken Language Translation, 2016.
+
+Mia Xu Chen, Orhan Firat, Ankur Bapna, Melvin Johnson, Wolfgang Macherey, George Foster, Llion Jones, Mike Schuster, Noam Shazeer, Niki Parmar, et al. The best of both worlds: Combining recent advances in neural machine translation. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 76–86, 2018.
+
+Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. 2018. URL https:// openreview.net/pdf?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Hko85plCW.
+
+Kyunghyun Cho and Masha Esipova. Can neural machine translation do simultaneous translation? arXiv preprint arXiv:1606.02012, 2016.
+
+Fahim Dalvi, Nadir Durrani, Hassan Sajjad, and Stephan Vogel. Incremental decoding and training methods for simultaneous translation in neural machine translation. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), pp. 493–499, New Orleans, Louisiana, June 2018. Association for Computational Linguistics. doi: 10.18653/v1/N18-2079. URL https://www.aclweb.org/anthology/N18-2079.
+
+Alvin Grissom II, He He, Jordan Boyd-Graber, John Morgan, and Hal Daume III. Don’t until the ´ final verb wait: Reinforcement learning for simultaneous machine translation. In Proceedings of the 2014 Conference on empirical methods in natural language processing (EMNLP), pp. 1342– 1352, 2014.
+
+Jiatao Gu, Graham Neubig, Kyunghyun Cho, and Victor OK Li. Learning to translate in real-time with neural machine translation. In 15th Conference of the European Chapter of the Association for Computational Linguistics, EACL 2017, pp. 1053–1062. Association for Computational Linguistics (ACL), 2017.
+
+Philipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondˇrej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open source toolkit for statistical machine translation. In Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics Companion Volume Proceedings of the Demo and Poster Sessions, pp. 177–180, Prague, Czech Republic, June 2007. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P07-2045.
+
+Dieterich Lawson, Chung-Cheng Chiu, George Tucker, Colin Raffel, Kevin Swersky, and Navdeep Jaitly. Learning hard alignments with variational inference. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5799–5803. IEEE, 2018.
+
+Yuping Luo, Chung-Cheng Chiu, Navdeep Jaitly, and Ilya Sutskever. Learning online alignments with continuous rewards policy gradient. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 2801–2805. IEEE, 2017.
+
+Minh-Thang Luong and Christopher D Manning. Stanford neural machine translation systems for spoken language domains. 2015.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. arXiv preprint arXiv:1508.04025, 2015.
+
+Mingbo Ma, Liang Huang, Hao Xiong, Renjie Zheng, Kaibo Liu, Baigong Zheng, Chuanqiang Zhang, Zhongjun He, Hairong Liu, Xing Li, Hua Wu, and Haifeng Wang. STACL: Simultaneous translation with implicit anticipation and controllable latency using prefix-to-prefix framework. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 3025–3036, Florence, Italy, July 2019. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P19-1289.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019.
+
+Matt Post. A call for clarity in reporting BLEU scores. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 186–191, Belgium, Brussels, October 2018. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ W18-6319.
+
+Colin Raffel, Minh-Thang Luong, Peter J Liu, Ron J Weiss, and Douglas Eck. Online and linear-time attention by enforcing monotonic alignments. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2837–2846. JMLR. org, 2017.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1715–1725, 2016.
+
+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.
+
+Baigong Zheng, Renjie Zheng, Mingbo Ma, and Liang Huang. Simpler and faster learning of adaptive policies for simultaneous translation. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 1349–1354, Hong Kong, China, November 2019a. Association for Computational Linguistics. doi: 10.18653/v1/D19-1137. URL https://www.aclweb.org/anthology/D19-1137.
+
+Baigong Zheng, Renjie Zheng, Mingbo Ma, and Liang Huang. Simultaneous translation with flexible policy via restricted imitation learning. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 5816–5822, Florence, Italy, July 2019b. Association for Computational Linguistics. doi: 10.18653/v1/P19-1582. URL https://www.aclweb. org/anthology/P19-1582.
+
+# A APPENDIX
+
+# A.1 HYPERPARAMETERS
+
+The hyperparameters we used for offline and monotonic transformer models are defined in Table 4.
+
+# A.2 LATENCY METRICS DEFINITIONS
+
+Given the delays $\mathbf { g } = \{ g _ { 1 } , g _ { 2 } , . . . , g _ { | \mathbf { y } | } \}$ of generating each target token, AP, AL and DAL are defined in Table 5.
+
+Table 4: Offline and monotonic models hyperparameters.   
+
+<table><tr><td>Hyperparameter</td><td>WMT15 German-English</td><td>IWSLT English-Vietnamese</td></tr><tr><td>encoder embed dim</td><td>1024</td><td>512</td></tr><tr><td>encoder ffn embed dim</td><td>4096</td><td>1024</td></tr><tr><td>encoder attention heads</td><td>16</td><td>4</td></tr><tr><td>encoder layers</td><td></td><td>6</td></tr><tr><td>decoder embed dim</td><td>1024</td><td>512</td></tr><tr><td>decoder ffn embed dim</td><td>4096</td><td>1024</td></tr><tr><td>decoder attention heads</td><td>16</td><td>4</td></tr><tr><td>decoder layers</td><td></td><td>6</td></tr><tr><td>dropout</td><td>0.3</td><td></td></tr><tr><td>optimizer</td><td></td><td>adam</td></tr><tr><td>adam-β</td><td></td><td>(0.9,0.98)</td></tr><tr><td>clip-norm</td><td></td><td>0.0</td></tr><tr><td>lr lr scheduler</td><td></td><td>0.0005</td></tr><tr><td></td><td></td><td>inverse sqrt</td></tr><tr><td>warmup-updates</td><td></td><td>4000</td></tr><tr><td>warmup-init-lr</td><td></td><td>1e-07</td></tr><tr><td>label-smoothing</td><td></td><td>0.1</td></tr><tr><td>max tokens</td><td>3584×8×8×2</td><td>16000</td></tr></table>
+
+Table 5: The calculation of latency metrics, given source $_ { \textbf { \em x } }$ , target $\textbf {  { y } }$ and delays $\pmb { g }$   
+
+<table><tr><td colspan="2">Latency Metric</td></tr><tr><td>Average Proportion</td><td>y 1 M gi lacllyl i=1</td></tr><tr><td>Average Lagging</td><td>1 T i-1 gi 1y1/ac T i=1 where T = arg maxi(gi = |xl)</td></tr><tr><td>1 ly Differentiable Average Lagging</td><td>lyl i-1 M gi lyl//ac| i=1 gi i=0 where g&#x27; = ly max(gi, 9i-1 i&lt;0 [x</td></tr></table>
+
+# A.3 DETAILED RESULTS
+
+We provide the detailed results in Figure 2 as Table 6 and Table 7.
+
+# A.4 THRESHOLD OF READING ACTION
+
+We explore a simple method that can adjust system’s latency at inference time without training new models. In Algorithm 1 line 8, 0.5 was used as an threshold. One can set different threshold $p$ during the inference time to control the latency. We run the pilot experiments on IWSLT15 En-Vi dataset and the results are shown as Table 8. Although this method doesn’t require training new model, it dramatically hurts the translation quality.
+
+Table 6: Detailed results for MMA-H and MMA-IL on WMT15 DeEn   
+
+<table><tr><td rowspan=1 colspan=1>BLEU  AP   AL   DAL</td></tr><tr><td rowspan=1 colspan=1>Xavg              MMA-IL</td></tr><tr><td rowspan=1 colspan=1>0.05   30.7   0.78  10.91  12.64</td></tr><tr><td rowspan=1 colspan=1>0.1    30.5   0.70  7.42   8.82</td></tr><tr><td rowspan=1 colspan=1>0.2    30.1   0.63  5.17   6.41</td></tr><tr><td rowspan=1 colspan=1>0.3    30.3   0.60  4.18   5.35</td></tr><tr><td rowspan=1 colspan=1>0.4    29.2   0.59  3.75   4.90</td></tr><tr><td rowspan=1 colspan=1>0.5    26.7   0.59  3.69   4.83</td></tr><tr><td rowspan=1 colspan=1>0.75   25.5   0.58  3.40   4.46</td></tr><tr><td rowspan=1 colspan=1>1.0   25.1   0.56  3.00   4.03</td></tr><tr><td rowspan=1 colspan=1>Xvar              MMA-H</td></tr><tr><td rowspan=1 colspan=1>0.1    28.5   0.74  8.94  10.83</td></tr><tr><td rowspan=1 colspan=1>0.2    28.9   0.69  6.82  8.622</td></tr><tr><td rowspan=1 colspan=1>0.3    29.2   0.64  5.45   7.03</td></tr><tr><td rowspan=1 colspan=1>0.4    28.5   0.59  3.90   5.21</td></tr><tr><td rowspan=1 colspan=1>0.5    28.5   0.59  3.88   5.19</td></tr><tr><td rowspan=1 colspan=1>0.6    29.6   0.56  3.13   4.32</td></tr><tr><td rowspan=1 colspan=1>0.7    29.1   0.56  2.93   4.10</td></tr></table>
+
+Table 7: Detailed results for MILk, MMA-H and MMA-IL on IWSLT15 En-Vi   
+
+<table><tr><td>BLEU</td><td></td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>入</td><td></td><td>MILk</td><td></td><td></td></tr><tr><td>0.1</td><td>24.62</td><td>0.71</td><td>5.93</td><td>7.19</td></tr><tr><td>0.2</td><td>24.68</td><td>0.67</td><td>4.90</td><td>5.97</td></tr><tr><td>0.3</td><td>24.31</td><td>0.65</td><td>4.45</td><td>5.43</td></tr><tr><td>0.4</td><td>23.73</td><td>0.64</td><td>4.28</td><td>5.24</td></tr><tr><td>Xaug</td><td></td><td>MMA-IL</td><td></td><td></td></tr><tr><td>0.02</td><td>28.28</td><td>0.76</td><td>7.09</td><td>8.29</td></tr><tr><td>0.04</td><td>28.33</td><td>0.70</td><td>5.44</td><td>6.57</td></tr><tr><td>0.1</td><td>28.42</td><td>0.67</td><td>4.63</td><td>5.65</td></tr><tr><td>0.2</td><td>28.47</td><td>0.63</td><td>3.57</td><td>4.44</td></tr><tr><td>0.3</td><td>27.9</td><td>0.59</td><td>2.98</td><td>3.81</td></tr><tr><td>0.4</td><td>27.73</td><td>0.58</td><td>2.68</td><td>3.46</td></tr><tr><td>Xuar</td><td></td><td>MMA-H</td><td></td><td></td></tr><tr><td>0.02</td><td>27.26</td><td>0.77</td><td>7.52</td><td>8.71</td></tr><tr><td>0.1</td><td></td><td></td><td>5.22</td><td>6.31</td></tr><tr><td></td><td>27.68</td><td>0.69</td><td>3.81</td><td></td></tr><tr><td>0.2</td><td>28.06</td><td>0.63</td><td></td><td>4.84</td></tr><tr><td>0.4</td><td>27.79</td><td>0.62</td><td>3.57</td><td>4.59</td></tr><tr><td>0.8</td><td>27.95</td><td>0.60</td><td>3.22</td><td>4.19</td></tr></table>
+
+# A.5 AVERAGE LOSS FOR MMA-H
+
+We explore applying a simple average instead of a weighted average loss to MMA-H. The results are shown in Figure 7 and Table 9. We find that even with very large weights, we are unable to reduce the overall latency. In addition, we find that the weighted average loss severely affects the translation quality negatively. On the other hand, the divergence loss we propose in Equation 16 can efficiently reduce the latency while retaining relatively good translation quality for MMA-H models.
+
+<table><tr><td colspan="6">Reading Threshold</td><td colspan="4">Weighted Average Latency Loss</td></tr><tr><td>p</td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td><td>Lavg</td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>0.5</td><td>25.5</td><td>0.792387</td><td>7.13673</td><td>8.27187</td><td>0.02</td><td>25.5</td><td>0.792387</td><td>7.13673</td><td>8.27187</td></tr><tr><td>0.4</td><td>25.25</td><td>0.73749</td><td>5.72003</td><td>6.85812</td><td>0.04</td><td>25.68</td><td>0.728107</td><td>5.52856</td><td>6.61744</td></tr><tr><td>0.3</td><td>23.06</td><td>0.697398</td><td>4.88087</td><td>6.03342</td><td>0.3</td><td>24.9</td><td>0.602703</td><td>2.90054</td><td>3.68039</td></tr><tr><td>0.2</td><td>18.37</td><td>0.678298</td><td>4.71099</td><td>5.94636</td><td>0.2</td><td>25.3</td><td>0.636914</td><td>3.54577</td><td>4.38623</td></tr><tr><td>0.1</td><td>8.73</td><td>0.696452</td><td>5.5225</td><td>7.20439</td><td>0.1</td><td>25.48</td><td>0.684424</td><td>4.57901</td><td>5.54102</td></tr></table>
+
+Table 8: Comparison between setting threshold for reading action and weighted average latency loss.
+
+![](images/aea53beea98c86b1baeb911bfa9ca93df3d5c23c9dfd3fe4f079a502cf059346.jpg)  
+Figure 7: Effect average loss, weighted average loss and variance loss on MMA-H on WMT15 DeEn development set.   
+Table 9: Detailed numbers on average loss, weighted average loss and head divergence loss on WMT15 De-En development set
+
+<table><tr><td></td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>Xaug</td><td colspan="4">Average</td></tr><tr><td>0.05</td><td>28.5</td><td>0.862581</td><td>14.3847</td><td>17.3702</td></tr><tr><td>0.1</td><td>27.8</td><td>0.855435</td><td>13.974</td><td>17.02</td></tr><tr><td>0.2</td><td>28</td><td>0.835324</td><td>12.8531</td><td>15.908</td></tr><tr><td>0.4</td><td>28.1</td><td>0.819408</td><td>11.9816</td><td>14.9763</td></tr><tr><td>1.0</td><td>28.2</td><td>0.810609</td><td>11.7528</td><td>14.6695</td></tr><tr><td>2.0</td><td>28.1</td><td>0.800258</td><td>11.1763</td><td>14.0761</td></tr><tr><td>8.0</td><td>28.4</td><td>0.806439</td><td>11.5289</td><td>14.6431</td></tr><tr><td>Xaug</td><td colspan="4">Weighted Average</td></tr><tr><td>0.02</td><td>28.24</td><td>0.773922</td><td>10.2109</td><td>12.2274</td></tr><tr><td>0.04</td><td>24.35</td><td>0.685834</td><td>7.06716</td><td>8.64069</td></tr><tr><td>0.06</td><td>7.80</td><td>0.875825</td><td>16.2046</td><td>19.0892</td></tr><tr><td>0.08</td><td>9.51</td><td>0.57372</td><td>3.92011</td><td>6.1421</td></tr><tr><td>0.1</td><td>9.78</td><td>0.556585</td><td>3.3007</td><td>5.46142</td></tr><tr><td>Xvar</td><td colspan="4">Divergence</td></tr><tr><td>0.1</td><td>27.35</td><td>0.736025</td><td>8.70968</td><td>10.5253</td></tr><tr><td>0.2</td><td>27.64</td><td>0.681491</td><td>6.63914</td><td>8.3856</td></tr><tr><td>0.3</td><td>27.37</td><td>0.6623</td><td>6.04902</td><td>7.71922</td></tr><tr><td>0.4</td><td>27.62</td><td>0.638188</td><td>5.31672</td><td>6.86834</td></tr><tr><td>0.5</td><td>27.50</td><td>0.625759</td><td>4.93044</td><td>6.38998</td></tr><tr><td>1.0</td><td>27.1</td><td>0.582194</td><td>3.64864</td><td>4.90997</td></tr></table>

parse/train/Hyg96gBKPS/Hyg96gBKPS_content_list.json

@@ -0,0 +1,1693 @@
+[
+    {
+        "type": "text",
+        "text": "MONOTONIC MULTIHEAD ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            633,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xutai $\\mathbf { M } \\mathbf { a } ^ { 2 }$ ∗, Juan Pino1, James Cross1, Liezl Puzon1, Jiatao $\\mathbf { G u } ^ { 1 }$ ",
+        "bbox": [
+            186,
+            143,
+            637,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Facebook   \n2Johns Hopkins University ",
+        "bbox": [
+            186,
+            166,
+            361,
+            195
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "xutai ma@jhu.edu, puzon@cs.stanford.edu {juancarabina,jcross,jgu}@fb.com ",
+        "bbox": [
+            186,
+            203,
+            565,
+            231
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            267,
+            544,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simultaneous machine translation models start generating a target sequence before they have encoded the source sequence. Recent approaches for this task either apply a fixed policy on a state-of-the art Transformer model, or a learnable monotonic attention on a weaker recurrent neural network-based structure. In this paper, we propose a new attention mechanism, Monotonic Multihead Attention (MMA), which extends the monotonic attention mechanism to multihead attention. We also introduce two novel and interpretable approaches for latency control that are specifically designed for multiple attention heads. We apply MMA to the simultaneous machine translation task and demonstrate better latency-quality tradeoffs compared to MILk, the previous state-of-the-art approach. We analyze how the latency controls affect the attention span and we study the relationship between the speed of a head and the layer it belongs to. Finally, we motivate the introduction of our model by analyzing the effect of the number of decoder layers and heads on quality and latency.1 ",
+        "bbox": [
+            233,
+            295,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            336,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simultaneous machine translation adds the capability of a live interpreter to machine translation: a simultaneous model starts generating a translation before it has finished reading the entire source sentence. Such models are useful in any situation where translation needs to be done in real time. For example, simultaneous models can translate live video captions or facilitate conversations between people speaking different languages. In a usual translation model, the encoder first reads the entire sentence, then the decoder writes the target sentence. On the other hand, a simultaneous neural machine translation model alternates between reading the input and writing the output using either a fixed or learned policy. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Monotonic attention mechanisms fall into the flexible policy category, in which the policies are automatically learned from data. Recent work exploring monotonic attention variants for simultaneous translation include: hard monotonic attention (Raffel et al., 2017), monotonic chunkwise attention (MoChA) (Chiu & Raffel, 2018) and monotonic infinite lookback attention (MILk) (Arivazhagan et al., 2019). MILk in particular has shown better quality/latency trade-offs than fixed policy approaches, such as wait- $k$ (Ma et al., 2019) or wait-if-\\* (Cho & Esipova, 2016) policies. MILk also outperforms hard monotonic attention and MoChA; while the other two monotonic attention mechanisms only consider a fixed window, MILk computes a softmax attention over all previous encoder states, which may be the key to its improved latency-quality tradeoffs. These monotonic attention approaches also provide a closed-form expression for the expected alignment between source and target tokens. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            814
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, monotonic attention-based models, including the state-of-the-art MILk, were built on top of RNN-based models. RNN-based models have been outperformed by the recent state-of-the-art Transformer model (Vaswani et al., 2017), which features multiple encoder-decoder attention layers and multihead attention at each layer. ",
+        "bbox": [
+            174,
+            821,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We thus propose monotonic multihead attention (MMA), which combines the high translation quality from multilayer multihead attention and low latency from monotonic attention. We propose two variants, Hard MMA (MMA-H) and Infinite Lookback MMA (MMA-IL). MMA-H is designed with streaming systems in mind where the attention span must be limited. MMA-IL emphasizes the quality of the translation system. We also propose two novel latency regularization methods. The first encourages the model to be faster by directly minimizing the average latency. The second encourages the attention heads to maintain similar positions, preventing the latency from being dominated by a single or a few heads. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of this paper are: (1) A novel monotonic attention mechanism, monotonic multihead attention, which enables the Transformer model to perform online decoding. This model leverages the power of the Transformer and the efficiency of monotonic attention. (2) Better latency/quality tradeoffs compared to the MILk model, the previous state-of-the-art, on two standard translation benchmarks, IWSLT15 English-Vietnamese (En-Vi) and WMT15 German-English (DeEn). (3) Analyses on how our model is able to control the attention span and on the relationship between the speed of a head and the layer it belongs to. We motivate the design of our model with an ablation study on the number of decoder layers and the number of decoder heads. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MONOTONIC MULTIHEAD ATTENTION MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            591,
+            369
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we review the monotonic attention-based approaches in RNN-based encoder-decoder models. We then introduce the two types of Monotonic Multihead Attention (MMA) for Transformer models: MMA-H and MMA-IL. Finally, we introduce strategies to control latency and coverage. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            426
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MONOTONIC ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            441,
+            390,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The hard monotonic attention mechanism (Raffel et al., 2017) was first introduced in order to achieve online linear time decoding for RNN-based encoder-decoder models. We denote the input sequence as $\\mathbf { x } = \\{ x _ { 1 } , . . . , x _ { T } \\}$ , and the corresponding encoder states as $\\mathbf { m } = \\{ m _ { 1 } , . . . , m _ { T } \\}$ , with $T$ being the length of the source sequence. The model generates a target sequence $\\mathbf { y } = \\{ y _ { 1 } , . . . , y _ { U } \\}$ with $U$ being the length of the target sequence. At the $i$ -th decoding step, the decoder only attends to one encoder state $m _ { t _ { i } }$ with $t _ { i } = j$ . When generating a new target token $y _ { i }$ , the decoder chooses whether to move one step forward or to stay at the current position based on a Bernoulli selection probability $p _ { i , j }$ , so that $t _ { i } \\ \\geq \\ t _ { i - 1 }$ . Denoting the decoder state at the $i$ -th position, starting from $j = t _ { i - 1 } , t _ { i - 1 } + 1 , t _ { i - 1 } + 2 , . . . _ $ , this process can be calculated as follows: 2 ",
+        "bbox": [
+            173,
+            467,
+            825,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e00e4ac01ca17148a42234276fd2bfe3915f021f95dc26ea66ee0c9a33d3eed.jpg",
+        "text": "$$\n\\begin{array} { l c l } { e _ { i , j } } & { = } & { \\mathrm { M o n o t o n i c E n e r g y } ( s _ { i - 1 } , m _ { j } ) } \\\\ { p _ { i , j } } & { = } & { \\mathrm { S i g m o i d } \\left( e _ { i , j } \\right) } \\\\ { z _ { i , j } } & { \\sim } & { \\mathrm { B e r n o u l l i } ( p _ { i , j } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            598,
+            630,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When $z _ { i , j } = 1$ , we set $t _ { i } = j$ and start generating a target token $y _ { i }$ ; otherwise, we set $t _ { i } = j + 1$ and repeat the process. During training, an expected alignment $_ { \\pmb { \\alpha } }$ is introduced to replace the softmax attention. It can be calculated in a recurrent manner, shown in Equation 4: ",
+        "bbox": [
+            174,
+            655,
+            825,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9fcfcb3331ff46aa76bca6824b0c78a69ca6768a0880249b79da62fe5c67246e.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\alpha _ { i , j } = p _ { i , j } \\sum _ { k = 1 } ^ { j } \\left( \\alpha _ { i - 1 , k } \\prod _ { l = k } ^ { j - 1 } \\left( 1 - p _ { i , l } \\right) \\right) } \\\\ { \\displaystyle = p _ { i , j } \\left( \\left( 1 - p _ { i , j - 1 } \\right) \\frac { \\alpha _ { i , j - 1 } } { p _ { i , j - 1 } } + \\alpha _ { i - 1 , j } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            699,
+            645,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Raffel et al. (2017) also introduce a closed-form parallel solution for the recurrence relation in Equation 5: ",
+        "bbox": [
+            171,
+            781,
+            825,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0260ef1810c1eebfba3c0000f312b7b966bc53ade5ae602fbde952ecf9512af.jpg",
+        "text": "$$\n\\alpha _ { i , : } = p _ { i , : } \\mathrm { c u m p r o d } ( 1 - p _ { i , : } ) \\mathrm { c u m s u m } \\left( \\frac { \\alpha _ { i - 1 , : } } { \\mathrm { c u m p r o d } ( 1 - p _ { i , : } ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            806,
+            709,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\mathtt { c u m p r o d } ( x ) = [ 1 , x _ { 1 } , x _ { 1 } x _ { 2 } , . . . , \\prod _ { i = 1 } ^ { | x | - 1 } x _ { i } ] } \\end{array}$ and $\\mathsf { c u m s u m } ( { \\pmb x } ) = [ x _ { 1 } , x _ { 1 } + x _ { 2 } , . . . , \\sum _ { i = 1 } ^ { | { \\pmb x } | } x _ { i } ]$ In practice, the denominator in Equation 5 is clamped into a range of [\u000f, 1] to avoid numerical instabilities introduced by cumprod. Although this monotonic attention mechanism achieves online linear time decoding, the decoder can only attend to one encoder state. This limitation can diminish translation quality as there may be insufficient information for reordering. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the model lacks a mechanism to adjust latency based on different requirements at decoding time. To address these issues, Chiu & Raffel (2018) introduce Monotonic Chunkwise Attention (MoChA), which allows the decoder to apply softmax attention to a fixed-length subsequence of encoder states. Alternatively, Arivazhagan et al. (2019) introduce Monotonic Infinite Lookback Attention (MILk) which allows the decoder to access encoder states from the beginning of the source sequence. The expected attention for the MILk model is defined in Equation 6. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78bfc0bec32bf57998374bb3d9fd4320e604813236b365050f7ae485aaf76c8b.jpg",
+        "text": "$$\n\\beta _ { i , j } = \\sum _ { k = j } ^ { | x | } \\left( \\frac { \\alpha _ { i , k } \\exp ( u _ { i , j } ) } { \\sum _ { l = 1 } ^ { k } \\exp ( u _ { i , l } ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            227,
+            602,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 MONOTONIC MULTIHEAD ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            480,
+            301
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous monotonic attention approaches are based on RNN encoder-decoder models with a single attention and haven’t explored the power of the Transformer model. 3 The Transformer architecture (Vaswani et al., 2017) has recently become the state-of-the-art for machine translation (Barrault et al., 2019). An important feature of the Transformer is the use of a separate multihead attention module at each layer. Thus, we propose a new approach, Monotonic Multihead Attention (MMA), which combines the expressive power of multihead attention and the low latency of monotonic attention. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            410
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multihead attention allows each decoder layer to have multiple heads, where each head can compute a different attention distribution. Given queries $Q$ , keys $K$ and values $V$ , multihead attention MultiHead $( Q , K , V )$ is defined in Equation 7. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de1d1097b118ce2087ff6b092be4c6925950224ebff552137d1e4295e9316fbe.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { l } { \\mathrm { M u l t i H e a d } ( Q , K , V ) = \\mathrm { C o n c a t } ( \\mathrm { h e a d } _ { 1 } , . . . , \\mathrm { h e a d } _ { H } ) W ^ { O } } \\\\ { \\mathrm { w h e r e ~ h e a d } _ { h } = \\mathrm { A t t e n t i o n } \\left( Q W _ { h } ^ { Q } , K W _ { h } ^ { K } , V W _ { h } ^ { V } , \\right) } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            463,
+            691,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The attention function is the scaled dot-product attention, defined in Equation 8: ",
+        "bbox": [
+            174,
+            512,
+            699,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d323037e45d49bd45cbb4027ffc444fe6c4f1f38ef8e2f5e64f180bada2e268.jpg",
+        "text": "$$\n{ \\mathrm { A t t e n t i o n } } ( Q , K , V ) = { \\mathrm { S o f t m a x } } \\left( { \\frac { Q K ^ { T } } { \\sqrt { d _ { k } } } } \\right) V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            530,
+            647,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are three applications of multihead attention in the Transformer model: ",
+        "bbox": [
+            173,
+            566,
+            681,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. The Encoder contains self-attention layers where all of the queries, keys and values come from previous layers.   \n2. The Decoder contains self-attention layers that allow each position in the decoder to attend to all positions in the decoder up to and including that position.   \n3. The Encoder-Decoder attention contains multihead attention layers where queries come from the previous decoder layer and the keys and values come from the output of the encoder. Every decoder layer has a separate encoder-decoder attention. ",
+        "bbox": [
+            212,
+            590,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For MMA, we assign each head to operate as a separate monotonic attention in encoder-decoder attention. ",
+        "bbox": [
+            173,
+            708,
+            821,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a transformer with $L$ decoder layers and $H$ attention heads per layer, we define the selection process of the $h$ -th head encoder-decoder attention in the $l$ -th decoder layer as ",
+        "bbox": [
+            173,
+            743,
+            823,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06a1000b3fd8419e67564e93aa659485bec477830abd46b839218bb915b6434b.jpg",
+        "text": "$$\n\\begin{array} { l c l } { e _ { i , j } ^ { { l , h } } } & { = } & { \\left( \\frac { m _ { j } W _ { { l , h } } ^ { K } ( s _ { i - 1 } W _ { { l , h } } ^ { Q } ) ^ { T } } { \\sqrt { d _ { k } } } \\right) _ { i , j } } \\\\ { p _ { i , j } ^ { { l , h } } } & { = } & { \\mathrm { S i g m o i d } ( e _ { i , j } ) } \\\\ { z _ { i , j } ^ { { l , h } } } & { \\sim } & { \\mathrm { B e r n o u l l i } ( p _ { i , j } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            775,
+            625,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d597335b4efb8a0b81899a74e4bee9cd4514669123bca34eef86fbf7c1b7c310.jpg",
+        "image_caption": [
+            "Figure 1: Monotonic Attention (Left) versus Monotonic Multihead Attention (Right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            97,
+            730,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { l , h }$ is the input projection matrix, $d _ { k }$ is the dimension of the attention head. We make the selection process independent for each head in each layer. We then investigate two types of MMA, MMA-H(ard) and MMA-IL(infinite lookback). For MMA-H, we use Equation 4 in order to calculate the expected alignment for each layer each head, given $p _ { i , j } ^ { l , h }$ . For MMA-IL, we calculate the softmax energy for each head as follows: ",
+        "bbox": [
+            174,
+            229,
+            825,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76dbee94d92d243f0b5d5234e42d63c1c42aef73bfbee0d4196977dd708667e3.jpg",
+        "text": "$$\nu _ { i , j } ^ { l , h } = \\mathrm { S o f t E n e r g y } = \\left( \\frac { m _ { j } \\hat { W } _ { l , h } ^ { K } ( s _ { i - 1 } \\hat { W } _ { l , h } ^ { Q } ) ^ { T } } { \\sqrt { d _ { k } } } \\right) _ { i , j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            309,
+            647,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and then use Equation 6 to calculate the expected attention. Each attention head in MMA-H hardattends to one encoder state. On the other hand, each attention head in MMA-IL can attend to all previous encoder states. Thus, MMA-IL allows the model to leverage more information for translation, but MMA-H may be better suited for streaming systems with stricter efficiency requirements. Finally, our models use unidirectional encoders: the encoder self-attention can only attend to previous states, which is also required for simultaneous translation. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At inference time, our decoding strategy is shown in Algorithm 1. For each $l , h$ , at decoding step $i$ , we apply the sampling processes discussed in subsection 2.1 individually and set the encoder step at $t _ { i } ^ { l , \\bar { h } }$ . Then a hard alignment or partial softmax attention from encoder states, shown in Equation 13, will be retrieved to feed into the decoder to generate the $i$ -th token. The model will write a new target token only after all the attentions have decided to write. In other words, the heads that have decided to write must wait until the others have finished reading. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/55a64c3eb31107e09be4521a10e290bda8cf5aa3c978766c5de794153806eee4.jpg",
+        "text": "$$\n\\begin{array}{c} \\begin{array} { r l } & { \\qquad c _ { i } ^ { l } = \\mathrm { C o n c a t } ( c _ { i } ^ { l , 1 } , c _ { i } ^ { l , 2 } , . . . , c _ { i } ^ { l , H } ) } \\\\ & { \\qquad \\mathrm \\quad \\mathbf { \\ \" } } \\\\ & { \\qquad \\mathbf { \\ \" } \\mathbf { \\ \" } e _ { i } ^ { l , h } = f _ { \\mathrm { c o n t e x t } } ( \\boldsymbol { h } , t _ { i } ^ { l , h } ) = \\displaystyle \\left\\{ \\sum _ { j = 1 } ^ { m _ { t _ { i } ^ { l , h } } } \\frac { \\mathrm { e x p } \\left( u _ { i , j } ^ { l , h } \\right) } { \\sum _ { j = 1 } ^ { t _ { i } ^ { l , h } } \\mathrm { e x p } \\left( u _ { i , j } ^ { l , h } \\right) } m _ { j } \\quad \\mathrm { M M A \\mathrm { - } I L } \\right.} \\end{array}   \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            542,
+            733,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates a comparison between our model and the monotonic model with one attention head. Compared with the monotonic model, the MMA model is able to set attention to different positions so that it can still attend to previous states while reading each new token. Each head can adjust its speed on-the-fly. Some heads read new inputs, while the others can stay in the past to retain the source history information. Even with the hard alignment variant (MMA-H), the model is still able to preserve the history information by setting heads to past states. In contrast, the hard monotonic model, which only has one head, loses the previous information at the attention layer. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            755
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 LATENCY CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            352,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Effective simultaneous machine translation must balance quality and latency. At a high level, latency measures how many source tokens the model has read until a translation is generated. The model we have introduced in subsection 2.2 is not able to control latency on its own. While MMA allows simultaneous translation by having a read or write schedule for each head, the overall latency is determined by the fastest head, i.e. the head that reads the most. It is possible that a head always reads new input without producing output, which would result in the maximum possible latency. Note that the attention behaviors in MMA-H and MMA-IL can be different. In MMA-IL, a head reaching the end of the sentence will provide the model with maximum information about the source sentence. On the other hand, in the case of MMA-H, reaching the end of sentence for a head only ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 MMA monotonic decoding. Because each head is independent, we compute line 3 to 16 in parallel ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: ${ \\bf { \\delta } } _ { \\bf { \\mathcal { X } } } =$ source tokens, $h =$ encoder states, $i = 1 , j = 1 , t _ { 0 } ^ { l , h } = 1 , y _ { 0 } =$ StartOfSequence. ",
+        "bbox": [
+            174,
+            137,
+            735,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d3ce67f84553fcb769a11cd9c9b6bc0f2cc38f43189af848cae8c2b15b180a38.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">1:while yi-1 ≠ EndOfSequence do</td></tr><tr><td>2:</td><td>tmax =1</td><td></td></tr><tr><td>3:</td><td>h = empty sequence</td><td></td></tr><tr><td>4:</td><td>forl←1toLdo</td><td></td></tr><tr><td>5:</td><td>forh←1to Hdo</td><td></td></tr><tr><td>6:</td><td>forj←ttoacldo</td><td></td></tr><tr><td>7:</td><td>l,h Pi,j, = Sigmoid (MonotonicEnergy(Si-1,mj ))</td><td></td></tr><tr><td>8:</td><td>ifpi l,h &gt; 0.5 then</td><td></td></tr><tr><td>9:</td><td>=j</td><td></td></tr><tr><td>10:</td><td>l,h =fcontext(h,t,h）</td><td></td></tr><tr><td>11:</td><td>Ci Break</td><td></td></tr><tr><td>12:</td><td>else</td><td></td></tr><tr><td>13:</td><td>if j&gt;tmax then</td><td></td></tr><tr><td>14:</td><td>Read token x j</td><td></td></tr><tr><td>15:</td><td></td><td>Calculate state h j and append to h</td></tr><tr><td>16:</td><td>tmax =j</td><td></td></tr><tr><td>17:</td><td>c = Concat(c,1,</td><td>,cH）</td></tr><tr><td>18:</td><td>s =DecoderLayer&#x27;(s-1,s)</td><td></td></tr><tr><td>19:</td><td>yi = Output(s)</td><td></td></tr><tr><td>20:</td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            148,
+            830,
+            430
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "gives a hard alignment to the end-of-sentence token, which provides very little information to the decoder. Furthermore, it is possible that an MMA-H attention head stays at the beginning of sentence without moving forward. Such a head would not cause latency issues but would degrade the model quality since the decoder would not have any information about the input. In addition, this behavior is not suited for streaming systems. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To address these issues, we introduce two latency control methods. The first one is weighted average latency, shown in Equation 14: ",
+        "bbox": [
+            173,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbc1c8df2033f3a8bb69ca4c0b77443bdc70f12f5d733fc36d65bd4af90e8f1b.jpg",
+        "text": "$$\ng _ { i } ^ { W } = \\frac { \\exp ( g _ { i } ^ { l , h } ) } { \\sum _ { l = 1 } ^ { L } \\sum _ { h = 1 } ^ { H } \\exp ( g _ { i } ^ { l , h } ) } g _ { i } ^ { l , h }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            561,
+            611,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { g _ { i } ^ { l , h } = \\sum _ { j = 1 } ^ { | x | } j \\alpha _ { i , j } } \\end{array}$ . Then we calculate the latency loss with a differentiable latency metric $\\mathcal { C }$ ",
+        "bbox": [
+            171,
+            608,
+            821,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fb597bba8952ce63096825ef7fd9a9f8875bf203ed1269e09e958a57183435b.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { L _ { a v g } } } & { { = } } & { { { \\mathcal { C } } \\left( g ^ { W } \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            628,
+            565,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Like Arivazhagan et al. (2019), we use the Differentiable Average Lagging. It is important to note that, unlike the original latency augmented training in Arivazhagan et al. (2019), Equation 15 is not the expected latency metric given $\\mathcal { C }$ , but weighted average $\\mathcal { C }$ on all the attentions. The real expected latency is $\\hat { \\pmb g } = \\mathrm { m a x } _ { l , h } \\left( \\pmb g ^ { l , h } \\right)$ instead of $\\bar { \\pmb { g } }$ , but using this directly would only affect the speed of the fastest head. Equation 15 can control every head in a way that the faster heads will be automatically assigned to larger weights and slower heads will also be moderately regularized. For MMA-H models, we found that the latency of are mainly due to outliers that skip almost every token. The weighted average latency loss is not sufficient to control the outliers. We therefore introduce the head divergence loss, the average variance of expected delays at each step, defined in Equation 16: ",
+        "bbox": [
+            173,
+            651,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d133be55bb9c06500803d6386f5b6eccc9edfd580fd7b016a14f265bd0e6ae51.jpg",
+        "text": "$$\n\\begin{array} { c c l } { { { \\cal L } _ { v a r } } } & { { = } } & { { \\displaystyle \\frac { 1 } { L H } \\sum _ { l = 1 } ^ { L } \\sum _ { h = 1 } ^ { H } \\left( g _ { i } ^ { l , h } - \\bar { g } _ { i } \\right) ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            780,
+            624,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\bar { g _ { i } } = \\frac { 1 } { L H } \\sum g _ { i } } \\end{array}$ The final objective function is presented in Equation 17: ",
+        "bbox": [
+            171,
+            828,
+            683,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b3bedce76971cb30dbdf17af15e5198dd875394ef3d36c4eb5806191c3ef503.jpg",
+        "text": "$$\nL ( \\theta ) = - \\log ( \\pmb { y } \\mid \\pmb { x } ; \\theta ) + \\lambda _ { a v g } L _ { a v g } + \\lambda _ { v a r } L _ { v a r }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            847,
+            660,
+            864
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { a v g } , \\lambda _ { v a r }$ are hyperparameters that control both losses. Intuitively, while $\\lambda _ { a v g }$ controls the overall speed, $\\lambda _ { v a r }$ controls the divergence of the heads. Combining these two losses, we are able to dynamically control the range of attention heads so that we can control the latency and the reading buffer. For MMA-IL model, we only use $L _ { a v g }$ ; for MMA-H we only use $L _ { v a r }$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            375,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our model using quality and latency. For translation quality, we use tokenized BLEU 4 for IWSLT15 En-Vi and detokenized BLEU with SacreBLEU (Post, 2018) for WMT15 De-En. For latency, we use three different recent metrics, Average Proportion (AP) (Cho & Esipova, 2016), Average Lagging (AL) (Ma et al., 2019) and Differentiable Average Lagging (DAL) (Arivazhagan et al., 2019) 5. We remind the reader of the metric definitions in Appendix A.2. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            246,
+            287,
+            260
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4adcb998588a1deeeefc79d3a485af2e00f0490e81384c1c82b26e2507977b3.jpg",
+        "table_caption": [
+            "Table 1: Number of sentences in each split. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Train</td><td>Validation</td><td>Test</td></tr><tr><td>IWSLT15 En-Vi</td><td>133k</td><td>1268</td><td>1553</td></tr><tr><td>WMT15 De-En</td><td>4.5M</td><td>3000</td><td>2169</td></tr></table>",
+        "bbox": [
+            348,
+            273,
+            647,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5a20b82351116b7130fbb23c91d9e020a3379820bc239f4a9c9b9c1744ddac41.jpg",
+        "table_caption": [
+            "Table 2: Offline model performance with unidirectional encoder and greedy decoding. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>RNN</td><td>Transformer</td></tr><tr><td>IWSLT15 En-Vi</td><td>25.66</td><td>28.7</td></tr><tr><td>WMT15 De-En</td><td>28.4 (Arivazhagan et al., 2019)</td><td>32.3</td></tr></table>",
+        "bbox": [
+            289,
+            352,
+            702,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3318ac05024d09cb9e614ffff33ca527e2945c2fe72be0d076ab05741cb6c556.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Effect of using a unidirectional encoder and greedy decoding to BLEU score. "
+        ],
+        "table_body": "<table><tr><td>Dataset</td><td>Beam Search</td><td>Bidirectional Encoder</td><td>Unidirectional Encoder</td></tr><tr><td rowspan=\"2\">WMT15 De-En</td><td>1</td><td>32.6</td><td>32.3</td></tr><tr><td>4</td><td>33.0</td><td>33.0</td></tr><tr><td rowspan=\"2\">IWSLT15 En-Vi</td><td>1</td><td>28.7</td><td>29.4</td></tr><tr><td>10</td><td>28.8</td><td>29.5</td></tr></table>",
+        "bbox": [
+            236,
+            431,
+            758,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on two standard machine translation datasets, IWSLT14 En-Vi and WMT15 De-En. Statistics of the datasets can be found in Table 1. For each dataset, we apply tokenization with the Moses (Koehn et al., 2007) tokenizer and preserve casing. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IWSLT15 English-Vietnamese TED talks from IWSLT 2015 Evaluation Campaign (Cettolo et al., 2016). We follow the settings from Luong & Manning (2015) and Raffel et al. (2017). We replace words with frequency less than 5 by $< u n k >$ . We use tst2012 as a validation set tst2013 as a test set. ",
+        "bbox": [
+            174,
+            593,
+            821,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "WMT15 German-English We follow the setting from Arivazhagan et al. (2019). We apply byte pair encoding (BPE) (Sennrich et al., 2016) jointly on the source and target to construct a shared vocabulary with 32K symbols. We use newstest2013 as validation set and newstest2015 as test set. ",
+        "bbox": [
+            174,
+            638,
+            821,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            698,
+            276,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate MMA-H and MMA-IL models on both datasets. The MILK model we evaluate on IWSLT15 En-Vi is based on Luong et al. (2015) rather than RNMT $^ +$ (Chen et al., 2018). In general, our offline models use unidirectional encoders, i.e. the encoder self-attention can only attend to previous states, and greedy decoding. We report offline model performance in Table 2 and the effect of using unidirectional encoders and greedy decoding in Table 3. For MMA models, we replace the encoder-decoder layers with MMA and keep other hyperparameter settings the same as the offline model. Detailed hyperparameter settings can be found in subsection A.1. We use the Fairseq library (Ott et al., 2019) for our implementation. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            281,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the main results of our model in terms of latency-quality tradeoffs, ablation studies and analyses. In the first study, we analyze the effect of the variance loss on the attention span. Then, we study the effect of the number of decoder layers and decoder heads on quality and latency. We also provide a case study for the behavior of attention heads in an example. Finally, we study the relationship between the rank of an attention head and the layer it belongs to. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e122b7036362526ca9df24fd1d502cd25f56d35adb6686383751be035f195e06.jpg",
+        "image_caption": [
+            "Figure 2: Latency-quality tradeoffs for MILk (Arivazhagan et al., 2019) and MMA on IWSLT15 En-Vi and WMT15 De-En. Black dashed line indicates the unidirectional offline transformer model with greedy search. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            224,
+            808,
+            465
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 LATENCY-QUALITY TRADEOFFS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            437,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We plot the quality-latency curves for MMA-H and MMA-IL in Figure 2. The BLEU and latency scores on the test sets are generated by setting a latency range and selecting the checkpoint with best BLEU score on the validation set. We use differentiable average lagging (Arivazhagan et al., 2019) when setting the latency range. We find that for a given latency, our models obtain a better translation quality. While MMA-IL tends to have a decrease in quality as the latency decreases, MMA-H has a small gain in quality as latency decreases: a larger latency does not necessarily mean an increase in source information available to the model. In fact, the large latency is from the outlier attention heads, which skip the entire source sentence and point to the end of the sentence. The outliers not only increase the latency but they also do not provide useful information. We introduce the attention variance loss to eliminate the outliers, as such a loss makes the attention heads focus on the current context for translating the new target token. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            726
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is interesting to observe that MMA-H has a better latency-quality tradeoff than $\\mathrm { M I L K } ^ { 7 }$ even though each head only attends to only one state. Although MMA-H is not yet able to handle an arbitrarily long input (without resorting to segmenting the input), since both encoder and decoder self-attention have an infinite lookback, that model represents a good step in that direction. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 ATTENTION SPAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            338,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In subsection 2.3, we introduced the attention variance loss to MMA-H in order to prevent outlier attention heads from increasing the latency or increasing the attention span. We have already evaluated the effectiveness of this method on latency in subsection 4.1. We also want to measure the difference between the fastest and slowest heads at each decoding step. We define the average ",
+        "bbox": [
+            174,
+            837,
+            825,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "attention span in Equation 18: ",
+        "bbox": [
+            174,
+            103,
+            370,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/abf4018244aad5899baee17fe91fedebf02e95cb4d0f3e9cc679c572b65b9cc5.jpg",
+        "text": "$$\n\\bar { S } = \\frac { 1 } { \\vert \\pmb { y } \\vert } \\left( \\sum _ { i } ^ { \\vert \\pmb { y } \\vert } \\underset { l , h } { \\operatorname* { m a x } } t _ { i } ^ { l , h } - \\underset { l , h } { \\operatorname* { m i n } } t _ { i } ^ { l , h } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            126,
+            620,
+            176
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It estimates the reading buffer we need for streaming translation. We show the relation between the average attention span versus $\\lambda _ { v a r }$ in Figure 3. As expected, the average attention span is reduced as we increase $\\lambda _ { v a r }$ . ",
+        "bbox": [
+            174,
+            183,
+            825,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f751c2faf86a11373cba7cf525d322dc182947f9c6a18f187c49c68d5fad146.jpg",
+        "image_caption": [
+            "Figure 3: Effect of $\\lambda _ { v a r }$ on the average attention span. The variance loss works as intended by reducing the span with higher weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            239,
+            710,
+            351
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT ON NUMBER OF LAYERS AND NUMBER OF HEADS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            611,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One motivation to introduce MMA is to adapt the Transformer, which is the current state-of-the-art model for machine translation, to online decoding. Important features of the Transformer architecture include having a separate attention layer for each decoder layer block and multihead attention. In this section, we test the effect of these two components on the offline, MMA-H, and MMA-IL models from a quality and latency perspective. We report quality as measured by detokenized BLEU and latency as measured by DAL on the WMT13 validation set in Figure 4. We set $\\lambda _ { a v g } = 0 . 2$ for MMA-IL and $\\lambda _ { v a r } = 0 . 2$ for MMA-H. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            550
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The offline model benefits from having more than one decoder layer. In the case of 1 decoder layer, increasing the number of attention heads is beneficial but in the case of 3 and 6 decoder layers, we do not see much benefit from using more than 2 heads. The best performance is obtained for 3 layers and 2 heads (6 effective heads). The MMA-IL model behaves similarly to the offline model, and the best performance is observed with 6 layers and 4 heads (24 effective heads). For MMA-H, with 1 layer, performance improves with more heads. With 3 layers, the single-head setting is the most effective (3 effective heads). Finally, with 6 layers, the best performance is reached with 16 heads (96 effective heads). ",
+        "bbox": [
+            174,
+            558,
+            825,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The general trend we observe is that performance improves as we increase the number of effective heads, either from multiple layers or multihead attention, up to a certain point, then either plateaus or degrades. This motivates the introduction of the MMA model. ",
+        "bbox": [
+            176,
+            676,
+            821,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also note that latency increases with the number of effective attention heads. This is due to having fixed loss weights: when more heads are involved, we should increase $\\lambda _ { v a r }$ or $\\lambda _ { a v g }$ to better control latency. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ATTENTION BEHAVIORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            380,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We characterize attention behaviors by providing a running example of MMA-H and MMA-IL, shown in Figure 5. Each curve represents the path that an attention head goes through at inference time. For MMA-H, shown in Figure 5a, we found that when the source and target tokens have the same order, the attention heads behave linearly and the distance between fastest head and slowest head is small. For example, this can be observed from partial sentence pair “I also didn’t know that” and target tokens “Tôi cũng không biết rằng”, which have the same order. However, when the source tokens and target tokens have different orders, such as “the second step” and “bước (step) thứ hai (second)”, the model will generate “bước (step)” first and some heads will stay in the past to retain the information for later reordered translation “thứ hai (second)”. We can also see that the attention heads have a near-diagonal trajectory, which is appropriate for streaming inputs. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/587b8944db8cce31706c574a36a9ec6d40a868064c34c383e996803aed29b0b0.jpg",
+        "image_caption": [
+            "Figure 4: Effect of the number of decoder attention heads and the number of decoder attention layers on quality and latency, reported on the WMT13 validation set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            103,
+            810,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            412,
+            821,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The behavior of the heads in MMA-IL models is shown in Figure 5b. Notice that we remove the partial softmax alignment in this figure. We don’t expect streaming capability for MMA-IL: some heads stop at early position of the source sentence to retain the history information. Moreover, because MMA-IL has more information when generating a new target token, it tends to produce translations with better quality. In this example, the MMA-IL model has a better translation on “isolate the victim” than MMA-H (“là cô lập nạn nhân” vs “là tách biệt nạn nhân”) ",
+        "bbox": [
+            174,
+            448,
+            825,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9caf5f55023339b16fb95b389bc65cc48ec79600f2fc76d230026679d0627e7.jpg",
+        "image_caption": [
+            "Figure 5: Running examples on IWSLT15 English-Vietnamese dataset "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            550,
+            758,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 RANK OF THE HEADS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            362,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we calculate the average and standard deviation of rank of each head when generating every target token. For MMA-IL, we find that heads in lower layers tend to have higher rank and are thus slower. However, in MMA-H, the difference of the average rank are smaller. Furthermore, the standard deviation is very large which means that the order of the heads in MMA-H changes frequently over the inference process. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/945370a5e1d53aa3ee0f21fc5e5f3110a0171fb97a8e1797f201cb0464090bba.jpg",
+        "image_caption": [
+            "Figure 6: The average rank of attention heads during inference on IWSLT15 En-Vi. Error bars indicate the standard deviation. L indicates the layer number and $\\mathrm { H }$ indicates the head number. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            101,
+            754,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            344,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Recent work on simultaneous machine translation falls into three categories. In the first one, models use a rule-based policy for reading input and writing output. Cho & Esipova (2016) propose a WaitIf-\\* policy to enable an offline model to decode simultaneously. Ma et al. (2019) propose a wait- $k$ policy where the model first reads $k$ tokens, then alternates between read and write actions. Dalvi et al. (2018) propose an incremental decoding method, also based on a rule-based schedule. In the second category, a flexible policy is learnt from data. Grissom II et al. (2014) introduce a Markov chain to phrase-based machine translation models for simultaneous machine translation, in which they apply reinforcement learning to learn the read-write policy based on states. Gu et al. (2017) introduce an agent which learns to make decisions on when to translate from the interaction with a pre-trained offline neural machine translation model. Luo et al. (2017) used continuous rewards policy gradient for online alignments for speech recognition. Lawson et al. (2018) proposed a hard alignment with variational inference for online decoding. Alinejad et al. (2018) propose a new operation ”predict” which predicts future source tokens. Zheng et al. (2019b) introduce a restricted dynamic oracle and restricted imitation learning for simultaneous translation. Zheng et al. (2019a) train the agent with an action sequence from labels that are generated based on the rank of the gold target word given partial input. Models from the last category leverage monotonic attention and replace the softmax attention with an expected attention calculated from a stepwise Bernoulli selection probability. Raffel et al. (2017) first introduce the concept of monotonic attention for online linear time decoding, where the attention only attends to one encoder state at a time. Chiu & Raffel (2018) extended that work to let the model attend to a chunk of encoder state. Arivazhagan et al. (2019) also make use of the monotonic attention but introduce an infinite lookback to improve the translation quality. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            698
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            318,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose two variants of the monotonic multihead attention model for simultaneous machine translation. By introducing two new targeted loss terms which allow us to control both latency and attention span, we are able to leverage the power of the Transformer architecture to achieve better quality-latency trade-offs than the previous state-of-the-art model. We also present detailed ablation studies demonstrating the efficacy and rationale of our approach. By introducing these stronger simultaneous sequence-to-sequence models, we hope to facilitate important applications, such as high-quality real-time interpretation between human speakers. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashkan Alinejad, Maryam Siahbani, and Anoop Sarkar. Prediction improves simultaneous neural machine translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 3022–3027, 2018. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Naveen Arivazhagan, Colin Cherry, Wolfgang Macherey, Chung-Cheng Chiu, Semih Yavuz, Ruoming Pang, Wei Li, and Colin Raffel. Monotonic infinite lookback attention for simultaneous machine translation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 1313–1323, Florence, Italy, July 2019. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P19-1126. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lo¨ıc Barrault, Ondˇrej Bojar, Marta R. Costa-jussa, Christian Federmann, Mark Fishel, Yvette \\` Graham, Barry Haddow, Matthias Huck, Philipp Koehn, Shervin Malmasi, Christof Monz, Mathias Muller, Santanu Pal, Matt Post, and Marcos Zampieri. Findings of the 2019 con- ¨ ference on machine translation (WMT19). In Proceedings of the Fourth Conference on Machine Translation (Volume 2: Shared Task Papers, Day 1), pp. 1–61, Florence, Italy, August 2019. Association for Computational Linguistics. doi: 10.18653/v1/W19-5301. URL https://www.aclweb.org/anthology/W19-5301. ",
+        "bbox": [
+            173,
+            255,
+            825,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mauro Cettolo, Niehues Jan, Stuker Sebastian, Luisa Bentivogli, Roldano Cattoni, and Marcello ¨ Federico. The iwslt 2016 evaluation campaign. In International Workshop on Spoken Language Translation, 2016. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mia Xu Chen, Orhan Firat, Ankur Bapna, Melvin Johnson, Wolfgang Macherey, George Foster, Llion Jones, Mike Schuster, Noam Shazeer, Niki Parmar, et al. The best of both worlds: Combining recent advances in neural machine translation. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 76–86, 2018. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. 2018. URL https:// openreview.net/pdf?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ Hko85plCW. ",
+        "bbox": [
+            168,
+            478,
+            821,
+            506
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho and Masha Esipova. Can neural machine translation do simultaneous translation? arXiv preprint arXiv:1606.02012, 2016. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fahim Dalvi, Nadir Durrani, Hassan Sajjad, and Stephan Vogel. Incremental decoding and training methods for simultaneous translation in neural machine translation. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), pp. 493–499, New Orleans, Louisiana, June 2018. Association for Computational Linguistics. doi: 10.18653/v1/N18-2079. URL https://www.aclweb.org/anthology/N18-2079. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alvin Grissom II, He He, Jordan Boyd-Graber, John Morgan, and Hal Daume III. Don’t until the ´ final verb wait: Reinforcement learning for simultaneous machine translation. In Proceedings of the 2014 Conference on empirical methods in natural language processing (EMNLP), pp. 1342– 1352, 2014. ",
+        "bbox": [
+            173,
+            645,
+            826,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Graham Neubig, Kyunghyun Cho, and Victor OK Li. Learning to translate in real-time with neural machine translation. In 15th Conference of the European Chapter of the Association for Computational Linguistics, EACL 2017, pp. 1053–1062. Association for Computational Linguistics (ACL), 2017. ",
+        "bbox": [
+            173,
+            709,
+            825,
+            766
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Philipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondˇrej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open source toolkit for statistical machine translation. In Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics Companion Volume Proceedings of the Demo and Poster Sessions, pp. 177–180, Prague, Czech Republic, June 2007. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P07-2045. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dieterich Lawson, Chung-Cheng Chiu, George Tucker, Colin Raffel, Kevin Swersky, and Navdeep Jaitly. Learning hard alignments with variational inference. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5799–5803. IEEE, 2018. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuping Luo, Chung-Cheng Chiu, Navdeep Jaitly, and Ilya Sutskever. Learning online alignments with continuous rewards policy gradient. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 2801–2805. IEEE, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong and Christopher D Manning. Stanford neural machine translation systems for spoken language domains. 2015. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. arXiv preprint arXiv:1508.04025, 2015. ",
+        "bbox": [
+            174,
+            191,
+            821,
+            220
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingbo Ma, Liang Huang, Hao Xiong, Renjie Zheng, Kaibo Liu, Baigong Zheng, Chuanqiang Zhang, Zhongjun He, Hairong Liu, Xing Li, Hua Wu, and Haifeng Wang. STACL: Simultaneous translation with implicit anticipation and controllable latency using prefix-to-prefix framework. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 3025–3036, Florence, Italy, July 2019. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P19-1289. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matt Post. A call for clarity in reporting BLEU scores. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 186–191, Belgium, Brussels, October 2018. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ W18-6319. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            429
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Minh-Thang Luong, Peter J Liu, Ron J Weiss, and Douglas Eck. Online and linear-time attention by enforcing monotonic alignments. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2837–2846. JMLR. org, 2017. ",
+        "bbox": [
+            176,
+            438,
+            823,
+            481
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1715–1725, 2016. ",
+        "bbox": [
+            173,
+            489,
+            823,
+            532
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            583
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Baigong Zheng, Renjie Zheng, Mingbo Ma, and Liang Huang. Simpler and faster learning of adaptive policies for simultaneous translation. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 1349–1354, Hong Kong, China, November 2019a. Association for Computational Linguistics. doi: 10.18653/v1/D19-1137. URL https://www.aclweb.org/anthology/D19-1137. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Baigong Zheng, Renjie Zheng, Mingbo Ma, and Liang Huang. Simultaneous translation with flexible policy via restricted imitation learning. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 5816–5822, Florence, Italy, July 2019b. Association for Computational Linguistics. doi: 10.18653/v1/P19-1582. URL https://www.aclweb. org/anthology/P19-1582. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            755
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            299,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            361,
+            827
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The hyperparameters we used for offline and monotonic transformer models are defined in Table 4. ",
+        "bbox": [
+            173,
+            838,
+            818,
+            853
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 LATENCY METRICS DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            450,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Given the delays $\\mathbf { g } = \\{ g _ { 1 } , g _ { 2 } , . . . , g _ { | \\mathbf { y } | } \\}$ of generating each target token, AP, AL and DAL are defined in Table 5. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/786fa73e10dfc49d9f8315c3ad84f607dc02200090f3349dded387e08a2387cf.jpg",
+        "table_caption": [
+            "Table 4: Offline and monotonic models hyperparameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>WMT15 German-English</td><td>IWSLT English-Vietnamese</td></tr><tr><td>encoder embed dim</td><td>1024</td><td>512</td></tr><tr><td>encoder ffn embed dim</td><td>4096</td><td>1024</td></tr><tr><td>encoder attention heads</td><td>16</td><td>4</td></tr><tr><td>encoder layers</td><td></td><td>6</td></tr><tr><td>decoder embed dim</td><td>1024</td><td>512</td></tr><tr><td>decoder ffn embed dim</td><td>4096</td><td>1024</td></tr><tr><td>decoder attention heads</td><td>16</td><td>4</td></tr><tr><td>decoder layers</td><td></td><td>6</td></tr><tr><td>dropout</td><td>0.3</td><td></td></tr><tr><td>optimizer</td><td></td><td>adam</td></tr><tr><td>adam-β</td><td></td><td>(0.9,0.98)</td></tr><tr><td>clip-norm</td><td></td><td>0.0</td></tr><tr><td>lr lr scheduler</td><td></td><td>0.0005</td></tr><tr><td></td><td></td><td>inverse sqrt</td></tr><tr><td>warmup-updates</td><td></td><td>4000</td></tr><tr><td>warmup-init-lr</td><td></td><td>1e-07</td></tr><tr><td>label-smoothing</td><td></td><td>0.1</td></tr><tr><td>max tokens</td><td>3584×8×8×2</td><td>16000</td></tr></table>",
+        "bbox": [
+            218,
+            101,
+            781,
+            380
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2b50d79a218d254a363d0b2b6eb603cad830f95fe74ac3ffb11fbfe8fcddcd5.jpg",
+        "table_caption": [
+            "Table 5: The calculation of latency metrics, given source $_ { \\textbf { \\em x } }$ , target $\\textbf {  { y } }$ and delays $\\pmb { g }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Latency Metric</td></tr><tr><td>Average Proportion</td><td>y 1 M gi lacllyl i=1</td></tr><tr><td>Average Lagging</td><td>1 T i-1 gi 1y1/ac T i=1 where T = arg maxi(gi = |xl)</td></tr><tr><td>1 ly Differentiable Average Lagging</td><td>lyl i-1 M gi lyl//ac| i=1 gi i=0 where g&#x27; = ly max(gi, 9i-1 i&lt;0 [x</td></tr></table>",
+        "bbox": [
+            232,
+            434,
+            766,
+            670
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 DETAILED RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            738,
+            354,
+            752
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We provide the detailed results in Figure 2 as Table 6 and Table 7. ",
+        "bbox": [
+            174,
+            770,
+            606,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 THRESHOLD OF READING ACTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            452,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We explore a simple method that can adjust system’s latency at inference time without training new models. In Algorithm 1 line 8, 0.5 was used as an threshold. One can set different threshold $p$ during the inference time to control the latency. We run the pilot experiments on IWSLT15 En-Vi dataset and the results are shown as Table 8. Although this method doesn’t require training new model, it dramatically hurts the translation quality. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a524a579244b5b105b551d4c29c7040c9b89dc48418684ab944b7caf945bb225.jpg",
+        "table_caption": [
+            "Table 6: Detailed results for MMA-H and MMA-IL on WMT15 DeEn "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>BLEU  AP   AL   DAL</td></tr><tr><td rowspan=1 colspan=1>Xavg              MMA-IL</td></tr><tr><td rowspan=1 colspan=1>0.05   30.7   0.78  10.91  12.64</td></tr><tr><td rowspan=1 colspan=1>0.1    30.5   0.70  7.42   8.82</td></tr><tr><td rowspan=1 colspan=1>0.2    30.1   0.63  5.17   6.41</td></tr><tr><td rowspan=1 colspan=1>0.3    30.3   0.60  4.18   5.35</td></tr><tr><td rowspan=1 colspan=1>0.4    29.2   0.59  3.75   4.90</td></tr><tr><td rowspan=1 colspan=1>0.5    26.7   0.59  3.69   4.83</td></tr><tr><td rowspan=1 colspan=1>0.75   25.5   0.58  3.40   4.46</td></tr><tr><td rowspan=1 colspan=1>1.0   25.1   0.56  3.00   4.03</td></tr><tr><td rowspan=1 colspan=1>Xvar              MMA-H</td></tr><tr><td rowspan=1 colspan=1>0.1    28.5   0.74  8.94  10.83</td></tr><tr><td rowspan=1 colspan=1>0.2    28.9   0.69  6.82  8.622</td></tr><tr><td rowspan=1 colspan=1>0.3    29.2   0.64  5.45   7.03</td></tr><tr><td rowspan=1 colspan=1>0.4    28.5   0.59  3.90   5.21</td></tr><tr><td rowspan=1 colspan=1>0.5    28.5   0.59  3.88   5.19</td></tr><tr><td rowspan=1 colspan=1>0.6    29.6   0.56  3.13   4.32</td></tr><tr><td rowspan=1 colspan=1>0.7    29.1   0.56  2.93   4.10</td></tr></table>",
+        "bbox": [
+            359,
+            101,
+            638,
+            385
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/ed333637461fbbafe957ae247c9ae36cee6ce1c0619093324347790c2ab3639c.jpg",
+        "table_caption": [
+            "Table 7: Detailed results for MILk, MMA-H and MMA-IL on IWSLT15 En-Vi "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>BLEU</td><td></td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>入</td><td></td><td>MILk</td><td></td><td></td></tr><tr><td>0.1</td><td>24.62</td><td>0.71</td><td>5.93</td><td>7.19</td></tr><tr><td>0.2</td><td>24.68</td><td>0.67</td><td>4.90</td><td>5.97</td></tr><tr><td>0.3</td><td>24.31</td><td>0.65</td><td>4.45</td><td>5.43</td></tr><tr><td>0.4</td><td>23.73</td><td>0.64</td><td>4.28</td><td>5.24</td></tr><tr><td>Xaug</td><td></td><td>MMA-IL</td><td></td><td></td></tr><tr><td>0.02</td><td>28.28</td><td>0.76</td><td>7.09</td><td>8.29</td></tr><tr><td>0.04</td><td>28.33</td><td>0.70</td><td>5.44</td><td>6.57</td></tr><tr><td>0.1</td><td>28.42</td><td>0.67</td><td>4.63</td><td>5.65</td></tr><tr><td>0.2</td><td>28.47</td><td>0.63</td><td>3.57</td><td>4.44</td></tr><tr><td>0.3</td><td>27.9</td><td>0.59</td><td>2.98</td><td>3.81</td></tr><tr><td>0.4</td><td>27.73</td><td>0.58</td><td>2.68</td><td>3.46</td></tr><tr><td>Xuar</td><td></td><td>MMA-H</td><td></td><td></td></tr><tr><td>0.02</td><td>27.26</td><td>0.77</td><td>7.52</td><td>8.71</td></tr><tr><td>0.1</td><td></td><td></td><td>5.22</td><td>6.31</td></tr><tr><td></td><td>27.68</td><td>0.69</td><td>3.81</td><td></td></tr><tr><td>0.2</td><td>28.06</td><td>0.63</td><td></td><td>4.84</td></tr><tr><td>0.4</td><td>27.79</td><td>0.62</td><td>3.57</td><td>4.59</td></tr><tr><td>0.8</td><td>27.95</td><td>0.60</td><td>3.22</td><td>4.19</td></tr></table>",
+        "bbox": [
+            366,
+            422,
+            632,
+            734
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 AVERAGE LOSS FOR MMA-H ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            784,
+            423,
+            799
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We explore applying a simple average instead of a weighted average loss to MMA-H. The results are shown in Figure 7 and Table 9. We find that even with very large weights, we are unable to reduce the overall latency. In addition, we find that the weighted average loss severely affects the translation quality negatively. On the other hand, the divergence loss we propose in Equation 16 can efficiently reduce the latency while retaining relatively good translation quality for MMA-H models. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            881
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d553d6e69ce5de1583cfa97a411d692404d8e6b604846e59cf235e6f7445988.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 8: Comparison between setting threshold for reading action and weighted average latency loss. "
+        ],
+        "table_body": "<table><tr><td colspan=\"6\">Reading Threshold</td><td colspan=\"4\">Weighted Average Latency Loss</td></tr><tr><td>p</td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td><td>Lavg</td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>0.5</td><td>25.5</td><td>0.792387</td><td>7.13673</td><td>8.27187</td><td>0.02</td><td>25.5</td><td>0.792387</td><td>7.13673</td><td>8.27187</td></tr><tr><td>0.4</td><td>25.25</td><td>0.73749</td><td>5.72003</td><td>6.85812</td><td>0.04</td><td>25.68</td><td>0.728107</td><td>5.52856</td><td>6.61744</td></tr><tr><td>0.3</td><td>23.06</td><td>0.697398</td><td>4.88087</td><td>6.03342</td><td>0.3</td><td>24.9</td><td>0.602703</td><td>2.90054</td><td>3.68039</td></tr><tr><td>0.2</td><td>18.37</td><td>0.678298</td><td>4.71099</td><td>5.94636</td><td>0.2</td><td>25.3</td><td>0.636914</td><td>3.54577</td><td>4.38623</td></tr><tr><td>0.1</td><td>8.73</td><td>0.696452</td><td>5.5225</td><td>7.20439</td><td>0.1</td><td>25.48</td><td>0.684424</td><td>4.57901</td><td>5.54102</td></tr></table>",
+        "bbox": [
+            173,
+            111,
+            844,
+            231
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/aea53beea98c86b1baeb911bfa9ca93df3d5c23c9dfd3fe4f079a502cf059346.jpg",
+        "image_caption": [
+            "Figure 7: Effect average loss, weighted average loss and variance loss on MMA-H on WMT15 DeEn development set. ",
+            "Table 9: Detailed numbers on average loss, weighted average loss and head divergence loss on WMT15 De-En development set "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            286,
+            810,
+            453
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/4e530cf2f50274c42af2cc82e308e69bcf9358bdf52a0d674618eb44495a7b1b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>BLEU</td><td>AP</td><td>AL</td><td>DAL</td></tr><tr><td>Xaug</td><td colspan=\"4\">Average</td></tr><tr><td>0.05</td><td>28.5</td><td>0.862581</td><td>14.3847</td><td>17.3702</td></tr><tr><td>0.1</td><td>27.8</td><td>0.855435</td><td>13.974</td><td>17.02</td></tr><tr><td>0.2</td><td>28</td><td>0.835324</td><td>12.8531</td><td>15.908</td></tr><tr><td>0.4</td><td>28.1</td><td>0.819408</td><td>11.9816</td><td>14.9763</td></tr><tr><td>1.0</td><td>28.2</td><td>0.810609</td><td>11.7528</td><td>14.6695</td></tr><tr><td>2.0</td><td>28.1</td><td>0.800258</td><td>11.1763</td><td>14.0761</td></tr><tr><td>8.0</td><td>28.4</td><td>0.806439</td><td>11.5289</td><td>14.6431</td></tr><tr><td>Xaug</td><td colspan=\"4\">Weighted Average</td></tr><tr><td>0.02</td><td>28.24</td><td>0.773922</td><td>10.2109</td><td>12.2274</td></tr><tr><td>0.04</td><td>24.35</td><td>0.685834</td><td>7.06716</td><td>8.64069</td></tr><tr><td>0.06</td><td>7.80</td><td>0.875825</td><td>16.2046</td><td>19.0892</td></tr><tr><td>0.08</td><td>9.51</td><td>0.57372</td><td>3.92011</td><td>6.1421</td></tr><tr><td>0.1</td><td>9.78</td><td>0.556585</td><td>3.3007</td><td>5.46142</td></tr><tr><td>Xvar</td><td colspan=\"4\">Divergence</td></tr><tr><td>0.1</td><td>27.35</td><td>0.736025</td><td>8.70968</td><td>10.5253</td></tr><tr><td>0.2</td><td>27.64</td><td>0.681491</td><td>6.63914</td><td>8.3856</td></tr><tr><td>0.3</td><td>27.37</td><td>0.6623</td><td>6.04902</td><td>7.71922</td></tr><tr><td>0.4</td><td>27.62</td><td>0.638188</td><td>5.31672</td><td>6.86834</td></tr><tr><td>0.5</td><td>27.50</td><td>0.625759</td><td>4.93044</td><td>6.38998</td></tr><tr><td>1.0</td><td>27.1</td><td>0.582194</td><td>3.64864</td><td>4.90997</td></tr></table>",
+        "bbox": [
+            326,
+            521,
+            671,
+            873
+        ],
+        "page_idx": 14
+    }
+]

parse/train/Skdvd2xAZ/Skdvd2xAZ.md

@@ -0,0 +1,373 @@
+# A SCALABLE LAPLACE APPROXIMATION FOR NEURAL NETWORKS
+
+Hippolyt Ritter1∗, Aleksandar Botev1, David Barber1 2 1University College London 2Alan Turing Institute
+
+# ABSTRACT
+
+We leverage recent insights from second-order optimisation for neural networks to construct a Kronecker factored Laplace approximation to the posterior over the weights of a trained network. Our approximation requires no modification of the training procedure, enabling practitioners to estimate the uncertainty of their models currently used in production without having to retrain them. We extensively compare our method to using Dropout and a diagonal Laplace approximation for estimating the uncertainty of a network. We demonstrate that our Kronecker factored method leads to better uncertainty estimates on out-of-distribution data and is more robust to simple adversarial attacks. Our approach only requires calculating two square curvature factor matrices for each layer. Their size is equal to the respective square of the input and output size of the layer, making the method efficient both computationally and in terms of memory usage. We illustrate its scalability by applying it to a state-of-the-art convolutional network architecture.
+
+# 1 INTRODUCTION
+
+Neural networks are most commonly trained in a maximum a posteriori (MAP) setting, which only yields point estimates of the parameters, ignoring any uncertainty about them. This often leads to overconfident predictions, especially in regimes that are weakly covered by training data or far away from the data manifold. While the confidence of wrong predictions is usually irrelevant in a research context, it is essential that a Machine Learning algorithm knows when it does not know in the real world, as the consequences of mistakes can be fatal, be it when driving a car or diagnosing a disease.
+
+The Bayesian framework of statistics provides a principled way for avoiding overconfidence in the parameters by treating them as unknown quantities and integrating over all possible values. Specifically, for the prediction of new data under a model, it fits a posterior distribution over the parameters given the training data and weighs the contribution of each setting of the parameters to the prediction by the probability of the data under those parameters times their prior probability. However, the posterior of neural networks is usually intractable due to their size and nonlinearity.
+
+There has been previous interest in integrating neural networks into the Bayesian framework (MacKay, 1992; Hinton & Van Camp, 1993; Neal, 1993; Barber & Bishop, 1998), however these approaches were designed for small networks by current standards. Recent adaptations to architectures of modern scale rely on crude approximations of the posterior to become tractable. All of (Graves, 2011; Hernandez-Lobato & Adams, 2015; Blundell et al., 2015) assume independence between the ´ individual weights. While they achieve good results on small datasets, this strong restriction of the posterior is susceptible to underestimating the uncertainty, in particular when optimising the variational bound. The approach in (Gal & Ghahramani, 2016) requires the use of certain stochastic regularisers which are not commonly present in most recent architectures. Furthermore, it is not clear if the approximate posterior defined by these regularisers is a good fit to the true posterior.
+
+Recent work on second-order optimisation of neural networks (Martens & Grosse, 2015; Botev et al., 2017) has demonstrated that the diagonal blocks of the curvature can be well approximated by a Kronecker product. We combine this insight with the idea of modelling the posterior over the weights as a Gaussian, using a Laplace approximation (MacKay, 1992) with Kronecker factored covariance matrices. This leads to a computationally efficient matrix normal posterior distribution (Gupta & Nagar, 1999) over the weights of every layer. Since the Laplace approximation is applied after training, our approach can be used to obtain uncertainty estimates from existing networks.
+
+# 2 THE CURVATURE OF NEURAL NETWORKS
+
+Our method is inspired by recent Kronecker factored approximations of the curvature of a neural network (Martens & Grosse, 2015; Botev et al., 2017) for optimisation and we give a high-level review of these in the following. While the two methods approximate the Gauss-Newton and Fisher matrix respectively, as they are guaranteed to be positive semi-definite (p.s.d.), we base all of our discussion on the Hessian in order to be as general as possible.
+
+# 2.1 NEURAL NETWORK NOTATION
+
+We denote a feedforward network as taking an input $a _ { 0 } = x$ and producing an output $h _ { L }$ . The intermediate representations for layers $\lambda = 1 , . . . , L$ are denoted as $h _ { \lambda } = W _ { \lambda } a _ { \lambda - 1 }$ and $a _ { \lambda } = f _ { \lambda } ( h _ { \lambda } )$ . We refer to $a _ { \lambda }$ as the activations, and $h _ { \lambda }$ as the (linear) pre-activations. The bias terms are absorbed into the $W _ { \lambda }$ by appending a 1 to each $a _ { \lambda }$ . The network parameters are optimised w.r.t. an error function $E ( y , h _ { L } )$ for targets $y$ . Most commonly used error functions, such as squared error and categorical cross-entropy, can be interpreted as exponential family negative log likelihoods $- \log p ( y | h _ { L } )$ .
+
+# 2.2 KRONECKER FACTORED SECOND-ORDER OPTIMISATION
+
+Traditional second-order methods use either the Hessian matrix or a positive semi-definite approximation thereof to generate parameter updates of the form $\Delta = C ^ { - 1 } g$ , where $C$ is the chosen curvature matrix and $g$ the gradient of the error function parameterised by the network. However, this curvature matrix is infeasbile to compute for modern neural networks as their number of parameters is often in the millions, rendering the size of $C$ of the order of several terabytes.
+
+Recent work (Martens & Grosse, 2015; Botev et al., 2017) exploits that, for a single data point, the diagonal blocks of these curvature matrices are Kronecker factored:
+
+$$
+H _ { \lambda } = \frac { \partial ^ { 2 } E } { \partial \operatorname { v e c } ( W _ { \lambda } ) \partial \operatorname { v e c } ( W _ { \lambda } ) } = \mathcal { Q } _ { \lambda } \otimes \mathcal { H } _ { \lambda }
+$$
+
+where $H _ { \lambda }$ is the Hessian w.r.t. the weights in layer $\lambda$ . $\mathcal { Q } _ { \lambda } = a _ { \lambda - 1 } a _ { \lambda - 1 } ^ { \top }$ denotes the covariance of the incoming activations aλ−1 and Hλ = ∂ E∂h ∂h the pre-activation Hessian, i.e. the Hessian of the error w.r.t. the linear pre-activations $h _ { \lambda }$ in a layer. We provide the derivation for this result as well as the recursion for calculating $\mathcal { H }$ in Appendix A.
+
+The Kronecker factorisation holds two key advantages: the matrices that need be computed and stored are much smaller — if we assume all layers to be of dimensionality $D$ , the two factors are each of size $D ^ { 2 }$ , whereas the full Hessian for the weights of only one layer would have $D ^ { 4 }$ elements. Furthermore, the inverse of a Kronecker product is equal to the Kronecker product of the inverses, so it is only necessary to invert those two moderately sized matrices.
+
+In order to maintain this structure over a minibatch of data, all Kronecker factored second-order methods make two core approximations: First, they only model the diagonal blocks corresponding to the weights of a layer, such that the curvature decomposes into $L$ independent matrices. Second, they assume $\mathcal { Q } _ { \lambda }$ and $\mathcal { H } _ { \lambda }$ to be independent. This is in order to maintain the Kronecker factorisation in expectation, i.e. $\mathbb { E } \left[ \mathcal { Q } _ { \lambda } \otimes \mathcal { H } _ { \lambda } \right] \approx \mathbb { E } \left[ \mathcal { Q } _ { \lambda } \right] \otimes \mathbb { E } \left[ \mathcal { H } _ { \lambda } \right]$ , since the expectation of a Kronecker product is not guaranteed to be Kronecker factored itself.
+
+The main difference between the Kronecker factored second-order optimisers lies in how they efficiently approximate $\mathbb { E } \left[ \mathcal { H } _ { \lambda } \right]$ . For exact calculation, it would be necessary to pass back an entire matrix per data point in a minibatch, which imposes infeasible memory and computational requirements. KFRA (Botev et al., 2017) simply passes back the expectation at every layer, while KFAC (Martens & Grosse, 2015) utilises the Fisher identity to only propagate a vector rather than a matrix, approximating the Kronecker factors with a stochastic rank-one matrix for each data point.
+
+The diagonal blocks of the Hessian and Gauss-Newton matrix are equal for neural networks with piecewise linear activation functions (Botev et al., 2017), thus both methods can be used to directly approximate the diagonal blocks of the Hessian of such networks, as the Gauss-Newton and Fisher are equivalent for networks that parameterise an exponential family log likelihood.
+
+# 3 A SCALABLE LAPLACE APPROXIMATION FOR NEURAL NETWORKS
+
+# 3.1 THE LAPLACE APPROXIMATION
+
+The standard Laplace approximation is obtained by taking the second-order Taylor expansion around a mode of a distribution. For a neural network, such a mode can be found using standard gradientbased methods. Specifically, if we approximate the log posterior over the weights of a network given some data $\mathcal { D }$ around a MAP estimate $\boldsymbol { \theta } ^ { * }$ , we obtain:
+
+$$
+\log p ( \boldsymbol { \theta } | \mathcal { D } ) \approx \log p ( \boldsymbol { \theta } ^ { * } | \mathcal { D } ) - \frac { 1 } { 2 } \big ( \boldsymbol { \theta } - \boldsymbol { \theta } ^ { * } \big ) ^ { \top } \bar { H } ( \boldsymbol { \theta } - \boldsymbol { \theta } ^ { * } )
+$$
+
+where $\theta = [ \mathrm { v e c } ( W _ { 1 } ) , . . . , \mathrm { v e c } ( W _ { L } ) ]$ is the stacked vector of weights and $\bar { H } = \mathbb { E } \left[ H \right]$ the average Hessian of the negative log posterior1. The first order term is missing because we expand the function around a maximum $\boldsymbol { \theta } ^ { * }$ , where the gradient is zero. If we exponentiate this equation, it is easy to notice that the right-hand side is of Gaussian functional form for $\theta$ , thus we obtain a normal distribution by integrating over it. The posterior over the weights is then approximated as Gaussian:
+
+$$
+\theta \sim \mathcal { N } ( \theta ^ { * } , \bar { H } ^ { - 1 } )
+$$
+
+assuming $\bar { H }$ is p.s.d. We can then approximate the posterior mean when predicting on unseen data $D ^ { * }$ by averaging the predictions of $T$ Monte Carlo samples ${ \boldsymbol { \theta } } ^ { ( t ) }$ from the approximate posterior:
+
+$$
+p ( \mathcal { D } ^ { * } | \mathcal { D } ) = \int p ( \mathcal { D } ^ { * } | \boldsymbol { \theta } ) p ( \boldsymbol { \theta } | \mathcal { D } ) d \boldsymbol { \theta } \approx \frac { 1 } { T } \sum _ { t = 1 } ^ { T } p ( \mathcal { D } ^ { * } | \boldsymbol { \theta } ^ { ( t ) } )
+$$
+
+# 3.2 DIAGONAL LAPLACE APPROXIMATION
+
+Unfortunately, it is not feasible to compute or invert the Hessian matrix w.r.t. all of the weights jointly. An approximation that is easy to compute in modern automatic differentiation frameworks is the diagonal of the Fisher matrix $F$ , which is simply the expectation of the squared gradients:
+
+$$
+H \approx \mathrm { d i a g } ( F ) = \mathrm { d i a g } ( \mathbb { E } \left[ \nabla _ { \theta } \log p ( y | x ) \nabla _ { \theta } \log p ( y | x ) ^ { \top } \right] ) = \mathrm { d i a g } ( \mathbb { E } \left[ ( \nabla _ { \theta } \log p ( y | x ) ) ^ { 2 } \right] )
+$$
+
+where diag extracts the diagonal of a matrix or turns a vector into a diagonal matrix. Such diagonal approximations to the curvature of a neural network have been used successfully for pruning the weights (LeCun et al., 1990) and, more recently, for transfer learning (Kirkpatrick et al., 2017).
+
+This corresponds to modelling the weights with a Normal distribution with diagonal covariance:
+
+$$
+\operatorname { v e c } ( W _ { \lambda } ) \sim { \mathcal { N } } ( \operatorname { v e c } ( W _ { \lambda } ^ { * } ) , \operatorname { d i a g } ( F _ { \lambda } ) ^ { - 1 } ) \quad { \mathrm { f o r ~ } } \lambda = 1 , \dots , L
+$$
+
+Unfortunately, even if the Taylor approximation is accurate, this will place significant probability mass in low probability areas of the true posterior if some weights exhibit high covariance.
+
+# 3.3 KRONECKER FACTORED LAPLACE APPROXIMATION
+
+So while it is desirable to model the covariance between the weights, some approximations are needed in order to remain computationally efficient. First, we assume the weights of the different layers to be independent. This corresponds to the block-diagonal approximation in KFAC and KFRA, which empirically preserves sufficient information about the curvature to obtain competitive optimisation performance. For our purposes this means that our posterior factorises over the layers.
+
+As discussed above, the Hessian of the log-likelihood for a single datapoint is Kronecker factored, and we denote the two factor matrices as ${ \cal H } _ { \lambda } = { \mathcal Q } _ { \lambda } \otimes { \mathcal H } _ { \lambda }$ .2 By further assuming independence between $\mathcal { Q }$ and $\mathcal { H }$ in all layers, we can approximate the expected Hessian of each layer as:
+
+$$
+\mathbb { E } \left[ H _ { \lambda } \right] = \mathbb { E } \left[ \mathcal { Q } _ { \lambda } \otimes \mathcal { H } _ { \lambda } \right] \approx \mathbb { E } \left[ \mathcal { Q } _ { \lambda } \right] \otimes \mathbb { E } \left[ \mathcal { H } _ { \lambda } \right]
+$$
+
+Hence, the Hessian of every layer is Kronecker factored over an entire dataset and the Laplace approximation can be approximated by a product of Gaussians. Each Gaussian has a Kronecker factored covariance, corresponding to a matrix normal distribution (Gupta & Nagar, 1999), which considers the two Kronecker factors of the covariance to be the covariances of the rows and columns of a matrix. The two factors are much smaller than the full covariance and allow for significantly more efficient inversion and sampling (we review the matrix normal distribution in Appendix B).
+
+Our resulting posterior for the weights in layer $\lambda$ is then:
+
+$$
+W _ { \lambda } \sim \mathcal { M N } ( W _ { \lambda } ^ { \ast } , \bar { \mathcal { Q } } _ { \lambda } ^ { - 1 } , \bar { \mathcal { H } } _ { \lambda } ^ { - 1 } )
+$$
+
+In contrast to optimisation methods, we do not need to approximate $\mathbb { E } \left[ \mathcal { H } _ { \lambda } \right]$ as it is only calculated once. However, when it is possible to augment the data (e.g. randomised cropping of images), it may be advantageous. We provide a more detailed discussion of this in Appendix C.
+
+# 3.4 INCORPORATING THE PRIOR AND REGULARISING THE CURVATURE FACTORS
+
+Just as the log posterior, the Hessian decomposes into a term depending on the data log likelihood and one on the prior. For the commonly used $L _ { 2 }$ -regularisation, corresponding to a Gaussian prior, the Hessian is equal to the precision of the prior times the identity matrix. We approximate this by adding a multiple of the identity to each of the Kronecker factors from the log likelihood:
+
+$$
+H _ { \lambda } = N \mathbb { E } \left[ - \frac { \partial ^ { 2 } \log p ( \mathcal { D } | \theta ) } { \partial \theta ^ { 2 } } \right] + \tau I \approx ( \sqrt { N } \mathbb { E } \left[ \mathcal { Q } _ { \lambda } \right] + \sqrt { \tau } I ) \otimes ( \sqrt { N } \mathbb { E } \left[ \mathcal { H } _ { \lambda } \right] + \sqrt { \tau } I )
+$$
+
+where $\tau$ is the precision of the Gaussian prior on the weights and $N$ the size of the dataset. However, we can also treat them as hyperparameters and optimise them w.r.t. the predictive performance on a validation set. We emphasise that this can be done without retraining the network, so it does not impose a large computational overhead and is trivial to parallelise.
+
+Setting $N$ to a larger value than the size of the dataset can be interpreted as including duplicates of the data points as pseudo-observations. Adding a multiple of the uncertainty to the precision matrix decreases the uncertainty about each parameter. This has a regularising effect both on our approximation to the true Laplace, which may be overestimating the variance in certain directions due to ignoring the covariances between the layers, as well as the Laplace approximation itself, which may be placing probability mass in low probability areas of the true posterior.
+
+# 4 RELATED WORK
+
+Most recent attempts to approximating the posterior of a neural network are based on formulating an approximate distribution to the posterior and optimising the variational lower bound w.r.t. its parameters. (Graves, 2011; Blundell et al., 2015; Kingma et al., 2015) as well as the expectation propagation based approaches of (Hernandez-Lobato & Adams, 2015) and (Ghosh et al., 2016) ´ assume independence between the individual weights which, particularly when optimising the KL divergence, often lets the model underestimate the uncertainty about the weights. Gal & Ghahramani (2016) interpret Dropout to approximate the posterior with a mixture of delta functions, assuming independence between the columns. (Lakshminarayanan et al., 2016) suggest using an ensemble of networks for estimating the uncertainty.
+
+Our work is a scalable approximation of (MacKay, 1992). Since the per-layer Hessian of a neural network is infeasible to compute, we suggest a factorisation of the covariance into a Kronecker product, leading to a more efficient matrix normal distribution. The posterior that we obtain is reminiscent of (Louizos & Welling, 2016) and (Sun et al., 2017), who optimise the parameters of a matrix normal distribution as their weights, which requires a modification of the training procedure.
+
+# 5 EXPERIMENTS
+
+Since the Laplace approximation is a method for predicting in a Bayesian manner and not for training, we focus on comparing to uncertainty estimates obtained from Dropout (Gal & Ghahramani, 2016). The trained networks will be identical, but the prediction methods will differ. We also compare to a diagonal Laplace approximation to highlight the benefit from modelling the covariances between the weights. All experiments are implemented using Theano (Theano Development Team, 2016) and Lasagne (Dieleman et al., 2015).3
+
+# 5.1 TOY REGRESSION DATASET
+
+As a first experiment, we visualise the uncertainty obtained from the Laplace approximations on a toy regression dataset, similar to (Hernandez-Lobato´ $\&$ Adams, 2015). We create a dataset of 20 uniformly distributed points $x \sim \mathcal { U } ( - 4 , 4 )$ and sample $y \sim \mathcal { N } ( x ^ { 3 } , 3 ^ { 2 } )$ . In contrast to (Hernandez- ´ Lobato & Adams, 2015), we use a two-layer network with seven units per layer rather than one layer with 100 units. This is because both the input and output are one-dimensional, hence the weight matrices are vectors and the matrix normal distribution reduces to a multivariate normal distribution. Furthermore, the Laplace approximation is sensitive to the ratio of the number of data points to parameters, and we want to visualise it both with and without hyperparameter tuning.
+
+![](images/debac792cdab601dfb06184753b4dcbf42158c1124917b3079299c753416bc64.jpg)  
+Figure 1: Toy regression uncertainty. Black dots are data points, the black line shows the noiseless function. The red line shows the deterministic prediction of the network, the blue line the mean output. Each shade of blue visualises one additional standard deviation. Best viewed on screen.
+
+Fig. 1 shows the uncertainty obtained from the Kronecker factored and diagonal Laplace approximation applied to the same network, as well as from a full Laplace approximation and $5 0 , 0 0 0 \mathrm { H M C }$ (Neal, 1993) samples. The latter two methods are feasible only for such a small model and dataset. For the diagonal and full Laplace approximation we use the Fisher identity and draw one sample per data point. We set the hyperparameters of the Laplace approximations (see Section 3.4) using a grid search over the likelihood of 20 validation points that are sampled the same way as the training set.
+
+The regularised Laplace approximations all give an overall good fit to the HMC predictive posterior. Their uncertainty is slightly higher close to the training data and increases more slowly away from the data than that of the HMC posterior. The diagonal and full Laplace approximation require stronger regularisation than our Kronecker factored one, as they have higher uncertainty when not regularised. In particular the full Laplace approximation vastly overestimates the uncertainty without additional regularisation, leading to a bad predictive mean (see Appendix E for the corresponding figures), as the Hessian of the log likelihood is underdetermined. This is commonly the case in deep learning, as the number of parameters is typically much larger than the number of data points. Hence restricting the structure of the covariance is not only a computational necessity for most architectures, but also allows for more precise estimation of the approximate covariance.
+
+# 5.2 OUT-OF-DISTRIBUTION UNCERTAINTY
+
+For a more realistic test, similar to (Louizos & Welling, 2017), we assess the uncertainty of the predictions when classifying data from a different distribution than the training data. For this we train a network with two layers of 1024 hidden units and ReLU transfer functions to classify MNIST digits. We use a learning rate of $1 0 ^ { - 2 }$ and momentum of 0.9 for 250 epochs. We apply Dropout with $p { = } 0 . 5$ after each inner layer, as our chief interest is to compare against its uncertainty estimates. We further use $L _ { 2 }$ -regularisation with a factor of $1 0 ^ { - 2 }$ and randomly binarise the images during training according to their pixel intensities and draw $1 , 0 0 0$ such samples per datapoint for estimating the curvature factors. We use this network to classify the images in the notMNIST dataset4, which contains $2 8 \times 2 8$ grey-scale images of the letters $\mathbf { \dot { A } } ^ { \prime }$ to $\mathbf { \hat { J } } ^ { \star }$ from various computer fonts, i.e. not digits. An ideal classifier would make uniform predictions over its classes.
+
+We compare the uncertainty obtained by predicting the digit class of the notMNIST images using 1. a deterministic forward pass through the Dropout trained network, 2. by sampling different Dropout masks and averaging the predictions, and by sampling different weight matrices from 3. the matrix normal distribution obtained from our Kronecker factored Laplace approximation as well as 4. the diagonal one. As an additional baseline similar to (Blundell et al., 2015; Graves, 2011), we compare to a network with identical architecture with a fully factorised Gaussian (FFG) approximate posterior on the weights and a standard normal prior. We train the model on the variational lower bound using the reparametrisation trick (Kingma & Welling, 2013). We use 100 samples for the stochastic forward passes and optimise the hyperparameters of the Laplace approximations w.r.t. the cross-entropy on the validation set of MNIST.
+
+![](images/d894a7edf56530a450cd12d773fa589c25cc119d5b25ad9f5c7d7640b554c41f.jpg)  
+Figure 2: Predictive entropy on notMNIST obtained from different methods for the forward pass on a network trained on MNIST.
+
+We measure the uncertainty of the different methods as the entropy of the predictive distribution, which has a minimal value of 0 when a single class is predicted with certainty and a maximum of about 2.3 for uniform predictions. Fig. 2 shows the inverse empirical cumulative distribution of the entropy values obtained from the four methods. Consistent with the results in (Gal & Ghahramani, 2016), averaging the probabilities of multiple passes through the network yields predictions with higher uncertainty than a deterministic pass that approximates the geometric average (Srivastava et al., 2014). However, there still are some images that are predicted to be a digit with certainty. Our Kronecker factored Laplace approximation makes hardly any predictions with absolute certainty and assigns high uncertainty to most of the letters as desired. The diagonal Laplace approximation required stronger regularisation towards predicting deterministically, yet it performs similarly to Dropout. As shown in Table 1, however, the network makes predictions on the test set of MNIST with similar accuracy to the deterministic forward pass and MC Dropout when using our approximation. The variational factorised Gaussian posterior has low uncertainty as expected.
+
+# 5.3 ADVERSARIAL EXAMPLES
+
+![](images/ed41abe45c3623949c3b8185e71c83cf08c0f3240991f92ab6369cada44c3cfe.jpg)  
+Figure 3: Untargeted adversarial attack.
+
+![](images/bd7abf0110987c858acf90a823a00cb267f5508f27375bc544386b20b41304ac.jpg)  
+Figure 4: Targeted adversarial attack.
+
+To further test the robustness of our prediction method close to the data distribution, we perform an adversarial attack on a neural network. As first demonstrated in (Szegedy et al., 2013), neural networks are prone to being fooled by gradient-based changes to their inputs. Li & Gal (2017) suggest, and provide empirical support, that Bayesian models may be more robust to such attacks, since they implicitly form an infinitely large ensemble by integrating over the model parameters. For our experiments, we use the fully connected net trained on MNIST from the previous section and compare the sensitivity of the different prediction methods for two kinds of adversarial attacks.
+
+First, we use the untargeted Fast Gradient Sign method $\begin{array} { r } { x _ { a d v } = x - \eta \mathrm { s g n } ( \nabla _ { x } \operatorname* { m a x } _ { y } \log p ^ { ( M ) } ( y | x ) ) } \end{array}$ suggested in (Goodfellow et al., 2014), which takes the gradient of the class predicted with maximal probability by method $M$ w.r.t. the input $x$ and reduces this probability with varying step size $\eta$ This step size is rescaled by the difference between the maximal and minimal value per dimension in the dataset. It is to be expected that this method generates examples away from the data manifold, as there is no clear subset of the data that corresponds to e.g. ”not ones”.
+
+Fig. 3 shows the average predictive uncertainty and the accuracy on the original class on the MNIST test set as the step size $\eta$ increases. The Kronecker factored Laplace approximation achieves significantly higher uncertainty than any other prediction method as the images move away from the data. Both the diagonal and the Kronecker factored Laplace maintain higher accuracy than MC Dropout on their original predictions. Interestingly, the deterministic forward pass appears to be most robust in terms of accuracy, however it has much smaller uncertainty on the predictions it makes and will confidently predict a false class for most images, whereas the other methods are more uncertain.
+
+Furthermore, we perform a targeted attack that attempts to force the network to predict a specific class, in our case $\cdot _ { 0 } \cdot \mathrm { \ }$ following (Li & Gal, 2017). Hence, for each method, we exclude all data points in the test set that are already predicted as $\cdot _ { 0 } \cdot \mathrm { \ }$ . The updates are of similar form to the untargeted attack, however they increase the probability of the pre-specified class $y$ rather than decreasing the current maximum as x(ty $x _ { y } ^ { ( t + 1 ) } = x _ { y } ^ { ( \bar { t } ) } + \eta \mathrm { s g n } \big ( \bar { \nabla } _ { x } \log \bar { p ^ { ( M ) } } ( y | x _ { y } ^ { ( t ) } ) \big )$ , where $x _ { y } ^ { ( 0 ) } = x$ .
+
+We use a step size of $\eta { = } 1 0 ^ { - 2 }$ for the targeted attack. The uncertainty and accuracy on the original and target class are shown in Fig. 4. Here, the Kronecker factored Laplace approximation has slightly smaller uncertainty at its peak in comparison to the other methods, however it appears to be much more robust. It only misclassifies over $5 0 \%$ of the images after about 20 steps, whereas for the other methods this is the case after roughly 10 steps and reaches $1 0 0 \%$ accuracy on the target class after almost 50 updates, whereas the other methods are fooled on all images after about 25 steps.
+
+In conjunction with the experiment on notMNIST, it appears that the Laplace approximation achieves higher uncertainty than Dropout away from the data, as in the untargeted attack. In the targeted attack it exhibits smaller uncertainty than Dropout, yet it is more robust to having its prediction changed. The diagonal Laplace approximation again performs similarly to Dropout.
+
+# 5.4 UNCERTAINTY ON MISCLASSIFICATIONS
+
+To highlight the scalability of our method, we apply it to a state-of-the-art convolutional network architecture. Recently, deep residual networks (He et al., 2016a;b) have been the most successful ones among those. As demonstrated in (Grosse & Martens, 2016), Kronecker factored curvature methods are applicable to convolutional layers by interpreting them as matrix-matrix multiplications.
+
+![](images/5ed41153d9002457c121cab0e2d0510ad1bedc3708935fa9b5bfa70ad80fe8a9.jpg)  
+Figure 5: Inverse ecdf of the predictive entropy from Wide Residual Networks trained with and without Dropout on CIFAR100. For misclassifications, curves on top corresponding to higher uncertainty are desirable, and curves on the bottom for correct classifications.
+
+We compare our uncertainty estimates on wide residual networks (Zagoruyko & Komodakis, 2016), a recent variation that achieved competitive performance on CIFAR100 (Krizhevsky & Hinton, 2009) while, in contrast to most other residual architectures, including Dropout at specific points. While this does not correspond to using Dropout in the Bayesian sense (Gal & Ghahramani, 2015), it allows us to at least compare our method to the uncertainty estimates obtained from Dropout.
+
+We note that it is straightforward to incorporate batch normalisation (Ioffe & Szegedy, 2015) into the curvature backpropagation algorithms, so we apply a standard Laplace approximation to its parameters as well. We are not aware of any interpretation of Dropout as performing Bayesian inference on the parameters of batch normalisation. Further implementation details are in Appendix G.
+
+Again, the accuracy of the prediction methods is comparable (see Table 2 in Appendix F). For calculating the curvature factors, we draw 5, 000 samples per image using the same data augmentation as during training, effectively increasing the dataset size to $2 . 5 \times 1 0 ^ { 8 }$ . The diagonal approximation had to be regularised to the extent of becoming deterministic, so we omit it from the results.
+
+In Fig. 5 we compare the distribution of the predictive uncertainty on the test set.5 We distinguish between the uncertainty on correct and incorrect classifications, as the mistakes of a system used in practice may be less severe if the network can at least indicate that it is uncertain. Thus, high uncertainty on misclassifications and low uncertainty on correct ones would be desirable, such that a system could return control to a human expert when it can not make a confident decision. In general, the network tends to be more uncertain on its misclassifcations than its correct ones regardless of whether it was trained with or without Dropout and of the method used for prediction. Both Dropout and the Laplace approximation similarly increase the uncertainty in the predictions, however this is irrespective of the correctness of the classification. Yet, our experiments show that the Kronecker factored Laplace approximation can be scaled to modern convolutional networks and maintain good classification accuracy while having similar uncertainty about the predictions as Dropout.
+
+We had to use much stronger regularisation for the Laplace approximation on the wide residual network, possibly because the block-diagonal approximation becomes more inaccurate on deep networks, possibly because the number of parameters is much higher relative to the number of data. It would be interesting to see how the Laplace approximations behaves on a much larger dataset like ImageNet for similarly sized networks, where we have a better ratio of data to parameters and curvature directions. However, even on a relatively small dataset like CIFAR we did not have to regularise the Laplace approximation to the degree of the posterior becoming deterministic.
+
+# 6 CONCLUSION
+
+We presented a scalable approximation to the Laplace approximation for the posterior of a neural network and provided experimental results suggesting that the uncertainty estimates are on par with current alternatives like Dropout, if not better. It enables practitioners to obtain principled uncertainty estimates from their models, even if they were trained in a maximum likelihood/MAP setting.
+
+There are many possible extensions to this work. One would be to automatically determine the scale and regularisation hyperparameters of the Kronecker factored Laplace approximation using the model evidence similar to how (MacKay, 1992) interpolates between the data log likelihood and the width of the prior. The model evidence could further be used to perform Bayesian model averaging on ensembles of neural networks, potentially improving their generalisation ability and uncertainty estimates. A challenging application would be active learning, where only little data is available relative to the number of curvature directions that need to be estimated.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the Alan Turing Institute under the EPSRC grant EP/N510129/1. We thank the anonymous reviewers for their feedback and Harshil Shah for his comments on an earlier draft of this paper.
+
+# REFERENCES
+
+Anoop Korattikara Balan, Vivek Rathod, Kevin P Murphy, and Max Welling. Bayesian Dark Knowledge. In Advances in Neural Information Processing Systems, pp. 3438–3446, 2015.   
+David Barber and Christopher M Bishop. Ensemble Learning for Multi-layer Networks. In Advances in Neural Information Processing Systems, pp. 395–401, 1998.   
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight Uncertainty in Neural Networks. In ICML, pp. 1613–1622, 2015.   
+Aleksandar Botev, Hippolyt Ritter, and David Barber. Practical Gauss-Newton Optimisation for Deep Learning. In ICML, pp. 557 – 565, 2017.   
+Sander Dieleman, Jan Schluter, Colin Raffel, Eben Olson, Søren Kaae Sønderby, Daniel Nouri, et al. ¨ Lasagne: First release., August 2015.   
+Yarin Gal and Zoubin Ghahramani. Bayesian Convolutional Neural Networks with BernoulliAapproximate Variational Inference. arXiv preprint arXiv:1506.02158, 2015.   
+Yarin Gal and Zoubin Ghahramani. Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning. In ICML, pp. 1050–1059, 2016.   
+Soumya Ghosh, Francesco Maria Delle Fave, and Jonathan S Yedidia. Assumed Density Filtering Methods for Learning Bayesian Neural Networks. In AAAI, pp. 1589–1595, 2016.   
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and Harnessing Adversarial Examples. arXiv preprint arXiv:1412.6572, 2014.   
+Alex Graves. Practical Variational Inference for Neural Networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011.   
+Roger Grosse and James Martens. A Kronecker-factored Approximate Fisher Matrix for Convolution Layers. In ICML, pp. 573–582, 2016.   
+Arjun K Gupta and Daya K Nagar. Matrix Variate Distributions, volume 104. CRC Press, 1999.   
+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, 2016a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity Mappings in Deep Residual Networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b.
+
+Jose Miguel Hern ´ andez-Lobato and Ryan Adams. Probabilistic Backpropagation for Scalable ´ Learning of Bayesian Neural Networks. In ICML, pp. 1861–1869, 2015.
+
+Geoffrey E Hinton and Drew Van Camp. Keeping the Neural Networks Simple by Minimizing the Description Length of the Weights. In COLT, pp. 5–13, 1993.
+
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In ICML, pp. 448–456, 2015.
+
+Diederik P Kingma and Max Welling. Auto-encoding Variational Bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Diederik P Kingma, Tim Salimans, and Max Welling. Variational Dropout and the Local Reparameterization Trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming Catastrophic Forgetting in Neural Networks. Proceedings of the National Academy of Sciences, pp. 201611835, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning Multiple Layers of Features from Tiny Images. 2009.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles. arXiv preprint arXiv:1612.01474, 2016.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal Brain Damage. In Advances in Neural Information Processing Systems, pp. 598–605, 1990.
+
+Yingzhen Li and Yarin Gal. Dropout Inference in Bayesian Neural Networks with Alphadivergences. arXiv preprint arXiv:1703.02914, 2017.
+
+Christos Louizos and Max Welling. Structured and Efficient Variational Deep Learning with Matrix Gaussian Posteriors. In ICML, pp. 1708–1716, 2016.
+
+Christos Louizos and Max Welling. Multiplicative Normalizing Flows for Variational Bayesian Neural Networks. In ICML, pp. 2218–2227, 2017.
+
+David J. C. MacKay. A Practical Bayesian Framework for Backpropagation Networks. Neural Computation, 4(3):448–472, 1992.
+
+James Martens and Roger Grosse. Optimizing Neural Networks with Kronecker-factored Approximate Curvature. In ICML, pp. 2408–2417, 2015.
+
+Radford M Neal. Bayesian Learning via Stochastic Dynamics. In Advances in Neural Information Processing Systems, pp. 475–482, 1993.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Shengyang Sun, Changyou Chen, and Lawrence Carin. Learning Structured Weight Uncertainty in Bayesian Neural Networks. In Artificial Intelligence and Statistics, pp. 1283–1292, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing Properties of Neural Networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Theano Development Team. Theano: A Python Framework for Fast Computation of Mathematical Expressions. arXiv e-prints, abs/1605.02688, May 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide Residual Networks. arXiv preprint arXiv:1605.07146, 2016.
+
+# Appendices
+
+# A DERIVATION OF THE ACTIVATION HESSIAN RECURSION
+
+Here, we provide the basic derivation of the factorisation of the diagonal blocks of the Hessian in Eq. 1 and the recursive formula for calculating $\mathcal { H }$ as presented in (Botev et al., 2017).
+
+The Hessian of a neural network with parameters $\theta$ as defined in the main text has elements:
+
+$$
+[ H ] _ { i j } = \frac { \partial ^ { 2 } } { \partial \theta _ { i } \partial \theta _ { j } } E ( \theta )
+$$
+
+For a given layer $\lambda$ , the gradient w.r.t. a weight $W _ { a , b } ^ { \lambda }$ is:
+
+$$
+{ \frac { \partial E } { \partial W _ { a , b } ^ { \lambda } } } = \sum _ { i } { \frac { \partial h _ { i } ^ { \lambda } } { \partial W _ { a , b } ^ { \lambda } } } { \frac { \partial E } { \partial h _ { i } ^ { \lambda } } } = a _ { b } ^ { \lambda - 1 } { \frac { \partial E } { \partial h _ { a } ^ { \lambda } } }
+$$
+
+Keeping $\lambda$ fixed and differentiating again, we find that the per-sample Hessian of that layer is:
+
+$$
+\left[ H _ { \lambda } \right] _ { ( a , b ) , ( c , d ) } \equiv \frac { \partial ^ { 2 } E } { \partial W _ { a , b } ^ { \lambda } \partial W _ { c , d } ^ { \lambda } } = a _ { b } ^ { \lambda - 1 } a _ { d } ^ { \lambda - 1 } \left[ \mathcal { H } _ { \lambda } \right] _ { a , c }
+$$
+
+where
+
+$$
+[ \mathcal { H } _ { \lambda } ] _ { a , b } = \frac { \partial ^ { 2 } E } { \partial h _ { a } ^ { \lambda } \partial h _ { b } ^ { \lambda } }
+$$
+
+is the pre-activation Hessian.
+
+We can reexpress this in matrix notation as a Kronecker product as in Eq. 1:
+
+$$
+H _ { \lambda } = \frac { \partial ^ { 2 } E } { \partial \operatorname { v e c } \left( W _ { \lambda } \right) \partial \operatorname { v e c } \left( W _ { \lambda } \right) } = \left( a _ { \lambda - 1 } a _ { \lambda - 1 } ^ { \mathsf { T } } \right) \otimes \mathcal { H } _ { \lambda }
+$$
+
+The pre-activation Hessian can be calculated recursively as:
+
+$$
+\mathcal { H } _ { \lambda } = B _ { \lambda } W _ { \lambda + 1 } ^ { \mathsf { T } } \mathcal { H } _ { \lambda + 1 } W _ { \lambda + 1 } B _ { \lambda } + D _ { \lambda }
+$$
+
+where the diagonal matrices $B$ and $D$ are defined as:
+
+$$
+\begin{array} { l } { { B _ { \lambda } = \mathrm { d i a g } \left( \mathbf f _ { \lambda } ^ { \prime } ( h _ { \lambda } ) \right) } } \\ { { D _ { \lambda } = \mathrm { d i a g } \left( \mathbf f _ { \lambda } ^ { \prime \prime } ( h _ { \lambda } ) { \frac { \partial E } { \partial a _ { \lambda } } } \right) } } \end{array}
+$$
+
+$\mathbf { f ^ { \prime } }$ and $\mathbf { f } ^ { \prime \prime }$ denote the first and second derivative of the transfer function. The recursion is initialised with the Hessian of the error w.r.t. the linear network outputs.
+
+For further details and on how to calculate the diagonal blocks of the Gauss-Newton and Fisher matrix, we refer the reader to (Botev et al., 2017) and (Martens & Grosse, 2015).
+
+# B MATRIX NORMAL DISTRIBUTION
+
+The matrix normal distribution (Gupta & Nagar, 1999) is a multivariate distribution over an entire matrix of shape $n \times p$ rather than just a vector. In contrast to the multivariate normal distribution, it is parameterised by two p.s.d. covariance matrices, $U : n \times n$ and $V : p \times p$ , which indicate the covariance of the rows and columns respectively. In addition it has a mean matrix $M : n \times p$ .
+
+A vectorised sample from a matrix normal distribution $X \sim { \mathcal { M N } } ( M , U , V )$ corresponds to a sample from a normal distribution $\operatorname { v e c } ( X ) \sim { \mathcal { N } } ( \operatorname { v e c } ( M ) , U \otimes V )$ . However, samples can be drawn more efficiently as $X = M + A Z B$ with $Z \sim \mathcal { M N } ( 0 , I , I )$ , and $A A ^ { \mathsf { T } } = U$ and $B ^ { \intercal } B = V$ . The sample $Z$ corresponds to a sample from a normal distribution of length $n p$ that has been reshaped to a $n \times p$ matrix. This is more efficient in the sense that we only need to calculate two matrix-matrix products of small matrices, rather than a matrix-vector product with one big one.
+
+# C APPROXIMATION OF THE EXPECTED ACTIVATION HESSIAN
+
+While the square root of $\mathcal { Q } _ { \lambda }$ is calculated during the forward pass on all layers, $\mathcal { H }$ requires an additional backward pass. Strictly speaking, it is not essential to approximate $\mathbb { E } \left[ \mathcal { H } \right]$ for the Kronecker factored Laplace approximation, as in contrast to optimisation procedures the curvature only needs to be calculated once and is thus not time critical. For datasets of the scale of ImageNet and the networks used for such datasets, it would still be impractically slow to perform the calculation for every data point individually. Furthermore, as most datasets are augmented during training, e.g. random cropping or reflections of images, the curvature of the network can be estimated using the same augmentations, effectively increasing the size of the dataset by orders of magnitude. Thus, we make use of the minibatch approximation in our experiments — as we make use of data augmentation — in order to demonstrate its practical applicability.
+
+We note that E [H] can be calculated exactly by running KFRA (Botev et al., 2017) with a minibatchsize of one, and then averaging the results. KFAC (Martens & Grosse, 2015), in contrast, stochastically approximates the Fisher matrix, so even when run for every datapoint separately, it cannot calculate the curvature factor exactly.
+
+In the following, we also show figures for the adversarial experiments in which we calculate the curvature per datapoint and without data augmentation:
+
+![](images/bd401ad0b8e9d0a6e372927c134409d5b015ccf19eb9e8745ca37ac78fb7f7a9.jpg)  
+Figure 6: Untargeted adversarial attack for Kronecker factored Laplace approximation with the curvature calculated with and without data augmentation/approximating the activation Hessian.
+
+Fig. 6 and Fig. 7 show how the Laplace approximation with the curvature estimated from 1000 randomly sampled binary MNIST images and the activation Hessian calculated with a minibatch size of 100 performs in comparison to the curvature factor being calculated without any data augmentation with a batch size of 100 or exactly. We note that without data augmentation we had to use much stronger regularisation of the curvature factors, in particular we had to add a non-negligible multiple of the identity to the factors, whereas with data augmentation it was only needed to ensure that the matrices are invertible. The Kronecker factored Laplace approximation reaches particularly high uncertainty on the untargeted adversarial attack and is most robust on the targeted attack when using data augmentation, suggesting that it is particularly well suited for large datasets and ones where some form of data augmentation can be applied. The difference between approximating the activation Hessian over a minibatch and calculating it exactly appears to be negligible.
+
+![](images/e31a6b6b0d0ab2399091e0aa6f1e8ffc0b21f98d8546841f2ad9096b7c2ec352.jpg)  
+Figure 7: Targeted adversarial attack for Kronecker factored Laplace approximation with the curvature calculated with and without data augmentation/approximating the activation Hessian.
+
+# D MEMORY AND COMPUTATIONAL REQUIREMENTS
+
+If we denote the dimensionality of the input to layer $\lambda$ as $D _ { \lambda - 1 }$ and its output as $D _ { \lambda }$ , the curvature factors correspond to the two precision matrices with Dλ−1(Dλ−1+1)2 and $\frac { D _ { \lambda } ( D _ { \lambda } + 1 ) } { 2 }$ ‘parameters’ to estimate, since they are symmetric. So across a network, the number of curvature directions that we are estimating grows linearly in the number of layers and quadratically in the dimension of the layers, i.e. the number of columns of the weight matrices. The size of the full Hessian, on the other hand, grows quadratically in the number of layers and with the fourth power in the dimensionality of the layers (assuming they are all the same size).
+
+Once the curvature factors are calculated, which only needs to be done once, we use their Cholesky decomposition to solve two triangular linear systems when sampling weights from the matrix normal distribution. We use the same weight samples for each minibatch, i.e. we do not sample a weight matrix per datapoint. This is for computational efficiency and does not change the expectation.
+
+One possibility to save computation time would be to sample a fixed set of weight matrices from the approximate posterior — in order to avoid solving the linear system on every forward pass — and treat the networks that they define as an ensemble. The individual ensemble members can be evaluated in parallel and their outputs averaged, which can be done with a small overhead over evaluating a single network given sufficient compute resources. A further speed up can be achieved by distilling the predictive distributions of the Laplace network into a smaller, deterministic feedforward network as successfully demonstrated in (Balan et al., 2015) for posterior samples using HMC.
+
+# E COMPLEMENTARY FIGURES FOR THE TOY DATASET
+
+Fig. 8 shows the different Laplace approximations (Kronecker factored, diagonal, full) from the main text without any hyperparameter tuning. The figure of the uncertainty obtained from samples using HMC is repeated. Note that the scale is larger than in the main text due to the high uncertainty of the Laplace approximations.
+
+The Laplace approximations are increasingly uncertain away from the data, as the true posterior estimated from HMC samples, however they all overestimate the uncertainty without regularisation. This is easy to fix by optimising the hyperparameters on a validation set as discussed in the main text, resulting in posterior uncertainty much more similar to the true posterior. As previously discussed in (Botev et al., 2017), the Hessian of a neural network is usually underdetermined as the number of data points is much smaller than the number of parameters — in our case we have 20 data points to estimate a $7 8 \times 7 8$ precision matrix. This leads to the full Laplace approximation vastly overestimating the uncertainty and a bad predictive mean. Both the Kronecker factored and the diagonal approximation exhibit smaller variance than the full Laplace approximation as they restrict the structure of the precision matrix. Consistently with the other experiments, we find the diagonal
+
+![](images/8728ab113d8def68159f046cb816ff9c7101a0cf17ad7545a887f6a29fd79c4f.jpg)  
+Figure 8: Toy regression uncertainty. Black dots are data points, the black line shows the underlying noiseless function. The red line shows the deterministic prediction of the trained network, the blue line the mean output. Each shade of blue visualises one additional standard deviation.
+
+Laplace approximation to place more mass in low probability areas of the posterior than the Kronecker factored approximation, resulting in higher variance on the regression problem. This leads to a need for greater regularisation of the diagonal approximation to obtain acceptable predictive performance, and underestimating the uncertainty.
+
+# F PREDICTION ACCURACY
+
+This section shows the accuracy values obtained from the different predictions methods on the feedforward networks for MNIST and the wide residual network for CIFAR100. The results for MNIST are shown in Table 1 and the results for CIFAR in Table 2.
+
+In all cases, neither MC Dropout nor the Laplace approximation significantly change the classification accuracy of the network in comparison to a deterministic forward pass.
+
+Table 1: Test accuracy of the feedforward network trained on MNIST   
+
+<table><tr><td>Prediction Method</td><td>Accuracy</td></tr><tr><td>FFG Deterministic</td><td>98.88% 98.86%</td></tr><tr><td>MC Dropout Diagonal Laplace</td><td>98.85% 98.85%</td></tr><tr><td>KF Laplace</td><td>98.80%</td></tr></table>
+
+Table 2: Accuracy on the final 5, 000 CIFAR100 test images for a wide residual network trained with and without Dropout.   
+
+<table><tr><td colspan="3">Accuracy</td></tr><tr><td>Prediction Method</td><td>Dropout</td><td>Deterministic</td></tr><tr><td>Deterministic</td><td>79.12%</td><td>79.18%</td></tr><tr><td>MC Dropout</td><td>79.20%</td><td>1</td></tr><tr><td>KF Laplace</td><td>79.10%</td><td>79.36%</td></tr></table>
+
+# G IMPLEMENTATION DETAILS FOR RESIDUAL NETWORKS
+
+Our wide residual network has $n { = } 3$ block repetitions and a width factor of $k { = } 8$ on CIFAR100 with and without Dropout using hyperparameters taken from (Zagoruyko & Komodakis, 2016): the network parameters are trained on a cross-entropy loss using Nesterov momentum with an initial learning rate of 0.1 and momentum of 0.9 for 200 epochs with a minibatch size of 128. We decay the learning rate every 50 epochs by a factor of 0.2, which is slightly different to the schedule used in (Zagoruyko & Komodakis, 2016) (they decay after 60, 120 and 160 epochs). As the original authors, we use $L _ { 2 }$ -regularisation with a factor of $5 \times 1 0 ^ { - 4 }$ .
+
+We make one small modification to the architecture: instead of downsampling with $1 \times 1$ convolutions with stride 2, we use $2 \times 2$ convolutions. This is due to Theano not supporting the transformation of images into the patches extracted by a convolution for $1 \times 1$ convolutions with stride greater than 1, which we require for our curvature backpropagation through convolutions.
+
+We apply a standard Laplace approximation to the batch normalisation parameters — a Kronecker factorisation is not needed, since the parameters are one-dimensional. When calculating the curvature factors, we use the moving averages for the per-layer means and standard deviations obtained after training, in order to maintain independence between the data points in a minibatch.
+
+We need to make a further approximation to the ones discussed in Section 2.2 when backpropagating the curvature for residual networks. The residual blocks compute a function of the form $r e s ( x ) =$ $x + f _ { \phi } ( x )$ , where $f _ { \phi }$ typically is a sequence of convolutions, batch normalisation and elementwise nonlinearities. This means that we would need to pass back two curvature matrices, one for each summand. However, this would double the number of backpropagated matrices for each residual connection, hence the computation time/memory requirements would grow exponentially in the number of residual blocks. Therefore, we simply add the curvature matrices after each residual connection.

parse/train/Skdvd2xAZ/Skdvd2xAZ_content_list.json

@@ -0,0 +1,1919 @@
+[
+    {
+        "type": "text",
+        "text": "A SCALABLE LAPLACE APPROXIMATION FOR NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            666,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hippolyt Ritter1∗, Aleksandar Botev1, David Barber1 2 1University College London 2Alan Turing Institute ",
+        "bbox": [
+            184,
+            166,
+            562,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We leverage recent insights from second-order optimisation for neural networks to construct a Kronecker factored Laplace approximation to the posterior over the weights of a trained network. Our approximation requires no modification of the training procedure, enabling practitioners to estimate the uncertainty of their models currently used in production without having to retrain them. We extensively compare our method to using Dropout and a diagonal Laplace approximation for estimating the uncertainty of a network. We demonstrate that our Kronecker factored method leads to better uncertainty estimates on out-of-distribution data and is more robust to simple adversarial attacks. Our approach only requires calculating two square curvature factor matrices for each layer. Their size is equal to the respective square of the input and output size of the layer, making the method efficient both computationally and in terms of memory usage. We illustrate its scalability by applying it to a state-of-the-art convolutional network architecture. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are most commonly trained in a maximum a posteriori (MAP) setting, which only yields point estimates of the parameters, ignoring any uncertainty about them. This often leads to overconfident predictions, especially in regimes that are weakly covered by training data or far away from the data manifold. While the confidence of wrong predictions is usually irrelevant in a research context, it is essential that a Machine Learning algorithm knows when it does not know in the real world, as the consequences of mistakes can be fatal, be it when driving a car or diagnosing a disease. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Bayesian framework of statistics provides a principled way for avoiding overconfidence in the parameters by treating them as unknown quantities and integrating over all possible values. Specifically, for the prediction of new data under a model, it fits a posterior distribution over the parameters given the training data and weighs the contribution of each setting of the parameters to the prediction by the probability of the data under those parameters times their prior probability. However, the posterior of neural networks is usually intractable due to their size and nonlinearity. ",
+        "bbox": [
+            174,
+            594,
+            823,
+            678
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There has been previous interest in integrating neural networks into the Bayesian framework (MacKay, 1992; Hinton & Van Camp, 1993; Neal, 1993; Barber & Bishop, 1998), however these approaches were designed for small networks by current standards. Recent adaptations to architectures of modern scale rely on crude approximations of the posterior to become tractable. All of (Graves, 2011; Hernandez-Lobato & Adams, 2015; Blundell et al., 2015) assume independence between the ´ individual weights. While they achieve good results on small datasets, this strong restriction of the posterior is susceptible to underestimating the uncertainty, in particular when optimising the variational bound. The approach in (Gal & Ghahramani, 2016) requires the use of certain stochastic regularisers which are not commonly present in most recent architectures. Furthermore, it is not clear if the approximate posterior defined by these regularisers is a good fit to the true posterior. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work on second-order optimisation of neural networks (Martens & Grosse, 2015; Botev et al., 2017) has demonstrated that the diagonal blocks of the curvature can be well approximated by a Kronecker product. We combine this insight with the idea of modelling the posterior over the weights as a Gaussian, using a Laplace approximation (MacKay, 1992) with Kronecker factored covariance matrices. This leads to a computationally efficient matrix normal posterior distribution (Gupta & Nagar, 1999) over the weights of every layer. Since the Laplace approximation is applied after training, our approach can be used to obtain uncertainty estimates from existing networks. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE CURVATURE OF NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            152,
+            555,
+            169
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method is inspired by recent Kronecker factored approximations of the curvature of a neural network (Martens & Grosse, 2015; Botev et al., 2017) for optimisation and we give a high-level review of these in the following. While the two methods approximate the Gauss-Newton and Fisher matrix respectively, as they are guaranteed to be positive semi-definite (p.s.d.), we base all of our discussion on the Hessian in order to be as general as possible. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            255
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NEURAL NETWORK NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            272,
+            429,
+            286
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We denote a feedforward network as taking an input $a _ { 0 } = x$ and producing an output $h _ { L }$ . The intermediate representations for layers $\\lambda = 1 , . . . , L$ are denoted as $h _ { \\lambda } = W _ { \\lambda } a _ { \\lambda - 1 }$ and $a _ { \\lambda } = f _ { \\lambda } ( h _ { \\lambda } )$ . We refer to $a _ { \\lambda }$ as the activations, and $h _ { \\lambda }$ as the (linear) pre-activations. The bias terms are absorbed into the $W _ { \\lambda }$ by appending a 1 to each $a _ { \\lambda }$ . The network parameters are optimised w.r.t. an error function $E ( y , h _ { L } )$ for targets $y$ . Most commonly used error functions, such as squared error and categorical cross-entropy, can be interpreted as exponential family negative log likelihoods $- \\log p ( y | h _ { L } )$ . ",
+        "bbox": [
+            173,
+            297,
+            825,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 KRONECKER FACTORED SECOND-ORDER OPTIMISATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            609,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Traditional second-order methods use either the Hessian matrix or a positive semi-definite approximation thereof to generate parameter updates of the form $\\Delta = C ^ { - 1 } g$ , where $C$ is the chosen curvature matrix and $g$ the gradient of the error function parameterised by the network. However, this curvature matrix is infeasbile to compute for modern neural networks as their number of parameters is often in the millions, rendering the size of $C$ of the order of several terabytes. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent work (Martens & Grosse, 2015; Botev et al., 2017) exploits that, for a single data point, the diagonal blocks of these curvature matrices are Kronecker factored: ",
+        "bbox": [
+            171,
+            503,
+            823,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8521042e25f111bdaac593dbe6b67fc61fa70b6a3348105b00e1d36391546d9.jpg",
+        "text": "$$\nH _ { \\lambda } = \\frac { \\partial ^ { 2 } E } { \\partial \\operatorname { v e c } ( W _ { \\lambda } ) \\partial \\operatorname { v e c } ( W _ { \\lambda } ) } = \\mathcal { Q } _ { \\lambda } \\otimes \\mathcal { H } _ { \\lambda }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            549,
+            638,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { \\lambda }$ is the Hessian w.r.t. the weights in layer $\\lambda$ . $\\mathcal { Q } _ { \\lambda } = a _ { \\lambda - 1 } a _ { \\lambda - 1 } ^ { \\top }$ denotes the covariance of the incoming activations aλ−1 and Hλ = ∂ E∂h ∂h the pre-activation Hessian, i.e. the Hessian of the error w.r.t. the linear pre-activations $h _ { \\lambda }$ in a layer. We provide the derivation for this result as well as the recursion for calculating $\\mathcal { H }$ in Appendix A. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Kronecker factorisation holds two key advantages: the matrices that need be computed and stored are much smaller — if we assume all layers to be of dimensionality $D$ , the two factors are each of size $D ^ { 2 }$ , whereas the full Hessian for the weights of only one layer would have $D ^ { 4 }$ elements. Furthermore, the inverse of a Kronecker product is equal to the Kronecker product of the inverses, so it is only necessary to invert those two moderately sized matrices. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to maintain this structure over a minibatch of data, all Kronecker factored second-order methods make two core approximations: First, they only model the diagonal blocks corresponding to the weights of a layer, such that the curvature decomposes into $L$ independent matrices. Second, they assume $\\mathcal { Q } _ { \\lambda }$ and $\\mathcal { H } _ { \\lambda }$ to be independent. This is in order to maintain the Kronecker factorisation in expectation, i.e. $\\mathbb { E } \\left[ \\mathcal { Q } _ { \\lambda } \\otimes \\mathcal { H } _ { \\lambda } \\right] \\approx \\mathbb { E } \\left[ \\mathcal { Q } _ { \\lambda } \\right] \\otimes \\mathbb { E } \\left[ \\mathcal { H } _ { \\lambda } \\right]$ , since the expectation of a Kronecker product is not guaranteed to be Kronecker factored itself. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main difference between the Kronecker factored second-order optimisers lies in how they efficiently approximate $\\mathbb { E } \\left[ \\mathcal { H } _ { \\lambda } \\right]$ . For exact calculation, it would be necessary to pass back an entire matrix per data point in a minibatch, which imposes infeasible memory and computational requirements. KFRA (Botev et al., 2017) simply passes back the expectation at every layer, while KFAC (Martens & Grosse, 2015) utilises the Fisher identity to only propagate a vector rather than a matrix, approximating the Kronecker factors with a stochastic rank-one matrix for each data point. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The diagonal blocks of the Hessian and Gauss-Newton matrix are equal for neural networks with piecewise linear activation functions (Botev et al., 2017), thus both methods can be used to directly approximate the diagonal blocks of the Hessian of such networks, as the Gauss-Newton and Fisher are equivalent for networks that parameterise an exponential family log likelihood. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 A SCALABLE LAPLACE APPROXIMATION FOR NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            183,
+            764,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 THE LAPLACE APPROXIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            214,
+            436,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The standard Laplace approximation is obtained by taking the second-order Taylor expansion around a mode of a distribution. For a neural network, such a mode can be found using standard gradientbased methods. Specifically, if we approximate the log posterior over the weights of a network given some data $\\mathcal { D }$ around a MAP estimate $\\boldsymbol { \\theta } ^ { * }$ , we obtain: ",
+        "bbox": [
+            173,
+            241,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/333314683c0abf6a5a733994f08d5666621f38a95390596a723f4505fce14fb6.jpg",
+        "text": "$$\n\\log p ( \\boldsymbol { \\theta } | \\mathcal { D } ) \\approx \\log p ( \\boldsymbol { \\theta } ^ { * } | \\mathcal { D } ) - \\frac { 1 } { 2 } \\big ( \\boldsymbol { \\theta } - \\boldsymbol { \\theta } ^ { * } \\big ) ^ { \\top } \\bar { H } ( \\boldsymbol { \\theta } - \\boldsymbol { \\theta } ^ { * } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            318,
+            671,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta = [ \\mathrm { v e c } ( W _ { 1 } ) , . . . , \\mathrm { v e c } ( W _ { L } ) ]$ is the stacked vector of weights and $\\bar { H } = \\mathbb { E } \\left[ H \\right]$ the average Hessian of the negative log posterior1. The first order term is missing because we expand the function around a maximum $\\boldsymbol { \\theta } ^ { * }$ , where the gradient is zero. If we exponentiate this equation, it is easy to notice that the right-hand side is of Gaussian functional form for $\\theta$ , thus we obtain a normal distribution by integrating over it. The posterior over the weights is then approximated as Gaussian: ",
+        "bbox": [
+            173,
+            359,
+            825,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf1e95882914704d05c830b48d2f12d37440a3d90aa302355aba74889230764b.jpg",
+        "text": "$$\n\\theta \\sim \\mathcal { N } ( \\theta ^ { * } , \\bar { H } ^ { - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            454,
+            558,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "assuming $\\bar { H }$ is p.s.d. We can then approximate the posterior mean when predicting on unseen data $D ^ { * }$ by averaging the predictions of $T$ Monte Carlo samples ${ \\boldsymbol { \\theta } } ^ { ( t ) }$ from the approximate posterior: ",
+        "bbox": [
+            173,
+            486,
+            828,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f13d48c5e36c255d6f912a3e1f350bef6320aee46d47d9383bec0c07e6aafda.jpg",
+        "text": "$$\np ( \\mathcal { D } ^ { * } | \\mathcal { D } ) = \\int p ( \\mathcal { D } ^ { * } | \\boldsymbol { \\theta } ) p ( \\boldsymbol { \\theta } | \\mathcal { D } ) d \\boldsymbol { \\theta } \\approx \\frac { 1 } { T } \\sum _ { t = 1 } ^ { T } p ( \\mathcal { D } ^ { * } | \\boldsymbol { \\theta } ^ { ( t ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            537,
+            678,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DIAGONAL LAPLACE APPROXIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            483,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, it is not feasible to compute or invert the Hessian matrix w.r.t. all of the weights jointly. An approximation that is easy to compute in modern automatic differentiation frameworks is the diagonal of the Fisher matrix $F$ , which is simply the expectation of the squared gradients: ",
+        "bbox": [
+            174,
+            625,
+            826,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67d188bafccb6d7e7a78a805a8871adc852fc39c49b2f49bd9a5d47743c3ee5d.jpg",
+        "text": "$$\nH \\approx \\mathrm { d i a g } ( F ) = \\mathrm { d i a g } ( \\mathbb { E } \\left[ \\nabla _ { \\theta } \\log p ( y | x ) \\nabla _ { \\theta } \\log p ( y | x ) ^ { \\top } \\right] ) = \\mathrm { d i a g } ( \\mathbb { E } \\left[ ( \\nabla _ { \\theta } \\log p ( y | x ) ) ^ { 2 } \\right] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            694,
+            781,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where diag extracts the diagonal of a matrix or turns a vector into a diagonal matrix. Such diagonal approximations to the curvature of a neural network have been used successfully for pruning the weights (LeCun et al., 1990) and, more recently, for transfer learning (Kirkpatrick et al., 2017). ",
+        "bbox": [
+            174,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This corresponds to modelling the weights with a Normal distribution with diagonal covariance: ",
+        "bbox": [
+            171,
+            785,
+            803,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d202f8c5ff2b2edab4d5ba7d43596938a2eb555b65c7068640ed3f9320b4c52f.jpg",
+        "text": "$$\n\\operatorname { v e c } ( W _ { \\lambda } ) \\sim { \\mathcal { N } } ( \\operatorname { v e c } ( W _ { \\lambda } ^ { * } ) , \\operatorname { d i a g } ( F _ { \\lambda } ) ^ { - 1 } ) \\quad { \\mathrm { f o r ~ } } \\lambda = 1 , \\dots , L\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            820,
+            694,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, even if the Taylor approximation is accurate, this will place significant probability mass in low probability areas of the true posterior if some weights exhibit high covariance. ",
+        "bbox": [
+            171,
+            853,
+            823,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 KRONECKER FACTORED LAPLACE APPROXIMATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            575,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "So while it is desirable to model the covariance between the weights, some approximations are needed in order to remain computationally efficient. First, we assume the weights of the different layers to be independent. This corresponds to the block-diagonal approximation in KFAC and KFRA, which empirically preserves sufficient information about the curvature to obtain competitive optimisation performance. For our purposes this means that our posterior factorises over the layers. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed above, the Hessian of the log-likelihood for a single datapoint is Kronecker factored, and we denote the two factor matrices as ${ \\cal H } _ { \\lambda } = { \\mathcal Q } _ { \\lambda } \\otimes { \\mathcal H } _ { \\lambda }$ .2 By further assuming independence between $\\mathcal { Q }$ and $\\mathcal { H }$ in all layers, we can approximate the expected Hessian of each layer as: ",
+        "bbox": [
+            174,
+            205,
+            825,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4e47d88af0576da23b9a0a7ce485ed4397c8ae1f2380f8a4bc9dfa977f43fd8.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ H _ { \\lambda } \\right] = \\mathbb { E } \\left[ \\mathcal { Q } _ { \\lambda } \\otimes \\mathcal { H } _ { \\lambda } \\right] \\approx \\mathbb { E } \\left[ \\mathcal { Q } _ { \\lambda } \\right] \\otimes \\mathbb { E } \\left[ \\mathcal { H } _ { \\lambda } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            270,
+            645,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hence, the Hessian of every layer is Kronecker factored over an entire dataset and the Laplace approximation can be approximated by a product of Gaussians. Each Gaussian has a Kronecker factored covariance, corresponding to a matrix normal distribution (Gupta & Nagar, 1999), which considers the two Kronecker factors of the covariance to be the covariances of the rows and columns of a matrix. The two factors are much smaller than the full covariance and allow for significantly more efficient inversion and sampling (we review the matrix normal distribution in Appendix B). ",
+        "bbox": [
+            174,
+            296,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our resulting posterior for the weights in layer $\\lambda$ is then: ",
+        "bbox": [
+            173,
+            388,
+            545,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8e7ca58ef6b39545d43d71a592e83d9d0fa209d6d79cfde44af829dd7be389d.jpg",
+        "text": "$$\nW _ { \\lambda } \\sim \\mathcal { M N } ( W _ { \\lambda } ^ { \\ast } , \\bar { \\mathcal { Q } } _ { \\lambda } ^ { - 1 } , \\bar { \\mathcal { H } } _ { \\lambda } ^ { - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            420,
+            599,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast to optimisation methods, we do not need to approximate $\\mathbb { E } \\left[ \\mathcal { H } _ { \\lambda } \\right]$ as it is only calculated once. However, when it is possible to augment the data (e.g. randomised cropping of images), it may be advantageous. We provide a more detailed discussion of this in Appendix C. ",
+        "bbox": [
+            174,
+            449,
+            826,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 INCORPORATING THE PRIOR AND REGULARISING THE CURVATURE FACTORS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            508,
+            748,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Just as the log posterior, the Hessian decomposes into a term depending on the data log likelihood and one on the prior. For the commonly used $L _ { 2 }$ -regularisation, corresponding to a Gaussian prior, the Hessian is equal to the precision of the prior times the identity matrix. We approximate this by adding a multiple of the identity to each of the Kronecker factors from the log likelihood: ",
+        "bbox": [
+            174,
+            534,
+            825,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f831ef21c86d130330cc83051752a1f5eecb53501d281a26f3ec861b7202903.jpg",
+        "text": "$$\nH _ { \\lambda } = N \\mathbb { E } \\left[ - \\frac { \\partial ^ { 2 } \\log p ( \\mathcal { D } | \\theta ) } { \\partial \\theta ^ { 2 } } \\right] + \\tau I \\approx ( \\sqrt { N } \\mathbb { E } \\left[ \\mathcal { Q } _ { \\lambda } \\right] + \\sqrt { \\tau } I ) \\otimes ( \\sqrt { N } \\mathbb { E } \\left[ \\mathcal { H } _ { \\lambda } \\right] + \\sqrt { \\tau } I )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            607,
+            781,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is the precision of the Gaussian prior on the weights and $N$ the size of the dataset. However, we can also treat them as hyperparameters and optimise them w.r.t. the predictive performance on a validation set. We emphasise that this can be done without retraining the network, so it does not impose a large computational overhead and is trivial to parallelise. ",
+        "bbox": [
+            176,
+            659,
+            823,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Setting $N$ to a larger value than the size of the dataset can be interpreted as including duplicates of the data points as pseudo-observations. Adding a multiple of the uncertainty to the precision matrix decreases the uncertainty about each parameter. This has a regularising effect both on our approximation to the true Laplace, which may be overestimating the variance in certain directions due to ignoring the covariances between the layers, as well as the Laplace approximation itself, which may be placing probability mass in low probability areas of the true posterior. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            344,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most recent attempts to approximating the posterior of a neural network are based on formulating an approximate distribution to the posterior and optimising the variational lower bound w.r.t. its parameters. (Graves, 2011; Blundell et al., 2015; Kingma et al., 2015) as well as the expectation propagation based approaches of (Hernandez-Lobato & Adams, 2015) and (Ghosh et al., 2016) ´ assume independence between the individual weights which, particularly when optimising the KL divergence, often lets the model underestimate the uncertainty about the weights. Gal & Ghahramani (2016) interpret Dropout to approximate the posterior with a mixture of delta functions, assuming independence between the columns. (Lakshminarayanan et al., 2016) suggest using an ensemble of networks for estimating the uncertainty. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our work is a scalable approximation of (MacKay, 1992). Since the per-layer Hessian of a neural network is infeasible to compute, we suggest a factorisation of the covariance into a Kronecker product, leading to a more efficient matrix normal distribution. The posterior that we obtain is reminiscent of (Louizos & Welling, 2016) and (Sun et al., 2017), who optimise the parameters of a matrix normal distribution as their weights, which requires a modification of the training procedure. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            301,
+            326,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the Laplace approximation is a method for predicting in a Bayesian manner and not for training, we focus on comparing to uncertainty estimates obtained from Dropout (Gal & Ghahramani, 2016). The trained networks will be identical, but the prediction methods will differ. We also compare to a diagonal Laplace approximation to highlight the benefit from modelling the covariances between the weights. All experiments are implemented using Theano (Theano Development Team, 2016) and Lasagne (Dieleman et al., 2015).3 ",
+        "bbox": [
+            174,
+            334,
+            825,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 TOY REGRESSION DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            406,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As a first experiment, we visualise the uncertainty obtained from the Laplace approximations on a toy regression dataset, similar to (Hernandez-Lobato´ $\\&$ Adams, 2015). We create a dataset of 20 uniformly distributed points $x \\sim \\mathcal { U } ( - 4 , 4 )$ and sample $y \\sim \\mathcal { N } ( x ^ { 3 } , 3 ^ { 2 } )$ . In contrast to (Hernandez- ´ Lobato & Adams, 2015), we use a two-layer network with seven units per layer rather than one layer with 100 units. This is because both the input and output are one-dimensional, hence the weight matrices are vectors and the matrix normal distribution reduces to a multivariate normal distribution. Furthermore, the Laplace approximation is sensitive to the ratio of the number of data points to parameters, and we want to visualise it both with and without hyperparameter tuning. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/debac792cdab601dfb06184753b4dcbf42158c1124917b3079299c753416bc64.jpg",
+        "image_caption": [
+            "Figure 1: Toy regression uncertainty. Black dots are data points, the black line shows the noiseless function. The red line shows the deterministic prediction of the network, the blue line the mean output. Each shade of blue visualises one additional standard deviation. Best viewed on screen. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            608,
+            807,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fig. 1 shows the uncertainty obtained from the Kronecker factored and diagonal Laplace approximation applied to the same network, as well as from a full Laplace approximation and $5 0 , 0 0 0 \\mathrm { H M C }$ (Neal, 1993) samples. The latter two methods are feasible only for such a small model and dataset. For the diagonal and full Laplace approximation we use the Fisher identity and draw one sample per data point. We set the hyperparameters of the Laplace approximations (see Section 3.4) using a grid search over the likelihood of 20 validation points that are sampled the same way as the training set. ",
+        "bbox": [
+            173,
+            809,
+            825,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The regularised Laplace approximations all give an overall good fit to the HMC predictive posterior. Their uncertainty is slightly higher close to the training data and increases more slowly away from the data than that of the HMC posterior. The diagonal and full Laplace approximation require stronger regularisation than our Kronecker factored one, as they have higher uncertainty when not regularised. In particular the full Laplace approximation vastly overestimates the uncertainty without additional regularisation, leading to a bad predictive mean (see Appendix E for the corresponding figures), as the Hessian of the log likelihood is underdetermined. This is commonly the case in deep learning, as the number of parameters is typically much larger than the number of data points. Hence restricting the structure of the covariance is not only a computational necessity for most architectures, but also allows for more precise estimation of the approximate covariance. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 OUT-OF-DISTRIBUTION UNCERTAINTY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            267,
+            482,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For a more realistic test, similar to (Louizos & Welling, 2017), we assess the uncertainty of the predictions when classifying data from a different distribution than the training data. For this we train a network with two layers of 1024 hidden units and ReLU transfer functions to classify MNIST digits. We use a learning rate of $1 0 ^ { - 2 }$ and momentum of 0.9 for 250 epochs. We apply Dropout with $p { = } 0 . 5$ after each inner layer, as our chief interest is to compare against its uncertainty estimates. We further use $L _ { 2 }$ -regularisation with a factor of $1 0 ^ { - 2 }$ and randomly binarise the images during training according to their pixel intensities and draw $1 , 0 0 0$ such samples per datapoint for estimating the curvature factors. We use this network to classify the images in the notMNIST dataset4, which contains $2 8 \\times 2 8$ grey-scale images of the letters $\\mathbf { \\dot { A } } ^ { \\prime }$ to $\\mathbf { \\hat { J } } ^ { \\star }$ from various computer fonts, i.e. not digits. An ideal classifier would make uniform predictions over its classes. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the uncertainty obtained by predicting the digit class of the notMNIST images using 1. a deterministic forward pass through the Dropout trained network, 2. by sampling different Dropout masks and averaging the predictions, and by sampling different weight matrices from 3. the matrix normal distribution obtained from our Kronecker factored Laplace approximation as well as 4. the diagonal one. As an additional baseline similar to (Blundell et al., 2015; Graves, 2011), we compare to a network with identical architecture with a fully factorised Gaussian (FFG) approximate posterior on the weights and a standard normal prior. We train the model on the variational lower bound using the reparametrisation trick (Kingma & Welling, 2013). We use 100 samples for the stochastic forward passes and optimise the hyperparameters of the Laplace approximations w.r.t. the cross-entropy on the validation set of MNIST. ",
+        "bbox": [
+            174,
+            449,
+            483,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d894a7edf56530a450cd12d773fa589c25cc119d5b25ad9f5c7d7640b554c41f.jpg",
+        "image_caption": [
+            "Figure 2: Predictive entropy on notMNIST obtained from different methods for the forward pass on a network trained on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            483,
+            792,
+            631
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            712,
+            625,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We measure the uncertainty of the different methods as the entropy of the predictive distribution, which has a minimal value of 0 when a single class is predicted with certainty and a maximum of about 2.3 for uniform predictions. Fig. 2 shows the inverse empirical cumulative distribution of the entropy values obtained from the four methods. Consistent with the results in (Gal & Ghahramani, 2016), averaging the probabilities of multiple passes through the network yields predictions with higher uncertainty than a deterministic pass that approximates the geometric average (Srivastava et al., 2014). However, there still are some images that are predicted to be a digit with certainty. Our Kronecker factored Laplace approximation makes hardly any predictions with absolute certainty and assigns high uncertainty to most of the letters as desired. The diagonal Laplace approximation required stronger regularisation towards predicting deterministically, yet it performs similarly to Dropout. As shown in Table 1, however, the network makes predictions on the test set of MNIST with similar accuracy to the deterministic forward pass and MC Dropout when using our approximation. The variational factorised Gaussian posterior has low uncertainty as expected. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            398,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed41abe45c3623949c3b8185e71c83cf08c0f3240991f92ab6369cada44c3cfe.jpg",
+        "image_caption": [
+            "Figure 3: Untargeted adversarial attack. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            176,
+            495,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/bd7abf0110987c858acf90a823a00cb267f5508f27375bc544386b20b41304ac.jpg",
+        "image_caption": [
+            "Figure 4: Targeted adversarial attack. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            176,
+            792,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further test the robustness of our prediction method close to the data distribution, we perform an adversarial attack on a neural network. As first demonstrated in (Szegedy et al., 2013), neural networks are prone to being fooled by gradient-based changes to their inputs. Li & Gal (2017) suggest, and provide empirical support, that Bayesian models may be more robust to such attacks, since they implicitly form an infinitely large ensemble by integrating over the model parameters. For our experiments, we use the fully connected net trained on MNIST from the previous section and compare the sensitivity of the different prediction methods for two kinds of adversarial attacks. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we use the untargeted Fast Gradient Sign method $\\begin{array} { r } { x _ { a d v } = x - \\eta \\mathrm { s g n } ( \\nabla _ { x } \\operatorname* { m a x } _ { y } \\log p ^ { ( M ) } ( y | x ) ) } \\end{array}$ suggested in (Goodfellow et al., 2014), which takes the gradient of the class predicted with maximal probability by method $M$ w.r.t. the input $x$ and reduces this probability with varying step size $\\eta$ This step size is rescaled by the difference between the maximal and minimal value per dimension in the dataset. It is to be expected that this method generates examples away from the data manifold, as there is no clear subset of the data that corresponds to e.g. ”not ones”. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows the average predictive uncertainty and the accuracy on the original class on the MNIST test set as the step size $\\eta$ increases. The Kronecker factored Laplace approximation achieves significantly higher uncertainty than any other prediction method as the images move away from the data. Both the diagonal and the Kronecker factored Laplace maintain higher accuracy than MC Dropout on their original predictions. Interestingly, the deterministic forward pass appears to be most robust in terms of accuracy, however it has much smaller uncertainty on the predictions it makes and will confidently predict a false class for most images, whereas the other methods are more uncertain. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we perform a targeted attack that attempts to force the network to predict a specific class, in our case $\\cdot _ { 0 } \\cdot \\mathrm { \\ }$ following (Li & Gal, 2017). Hence, for each method, we exclude all data points in the test set that are already predicted as $\\cdot _ { 0 } \\cdot \\mathrm { \\ }$ . The updates are of similar form to the untargeted attack, however they increase the probability of the pre-specified class $y$ rather than decreasing the current maximum as x(ty $x _ { y } ^ { ( t + 1 ) } = x _ { y } ^ { ( \\bar { t } ) } + \\eta \\mathrm { s g n } \\big ( \\bar { \\nabla } _ { x } \\log \\bar { p ^ { ( M ) } } ( y | x _ { y } ^ { ( t ) } ) \\big )$ , where $x _ { y } ^ { ( 0 ) } = x$ . ",
+        "bbox": [
+            173,
+            623,
+            825,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use a step size of $\\eta { = } 1 0 ^ { - 2 }$ for the targeted attack. The uncertainty and accuracy on the original and target class are shown in Fig. 4. Here, the Kronecker factored Laplace approximation has slightly smaller uncertainty at its peak in comparison to the other methods, however it appears to be much more robust. It only misclassifies over $5 0 \\%$ of the images after about 20 steps, whereas for the other methods this is the case after roughly 10 steps and reaches $1 0 0 \\%$ accuracy on the target class after almost 50 updates, whereas the other methods are fooled on all images after about 25 steps. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In conjunction with the experiment on notMNIST, it appears that the Laplace approximation achieves higher uncertainty than Dropout away from the data, as in the untargeted attack. In the targeted attack it exhibits smaller uncertainty than Dropout, yet it is more robust to having its prediction changed. The diagonal Laplace approximation again performs similarly to Dropout. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 UNCERTAINTY ON MISCLASSIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            495,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To highlight the scalability of our method, we apply it to a state-of-the-art convolutional network architecture. Recently, deep residual networks (He et al., 2016a;b) have been the most successful ones among those. As demonstrated in (Grosse & Martens, 2016), Kronecker factored curvature methods are applicable to convolutional layers by interpreting them as matrix-matrix multiplications. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ed41153d9002457c121cab0e2d0510ad1bedc3708935fa9b5bfa70ad80fe8a9.jpg",
+        "image_caption": [
+            "Figure 5: Inverse ecdf of the predictive entropy from Wide Residual Networks trained with and without Dropout on CIFAR100. For misclassifications, curves on top corresponding to higher uncertainty are desirable, and curves on the bottom for correct classifications. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            99,
+            794,
+            241
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our uncertainty estimates on wide residual networks (Zagoruyko & Komodakis, 2016), a recent variation that achieved competitive performance on CIFAR100 (Krizhevsky & Hinton, 2009) while, in contrast to most other residual architectures, including Dropout at specific points. While this does not correspond to using Dropout in the Bayesian sense (Gal & Ghahramani, 2015), it allows us to at least compare our method to the uncertainty estimates obtained from Dropout. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We note that it is straightforward to incorporate batch normalisation (Ioffe & Szegedy, 2015) into the curvature backpropagation algorithms, so we apply a standard Laplace approximation to its parameters as well. We are not aware of any interpretation of Dropout as performing Bayesian inference on the parameters of batch normalisation. Further implementation details are in Appendix G. ",
+        "bbox": [
+            174,
+            455,
+            823,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Again, the accuracy of the prediction methods is comparable (see Table 2 in Appendix F). For calculating the curvature factors, we draw 5, 000 samples per image using the same data augmentation as during training, effectively increasing the dataset size to $2 . 5 \\times 1 0 ^ { 8 }$ . The diagonal approximation had to be regularised to the extent of becoming deterministic, so we omit it from the results. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 5 we compare the distribution of the predictive uncertainty on the test set.5 We distinguish between the uncertainty on correct and incorrect classifications, as the mistakes of a system used in practice may be less severe if the network can at least indicate that it is uncertain. Thus, high uncertainty on misclassifications and low uncertainty on correct ones would be desirable, such that a system could return control to a human expert when it can not make a confident decision. In general, the network tends to be more uncertain on its misclassifcations than its correct ones regardless of whether it was trained with or without Dropout and of the method used for prediction. Both Dropout and the Laplace approximation similarly increase the uncertainty in the predictions, however this is irrespective of the correctness of the classification. Yet, our experiments show that the Kronecker factored Laplace approximation can be scaled to modern convolutional networks and maintain good classification accuracy while having similar uncertainty about the predictions as Dropout. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We had to use much stronger regularisation for the Laplace approximation on the wide residual network, possibly because the block-diagonal approximation becomes more inaccurate on deep networks, possibly because the number of parameters is much higher relative to the number of data. It would be interesting to see how the Laplace approximations behaves on a much larger dataset like ImageNet for similarly sized networks, where we have a better ratio of data to parameters and curvature directions. However, even on a relatively small dataset like CIFAR we did not have to regularise the Laplace approximation to the degree of the posterior becoming deterministic. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a scalable approximation to the Laplace approximation for the posterior of a neural network and provided experimental results suggesting that the uncertainty estimates are on par with current alternatives like Dropout, if not better. It enables practitioners to obtain principled uncertainty estimates from their models, even if they were trained in a maximum likelihood/MAP setting. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are many possible extensions to this work. One would be to automatically determine the scale and regularisation hyperparameters of the Kronecker factored Laplace approximation using the model evidence similar to how (MacKay, 1992) interpolates between the data log likelihood and the width of the prior. The model evidence could further be used to perform Bayesian model averaging on ensembles of neural networks, potentially improving their generalisation ability and uncertainty estimates. A challenging application would be active learning, where only little data is available relative to the number of curvature directions that need to be estimated. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            316,
+            367,
+            330
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the Alan Turing Institute under the EPSRC grant EP/N510129/1. We thank the anonymous reviewers for their feedback and Harshil Shah for his comments on an earlier draft of this paper. ",
+        "bbox": [
+            176,
+            347,
+            825,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            285,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anoop Korattikara Balan, Vivek Rathod, Kevin P Murphy, and Max Welling. Bayesian Dark Knowledge. In Advances in Neural Information Processing Systems, pp. 3438–3446, 2015.   \nDavid Barber and Christopher M Bishop. Ensemble Learning for Multi-layer Networks. In Advances in Neural Information Processing Systems, pp. 395–401, 1998.   \nCharles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight Uncertainty in Neural Networks. In ICML, pp. 1613–1622, 2015.   \nAleksandar Botev, Hippolyt Ritter, and David Barber. Practical Gauss-Newton Optimisation for Deep Learning. In ICML, pp. 557 – 565, 2017.   \nSander Dieleman, Jan Schluter, Colin Raffel, Eben Olson, Søren Kaae Sønderby, Daniel Nouri, et al. ¨ Lasagne: First release., August 2015.   \nYarin Gal and Zoubin Ghahramani. Bayesian Convolutional Neural Networks with BernoulliAapproximate Variational Inference. arXiv preprint arXiv:1506.02158, 2015.   \nYarin Gal and Zoubin Ghahramani. Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning. In ICML, pp. 1050–1059, 2016.   \nSoumya Ghosh, Francesco Maria Delle Fave, and Jonathan S Yedidia. Assumed Density Filtering Methods for Learning Bayesian Neural Networks. In AAAI, pp. 1589–1595, 2016.   \nIan J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and Harnessing Adversarial Examples. arXiv preprint arXiv:1412.6572, 2014.   \nAlex Graves. Practical Variational Inference for Neural Networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011.   \nRoger Grosse and James Martens. A Kronecker-factored Approximate Fisher Matrix for Convolution Layers. In ICML, pp. 573–582, 2016.   \nArjun K Gupta and Daya K Nagar. Matrix Variate Distributions, volume 104. CRC Press, 1999.   \nKaiming 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, 2016a. ",
+        "bbox": [
+            171,
+            421,
+            826,
+            928
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity Mappings in Deep Residual Networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jose Miguel Hern ´ andez-Lobato and Ryan Adams. Probabilistic Backpropagation for Scalable ´ Learning of Bayesian Neural Networks. In ICML, pp. 1861–1869, 2015. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Drew Van Camp. Keeping the Neural Networks Simple by Minimizing the Description Length of the Weights. In COLT, pp. 5–13, 1993. ",
+        "bbox": [
+            178,
+            175,
+            821,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In ICML, pp. 448–456, 2015. ",
+        "bbox": [
+            176,
+            212,
+            823,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding Variational Bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            176,
+            247,
+            821,
+            276
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma, Tim Salimans, and Max Welling. Variational Dropout and the Local Reparameterization Trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015. ",
+        "bbox": [
+            176,
+            284,
+            823,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming Catastrophic Forgetting in Neural Networks. Proceedings of the National Academy of Sciences, pp. 201611835, 2017. ",
+        "bbox": [
+            173,
+            333,
+            826,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning Multiple Layers of Features from Tiny Images. 2009. ",
+        "bbox": [
+            173,
+            396,
+            821,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles. arXiv preprint arXiv:1612.01474, 2016. ",
+        "bbox": [
+            174,
+            433,
+            821,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, and Sara A. Solla. Optimal Brain Damage. In Advances in Neural Information Processing Systems, pp. 598–605, 1990. ",
+        "bbox": [
+            176,
+            468,
+            823,
+            498
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yingzhen Li and Yarin Gal. Dropout Inference in Bayesian Neural Networks with Alphadivergences. arXiv preprint arXiv:1703.02914, 2017. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos and Max Welling. Structured and Efficient Variational Deep Learning with Matrix Gaussian Posteriors. In ICML, pp. 1708–1716, 2016. ",
+        "bbox": [
+            173,
+            541,
+            823,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos and Max Welling. Multiplicative Normalizing Flows for Variational Bayesian Neural Networks. In ICML, pp. 2218–2227, 2017. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David J. C. MacKay. A Practical Bayesian Framework for Backpropagation Networks. Neural Computation, 4(3):448–472, 1992. ",
+        "bbox": [
+            173,
+            613,
+            823,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing Neural Networks with Kronecker-factored Approximate Curvature. In ICML, pp. 2408–2417, 2015. ",
+        "bbox": [
+            171,
+            648,
+            823,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Radford M Neal. Bayesian Learning via Stochastic Dynamics. In Advances in Neural Information Processing Systems, pp. 475–482, 1993. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            714
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shengyang Sun, Changyou Chen, and Lawrence Carin. Learning Structured Weight Uncertainty in Bayesian Neural Networks. In Artificial Intelligence and Statistics, pp. 1283–1292, 2017. ",
+        "bbox": [
+            173,
+            771,
+            821,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing Properties of Neural Networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            174,
+            808,
+            823,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python Framework for Fast Computation of Mathematical Expressions. arXiv e-prints, abs/1605.02688, May 2016. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide Residual Networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            173,
+            893,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Appendices ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            334,
+            127
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DERIVATION OF THE ACTIVATION HESSIAN RECURSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            145,
+            676,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here, we provide the basic derivation of the factorisation of the diagonal blocks of the Hessian in Eq. 1 and the recursive formula for calculating $\\mathcal { H }$ as presented in (Botev et al., 2017). ",
+        "bbox": [
+            171,
+            179,
+            825,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The Hessian of a neural network with parameters $\\theta$ as defined in the main text has elements: ",
+        "bbox": [
+            176,
+            214,
+            777,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f296d35cb406ef6eb9012ee3b6a4216e5267cab6413a299488245fd078eadb1.jpg",
+        "text": "$$\n[ H ] _ { i j } = \\frac { \\partial ^ { 2 } } { \\partial \\theta _ { i } \\partial \\theta _ { j } } E ( \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            250,
+            573,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For a given layer $\\lambda$ , the gradient w.r.t. a weight $W _ { a , b } ^ { \\lambda }$ is: ",
+        "bbox": [
+            173,
+            303,
+            539,
+            320
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83dba684467e560f40061ae37edaec35ad0a2115e940c900c683886e03489863.jpg",
+        "text": "$$\n{ \\frac { \\partial E } { \\partial W _ { a , b } ^ { \\lambda } } } = \\sum _ { i } { \\frac { \\partial h _ { i } ^ { \\lambda } } { \\partial W _ { a , b } ^ { \\lambda } } } { \\frac { \\partial E } { \\partial h _ { i } ^ { \\lambda } } } = a _ { b } ^ { \\lambda - 1 } { \\frac { \\partial E } { \\partial h _ { a } ^ { \\lambda } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            339,
+            630,
+            381
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keeping $\\lambda$ fixed and differentiating again, we find that the per-sample Hessian of that layer is: ",
+        "bbox": [
+            171,
+            393,
+            787,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4a81dbe7d6040535c7d848c28f2c79f66c521dabc27e35ecc127cf4e545e4a9.jpg",
+        "text": "$$\n\\left[ H _ { \\lambda } \\right] _ { ( a , b ) , ( c , d ) } \\equiv \\frac { \\partial ^ { 2 } E } { \\partial W _ { a , b } ^ { \\lambda } \\partial W _ { c , d } ^ { \\lambda } } = a _ { b } ^ { \\lambda - 1 } a _ { d } ^ { \\lambda - 1 } \\left[ \\mathcal { H } _ { \\lambda } \\right] _ { a , c }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            429,
+            671,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            173,
+            483,
+            217,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19269707e999e2664986cce1d5888ad8b2f6e20b86f3dc7bbadf68aee2228634.jpg",
+        "text": "$$\n[ \\mathcal { H } _ { \\lambda } ] _ { a , b } = \\frac { \\partial ^ { 2 } E } { \\partial h _ { a } ^ { \\lambda } \\partial h _ { b } ^ { \\lambda } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            517,
+            566,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "is the pre-activation Hessian. ",
+        "bbox": [
+            174,
+            569,
+            364,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We can reexpress this in matrix notation as a Kronecker product as in Eq. 1: ",
+        "bbox": [
+            171,
+            590,
+            671,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36187593be22e70d34cda56a97545b1794bc291950b32db101df9d3a58cf5d5e.jpg",
+        "text": "$$\nH _ { \\lambda } = \\frac { \\partial ^ { 2 } E } { \\partial \\operatorname { v e c } \\left( W _ { \\lambda } \\right) \\partial \\operatorname { v e c } \\left( W _ { \\lambda } \\right) } = \\left( a _ { \\lambda - 1 } a _ { \\lambda - 1 } ^ { \\mathsf { T } } \\right) \\otimes \\mathcal { H } _ { \\lambda }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            625,
+            674,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The pre-activation Hessian can be calculated recursively as: ",
+        "bbox": [
+            173,
+            675,
+            565,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/066d8f5662937414b7ff787c091a3dc30e6371e80531770315d17352185108d7.jpg",
+        "text": "$$\n\\mathcal { H } _ { \\lambda } = B _ { \\lambda } W _ { \\lambda + 1 } ^ { \\mathsf { T } } \\mathcal { H } _ { \\lambda + 1 } W _ { \\lambda + 1 } B _ { \\lambda } + D _ { \\lambda }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            709,
+            625,
+            732
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where the diagonal matrices $B$ and $D$ are defined as: ",
+        "bbox": [
+            173,
+            744,
+            521,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d283728938d16ef2672bdb5f416bcd470208dcd734b67d9666da1668ae8810e.jpg",
+        "text": "$$\n\\begin{array} { l } { { B _ { \\lambda } = \\mathrm { d i a g } \\left( \\mathbf f _ { \\lambda } ^ { \\prime } ( h _ { \\lambda } ) \\right) } } \\\\ { { D _ { \\lambda } = \\mathrm { d i a g } \\left( \\mathbf f _ { \\lambda } ^ { \\prime \\prime } ( h _ { \\lambda } ) { \\frac { \\partial E } { \\partial a _ { \\lambda } } } \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            787,
+            584,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { f ^ { \\prime } }$ and $\\mathbf { f } ^ { \\prime \\prime }$ denote the first and second derivative of the transfer function. The recursion is initialised with the Hessian of the error w.r.t. the linear network outputs. ",
+        "bbox": [
+            174,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For further details and on how to calculate the diagonal blocks of the Gauss-Newton and Fisher matrix, we refer the reader to (Botev et al., 2017) and (Martens & Grosse, 2015). ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B MATRIX NORMAL DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            488,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The matrix normal distribution (Gupta & Nagar, 1999) is a multivariate distribution over an entire matrix of shape $n \\times p$ rather than just a vector. In contrast to the multivariate normal distribution, it is parameterised by two p.s.d. covariance matrices, $U : n \\times n$ and $V : p \\times p$ , which indicate the covariance of the rows and columns respectively. In addition it has a mean matrix $M : n \\times p$ . ",
+        "bbox": [
+            174,
+            133,
+            825,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A vectorised sample from a matrix normal distribution $X \\sim { \\mathcal { M N } } ( M , U , V )$ corresponds to a sample from a normal distribution $\\operatorname { v e c } ( X ) \\sim { \\mathcal { N } } ( \\operatorname { v e c } ( M ) , U \\otimes V )$ . However, samples can be drawn more efficiently as $X = M + A Z B$ with $Z \\sim \\mathcal { M N } ( 0 , I , I )$ , and $A A ^ { \\mathsf { T } } = U$ and $B ^ { \\intercal } B = V$ . The sample $Z$ corresponds to a sample from a normal distribution of length $n p$ that has been reshaped to a $n \\times p$ matrix. This is more efficient in the sense that we only need to calculate two matrix-matrix products of small matrices, rather than a matrix-vector product with one big one. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C APPROXIMATION OF THE EXPECTED ACTIVATION HESSIAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            699,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "While the square root of $\\mathcal { Q } _ { \\lambda }$ is calculated during the forward pass on all layers, $\\mathcal { H }$ requires an additional backward pass. Strictly speaking, it is not essential to approximate $\\mathbb { E } \\left[ \\mathcal { H } \\right]$ for the Kronecker factored Laplace approximation, as in contrast to optimisation procedures the curvature only needs to be calculated once and is thus not time critical. For datasets of the scale of ImageNet and the networks used for such datasets, it would still be impractically slow to perform the calculation for every data point individually. Furthermore, as most datasets are augmented during training, e.g. random cropping or reflections of images, the curvature of the network can be estimated using the same augmentations, effectively increasing the size of the dataset by orders of magnitude. Thus, we make use of the minibatch approximation in our experiments — as we make use of data augmentation — in order to demonstrate its practical applicability. ",
+        "bbox": [
+            173,
+            335,
+            825,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We note that E [H] can be calculated exactly by running KFRA (Botev et al., 2017) with a minibatchsize of one, and then averaging the results. KFAC (Martens & Grosse, 2015), in contrast, stochastically approximates the Fisher matrix, so even when run for every datapoint separately, it cannot calculate the curvature factor exactly. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            537
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the following, we also show figures for the adversarial experiments in which we calculate the curvature per datapoint and without data augmentation: ",
+        "bbox": [
+            174,
+            545,
+            823,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/bd401ad0b8e9d0a6e372927c134409d5b015ccf19eb9e8745ca37ac78fb7f7a9.jpg",
+        "image_caption": [
+            "Figure 6: Untargeted adversarial attack for Kronecker factored Laplace approximation with the curvature calculated with and without data augmentation/approximating the activation Hessian. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            587,
+            821,
+            741
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fig. 6 and Fig. 7 show how the Laplace approximation with the curvature estimated from 1000 randomly sampled binary MNIST images and the activation Hessian calculated with a minibatch size of 100 performs in comparison to the curvature factor being calculated without any data augmentation with a batch size of 100 or exactly. We note that without data augmentation we had to use much stronger regularisation of the curvature factors, in particular we had to add a non-negligible multiple of the identity to the factors, whereas with data augmentation it was only needed to ensure that the matrices are invertible. The Kronecker factored Laplace approximation reaches particularly high uncertainty on the untargeted adversarial attack and is most robust on the targeted attack when using data augmentation, suggesting that it is particularly well suited for large datasets and ones where some form of data augmentation can be applied. The difference between approximating the activation Hessian over a minibatch and calculating it exactly appears to be negligible. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/e31a6b6b0d0ab2399091e0aa6f1e8ffc0b21f98d8546841f2ad9096b7c2ec352.jpg",
+        "image_caption": [
+            "Figure 7: Targeted adversarial attack for Kronecker factored Laplace approximation with the curvature calculated with and without data augmentation/approximating the activation Hessian. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            823,
+            256
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            321,
+            823,
+            351
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D MEMORY AND COMPUTATIONAL REQUIREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            620,
+            386
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "If we denote the dimensionality of the input to layer $\\lambda$ as $D _ { \\lambda - 1 }$ and its output as $D _ { \\lambda }$ , the curvature factors correspond to the two precision matrices with Dλ−1(Dλ−1+1)2 and $\\frac { D _ { \\lambda } ( D _ { \\lambda } + 1 ) } { 2 }$ ‘parameters’ to estimate, since they are symmetric. So across a network, the number of curvature directions that we are estimating grows linearly in the number of layers and quadratically in the dimension of the layers, i.e. the number of columns of the weight matrices. The size of the full Hessian, on the other hand, grows quadratically in the number of layers and with the fourth power in the dimensionality of the layers (assuming they are all the same size). ",
+        "bbox": [
+            173,
+            400,
+            825,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Once the curvature factors are calculated, which only needs to be done once, we use their Cholesky decomposition to solve two triangular linear systems when sampling weights from the matrix normal distribution. We use the same weight samples for each minibatch, i.e. we do not sample a weight matrix per datapoint. This is for computational efficiency and does not change the expectation. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "One possibility to save computation time would be to sample a fixed set of weight matrices from the approximate posterior — in order to avoid solving the linear system on every forward pass — and treat the networks that they define as an ensemble. The individual ensemble members can be evaluated in parallel and their outputs averaged, which can be done with a small overhead over evaluating a single network given sufficient compute resources. A further speed up can be achieved by distilling the predictive distributions of the Laplace network into a smaller, deterministic feedforward network as successfully demonstrated in (Balan et al., 2015) for posterior samples using HMC. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            671
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E COMPLEMENTARY FIGURES FOR THE TOY DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            640,
+            707
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fig. 8 shows the different Laplace approximations (Kronecker factored, diagonal, full) from the main text without any hyperparameter tuning. The figure of the uncertainty obtained from samples using HMC is repeated. Note that the scale is larger than in the main text due to the high uncertainty of the Laplace approximations. ",
+        "bbox": [
+            173,
+            722,
+            823,
+            777
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The Laplace approximations are increasingly uncertain away from the data, as the true posterior estimated from HMC samples, however they all overestimate the uncertainty without regularisation. This is easy to fix by optimising the hyperparameters on a validation set as discussed in the main text, resulting in posterior uncertainty much more similar to the true posterior. As previously discussed in (Botev et al., 2017), the Hessian of a neural network is usually underdetermined as the number of data points is much smaller than the number of parameters — in our case we have 20 data points to estimate a $7 8 \\times 7 8$ precision matrix. This leads to the full Laplace approximation vastly overestimating the uncertainty and a bad predictive mean. Both the Kronecker factored and the diagonal approximation exhibit smaller variance than the full Laplace approximation as they restrict the structure of the precision matrix. Consistently with the other experiments, we find the diagonal ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8728ab113d8def68159f046cb816ff9c7101a0cf17ad7545a887f6a29fd79c4f.jpg",
+        "image_caption": [
+            "Figure 8: Toy regression uncertainty. Black dots are data points, the black line shows the underlying noiseless function. The red line shows the deterministic prediction of the trained network, the blue line the mean output. Each shade of blue visualises one additional standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            121,
+            769,
+            593
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Laplace approximation to place more mass in low probability areas of the posterior than the Kronecker factored approximation, resulting in higher variance on the regression problem. This leads to a need for greater regularisation of the diagonal approximation to obtain acceptable predictive performance, and underestimating the uncertainty. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            753
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F PREDICTION ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            411,
+            815
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "This section shows the accuracy values obtained from the different predictions methods on the feedforward networks for MNIST and the wide residual network for CIFAR100. The results for MNIST are shown in Table 1 and the results for CIFAR in Table 2. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In all cases, neither MC Dropout nor the Laplace approximation significantly change the classification accuracy of the network in comparison to a deterministic forward pass. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/2917d1b2ef29894240396badcccee0730023770a1a2a6738ee3bf4a150af869d.jpg",
+        "table_caption": [
+            "Table 1: Test accuracy of the feedforward network trained on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Prediction Method</td><td>Accuracy</td></tr><tr><td>FFG Deterministic</td><td>98.88% 98.86%</td></tr><tr><td>MC Dropout Diagonal Laplace</td><td>98.85% 98.85%</td></tr><tr><td>KF Laplace</td><td>98.80%</td></tr></table>",
+        "bbox": [
+            382,
+            126,
+            611,
+            215
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/52092b0b4adc367a00e011aebda2cedf442164045a787b26e985b415a1e76a5f.jpg",
+        "table_caption": [
+            "Table 2: Accuracy on the final 5, 000 CIFAR100 test images for a wide residual network trained with and without Dropout. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Accuracy</td></tr><tr><td>Prediction Method</td><td>Dropout</td><td>Deterministic</td></tr><tr><td>Deterministic</td><td>79.12%</td><td>79.18%</td></tr><tr><td>MC Dropout</td><td>79.20%</td><td>1</td></tr><tr><td>KF Laplace</td><td>79.10%</td><td>79.36%</td></tr></table>",
+        "bbox": [
+            333,
+            270,
+            660,
+            343
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G IMPLEMENTATION DETAILS FOR RESIDUAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            673,
+            385
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our wide residual network has $n { = } 3$ block repetitions and a width factor of $k { = } 8$ on CIFAR100 with and without Dropout using hyperparameters taken from (Zagoruyko & Komodakis, 2016): the network parameters are trained on a cross-entropy loss using Nesterov momentum with an initial learning rate of 0.1 and momentum of 0.9 for 200 epochs with a minibatch size of 128. We decay the learning rate every 50 epochs by a factor of 0.2, which is slightly different to the schedule used in (Zagoruyko & Komodakis, 2016) (they decay after 60, 120 and 160 epochs). As the original authors, we use $L _ { 2 }$ -regularisation with a factor of $5 \\times 1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            173,
+            398,
+            825,
+            500
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We make one small modification to the architecture: instead of downsampling with $1 \\times 1$ convolutions with stride 2, we use $2 \\times 2$ convolutions. This is due to Theano not supporting the transformation of images into the patches extracted by a convolution for $1 \\times 1$ convolutions with stride greater than 1, which we require for our curvature backpropagation through convolutions. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            563
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We apply a standard Laplace approximation to the batch normalisation parameters — a Kronecker factorisation is not needed, since the parameters are one-dimensional. When calculating the curvature factors, we use the moving averages for the per-layer means and standard deviations obtained after training, in order to maintain independence between the data points in a minibatch. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            625
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We need to make a further approximation to the ones discussed in Section 2.2 when backpropagating the curvature for residual networks. The residual blocks compute a function of the form $r e s ( x ) =$ $x + f _ { \\phi } ( x )$ , where $f _ { \\phi }$ typically is a sequence of convolutions, batch normalisation and elementwise nonlinearities. This means that we would need to pass back two curvature matrices, one for each summand. However, this would double the number of backpropagated matrices for each residual connection, hence the computation time/memory requirements would grow exponentially in the number of residual blocks. Therefore, we simply add the curvature matrices after each residual connection. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            743
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SywMS6ZfM/SywMS6ZfM.md

@@ -0,0 +1,517 @@
+# DISTRIBUTIONAL INCLUSION VECTOR EMBEDDING FOR UNSUPERVISED HYPERNYMY DETECTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Modeling hypernymy, such as poodle is-a dog, is an important generalization aid to many NLP tasks, such as entailment, relation extraction, and question answering. Supervised learning from labeled hypernym sources, such as WordNet, limit the coverage of these models, which can be addressed by learning hypernyms from unlabeled text. Existing unsupervised methods either do not scale to large vocabularies or yield unacceptably poor accuracy. This paper introduces distributional inclusion vector embedding (DIVE), a simple-to-implement unsupervised method of hypernym discovery via per-word non-negative vector embeddings which preserve the inclusion property of word contexts. In experimental evaluations more comprehensive than any previous literature of which we are aware—evaluating on 11 datasets using multiple existing as well as newly proposed scoring functions— we find that our method provides up to double the precision of previous unsupervised methods, and the highest average performance, using a much more compact word representation, and yielding many new state-of-the-art results. In addition, the meaning of each dimension in DIVE is interpretable, which leads to a novel approach on word sense disambiguation as another promising application of DIVE.
+
+# 1 INTRODUCTION
+
+Numerous applications benefit from compactly representing context distributions, which assign meaning to objects under the rubric of distributional semantics. In natural language processing, distributional semantics has long been used to assign meanings to words (that is, to lexemes in the dictionary, not individual instances of word tokens). The meaning of a word in the distributional sense is often taken to be the set of textual contexts (nearby tokens) in which that word appears, represented as a large sparse bag of words (SBOW). Without any supervision, word2vec (Mikolov et al., 2013), among other approaches based on matrix factorization (Levy et al., 2015a), successfully compress the SBOW into a much lower dimensional embedding space, increasing the scalability and applicability of the embeddings while preserving (or even improving) the correlation of geometric embedding similarities with human word similarity judgments.
+
+While embedding models have achieved impressive results, context distributions capture more semantic features than just word similarity. The distributional inclusion hypothesis (DIH) (Weeds & Weir, 2003; Geffet & Dagan, 2005; Cimiano et al., 2005) posits that the context set of a word tends to be a subset of the contexts of its hypernyms. For a concrete example, most adjectives that can be applied to poodle can also be applied to dog, because dog is a hypernym of poodle. For instance, both can be obedient. However, the converse is not necessarily true — a dog can be straight-haired but a poodle cannot. Therefore, dog tends to have a broader context set than poodle. Many asymmetric scoring functions comparing SBOW based on DIH have been developed for automatic hypernymy detection (Weeds & Weir, 2003; Geffet & Dagan, 2005; Santus et al., 2017).
+
+Hypernymy detection plays a key role in many challenging NLP tasks, such as textual entailment (Sammons et al., 2011), coreference (Ponzetto & Strube, 2006), relation extraction (Demeester et al., 2016) and question answering (Huang et al., 2008). Leveraging the variety of contexts and inclusion properties in context distributions can greatly increase the ability to discover taxonomic structure among words (Santus et al., 2017). The inability to preserve these features limits the semantic representation power and downstream applicability of some popular existing unsupervised learning approaches such as word2vec.
+
+Several recently proposed methods aim to encode hypernym relations between words in dense embeddings, such as Gaussian embedding (Vilnis & McCallum, 2015; Athiwaratkun & Wilson, 2017), order embedding (Vendrov et al., 2016), H-feature detector (Roller & Erk, 2016), HyperScore (Nguyen et al., 2017), dual tensor (Glavas & Ponzetto, 2017), Poincar ˇ e embedding (Nickel ´ & Kiela, 2017), and LEAR (Vulic & Mrk ´ siˇ c, 2017). However, the methods focus on supervised ´ or semi-supervised setting (Vendrov et al., 2016; Roller & Erk, 2016; Nguyen et al., 2017; Glavasˇ & Ponzetto, 2017; Vulic & Mrk ´ siˇ c, 2017), do not learn from raw text (Nickel & Kiela, 2017) or ´ lack comprehensive experiments on the hypernym detection task (Vilnis & McCallum, 2015; Athiwaratkun & Wilson, 2017).
+
+Recent studies (Levy et al., 2015b; Santus et al., 2017) have underscored the difficulty of generalizing supervised hypernymy annotations to unseen pairs — classifiers often effectively memorize prototypical hypernyms (‘general’ words) and ignore relations between words. These findings motivate us to develop more accurate and scalable unsupervised embeddings to detect hypernymy and propose several scoring functions to analyze the embeddings from different perspectives.
+
+# 1.1 CONTRIBUTIONS
+
+• A novel unsupervised low-dimensional embedding method to model inclusion relations among word contexts via performing non-negative matrix factorization (NMF) on a weighted PMI matrix, which can be efficiently optimized using modified skip-grams. Several new asymmetric comparison functions to measure inclusion and generality properties and to evaluate different aspects of unsupervised embeddings. Extensive experiments on 11 datasets demonstrate the learned embeddings and comparison functions achieve state-of-the-art performances on unsupervised hypernym detection while requiring much less memory and compute than approaches based on the full SBOW. • A qualitative experiment illustrates DIVE can be used to solve word sense disambiguation, especially when efficiently modeling word senses at multiple granularities is desirable.
+
+# 2 METHOD
+
+The distributional inclusion hypothesis (DIH) suggests that the context set of a hypernym tends to contain the context set of its hyponyms. That is, when representing a word as the counts of contextual co-occurrences, the count in every dimension of hypernym $y$ tends to be larger than or equal to the corresponding count of its hyponym $x$ :
+
+$$
+x \preceq y \iff \forall c \in V , \# ( x , c ) \leq \# ( y , c ) ,
+$$
+
+where $x \preceq y$ means $y$ is a hypernym of $x , V$ is the set of vocabulary, and $\# ( x , c )$ indicates the number of times that word $x$ and its context word $c$ co-occur in a small window with size $| W |$ in corpus $D$ .
+
+Our goal is to produce lower-dimensional embeddings that preserve the inclusion property that the embedding of hypernym $y$ is larger than or equal to the embedding of its hyponym $x$ in every dimension. Formally, the desirable property can be written as
+
+$$
+x \preceq y \iff \mathbf { x } [ i ] \leq \mathbf { y } [ i ] , \forall i \in \{ 1 , . . . , d _ { 0 } \} ,
+$$
+
+where $d _ { 0 }$ is number of dimensions in the embedding space. We add additional non-negativity constraints, i.e. $x [ i ] \ge 0 , y [ i ] \ge 0 , \forall i$ , in order to increase the interpretability of the embeddings (the reason will be explained later in this section).
+
+This is a challenging task. In reality, there are a lot of noise and systematic biases which cause the violation of DIH in Equation (1) (i.e. $\# ( x , c ) > \# ( y , c )$ for some neighboring word $c$ ), but the general trend can be discovered by processing several thousands of neighboring words in SBOW together. After the compression, the same trend has to be estimated in a much smaller embedding space which discards most of the information in SBOW, so it is not surprising to see most of the unsupervised hypernymy detection studies use SBOW (Santus et al., 2017) and the existing unsupervised embeddings like Gaussian embedding have degraded accuracy (Vulic et al., 2016). ´
+
+# 2.1 INCLUSION PRESERVING MATRIX FACTORIZATION
+
+Popular methods of unsupervised word embedding are usually based on matrix factorization (Levy et al., 2015a). The approaches first compute a co-occurrence statistic between the wth word and the cth context word as the $( w , c )$ th element of the matrix $M [ w , c ]$ . Next, the matrix $M$ is factorized such that $M [ w , c ] \approx \mathbf { w } ^ { T } \mathbf { \dot { c } }$ , where w is the low dimension embedding of $w$ th word and $\mathbf { c }$ is the cth context embedding.
+
+The statistic in $M [ w , c ]$ is usually related to pointwise mutual information: $P M I ( w , c ) ~ =$ $\textstyle \log ( { \frac { P ( w , c ) } { P ( w ) \cdot P ( c ) } } )$ , where $\begin{array} { r } { P ( w , c ) = \frac { \# ( w , c ) } { | D | } } \end{array}$ , $| D | = \sum _ { w \in V } \sum _ { c \in V } \# ( w , c )$ is number of co-occurrence word pairs in the corpus, $\begin{array} { r } { P ( w ) = \frac { \# ( w ) } { | D | } } \end{array}$ , $\# ( w ) = \sum _ { c \in V } \# ( w , c )$ is the frequency of the word $w$ times the window size $| W |$ , and similarly for $P ( c )$ . For example, $M [ w , c ]$ could be set as positive PMI (PPMI), $\operatorname* { m a x } ( P M I ( w , c ) , 0 )$ , or shifted PMI, $P M I ( w , c ) - \log ( k )$ , like skip-grams with negative sampling (SGNS) (Levy et al., 2015a). Intuitively, since $\dot { M } [ w , \bar { c ] } \approx \mathbf { w } ^ { T } \mathbf { c }$ , larger embedding values of w at every dimension seems to imply larger $\mathbf { \bar { w } } ^ { T } \mathbf { c }$ , larger $M [ w , c ]$ , larger $\bar { P } M I ( w , c )$ , and thus larger co-occurrence count $\# ( w , c )$ . However, the derivation has two flaws: (1) c could be negative and (2) lower $\# ( w , c )$ could still lead to larger $P M I ( w , c )$ as long as the $\# ( w )$ is small enough.
+
+To preserve DIH, we propose a novel word embedding method, distributional inclusion vector embedding $( D I V E )$ , which fixes the two flaws by performing non-negative factorization (NMF) on the matrix $M$ , where
+
+$$
+M [ w , c ] = \log ( \frac { P ( w , c ) } { P ( w ) \cdot P ( c ) } \cdot \frac { \# ( w ) } { k \cdot Z } ) = \log ( \frac { \# ( w , c ) | V | } { \# ( c ) k } ) ,
+$$
+
+where $k$ is a constant which shifts PMI value like SGNS, $\begin{array} { r } { Z = \frac { | D | } { | V | } } \end{array}$ is the average word frequency, and $| V |$ is the vocabulary size.
+
+The design encourages the inclusion property in DIVE (i.e. Equation (2)) to be satisfied because the property implies that Equation (1) (DIH) holds if the matrix is reconstructed perfectly. The derivation is simple: Since context vector c is non-negative, if the embedding of hypernym $\mathbf { y }$ is greater than or equal to the embedding of its hyponym $\mathbf { X }$ in every dimension, $\mathbf { \bar { x } } ^ { T } \mathbf { c } \leq \mathbf { y } ^ { T } \mathbf { c }$ . Then, $\mathbf { \bar { \boldsymbol { M } } } [ \boldsymbol { x } , \boldsymbol { c } ] \le M [ \boldsymbol { y } , \boldsymbol { \bar { c } } ]$ tends to be true because $\mathbf { w } ^ { \hat { T } } \mathbf { c } \ \tilde { \approx } \ M [ w , c ]$ . This leads to $\# ( x , c ) \leq \# ( y , c )$ because M [w, c] = log( #(w,c)|V |#(c)k ) and only $\# ( w , c )$ change with $w$ .
+
+# 2.2 OPTIMIZATION
+
+Due to its appealing scalability properties during training time (Levy et al., 2015a), we optimize our embedding based on the skip-gram with negative sampling (SGNS) (Mikolov et al., 2013). The objective function of SGNS is
+
+$$
+l _ { S G N S } = \sum _ { w \in V } \sum _ { c \in V } \# ( w , c ) \log \sigma ( \mathbf { w } ^ { T } \mathbf { c } ) \ + \ \sum _ { w \in V } k ^ { \prime } \sum _ { c \in V } \# ( w , c ) \operatorname { \mathbb { E } } _ { c _ { N } \sim P _ { D } } [ \log \sigma ( - \mathbf { w } ^ { T } \mathbf { c } _ { \mathbf { N } } ) ] ,
+$$
+
+where $\mathbf { w } \in \mathbb { R } , \mathbf { c } \in \mathbb { R } , \mathbf { c _ { N } } \in \mathbb { R } , k ^ { \prime }$ is a constant hyper-parameter indicating the ratio between positive and negative samples.
+
+Levy & Goldberg (2014) prove SGNS is equivalent to factorizing a shifted PMI matrix $M ^ { \prime }$ , where $\begin{array} { r } { M ^ { \prime } [ w , c ] = \log ( \frac { P ( w , c ) } { P ( w ) \cdot P ( c ) } \cdot \frac { 1 } { k ^ { \prime } } ) } \end{array}$ . By setting $\begin{array} { r } { k ^ { \prime } = \frac { k \cdot Z } { \# ( w ) } } \end{array}$ and applying non-negativity constraints to the embeddings, DIVE can be optimized using the similar objective function:
+
+$$
+l _ { D I V E } = \sum _ { w \in V } \sum _ { c \in V } \# ( w , c ) \log \sigma ( \mathbf { w } ^ { T } \mathbf { c } ) \ + k \sum _ { w \in V } \frac { Z } { \# ( w ) } \sum _ { c \in V } \# ( w , c ) \operatorname { \mathbb { E } } _ { c _ { N } \sim P _ { D } } [ \log \sigma ( - \mathbf { w } ^ { T } \mathbf { c } _ { \mathbf { N } } ) ] ,
+$$
+
+where $\mathbf { w } \geq 0 , \mathbf { c } \geq 0 , \mathbf { c } _ { \mathbf { N } } \geq 0 ,$ $\sigma$ is the logistic sigmoid function, and $k$ is a constant hyper-parameter. $P _ { D }$ is the distribution of negative samples, which we set to be the corpus word frequency distribution in this paper. Equation (5) is optimized by ADAM (Kingma & Ba, 2015), a variant of stochastic gradient descent (SGD). The non-negativity constraint is implemented by projection (i.e., clipping any embedding which crosses the zero boundary after an update).
+
+![](images/bc81173fe9f03c1c3657656ec72c8d5249f2772d104addb772d049e2d14a7de5.jpg)
+
+Figure 1: The top 15 dimensions in the distributional inclusion vector embedding (DIVE) of the word core trained by the co-occurrence statistics of context words. The index of dimensions is sorted by the embedding values. The words in each row of the table are sorted by its embedding value in the dimension.   
+
+<table><tr><td rowspan=1 colspan=1>id</td><td rowspan=1 colspan=1>Top 1-5 words</td><td rowspan=1 colspan=1>Top 101-105 words</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>element,gas,atom,rock,carbon</td><td rowspan=1 colspan=1>methane,llio</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>system,rcieturvelope,ge</td><td rowspan=1 colspan=1>functional,rnt,ocsing,</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>also, well,svral,rly</td><td rowspan=1 colspan=1>fall, eventually, main,ise,mosty</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>part</td><td rowspan=1 colspan=1>incorporate,ge,iead,oing,dd</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>star,orbit,snbital,</td><td rowspan=1 colspan=1>bright,posion,turieractio</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>several,ic</td><td rowspan=1 colspan=1>designate,ist,iss,bch,i</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>science,plosophy, thory,plosophr,r</td><td rowspan=1 colspan=1>ethical,dvocte,oic,bic,</td></tr><tr><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>version,game,release,original,ile</td><td rowspan=1 colspan=1>cassette, rtual,code,project, kb</td></tr><tr><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>electron,ttric,cit</td><td rowspan=1 colspan=1>anode,wire,ac,perform,eistor</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>tank, cylinder,heel,gi</td><td rowspan=1 colspan=1>aluminumtic,ott</td></tr><tr><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>school,itil</td><td rowspan=1 colspan=1>doctorateldert</td></tr><tr><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>network,r,er,dtum,prl</td><td rowspan=1 colspan=1>technologyoutgnt,crooft,</td></tr><tr><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>high,low,turergy</td><td rowspan=1 colspan=1>atmosphric,tod,,io</td></tr><tr><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>acid, carbon, product, ue,inc</td><td rowspan=1 colspan=1>ph,monoided</td></tr><tr><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>access,nd,rquire,llow,program</td><td rowspan=1 colspan=1>size,abilitytlly</td></tr></table>
+
+The optimization process provides an alternative angle to explain how DIVE preserves DIH. The gradients for the word embedding w is
+
+$$
+\frac { d l _ { D I V E } } { d \mathbf { w } } = \sum _ { c \in V } \# ( w , c ) ( 1 - \sigma ( \mathbf { w } ^ { T } \mathbf { c } ) ) \mathbf { c } - k \sum _ { c _ { N } \in V } \frac { \# ( c _ { N } ) } { | V | } \sigma ( \mathbf { w } ^ { T } \mathbf { c } _ { \mathbf { N } } ) \mathbf { c } _ { \mathbf { N } } .
+$$
+
+Assume hyponym $\mathbf { X }$ and hypernym y satisfy DIH in Equation (1) and the embeddings $\mathbf { x }$ and $\mathbf { y }$ are the same at some point during the gradient ascent. In the case, the gradients coming from negative sampling (the second term) decrease the same amount of embedding values for both $x$ and $y$ because $k$ is a constant hyper-parameter. However, the embedding of hypernym $\mathbf { y }$ would get higher or equal positive gradients from the first term than $\mathbf { x }$ in every dimension because $\# ( x , \bar { c } ) \leq \bar { \# } ( y , c )$ . This means Equation (1) tends to imply Equation (2). Combining the analysis from the matrix factorization viewpoint, DIH in Equation (1) is approximately equivalent to the inclusion property in DIVE (i.e. Equation (2)).
+
+# 2.3 PMI FILTERING
+
+For a frequent target word, there must be many neighboring words that incidentally appear near the target word without being semantically meaningful, especially when a large context window size is used. The unrelated context words cause noise in both the word vector and the context vector of DIVE. We address this issue by filtering out context words $c$ for each target word $w$ when the PMI of the co-occurring words is too small (i.e., $\begin{array} { r } { \log ( \frac { P ( w , c ) } { P ( w ) \cdot P ( c ) } ) < \log ( k _ { f } ) ) } \end{array}$ . That is, we set $\# ( w , c ) = 0$ in the objective function. This preprocessing step is similar with computing PPMI in SBOW (Bullinaria & Levy, 2007), where low PMI co-occurrences are removed from the count-based representation.
+
+# 2.4 INTERPRETABILITY
+
+After applying the non-negativity constraint, we observe that each dimension roughly corresponds to a topic, as previous findings suggest (Pauca et al., 2004; Murphy et al., 2012). This gives rise to a natural and intuitive interpretation of our word embeddings: the word embeddings can be seen as unnormalized probability distributions over topics. By removing the normalization of the target word frequency in the shifted PMI matrix, specific words have values in few dimensions (topics), while general words appear in more topics and correspondingly have high values in more dimensions, so the concreteness level of two words can be easily compared using the magnitude of their embeddings. In other words, general words have more diverse context distributions, so we need more dimensions to store the information in order to compress SBOW well (Nalisnick & Ravi, 2015).
+
+In Figure 1, we present three mentions of the word core and its surrounding contexts. These various context words increase the embedding values in different dimensions. Each dimension of the learned embeddings roughly corresponds to a topic, and the more general or representative words for each topic tend to have the higher value in the corresponding dimension (e.g. words in the second column of the table). The embedding is able to capture the common contexts where the word core appears. For example, the context of the first mention is related to the atom topic (dimension id 1) and the electron topic (id 9), while the second and third mention occur in the computer architecture topic (id 2) and education topic (id 11), respectively.
+
+# 3 EXPERIMENT SETUP
+
+We describe four experiments in Section 4-7. The first 3 experiments compare DIVE with other unsupervised embeddings and SBOW using different hypernymy scoring functions. In these experiments, unsupervised approaches refer to the methods that only train on plaintext corpus without using any hypernymy or lexicon annotation. The last experiment presents qualitative results on word sense disambiguation.
+
+# 3.1 DATASETS AND TESTING SETUP
+
+The SBOW and embeddings are tested on 11 datasets. The first 4 datasets come from the recent review of Santus et al. (2017): BLESS (Baroni & Lenci, 2011), EVALution (Santus et al., 2015), Lenci/Benotto (Benotto, 2015), and Weeds (Weeds et al., 2014). The next 4 datasets are downloaded from the code repository of the H-feature detector (Roller & Erk, 2016): Medical (i.e., Levy 2014) (Levy et al., 2014), LEDS (also referred to as ENTAILMENT or Baroni 2012) (Baroni et al., 2012), TM14 (i.e., Turney 2014) (Turney & Mohammad, 2015), and Kotlerman 2010 (Kotlerman et al., 2010). In addition, the performance on the test set of HyperNet (Shwartz et al., 2016) (using the random train/test split), the test set of WordNet (Vendrov et al., 2016), and all pairs in HyperLex (Vulic et al., 2016) are also evaluated. ´
+
+The F1 and accuracy measurements are sometimes very similar even though the quality of prediction varies, so average precision $\operatorname { A P } @$ all is adopted as the main evaluation metric. The HyperLex dataset has a continuous score on each candidate word pair, so we adopt Spearman rank coefficient $\rho$ as suggested by the review study of Vulic et al. (2016). Any OOV (out-of-vocabulary) word en- ´ countered in the testing data is pushed to the bottom of the prediction list (effectively assuming the word pair does not have a hypernym relation).
+
+# 3.2 TRAINING SETUP
+
+We use WaCkypedia corpus (Baroni et al., 2009), a 2009 Wikipedia dump, to compute SBOW and train the embedding. For the datasets without Part of Speech (POS) information (i.e. Medical, LEDS, TM14, Kotlerman 2010, and HyperNet), the training data of SBOW and embeddings are raw text. For other datasets, we concatenate each token with the Part of Speech (POS) of the token before training the models except the case when we need to match the training setup of another paper.
+
+All words are lower cased. Stop words and rare words (occurs less than 10 times) are removed during our preprocessing step. The number of embedding dimensions in DIVE $d _ { 0 }$ is set to be 100. Other hyper-parameters used in the experiments are listed in the supplementary materials. The hyper-parameters of DIVE were decided based on the performance of HyperNet training set. To train embeddings more efficiently, we chunk the corpus into subsets/lines of 100 tokens instead of using sentence segmentation. Preliminary experiments show that this implementation simplification does not hurt the performance.
+
+Table 1: Comparison with previous unsupervised embeddings. All values are percentages. $\mathbf { A P } @$ all $( \% )$ for 10 datasets and Spearman $\rho$ $( \% )$ for HyperLex. Word2Vec $+ \mathrm { C }$ scores the word pairs using the cosine similarity on skip-grams (SGNS). $\mathrm { G E + C }$ and $\mathrm { G E + K L }$ computes cosine similarity and negative KL divergence on Gaussian embedding, respectively.   
+
+<table><tr><td>Dataset</td><td>BLESS</td><td>EVALution</td><td>LenciBenotto</td><td>Weeds</td><td>Medical</td><td>LEDS</td></tr><tr><td>Random Word2Vec+C</td><td>5.3 9.2</td><td>26.6 25.4</td><td>41.2 40.8</td><td>51.4 51.6</td><td>8.5 11.2</td><td>50.5 71.8</td></tr><tr><td>GE+C GE+KL</td><td>10.5 7.6</td><td>26.7 29.6</td><td>43.3</td><td>52.0</td><td>14.9</td><td>69.7</td></tr><tr><td>DIVE+C.△S</td><td></td><td></td><td>45.1</td><td>51.3</td><td>15.7</td><td>64.6</td></tr><tr><td></td><td>16.3</td><td>33.0</td><td>50.4</td><td>65.5</td><td>25.3</td><td>83.5</td></tr><tr><td>Dataset</td><td>TM14</td><td>Kotlerman 2010</td><td>HyperNet</td><td>WordNet</td><td>HyperLex</td><td></td></tr><tr><td>Random</td><td>52.0</td><td>30.8</td><td>24.5</td><td>55.2</td><td>0</td><td></td></tr><tr><td>Word2Vec+C</td><td>52.1</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>39.5</td><td>20.7</td><td>63.0</td><td>16.3</td><td></td></tr><tr><td>GE+C</td><td>53.9</td><td>36.0</td><td>21.6</td><td>58.2</td><td>16.4</td><td></td></tr><tr><td>GE+KL</td><td>52.0</td><td>39.4</td><td>23.7</td><td>54.4</td><td>9.6</td><td></td></tr><tr><td>DIVE+C·△S</td><td>57.2</td><td>36.6</td><td>41.9</td><td>60.9</td><td>32.8</td><td></td></tr></table>
+
+In the following experiments, we train both SBOW and DIVE on only the first 512,000 lines (51.2 million tokens) because we find this way of training setting provides better performances (for both SBOW and DIVE) than training on the whole WaCkypedia or training on randomly sampled 512,000 lines. We suspect this is due to the corpus being sorted by the Wikipedia page titles, which makes some categorical words such as animal and mammal occur 3-4 times more frequently in the first 51.2 million tokens than the rest. The performances of training SBOW PPMI on the whole WaCkypedia is also provided for reference in Table 4 and Table 5.
+
+# 4 EXPERIMENT 1: COMPARISON WITH UNSUPERVISED EMBEDDINGS
+
+If a pair of words has the hypernym relation, the words tend to be similar and the hypernym should be more general than the hyponym. As in HyperScore (Nguyen et al., 2017), we score the hypernym candidates by multiplying two factors corresponding to these properties. The ${ \bf C } { \cdot } { \Delta } { \cal S }$ (i.e. the cosine similarity multiply the difference of summation) scoring function is defined as
+
+$$
+C \cdot \Delta S ( \mathbf { w } _ { q }  \mathbf { w } _ { p } ) = \frac { \mathbf { w } _ { q } ^ { T } \mathbf { w } _ { p } } { | | \mathbf { w } _ { q } | | _ { 2 } \cdot | | \mathbf { w } _ { p } | | _ { 2 } } \cdot ( | | \mathbf { w } _ { p } | | _ { 1 } - | | \mathbf { w } _ { q } | | _ { 1 } ) ,
+$$
+
+where ${ \bf w } _ { p }$ is the embedding of hypernym and ${ \bf w } _ { q }$ is the embedding of hyponym.
+
+As far as we know, Gaussian embedding (GE) is the only unsupervised embedding method which can capture the asymmetric relations between a hypernym and its hyponyms. Using the same training and testing setup, we use the code implemented by Athiwaratkun $\&$ Wilson $( 2 0 1 7 ) ^ { 1 }$ to train Gaussian embedding on the first 51.2 million tokens and test the embeddings on 11 datasets. Its hyper-parameters are determined using the same way as DIVE (i.e. maximizing the AP on HyperNet training set). We compare DIVE with $\mathrm { G E } ^ { 2 }$ in Table 1, and the performances of random scores and only measuring word similarity using skip-grams are also presented for reference. As we can see, DIVE is usually significantly better than other baselines.
+
+# 5 EXPERIMENT 2: HYPERNYMY SCORING FUNCTIONS ANALYSIS
+
+In Experiment 1, we show that there exists a scoring function $\left( \mathbf { C } { \cdot } \Delta \mathbf { S } \right)$ which detects hypernymy accurately using the embedding space of DIVE. Nevertheless, different scoring functions measure different signals in SBOW or embeddings. Since there are so many scoring functions and datasets available in the domain, we first introduce and test the performances of various scoring functions so as to select the representative ones for a more comprehensive evaluation of DIVE on the hypernymy detection tasks. We denote the embedding/context vector of the hypernym candidate and the hyponym candidate as ${ \bf w } _ { p }$ and ${ \bf w } _ { q }$ , respectively. The SBOW model which represents a word by the frequency of its neighboring words is denoted as SBOW Freq, while the SBOW which uses PPMI of its neighboring words as the features (Bullinaria & Levy, 2007) is denoted as SBOW PPMI.
+
+# 5.1 UNSUPERVISED SCORING FUNCTIONS
+
+# 5.1.1 SIMILARITY
+
+A hypernym tends to be similar to its hyponym, so we measure the cosine similarity between word vectors of the SBOW features (Levy et al., 2015b) or DIVE. We refer to the symmetric scoring function as Cosine or C for short in the following tables. We also train the original skip-grams with 100 dimensions and measure the cosine similarity between the resulting word2vec embeddings. This scoring function is referred to as Word2vec or W.
+
+# 5.1.2 GENERALITY
+
+The distributional informativeness hypothesis (Santus et al., 2014) observes that in many corpora, semantically ‘general’ words tend to appear more frequently and in more varied contexts. Thus, Santus et al. (2014) advocate using entropy of context distributions to capture the diversity of context. We adopt the two variations of the approach proposed by Santus et al. (2017): SLQS Row and SLQS Sub functions. We also refer to SLQS Row as $\Delta \mathrm { E }$ because it measures the entropy difference of context distributions. For SLQS Sub, the number of top context words is fixed as 100.
+
+Although effective at measuring diversity, the entropy totally ignores the frequency signal from the corpus. To leverage the information, we measure the generality of a word by its L1 norm $( | \mathbf { w } _ { p } | _ { 1 } )$ and L2 norm $( | | \mathbf { w } _ { p } | | _ { 2 } )$ . Recall that Equation (2) indicates that the embedding of the hypernym $\mathbf { y }$ should have a larger value at every dimension than the embedding of the hyponym x. When the inclusion property holds, $\begin{array} { r } { | { \bf y } | _ { 1 } = \sum _ { i } { \bf y } [ i ] \geq \sum _ { i } { \bf x } [ i ] = | { \bf x } | _ { 1 } } \end{array}$ and similarly $| | \mathbf { y } | | _ { 2 } \geq | | \mathbf { x } | | _ { 2 }$ . Thus, we propose two scoring functions, difference of vector summation $( | \mathbf { w } _ { p } | _ { 1 } - | \mathbf { w } _ { q } | _ { 1 } )$ and the difference of vector 2-norm $( | | \mathbf { \bar { w } } _ { p } | | _ { 2 } - | | \mathbf { w } _ { q } | | _ { 2 } )$ . Notice that when applying the difference of vector summations (denoted as $\Delta S$ ) to SBOW Freq, it is equivalent to computing the word frequency difference between the hypernym candidate pair.
+
+# 5.1.3 COMBINATION
+
+The combination of 2 similarity functions (Cosine and Word2vec) and the 3 generality functions (difference of entropy, summation, and 2-norm of vectors) leads to six different scoring functions as shown in Table 2, and ${ \bf C } { \cdot } { \Delta } { \cal S }$ is the same scoring function we used in Experiment 1. It should be noted that if we use skip-grams with negative sampling (word2vec) as the similarity measurement (i.e., $W \cdot \Delta \ \{ \mathrm { E } , \mathrm { S } , \mathrm { Q } \} ,$ ), the scores are determined by two embedding/feature spaces together (word2vec and DIVE/SBOW).
+
+# 5.1.4 INCLUSION
+
+Several scoring functions are proposed to measure inclusion properties of SBOW based on DIH. Weeds Precision (Weeds & Weir, 2003) and CDE (Clarke, 2009) both measure the magnitude of the intersection between feature vectors $( | \mathbf { w } _ { p } \cap \mathbf { w } _ { q } | )$ . For example, ${ \bf w } _ { p } \cap { \bf w } _ { q }$ is defined by the elementwise minimum in CDE. Then, both scoring functions divide the intersection by the magnitude of the potential hyponym vector $( | \mathbf { w } _ { q } | )$ . invCL (Lenci & Benotto, 2012) (A variant of CDE) is also tested.
+
+We choose these 3 functions because they have been shown to detect hypernymy well in a recent study (Santus et al., 2017). However, it is hard to confirm that their good performances come from the inclusion property between context distributions — it is also possible that the context vectors of more general words have higher chance to overlap with all other words due to their high frequency. For instance, considering a one dimension feature which stores only the frequency of words, the naive embedding could still have reasonable performance on the CDE function, but the embedding in fact only memorizes the general words without modeling relations between words (Levy et al., 2015b) and loses lots of inclusion signals in the word co-occurrence statistics.
+
+Table 2: Micro average AP@all $( \% )$ of 10 datasets using different scoring functions. The feature space is SBOW using word frequency.   
+
+<table><tr><td>Word2vec (W) 24.8</td><td>Cosine (C) 26.7</td><td>SLQS Sub 27.4</td><td>SLQS Row (△E) 27.6</td><td>Summation (△S) 31.5</td><td>Two norm (△Q) 31.2</td></tr><tr><td>W.△E</td><td>C.△E</td><td>W.△S</td><td>C.△S</td><td>W.△Q</td><td>C.△Q</td></tr><tr><td>28.8</td><td>29.5</td><td>31.6</td><td>31.2</td><td>31.4</td><td>31.1</td></tr><tr><td>Weeds</td><td>CDE</td><td>invCL</td><td>Asymmetric L1(AL1)</td><td></td><td></td></tr><tr><td>19.0</td><td>31.1</td><td>30.7</td><td>28.2</td><td></td><td></td></tr></table>
+
+In order to measure the inclusion property without the interference of the word frequency signal from the SBOW or embeddings, we propose a new measurement called asymmetric $L _ { 1 }$ distance. We first get context distributions ${ \bf d } _ { p }$ and ${ \bf d } _ { q }$ by normalizing $\mathbf { w } _ { p }$ and ${ \bf w } _ { q }$ , respectively. Ideally, the context distribution of the hypernym ${ \bf d } _ { p }$ will include ${ \bf d } _ { q }$ . This suggests the hypernym distribution ${ \bf d } _ { p }$ is larger than context distribution of the hyponym with a proper scaling factor $a \mathbf { d } _ { q }$ (i.e., $\operatorname* { m a x } ( a \mathbf { d } _ { q } \bar { - }$ ${ \bf d } _ { p } , 0 )$ should be small). Furthermore, both distributions should be similar, so $a \mathbf { d } _ { q }$ should not be too different from ${ \bf d } _ { p }$ (i.e., $\operatorname* { m a x } ( \mathbf { d } _ { p } - a \mathbf { d } _ { q } , 0 )$ should also be small). Therefore, we define asymmetric L1 distance as
+
+$$
+A L _ { 1 } = \operatorname* { m i n } _ { a } \sum _ { c } w _ { 0 } \cdot \operatorname* { m a x } ( a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] , 0 ) + \operatorname* { m a x } ( \mathbf { d } _ { p } [ c ] - a \mathbf { d } _ { q } [ c ] , 0 ) ,
+$$
+
+where $w _ { 0 }$ is a constant which emphasizes the inclusion penalty. If $w _ { 0 } ~ = ~ 1$ and $a \ = \ 1$ , $A L _ { 1 }$ is equivalent to L1 distance. The lower $A L _ { 1 }$ distance implies a higher chance of observing the hypernym relation. We tried $w _ { 0 } = 5$ and $w _ { 0 } = 2 0$ . $w _ { 0 } = 2 0$ produces a worse micro-average AP@all on SBOW Freq, SBOW PPMI and DIVE, so we fix $w _ { 0 }$ to be 5 in all experiments. An efficient way to solve the optimization in $A L _ { 1 }$ is presented in the supplementary materials.
+
+# 5.2 RESULTS AND DISCUSSIONS
+
+We show the micro average $\mathbf { A P } @$ all on 10 datasets using different hypernymy scoring functions in Table 2. We can see the combination functions such as ${ \bf C } { \cdot } { \Delta } { \cal S }$ and ${ \bf W } { \cdot } { \Delta } { \cal S }$ perform the best overall. Among the unnormalized inclusion based scoring functions, CDE works the best. $A L _ { 1 }$ performs well compared with other functions which remove the frequency signal such as Word2vec, Cosine, and SLQS Row. The summation is the most robust generality measurement. In the table, the scoring functions are applied to SBOW Freq, but the performances of hypernymy scoring functions on the other feature spaces (e.g. DIVE) have a similar trend.
+
+# 6 EXPERIMENT 3: COMPARISON WITH SBOW
+
+# 6.1 COMPARISON WITH PREVIOUSLY REPORTED RESULTS
+
+In Table 3, DIVE with two of the best scoring functions $C { \cdot } \Delta s$ and ${ \bf W } { \cdot } { \Delta S }$ ) is compared with the previous unsupervised state-of-the-art approaches based on SBOW on different datasets.
+
+There are several reasons which might cause the large performance gaps in some datasets. In addition to the effectiveness of DIVE, some improvements come from our proposed scoring functions. The fact that every paper uses a different training corpus also affects the performances. Furthermore, Santus et al. (2017) select the scoring functions and feature space for the first 4 datasets based on $\mathbf { A P } @ 1 0 0$ , which we believe is too sensitive to the hyper-parameter settings of different methods. To isolate the impact of each factor, we perform a more comprehensive comparison next.
+
+# 6.2 PERFORMANCE ANALYSIS
+
+In this experiment, we examine whether DIVE successfully preserves the signals for hypernymy detection tasks, which are measured by the same scoring functions designed for SBOW. Summation difference $( \Delta \boldsymbol { S } )$ and CDE perform the best among generality and inclusion functions in Table 2,
+
+Table 3: Comparison with previous methods based on sparse bag of word (SBOW). All values are percentages. The results of invCL (Lenci & Benotto, 2012), APSyn (Santus et al., 2016), and CDE (Clarke, 2009) are selected because they have the best $\mathbf { A P } @ 1 0 0$ in the first 4 datasets (Santus et al., 2017). Cosine similarity (Levy et al., 2015b), balAPinc (Kotlerman et al., 2010) in 3 datasets (Turney & Mohammad, 2015), SLQS (Santus et al., 2014) in HyperNet dataset (Shwartz et al., 2016), and Freq ratio (FR) (Vulic et al., 2016) are compared. ´
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=2>BLESS EVALution</td><td rowspan=1 colspan=1>LenciBenotto</td><td rowspan=1 colspan=1>Weeds</td><td rowspan=1 colspan=1>Medical</td></tr><tr><td rowspan=1 colspan=1>Metric</td><td rowspan=1 colspan=4>AP@all</td><td rowspan=1 colspan=1>F1</td></tr><tr><td rowspan=2 colspan=1>Baselines</td><td rowspan=1 colspan=2>invCL</td><td rowspan=1 colspan=1>APSyn</td><td rowspan=1 colspan=1>CDE</td><td rowspan=1 colspan=1>Cosine</td></tr><tr><td rowspan=1 colspan=1>5.1</td><td rowspan=1 colspan=1>35.3</td><td rowspan=1 colspan=1>38.2</td><td rowspan=1 colspan=1>44.1</td><td rowspan=1 colspan=1>23.1</td></tr><tr><td rowspan=1 colspan=1>DIVE+C·△S</td><td rowspan=1 colspan=1>16.3</td><td rowspan=1 colspan=1>33.0</td><td rowspan=1 colspan=1>50.4</td><td rowspan=1 colspan=1>65.5</td><td rowspan=1 colspan=1>25.3</td></tr><tr><td rowspan=1 colspan=1>DIVE +W·△S</td><td rowspan=1 colspan=1>18.6</td><td rowspan=1 colspan=1>32.3</td><td rowspan=1 colspan=1>51.5</td><td rowspan=1 colspan=1>68.6</td><td rowspan=1 colspan=1>25.7</td></tr><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>LEDS</td><td rowspan=1 colspan=1>TM14</td><td rowspan=1 colspan=1>Kotlerman 2010</td><td rowspan=1 colspan=1>HyperNet</td><td rowspan=1 colspan=1>HyperLex</td></tr><tr><td rowspan=1 colspan=1>Metric</td><td rowspan=1 colspan=2>AP@all</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>F1</td><td rowspan=1 colspan=1>Spearman p</td></tr><tr><td rowspan=2 colspan=1>Baselines</td><td rowspan=1 colspan=3>balAPinc</td><td rowspan=1 colspan=1>SLQS</td><td rowspan=1 colspan=1>Freq ratio</td></tr><tr><td rowspan=1 colspan=1>73</td><td rowspan=1 colspan=1>56</td><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>22.8</td><td rowspan=1 colspan=1>27.9</td></tr><tr><td rowspan=1 colspan=1>DIVE+C·△S</td><td rowspan=1 colspan=1>83.5</td><td rowspan=1 colspan=1>57.2</td><td rowspan=1 colspan=1>36.6</td><td rowspan=1 colspan=1>41.9</td><td rowspan=1 colspan=1>32.8</td></tr><tr><td rowspan=1 colspan=1>DIVE+W·△S</td><td rowspan=1 colspan=1>86.4</td><td rowspan=1 colspan=1>57.3</td><td rowspan=1 colspan=1>37.4</td><td rowspan=1 colspan=1>38.6</td><td rowspan=1 colspan=1>33.3</td></tr></table>
+
+respectively. $A L _ { 1 }$ could be used to examine the inclusion properties after removing the frequency signal. Therefore, we will present the results using these 3 scoring functions, along with ${ \bf W } { \cdot } { \Delta } S$ and ${ \bf C } { \cdot } { \Delta } { \cal S }$ .
+
+# 6.2.1 BASELINES
+
+In addition to classic representations such as SBOW Freq and SBOW PPMI, we compare distributional inclusion vector embedding (DIVE) with additional 4 baselines in Table 4.
+
+• SBOW PPMI with additional frequency weighting (PPMI w/ FW). Specifically, $\mathbf { w } [ c ] =$ $\begin{array} { r } { \operatorname* { m a x } ( \log ( \frac { P ( w , c ) } { P ( w ) * P ( c ) * \frac { Z } { \# ( w ) } } ) , 0 ) } \end{array}$ . This forms the matrix reconstructed by DIVE when $k = 1$ .   
+• DIVE without the PMI filter (DIVE w/o PMI)   
+• NMF on shifted PMI: Non-negative matrix factorization (NMF) on the shifted PMI without frequency weighting for DIVE (DIVE w/o FW). This is the same as applying the nonnegative constraint on the skip-gram model.   
+K-means (Freq NMF): The method first uses Mini-batch $\mathbf { k }$ -means (Sculley, 2010) to cluster words in skip-gram embedding space into 100 topics, and hashes each frequency count in SBOW into the corresponding topic. If running $\mathbf { k }$ -means on skip-grams is viewed as an approximation of clustering the SBOW context vectors, the method can be viewed as a kind of NMF (Ding et al., 2005). Let the $N \times N$ context matrix be denoted as $M _ { c }$ , where the $( i , j )$ th element stores the count of word $j$ appearing beside word $i$ . K-means hashing creates a $N \times 1 0 0$ matrix $G$ with orthonormal rows $\tilde { G } ^ { T } G = I )$ , where the $( i , k )$ th element is 0 if the word $i$ does not belong to cluster $k$ . The orthonormal $G$ is also an approximated solution of a type of NMF $( M _ { c } \overset { \mathbf { \backsimeq } } { \approx } F G ^ { T }$ ) (Ding et al., 2005). Hashing context vectors into topic vectors can be written as $M _ { c } G \approx F G ^ { T } G = F$ .
+
+In the experiment, we also tried to apply a constant $\log ( k )$ shifting to SBOW PPMI (i.e. $\operatorname* { m a x } ( P M I - \log ( k ) , 0 ) )$ ). We found that the performance degrades as $k$ increases. Similarly, applying PMI filter to SBOW PPMI (set context feature to be 0 if the value is lower than $\log ( k _ { f } ) )$ usually makes the performances worse, especially when $k _ { f }$ is large. Applying PMI filter to SBOW Freq only makes its performances closer to (but still much worse than) SBOW PPMI, so we omit this baseline as well.
+
+# 6.2.2 RESULTS AND DISCUSSIONS
+
+In Table 4, we first confirm the finding of the previous review study of Santus et al. (2017): there is no single hypernymy scoring function which always outperforms others. One of the main reasons is that different datasets collect negative samples differently. This is also why we evaluate our method on many datasets to make sure our conclusions hold in general. For example, if negative samples come from random word pairs (e.g. WordNet dataset), a symmetric similarity measure is already a pretty good scoring function. On the other hand, negative samples come from related or similar words in HyperNet, EVALution, Lenci/Benotto, and Weeds, so only computing generality difference leads to the best (or close to the best) performance. The negative samples in many datasets are composed of both random samples and similar words (such as BLESS), so the combination of similarity and generality difference yields the most stable results.
+
+Table 4: $\mathbf { A P } @$ all $( \% )$ of 10 datasets. The box at lower right corner compares the micro average AP across all 10 datasets. Numbers in different rows come from different feature or embedding spaces. Numbers in different columns come from different datasets and unsupervised scoring functions. We also present the micro average AP across the first 4 datasets (BLESS, EVALution, Lenci/Benotto and Weeds). All wiki means SBOW using PPMI features trained on the whole WaCkypedia. FW refers to frequency weighting on the shifted PMI matrix.   
+
+<table><tr><td rowspan="2" colspan="2">AP@all(%)</td><td colspan="5">BLESS</td><td colspan="4">EVALution</td><td colspan="5">Lenci/Benotto</td></tr><tr><td>CDE</td><td>AL1</td><td>△S</td><td>W△S</td><td>C△S</td><td>CDE AL1</td><td>△S</td><td>W△S</td><td>C△S</td><td>CDE</td><td>AL1</td><td>△S</td><td>W△S</td><td>C△S</td></tr><tr><td rowspan="4">SBOW</td><td>Freq</td><td>6.3</td><td>7.3 5.6 5.6</td><td>11.0 17.2</td><td>5.9 15.3</td><td>35.3 30.4</td><td>32.6 27.7</td><td>36.2</td><td>33.0</td><td>36.3</td><td>51.8</td><td>47.6</td><td>51.0</td><td>51.8</td><td>51.1</td></tr><tr><td>PPMI</td><td>13.6</td><td>5.1</td><td></td><td></td><td></td><td>27.5</td><td>34.1</td><td>31.9</td><td>34.3</td><td>47.2</td><td>39.7</td><td>50.8</td><td>51.1</td><td>52.0</td></tr><tr><td>PPMI w/FW</td><td>6.2</td><td>5.0</td><td>5.5 12.4</td><td></td><td>5.8</td><td>36.0</td><td>36.3</td><td>32.9</td><td>36.4</td><td>52.0</td><td>43.1</td><td>50.9</td><td>51.9</td><td>50.7</td></tr><tr><td>All wiki</td><td>12.1</td><td>5.2</td><td>6.9 12.5</td><td></td><td>13.4 28.5</td><td>27.1</td><td>30.3</td><td>29.9</td><td>31.0</td><td>47.1</td><td>39.9</td><td>48.5</td><td>48.7</td><td>51.1</td></tr><tr><td rowspan="3">DIVE</td><td>Full</td><td>9.3</td><td>7.6 6.0 5.6</td><td>18.6</td><td>16.3</td><td>30.0</td><td>27.5</td><td>34.9</td><td>33.0</td><td>46.7</td><td>43.2</td><td>51.3</td><td>51.5</td><td>50.4</td><td></td></tr><tr><td>w/o PMI</td><td>7.8</td><td>6.9</td><td>16.7</td><td>7.1</td><td>32.8</td><td>32.2</td><td>35.7</td><td>32.3 32.5</td><td>35.4</td><td>47.6</td><td>44.9</td><td>50.9</td><td>51.6</td><td>49.7</td></tr><tr><td>w/o FW</td><td>9.0</td><td>6.2</td><td>6.2</td><td>7.3</td><td>24.3</td><td>25.0</td><td>22.9</td><td>23.5</td><td>23.9</td><td>38.8</td><td>38.1</td><td>38.2</td><td>38.2</td><td>38.4</td></tr><tr><td>Kmean (Freq NMF)</td><td></td><td>6.5</td><td>7.3 5.6</td><td>10.9</td><td>5.8</td><td>33.7</td><td>27.2</td><td>36.2</td><td>33.0</td><td>36.2</td><td>49.6</td><td>42.5</td><td>51.0</td><td>51.8</td><td>51.2</td></tr><tr><td colspan="2"></td><td colspan="4">7.3 Weeds</td><td colspan="4">Micro Average (4 datasets)</td><td></td><td colspan="4">Medical</td><td></td></tr><tr><td colspan="2">AP@all(%)</td><td>CDE AL1</td><td colspan="3">△S</td><td>CDE</td><td colspan="3">AL1</td><td></td><td>CDE</td><td>AL1</td><td>△S</td><td>W·△S</td><td>C△S</td></tr><tr><td rowspan="5">SBOW</td><td>Freq</td><td>69.5</td><td>58.0 68.8</td><td>W△S 68.2</td><td>C△S 68.4</td><td>23.1</td><td>21.8</td><td>△S 22.9</td><td>W△S 25.0</td><td>C△S 23.0</td><td>19.4</td><td>19.2</td><td>14.1</td><td>18.4</td><td>15.3</td></tr><tr><td>PPMI</td><td>61.0</td><td>50.3</td><td>70.3</td><td>69.2</td><td>69.3</td><td>24.7 17.9</td><td>22.3</td><td>28.1</td><td>27.8</td><td>23.4</td><td>8.7</td><td>13.2</td><td>20.1</td><td>24.4</td></tr><tr><td>PPMI w/FW</td><td>67.6</td><td>52.2</td><td>69.4</td><td>68.7</td><td>67.7</td><td>23.2 18.2</td><td>22.9</td><td>25.8</td><td>22.9</td><td>22.8</td><td>10.6</td><td>13.7</td><td>18.6</td><td>17.0</td></tr><tr><td>All wiki</td><td>61.3</td><td>48.6</td><td>70.0</td><td></td><td>70.4</td><td>23.4</td><td></td><td></td><td>25.8</td><td>22.3</td><td>8.9</td><td>12.2</td><td>17.6</td><td>21.1</td></tr><tr><td>Full</td><td>59.2</td><td>55.0</td><td>68.5</td><td></td><td></td><td>17.7 19.8</td><td>21.7 22.8</td><td>24.6 28.9</td><td>27.6</td><td>11.7</td><td>9.3</td><td>13.7</td><td>21.4</td><td>19.2</td></tr><tr><td>DIVE w/o PMI</td><td>60.4</td><td>56.4</td><td>69.7 69.3</td><td>68.6 68.6</td><td>65.5 64.8</td><td>22.1 22.2</td><td>21.0</td><td></td><td>23.1</td><td>10.7</td><td>8.4</td><td>13.3</td><td>19.8</td><td></td><td>16.2</td></tr><tr><td rowspan="3"></td><td>w/o FW</td><td>49.2</td><td>47.3 45.1</td><td>45.1</td><td>44.9</td><td>18.9</td><td>17.3</td><td>22.7 17.2</td><td>28.0 16.8</td><td>17.5</td><td>10.9</td><td>9.8</td><td>7.4</td><td>7.6</td><td>7.7</td></tr><tr><td>Kmean (Freq NMF)</td><td>69.4</td><td>51.1 68.8</td><td>68.2</td><td>68.9</td><td>22.5</td><td>19.3</td><td>22.9</td><td>24.9</td><td>23.0</td><td>12.6</td><td>10.9</td><td>14.0</td><td>18.1</td><td>14.6</td></tr><tr><td></td><td></td><td>LEDS</td><td></td><td></td><td></td><td></td><td>TM14</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan="2">AP@all(%)</td><td colspan="4">AL1 △S</td><td colspan="4">CDE AL1</td><td></td><td colspan="4">Kotlerman 2010</td><td></td></tr><tr><td colspan="2">SBOWFreq</td><td>CDE</td><td>70.4 70.7</td><td>W·△S 83.3</td><td>C△S 73.3</td><td>55.6</td><td>53.2</td><td>△S 54.9</td><td>W·△S 55.7</td><td>C.△S 55.0</td><td>CDE 35.9</td><td>AL1 40.5</td><td>△S 34.5</td><td>W.△S 37.0</td><td>C.△S 35.4</td></tr><tr><td colspan="2">SBOWPPMI</td><td>82.7 84.4</td><td>50.2 72.2</td><td>86.5</td><td>84.5</td><td>56.2</td><td>52.3</td><td>54.4</td><td></td><td>57.6</td><td>39.1</td><td>30.9</td><td>33.0</td><td>37.0</td><td>36.3</td></tr><tr><td colspan="2">All wiki</td><td>83.1</td><td>49.7 67.9</td><td>82.9</td><td>81.4</td><td>54.7</td><td>50.5</td><td>52.6</td><td>57.0 55.1</td><td>54.9</td><td>38.5</td><td>31.2</td><td>32.2</td><td>35.4</td><td>35.3</td></tr><tr><td colspan="2">DIVE</td><td>83.3</td><td>72.7</td><td>86.4</td><td>83.5</td><td>55.3</td><td>52.6</td><td>55.2</td><td>57.3</td><td>57.2</td><td>35.3</td><td>31.6</td><td>33.6</td><td>37.4</td><td>36.6 MicroAverage(10datasets)</td></tr><tr><td colspan="2">AP@all (%)</td><td>74.7</td><td>HyperNet</td><td></td><td></td><td></td><td></td><td>WordNet</td><td></td><td></td></table>
+
+DIVE performs similar or better on all the scoring functions compared with SBOW consistently across all datasets in Table 4, while using many fewer dimensions (see Table 6). Its results on combination scoring functions outperform SBOW Freq. Meanwhile, its results on $A L _ { 1 }$ outperform SBOW PPMI. The fact that combination scoring functions (i.e., W·∆S or $\mathbf { C } { \cdot } \Delta \mathbf { S }$ ) usually outperform generality functions suggests that only memorizing general words is not sufficient. The best average performance on 4 and 10 datasets are both produced by ${ \bf W } { \cdot } { \Delta } { \cal S }$ on DIVE.
+
+SBOW PPMI improves the combination functions from SBOW Freq but sacrifices AP on the inclusion functions. It generally hurts performance to change the frequency sampling of PPMI (PPMI w/ FW) or compute SBOW PPMI on the whole WaCkypedia (all wiki) instead of the first 51.2 million tokens. The similar trend can also be seen in Table 5. Note that $A L _ { 1 }$ completely fails in HyperLex dataset using SBOW PPMI, which suggests that PPMI might not necessarily preserve the distributional inclusion property, even though it can have good performance on combination functions.
+
+Removing the PMI filter from DIVE slightly drops the overall precision while removing frequency weights on shifted PMI (w/o FW) leads to poor performances. K-means (Freq NMF) produces similar AP compared with SBOW Freq, but has worse $A L _ { 1 }$ scores. Its best AP scores on different datasets are also significantly worse than the best AP of DIVE. This means that only making word2vec (skip-grams with negative sampling) non-negative or naively accumulating topic distribution in contexts cannot lead to satisfactory embeddings.
+
+Table 5: Spearman $\rho \left( \% \right)$ in HyperLex.   
+
+<table><tr><td rowspan="2">Spearman p (%)</td><td colspan="5">HyperLex</td></tr><tr><td>CDE</td><td>AL1</td><td>△S</td><td>W·△S</td><td>C.△S</td></tr><tr><td>SBOWFreq</td><td>31.7</td><td>19.6</td><td>27.6</td><td>29.6</td><td>27.3</td></tr><tr><td>SBOW PPMI</td><td>28.1</td><td>-2.3</td><td>31.8</td><td>34.3</td><td>34.5</td></tr><tr><td>All wiki</td><td>25.3</td><td>-2.2</td><td>28.0</td><td>30.5</td><td>31.0</td></tr><tr><td>DIVE</td><td>28.9</td><td>18.7</td><td>31.2</td><td>33.3</td><td>32.8</td></tr></table>
+
+Table 6: The average number of non-zero dimensions across all testing words in 10 datasets.   
+
+<table><tr><td rowspan=1 colspan=1>SBOW Freq</td><td rowspan=1 colspan=1>SBOWPPMI</td><td rowspan=1 colspan=1>DIVE</td></tr><tr><td rowspan=1 colspan=1>5799</td><td rowspan=1 colspan=1>3808</td><td rowspan=1 colspan=1>20</td></tr></table>
+
+Table 7: Spectral clustering on the non-zero DIVE dimensions of the query word. When the number of clusters is set to be 2, we present the top 4 dimensions in each cluster, which have the highest values on the query word embedding. Otherwise, the top 2 dimensions are presented. CID refers to cluster ID. The top 5 words with the highest values of each dimension are presented.
+
+<table><tr><td>Query</td><td>CID</td><td colspan="2">Top 5 words in the top dimensions</td></tr><tr><td rowspan="2">rock</td><td>1</td><td>element,gas,atom,rock,carbon find, specie,species,animal,bird</td><td>sea,lake,river,area,water point,side,line, front,circle</td></tr><tr><td>2</td><td>band,song,album,music,rock early,work,century,late,begin</td><td>write,john,guitar,band,author include,several, show, television,film</td></tr><tr><td rowspan="2">bank</td><td>1</td><td>county,area,city, town,west building,build,house, palace, site</td><td>several,main, province, include,consist sea,lake,river,area,water</td></tr><tr><td>2</td><td>money, tax,price, pay, income united, states,country, world, europe</td><td>company,corporation,system,agency, service state,palestinian,israel,right, palestine</td></tr><tr><td rowspan="2">apple</td><td>1</td><td>food, fruit,vegetable,meat, potato war,german,ii,germany,world</td><td>goddess,zeus,god,hero,sauron write, john,guitar,band,author</td></tr><tr><td>2</td><td>version, game,release,original, file system,architecture,develop,base,language</td><td>car,company,sell, manufacturer,model include,several, show, television,film</td></tr><tr><td rowspan="2">star</td><td>1</td><td>film, role, production, play, stage wear,blue,color, instrument,red</td><td>character,series,game,novel, fantasy write, john,guitar,band,author</td></tr><tr><td>2</td><td>element,gas,atom,rock,carbon give, term,vector,mass,momentum</td><td>star,orbit,sun,orbital,planet light, image,lens,telescope,camera</td></tr><tr><td rowspan="2">tank</td><td>1</td><td>tank,cylinder,wheel, engine,steel acid,carbon,product, use, zinc</td><td>industry, export, industrial, economy,company network,user,server, datum, protocol</td></tr><tr><td>2</td><td>army,force,infantry,military,battle however,attempt,result, despite, fail</td><td>aircraft,navy,missile,ship,flight war, german, ii, germany, world</td></tr><tr><td rowspan="3">race</td><td>1</td><td>win,world,cup,play,championship</td><td>two,one,three,four,another</td></tr><tr><td>2 3</td><td>railway, line, train,road, rail</td><td>car,company, sell, manufacturer,model</td></tr><tr><td></td><td>population,language, ethnic, native, people</td><td>female,age,woman,male,household</td></tr><tr><td rowspan="3">run</td><td>1</td><td>system,architecture, develop,base,language</td><td>access, need, require,allow, program</td></tr><tr><td>2</td><td>railway,line,train,road,rail</td><td>also,well, several, early, see</td></tr><tr><td>3</td><td>game,team,season,win,league</td><td>game,player,run,deal,baseball</td></tr><tr><td rowspan="3">tablet</td><td>1</td><td>bc, source, greek, ancient, date</td><td>book,publish,write,work,edition</td></tr><tr><td>2</td><td>use,system,design,term,method</td><td>version, game,release,original, file</td></tr><tr><td>3</td><td>system,blood,vessel,artery,intestine</td><td>patient, symptom, treatment,disorder, may</td></tr></table>
+
+# 7 EXPERIMENT 4: WORD SENSE DISAMBIGUATION
+
+In addition to hypernymy detection, Athiwaratkun & Wilson (2017) show that the mixture of Gaussian distributions can also be used to discover multiple senses of each word. In our qualitative experiment, we show that DIVE can achieve the similar goal without fixing the number of senses before training the embedding.
+
+Recall that each dimension roughly corresponds to one topic. Given a query word, the higher embedding value on a dimension implies higher likelihood to observe the word in the context of the topic. The embedding of a polysemy would have high values on different groups of topics/dimensions. This allows us to discover the senses by clustering the topics/dimensions of the polysemy. We use the embedding values as the feature each dimension, compute the pairwise similarity between dimensions, and apply spectral clustering (Stella & Shi, 2003) to group topics as shown in the Table 7. See more implementation details in the supplementary materials.
+
+In the word sense disambiguation tasks, it is usually challenging to determine how many senses/clusters each word should have. Many existing approaches fix the number of senses before training the embedding (Tian et al., 2014; Athiwaratkun & Wilson, 2017). Neelakantan et al. (2014) make the number of clusters approximately proportional to the diversity of the context, but the assumption does not always hold. Furthermore, the training process cannot capture different granularity of senses. For instance, race in the car context could share the same sense with the race in the game topic because they all mean contest, but the race in the car context actually refers to the specific contest of speed. Therefore, they can also be viewed as separate senses (like the results in Table 7). This means the correct number of clusters is not unique, and the methods, which fixes the cluster numbers, need to re-train the embedding many times to capture such granularity.
+
+In our approach, clustering dimensions is done after the training process of DIVE is completed, so it is fairly efficient to change the cluster numbers and hierarchical clustering is also an option. Similar to our method, Pelevina et al. (2016) also discover word senses by graph-based clustering. The main difference is that they cluster the top $n$ words which are most related to the query word instead of topics. However, choosing the hyper-parameter $n$ is difficult. Large $n$ would make graph clustering algorithm inefficient, while small $n$ would make less frequent senses difficult to discover.
+
+# 8 RELATED WORK
+
+Most previous unsupervised approaches focus on designing better hypernymy scoring functions for sparse bag of word (SBOW) features. They are well summarized in the recent study (Santus et al., 2017). Santus et al. (2017) also evaluate the influence of different contexts, such as changing the window size of contexts or incorporating dependency parsing information, but neglect scalability issues inherent to SBOW methods.
+
+A notable exception is the Gaussian embedding model (Vilnis & McCallum, 2015). The context distribution of each word is encoded as a multivariate Gaussian distribution, where the embeddings of hypernyms tend to have higher variance and overlap with the embedding of their hyponyms. However, since a Gaussian distribution is normalized, it is difficult to retain frequency information during the embedding process, and experiments on HyperLex (Vulic et al., 2016) demonstrate that a simple ´ baseline only relying on word frequency can achieve good results. Follow-up work models contexts by a mixture of Gaussians (Athiwaratkun & Wilson, 2017) relaxing the unimodality assumption but achieves little improvement on hypernym detection tasks.
+
+Kiela et al. (2015) show that images retrieved by a search engine can be a useful source of information to determine the generality of lexicons, but the resources might not be available for some corpora such as scientific literature.
+
+Order embedding (Vendrov et al., 2016) is a supervised approach to encode many annotated hypernym pairs (e.g. all of the whole WordNet (Miller, 1995)) into a compact embedding space, where the embedding of a hypernym should be smaller than the embedding of its hyponym in every dimension. Our method learns embedding from raw text, where a hypernym embedding should be larger than the embedding of its hyponym in every dimension. Thus, DIVE can be viewed as an unsupervised and reversed form of order embedding.
+
+Other semi-supervised hypernym detection methods aim to generalize from sets of annotated word pairs using raw text corpora. The goal of HyperScore (Nguyen et al., 2017) is similar to our model: the embedding of a hypernym should be similar to its hyponym but with higher magnitude. However, their training process relies heavily on annotated hypernym pairs, and the performance drops significantly when reducing the amount of supervision. In addition to context distributions, previous work also leverages training data to discover useful text pattern indicating is-a relation (Shwartz et al., 2016; Roller & Erk, 2016), but it remains challenging to increase recall of hypernym detection because commonsense facts like cat is-a animal might not appear in the corpus.
+
+Non-negative matrix factorization (NMF) has a long history in NLP, for example in the construction of topic models (Pauca et al., 2004). Non-negative sparse embedding (NNSE) (Murphy et al., 2012) and Faruqui et al. (2015) indicate that non-negativity can make embeddings more interpretable and improve word similarity evaluations. The sparse NMF is also shown to be effective in cross-lingual lexical entailment tasks but does not necessarily improve monolingual hypernymy detection (Vyas &
+
+Carpuat, 2016). In our study, a new type of NMF is proposed, and the comprehensive experimental analysis demonstrates its state-of-the-art performances on unsupervised hypernymy detection.
+
+# 9 CONCLUSIONS
+
+Compressing unsupervised SBOW models into a compact representation is challenging while preserving the inclusion, generality, and similarity signals which are important for hypernym detection. Our experiments suggest that simple baselines such as accumulating K-mean clusters and non-negative skip-grams do not lead to satisfactory performances in this task.
+
+To achieve this goal, we proposed an interpretable and scalable embedding method called distributional inclusion vector embedding (DIVE) by performing non-negative matrix factorization (NMF) on a weighted PMI matrix. We demonstrate that scoring functions which measure inclusion and generality properties in SBOW can also be applied to DIVE to detect hypernymy, and DIVE performs the best on average, slightly better than SBOW while using many fewer dimensions.
+
+Our experiments also indicate that unsupervised scoring functions, which combine similarity and generality measurements, work the best in general, but no one scoring function dominates across all datasets. A combination of unsupervised DIVE with the proposed scoring functions produces new state-of-the-art performances on many datasets under the unsupervised setup.
+
+Finally, a qualitative experiment shows that clusters of the topics discovered by DIVE often correspond to the word senses, which allow us to do word sense disambiguation without the need to know the number of senses before training the embeddings.
+
+# REFERENCES
+
+Ben Athiwaratkun and Andrew Gordon Wilson. Multimodal word distributions. In ACL, 2017.
+
+Marco Baroni and Alessandro Lenci. How we BLESSed distributional semantic evaluation. In Workshop on GEometrical Models of Natural Language Semantics (GEMS), 2011.
+
+Marco Baroni, Silvia Bernardini, Adriano Ferraresi, and Eros Zanchetta. The WaCky wide web: a collection of very large linguistically processed web-crawled corpora. Language resources and evaluation, 43(3):209–226, 2009.
+
+Marco Baroni, Raffaella Bernardi, Ngoc-Quynh Do, and Chung-chieh Shan. Entailment above the word level in distributional semantics. In EACL, 2012.
+
+Giulia Benotto. Distributional models for semantic relations: A study on hyponymy and antonymy. PhD Thesis, University of Pisa, 2015.
+
+John A Bullinaria and Joseph P Levy. Extracting semantic representations from word co-occurrence statistics: A computational study. Behavior research methods, 39(3):510–526, 2007.
+
+Philipp Cimiano, Andreas Hotho, and Steffen Staab. Learning concept hierarchies from text corpora using formal concept analysis. J. Artif. Intell. Res.(JAIR), 24(1):305–339, 2005.
+
+Daoud Clarke. Context-theoretic semantics for natural language: an overview. In workshop on geometrical models of natural language semantics, pp. 112–119, 2009.
+
+Thomas Demeester, Tim Rocktaschel, and Sebastian Riedel. Lifted rule injection for relation em- ¨ beddings. In EMNLP, 2016.
+
+Chris Ding, Xiaofeng He, and Horst D Simon. On the equivalence of nonnegative matrix factorization and spectral clustering. In ICDM, 2005.
+
+Manaal Faruqui, Yulia Tsvetkov, Dani Yogatama, Chris Dyer, and Noah Smith. Sparse overcomplete word vector representations. In ACL, 2015.
+
+Maayan Geffet and Ido Dagan. The distributional inclusion hypotheses and lexical entailment. In ACL, 2005.
+
+Goran Glavas and Simone Paolo Ponzetto. Dual tensor model for detecting asymmetric lexico- ˇ semantic relations. In EMNLP, 2017.
+
+Zhiheng Huang, Marcus Thint, and Zengchang Qin. Question classification using head words and their hypernyms. In EMNLP, 2008.
+
+Douwe Kiela, Laura Rimell, Ivan Vulic, and Stephen Clark. Exploiting image generality for lexical entailment detection. In ACL, 2015.
+
+Diederik Kingma and Jimmy Ba. ADAM: A method for stochastic optimization. In ICLR, 2015.
+
+Lili Kotlerman, Ido Dagan, Idan Szpektor, and Maayan Zhitomirsky-Geffet. Directional distributional similarity for lexical inference. Natural Language Engineering, 16(4):359–389, 2010.
+
+Alessandro Lenci and Giulia Benotto. Identifying hypernyms in distributional semantic spaces. In SemEval, 2012.
+
+Omer Levy and Yoav Goldberg. Neural word embedding as implicit matrix factorization. In NIPS, 2014.
+
+Omer Levy, Ido Dagan, and Jacob Goldberger. Focused entailment graphs for open IE propositions. In CoNLL, 2014.
+
+Omer Levy, Yoav Goldberg, and Ido Dagan. Improving distributional similarity with lessons learned from word embeddings. Transactions of the Association for Computational Linguistics, 3:211– 225, 2015a.
+
+Omer Levy, Steffen Remus, Chris Biemann, and Ido Dagan. Do supervised distributional methods really learn lexical inference relations? In NAACL-HTL, 2015b.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013.
+
+George A. Miller. Wordnet: a lexical database for english. Communications of the ACM, 38(11): 39–41, 1995.
+
+Brian Murphy, Partha Talukdar, and Tom Mitchell. Learning effective and interpretable semantic models using non-negative sparse embedding. COLING, pp. 1933–1950, 2012.
+
+Eric Nalisnick and Sachin Ravi. Infinite dimensional word embeddings. arXiv preprint arXiv:1511.05392, 2015.
+
+Arvind Neelakantan, Jeevan Shankar, Alexandre Passos, and Andrew McCallum. Efficient nonparametric estimation of multiple embeddings per word in vector space. In EMNLP, 2014.
+
+Kim Anh Nguyen, Maximilian Koper, Sabine Schulte im Walde, and Ngoc Thang Vu. Hierarchical ¨ embeddings for hypernymy detection and directionality. In EMNLP, 2017.
+
+Maximilian Nickel and Douwe Kiela. Poincare embeddings for learning hierarchical representa- ´ tions. In NIPS, 2017.
+
+V. Paul Pauca, Farial Shahnaz, Michael W Berry, and Robert J. Plemmons. Text mining using non-negative matrix factorizations. In ICDM, 2004.
+
+F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12(Oct):2825–2830, 2011.
+
+Maria Pelevina, Nikolay Arefyev, Chris Biemann, and Alexander Panchenko. Making sense of word embeddings. In Workshop on Representation Learning for NLP, 2016.
+
+Simone Paolo Ponzetto and Michael Strube. Exploiting semantic role labeling, wordnet and wikipedia for coreference resolution. In ACL, 2006.
+
+Stephen Roller and Katrin Erk. Relations such as hypernymy: Identifying and exploiting hearst patterns in distributional vectors for lexical entailment. In EMNLP, 2016.
+
+Mark Sammons, V Vydiswaran, and Dan Roth. Recognizing textual entailment. Multilingual Natural Language Applications: From Theory to Practice. Prentice Hall, Jun, 2011.
+
+Enrico Santus, Alessandro Lenci, Qin Lu, and Sabine Schulte Im Walde. Chasing hypernyms in vector spaces with entropy. In EACL, 2014.
+
+Enrico Santus, Frances Yung, Alessandro Lenci, and Chu-Ren Huang. EVALution 1.0: an evolving semantic dataset for training and evaluation of distributional semantic models. In Workshop on Linked Data in Linguistics (LDL), 2015.
+
+Enrico Santus, Tin-Shing Chiu, Qin Lu, Alessandro Lenci, and Chu-Ren Huang. Unsupervised measure of word similarity: how to outperform co-occurrence and vector cosine in vsms. arXiv preprint arXiv:1603.09054, 2016.
+
+Enrico Santus, Vered Shwartz, and Dominik Schlechtweg. Hypernyms under siege: Linguisticallymotivated artillery for hypernymy detection. In EACL, 2017.
+
+David Sculley. Web-scale k-means clustering. In WWW, 2010.
+
+Vered Shwartz, Yoav Goldberg, and Ido Dagan. Improving hypernymy detection with an integrated path-based and distributional method. In ACL, 2016.
+
+X Yu Stella and Jianbo Shi. Multiclass spectral clustering. In ICCV, 2003.
+
+Fei Tian, Hanjun Dai, Jiang Bian, Bin Gao, Rui Zhang, Enhong Chen, and Tie-Yan Liu. A probabilistic model for learning multi-prototype word embeddings. In COLING, 2014.
+
+Peter D Turney and Saif M Mohammad. Experiments with three approaches to recognizing lexical entailment. Natural Language Engineering, 21(3):437–476, 2015.
+
+Ivan Vendrov, Ryan Kiros, Sanja Fidler, and Raquel Urtasun. Order-embeddings of images and language. In ICLR, 2016.
+
+Luke Vilnis and Andrew McCallum. Word representations via gaussian embedding. In ICLR, 2015.
+
+Ivan Vulic and Nikola Mrk ´ siˇ c. Specialising word vectors for lexical entailment. ´ arXiv preprint arXiv:1710.06371, 2017.
+
+Ivan Vulic, Daniela Gerz, Douwe Kiela, Felix Hill, and Anna Korhonen. Hyperlex: A large-scale ´ evaluation of graded lexical entailment. arXiv preprint arXiv:1608.02117, 2016.
+
+Yogarshi Vyas and Marine Carpuat. Sparse bilingual word representations for cross-lingual lexical entailment. In HLT-NAACL, 2016.
+
+Julie Weeds and David Weir. A general framework for distributional similarity. In EMNLP, 2003.
+
+Julie Weeds, Daoud Clarke, Jeremy Reffin, David Weir, and Bill Keller. Learning to distinguish hypernyms and co-hyponyms. In COLING, 2014.
+
+Table 8: Comparison with semi-supervised embeddings (with limited training data). All values are percentages. The number in parentheses beside each approach indicates the number of annotated hypernymy word pairs used to train the model. Semi-supervised embeddings include HyperScore (Nguyen et al., 2017) and H-feature (Roller & Erk, 2016). When we compare F1 with the results from other papers, we use 20 fold cross validation to determine prediction thresholds, as done by Roller & Erk (2016). Note that HyperScore ignores POS in the testing data, so we follow the setup when comparing with it.
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>HyperLex</td><td rowspan=1 colspan=3>EVALution  LenciBenotto  Weeds</td><td rowspan=1 colspan=1>Medical</td></tr><tr><td rowspan=1 colspan=1>Metric</td><td rowspan=1 colspan=1>Spearman p</td><td rowspan=1 colspan=3>AP@all</td><td rowspan=1 colspan=1>F1</td></tr><tr><td rowspan=2 colspan=1>Baselines(#Training Hypernymy)</td><td rowspan=1 colspan=4>HyperScore(1337)</td><td rowspan=1 colspan=1>H-feature (897)</td></tr><tr><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>44.8</td><td rowspan=1 colspan=1>58.5</td><td rowspan=1 colspan=1>26</td></tr><tr><td rowspan=1 colspan=1>DIVE+C·△S (0)</td><td rowspan=1 colspan=1>34.5</td><td rowspan=1 colspan=1>33.8</td><td rowspan=1 colspan=1>52.9</td><td rowspan=1 colspan=1>70.0</td><td rowspan=1 colspan=1>25.3</td></tr></table>
+
+Table 9: We show the top 30 words with the highest embedding magnitude after dot product with the query embedding $\mathbf { q }$ (i.e. showing w such that $| \mathbf { w } ^ { T } \mathbf { q } | _ { 1 }$ is one of the top 30 highest values). The rows with the empty query word sort words based on $| \mathbf { w } | _ { 1 }$ .
+
+<table><tr><td>Query</td><td colspan="6">Top30 generalwords</td></tr><tr><td></td><td>use large american design study</td><td>name state life work lead</td><td>system group may produce type</td><td>include power small control people</td><td>base death find great high</td><td>city form body write create</td></tr><tr><td>species</td><td>specie human gene fish evidence</td><td>species bird tree disease breed</td><td>animal genus name live protein</td><td>find family genetic food wild</td><td>plant organism study cell similar</td><td>may suggest occur mammal fossil</td></tr><tr><td>system</td><td>system standard allow process network</td><td>use type function code file</td><td>design computer datum via development</td><td>provide application device base service</td><td>operate develop control program transport</td><td>model method information software law</td></tr></table>
+
+# A SUPPLEMENTARY MATERIALS
+
+# A.1 COMPARISON WITH SEMI-SUPERVISED EMBEDDINGS
+
+In addition to the unsupervised approach, we also compare DIVE with semi-supervised approaches. When there are sufficient training data, there is no doubt that the semi-supervised embedding approaches such as HyperNet (Shwartz et al., 2016), H-feature detector (Roller & Erk, 2016), and HyperScore (Nguyen et al., 2017) can achieve better performance than all unsupervised methods. However, in many domains such as scientific literature, there are often not many annotated hypernymy pairs (e.g. Medical dataset (Levy et al., 2014)).
+
+Since we are comparing an unsupervised method with semi-supervised methods, it is hard to fairly control the experimental setups and tune the hyper-parameters. In Table 8, we only show several performances which are copied from the original paper when training data are limited3. As we can see, the performance from DIVE is roughly comparable to the previous semi-supervised approaches trained on small amount of hypernym pairs. This demonstrates the robustness of our approach and the difficulty of generalizing hypernymy annotations with semi-supervised approaches.
+
+# A.2 GENERALITY ESTIMATION AND HYPERNYM DIRECTIONALITY DETECTION
+
+In Table 9, we show the most general words in DIVE under different queries as constraints. We also present the accuracy of judging which word is a hypernym (more general) given word pairs with
+
+Table 10: Accuracy $( \% )$ of hypernym directionality prediction across 10 datasets.   
+
+<table><tr><td rowspan=1 colspan=4>Micro Average (1O datasets)</td></tr><tr><td rowspan=1 colspan=1>SBOW Freq+ SLQS Sub64.4</td><td rowspan=1 colspan=1>SBOW Freq +△S66.8</td><td rowspan=1 colspan=1>SBOW PPMI+△S66.8</td><td rowspan=1 colspan=1>DIVE+△S67.0</td></tr></table>
+
+Table 11: Dataset sizes. N denotes the number of word pairs in the dataset, and OOV shows how many word pairs are not processed by all the methods in Table 4 and Table 5.
+
+<table><tr><td colspan="2">BLESS</td><td colspan="2">EVALution</td><td colspan="2">Lenci/Benotto</td><td colspan="2">Weeds</td><td colspan="2">Avg (4 datasets)</td></tr><tr><td>N 26554</td><td>0OV 1507</td><td>N 13675</td><td>OOV 2475</td><td>N 5010</td><td>OOV 1464</td><td>N 2928</td><td>0OV 643</td><td>N 48167</td><td>OOv 6089</td></tr><tr><td colspan="2">Medical</td><td colspan="2"></td><td colspan="2"></td><td colspan="2">Kotlerman 2010</td><td colspan="2"></td></tr><tr><td colspan="2">N</td><td colspan="2">LEDS</td><td colspan="2">TM14</td><td colspan="2"></td><td colspan="2">HyperNet</td></tr><tr><td>12602</td><td>OOV 3711</td><td>N</td><td>OOV 28</td><td>N</td><td>OOV 178</td><td>N</td><td>OOV 89</td><td>N</td><td>OOV 9424</td></tr><tr><td colspan="2"></td><td colspan="2">2770</td><td colspan="2">2188</td><td colspan="2">2940</td><td colspan="2">17670</td></tr><tr><td colspan="2">WordNet</td><td colspan="2">Avg(10 datasets)</td><td colspan="2">HyperLex</td><td colspan="2"></td><td colspan="2"></td></tr><tr><td colspan="2">N OOV</td><td colspan="2">N</td><td colspan="2">N</td><td colspan="2"></td><td colspan="2"></td></tr><tr><td colspan="2">8000 3596</td><td colspan="2">94337</td><td colspan="2">2616</td><td colspan="2">0OV 59</td><td colspan="2"></td></tr></table>
+
+hypernym relations in Table 10. The direction is classified correctly if the generality score is greater than 0 (hypernym is indeed predicted as the more general word). For instance, summation difference $( \Delta \mathsf { S } )$ classifies correctly if $\vert \mathbf { \bar { w } } _ { p } \vert _ { 1 } - \vert \mathbf { w } _ { q } \vert _ { 1 } > 0$ $( | \bar { \mathbf { w } _ { p } } | _ { 1 } > | \mathbf { w } _ { q } | _ { 1 } )$ .
+
+From the table, we can see that the simple summation difference performs better than SQLS Sub, and DIVE predicts directionality as well as SBOW. Notice that whenever we encounter OOV, the directionality is predicted randomly. If OOV is excluded, the accuracy of predicting directionality using unsupervised methods can reach around 0.7-0.75.
+
+# A.3 EXPERIMENTAL DETAILS FOR HYPERNYMY DETECTION
+
+In HyperNet and WordNet, some hypernym relations are determined between phrases instead of words. Phrase embeddings are composed by averaging word embeddings or SBOW features. For WordNet, we assume the Part of Speech (POS) tags of the words are the same as the phrase. All part-of-speech (POS) tags in the experiments come from NLTK.
+
+The window size $| W |$ of SBOW, DIVE, and GE are set as 20 (left 10 words and right 10 words). For DIVE, the number of epochs is 15, the learning rate is 0.001, the batch size is 128, the threshold in PMI filter $k _ { f }$ is set to be 30, and the ratio between negative and positive samples ${ \mathrm { ( k ) } }$ is 1.5. The hyper-parameters of DIVE were decided based on the performance of HyperNet training set. The window size of skip-grams (word2vec) is 10. The number of negative samples $( k ^ { \prime } )$ in skip-gram is set as 5. When composing skip gram into phrase embedding, average embedding is used.
+
+For Gaussian embedding (GE), the number of mixture is 1, the number of dimension is 100, the learning rate is 0.01, the lowest variance is 0.1, the highest variance is 100, the highest Gaussian mean is 10, and other hyper-parameters are the default value in https://github.com/ benathi/word2gm. The hyper-parameters of GE were also decided based on the performance of HyperNet training set. When determining the score between two phrases, we use the average score of every pair of tokens in two phrases.
+
+The number of testing pairs $_ \mathrm { N }$ and the number of OOV word pairs is presented in Table 11.
+
+# A.4 CLUSTERING DIMENSIONS FOR WORD SENSE DISAMBIGUATION
+
+We use all the default hyper-parameters of the spectral clustering library in Scikit-learn 0.18.2 (Pedregosa et al., 2011) except the number of clusters is set manually. A simple way to prepare the feature of each dimension $f ( c _ { i } )$ is to use the embedding values in that dimension $\mathbf { w } [ c _ { i } ]$ of all the words in our vocabulary $w \in V$ . That is,
+
+$$
+f ( c _ { i } ) = [ \mathbf { w } [ c _ { i } ] ] _ { w \in V } .
+$$
+
+However, clustering on the global features might group topics together based on the co-occurrence of words which are unrelated to the query words and we want to make the similarity dependent on the query word. For example, a country topic should be clustered together with a city topic if the query word is place, but it makes more sense to group the country topic with the money topic together if the query word is bank like we did in the word sense disambiguation experiment (Table 7). This means we want to focus on the geographical meaning of country when the query is related to geography, while focus on the economic meaning of country when the query is about economics.
+
+To create query dependent similarity measurement, we only consider the embedding of words which are related to the query word when preparing the features of dimensions. Specifically, given a query word $q$ , the feature vector of the $i$ th dimension $f ( c _ { i } , q )$ is defined as:
+
+$$
+f ( c _ { i } , q ) = \bigoplus _ { j = 1 } ^ { d _ { 0 } } \left[ \mathbf { w } [ c _ { i } ] \cdot \mathbf { w } _ { q } [ c _ { j } ] \right] _ { w \in C _ { j } ( n ) } ,
+$$
+
+where ${ \bf w } _ { q } [ c _ { j } ]$ is the value of $j$ th dimension of query word embedding, $C _ { j } ( n )$ is the set of embeddings of top $n$ words in the $j$ th dimension, and the operator $\oplus$ means concatenation. This means instead of considering all the words in the vocabulary, we only take the top $n$ words of every dimension $j$ (n is fixed as 100 in the experiment), weight the feature based on how likely to observe query word in dimension $j$ $( \mathbf { w } _ { q } [ c _ { j } ] )$ , and concatenate all features together. That is, when measuring the similarity of dimensions, we only consider the aspects related to query word (e.g. mostly considering words related to facility and money when the query word is bank).
+
+After the features of all dimensions are collected, we normalize the feature of each dimension to have the norm 1, compute the pairwise similarity and run the spectral clustering to get the clustering results.
+
+# A.5 EFFICIENT WAY TO COMPUTE ASYMMETRIC L1 $( A L _ { 1 } )$
+
+Recall that Equation (8) defines $A L _ { 1 }$ as follows:
+
+$$
+A L _ { 1 } = \mathcal { L } = \operatorname* { m i n } _ { a } \ \sum _ { c } w _ { 0 } \operatorname* { m a x } ( a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] , 0 ) + \operatorname* { m a x } ( \mathbf { d } _ { p } [ c ] - a \mathbf { d } _ { q } [ c ] , 0 ) ,
+$$
+
+where $\mathbf { d } _ { p } [ c ]$ is one of dimension in the feature vector of hypernym $\mathbf { d } _ { p }$ , $a \mathbf { d } _ { q }$ is the feature vector of hyponym after proper scaling. In Figure 2, an simple example is visualized to illustrate the intuition behind the distance function.
+
+By adding slack variables $\zeta$ and $\xi$ , the problem could be converted into a linear programming problem:
+
+$$
+\begin{array} { l } { \mathcal { L } = \displaystyle \operatorname* { m i n } _ { a , \zeta , \xi } ~ w _ { 0 } \sum _ { c } \zeta _ { c } + \sum _ { c } \xi _ { c } } \\ { ~ \zeta _ { c } \geq a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] , ~ \zeta _ { c } \geq 0 } \\ { \displaystyle ~ \xi _ { c } \geq \mathbf { d } _ { p } [ c ] - a \mathbf { d } _ { q } [ c ] , ~ \xi _ { c } \geq 0 } \\ { ~ a \geq 0 , ~ } \end{array}
+$$
+
+so it can be simply solved by a general linear programming library.
+
+Nevertheless, the structure in the problem actually allows us to solve this optimization by a simple sorting. In this section, we are going to derive the efficient optimization algorithm.
+
+By introducing Lagrangian multiplier for the constraints, we can rewrite the problem as
+
+$$
+\begin{array} { l l } { { \mathcal { L } = \displaystyle \operatorname* { m i n } _ { a , \zeta , \xi } \operatorname* { m a x } _ { \alpha , \beta , \gamma , \delta } w _ { 0 } \sum _ { c } \zeta _ { c } + \sum _ { c } \xi _ { c } - \sum _ { c } \alpha _ { c } ( \zeta _ { c } - a { \bf d } _ { q } [ c ] + { \bf d } _ { p } [ c ] ) } } \\ { { \mathrm { ~ } } } \\ { { \mathrm { ~ } - \sum _ { c } \beta _ { c } ( \xi _ { c } - { \bf d } _ { p } [ c ] + a { \bf d } _ { q } [ c ] ) - \sum _ { c } \gamma _ { c } \zeta _ { c } - \sum _ { c } \delta _ { c } \xi _ { c } } } \\ { { \mathrm { ~ } } } \\ { { \zeta _ { c } \geq 0 , \xi _ { c } \geq 0 , \alpha _ { c } \geq 0 , \beta _ { c } \geq 0 , \gamma _ { c } \geq 0 , \delta _ { c } \geq 0 , a \geq 0 } } \end{array}
+$$
+
+![](images/8c0cf76ff70a7b6ae235a8767dbac4aa77b900b1aa3ec191dfbdfa9da0d93c69.jpg)  
+Figure 2: An example of $A L _ { 1 }$ distance. If the word pair indeed has the hypernym relation, the context distribution of hyponym $( \mathbf { d } _ { q } )$ tends to be included in the context distribution of hypernym $( \mathbf { d } _ { p } )$ after proper scaling according to DIH. Thus, the context words only appear beside the hyponym candidate $( a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] )$ causes higher penalty.
+
+First, we eliminate the slack variables by taking derivatives with respect to them:
+
+$$
+\begin{array} { r l r } { \displaystyle \frac { \partial \mathcal { L } } { \partial \zeta _ { c } } = 0 = 1 - \beta _ { c } - \delta _ { c } } & { } & \\ { \displaystyle \delta _ { c } = 1 - \beta _ { c } , ~ \beta _ { c } \le 1 } & { } \\ { \displaystyle \frac { \partial \mathcal { L } } { \partial \xi _ { c } } = 0 = 1 - \gamma _ { c } - \alpha _ { c } } & { } \\ { \displaystyle \gamma _ { c } = w _ { 0 } - \alpha _ { c } , ~ \alpha _ { c } \le w _ { 0 } . } & { } \end{array}
+$$
+
+By substituting in these values for $\gamma _ { c }$ and $\delta _ { c }$ , we get rid of the slack variables and have a new Lagrangian:
+
+$$
+\begin{array} { c l l } { { } } & { { { \mathcal { L } } = \underset { a } { \mathrm { m i n } } \underset { \alpha , \beta } { \mathrm { m a x } } ~ - \sum _ { c } \alpha _ { c } ( - a \mathbf { d } _ { q } [ c ] + \mathbf { d } _ { p } [ c ] ) - \sum _ { c } \beta _ { c } ( - \mathbf { d } _ { p } [ c ] + a \mathbf { d } _ { q } [ c ] ) } } \\ { { } } & { { } } \\ { { } } & { { 0 \leq \alpha _ { c } \leq w _ { 0 } , 0 \leq \beta _ { c } \leq 1 , a \geq 0 } } \end{array}
+$$
+
+We can introduce a new dual variable $\lambda _ { c } = \alpha _ { c } - \beta _ { c } + 1$ and rewrite this as:
+
+$$
+\begin{array} { c } { \mathcal { L } = \displaystyle \underset { a } { \mathrm { m i n } } \displaystyle \operatorname* { m a x } _ { \lambda } \ \sum _ { c } ( \lambda _ { c } - 1 ) ( a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] ) } \\ { 0 \leq \lambda _ { c } \leq w _ { 0 } + 1 , a \geq 0 } \end{array}
+$$
+
+Let’s remove the constraint on $a$ and replace with a dual variable $\eta$ :
+
+$$
+\begin{array} { c } { \mathcal { L } = \displaystyle \underset { a } { \mathrm { m i n } } \displaystyle \operatorname* { m a x } _ { \lambda } \ \sum _ { c } ( \lambda _ { c } - 1 ) ( a \mathbf { d } _ { q } [ c ] - \mathbf { d } _ { p } [ c ] ) - \eta a } \\ { 0 \leq \lambda _ { c } \leq w _ { 0 } + 1 , \eta \geq 0 } \end{array}
+$$
+
+Now let’s differentiate with respect to $a$ to get rid of the primal objective and add a new constraint:
+
+$$
+\begin{array} { c } { { \displaystyle \frac { \partial \mathcal { L } } { \partial a } = 0 = \sum _ { c } \lambda _ { c } \mathbf { d } _ { q } [ c ] - \sum _ { c } \mathbf { d } _ { q } [ c ] - \eta } } \\ { { \displaystyle \sum _ { c } \lambda _ { c } \mathbf { d } _ { q } [ c ] = \sum _ { c } \mathbf { d } _ { q } [ c ] + \eta } } \\ { { \displaystyle \mathcal { L } = \operatorname* { m a x } _ { \lambda } \ \sum _ { c } \mathbf { d } _ { p } [ c ] - \sum _ { c } \lambda _ { c } \mathbf { d } _ { p } [ c ] } } \\ { { \displaystyle \sum _ { c } \lambda _ { c } \mathbf { d } _ { q } [ c ] = \sum _ { c } \mathbf { d } _ { q } [ c ] + \eta } } \\ { { \displaystyle 0 \leq \lambda _ { c } \leq w _ { 0 } + 1 , \eta \geq 0 } } \end{array}
+$$
+
+Now we have some constant terms that are just the sums of $\mathbf { d } _ { p }$ and ${ \mathbf { d } } _ { q }$ , which will be 1 if they are distributions.
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } = \displaystyle \operatorname* { m a x } _ { \lambda } ~ 1 - \sum _ { c } \lambda _ { c } \mathbf { d } _ { p } [ c ] } \\ { \displaystyle \sum _ { c } \lambda _ { c } \mathbf { d } _ { q } [ c ] = 1 + \eta } \\ { \displaystyle 0 \leq \lambda _ { c } \leq w _ { 0 } + 1 , \eta \geq 0 } \end{array}
+$$
+
+Now we introduce a new set of variables $\mu _ { c } = \lambda _ { c } \mathbf { d } _ { q } [ c ]$ and we can rewrite the objective as:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } = \underset { \mu } { \mathrm { m a x } } ~ 1 - \sum _ { c } \mu _ { c } \frac { \mathbf { d } _ { p } [ c ] } { \mathbf { d } _ { q } [ c ] } } \\ { \displaystyle \sum _ { c } \mu _ { c } = 1 + \eta } \\ { \displaystyle 0 \leq \mu _ { c } \leq ( w _ { 0 } + 1 ) \mathbf { d } _ { q } [ c ] , \eta \geq 0 } \end{array}
+$$
+
+Note that for terms where $\mathbf { d } _ { q } [ c ] = 0$ we can just set $\mathbf { d } _ { q } [ c ] = \epsilon$ for some very small epsilon, and in practice, our algorithm will not encounter these because it sorts.
+
+So $\mu$ we can think of as some fixed budget that we have to spend up until it adds up to 1, but it has a limit of how much we can spend for each coordinate, given by $( w _ { 0 } + 1 ) { \bf d } _ { q } [ c ]$ . Since we’re trying to minimize the term involving $\mu$ , we want to allocate as much budget as possible to the smallest terms in the summand, and then 0 to the rest once we’ve spent the budget. This also shows us that our optimal value for the dual variable $\eta$ is just 0 since we want to minimize the amount of budget we have to allocate.
+
+To make presentation easier, lets assume we sort the vectors in order of increasing $\begin{array} { r } { \frac { \mathbf { d } _ { p } [ c ] } { \mathbf { d } _ { q } [ c ] } } \end{array}$ , so that $\frac { \mathbf { d } _ { p } [ 1 ] } { \mathbf { d } _ { q } [ 1 ] }$ is the smallest element, etc. We can now give the following algorithm to find the optimal $\mu$ .
+
+$$
+\begin{array} { r l } & { \operatorname { i n i t } \ S = 0 , c = 1 , \mu = 0 } \\ & { \operatorname { w h i l e } \ S \le 1 : } \\ & { \ \mu _ { c } = \operatorname* { m i n } ( 1 - S , ( w _ { 0 } + 1 ) { \bf d } _ { q } [ c ] ) } \\ & { \ { S = S + \mu _ { c } } } \\ & { \ { c = c + 1 } } \end{array}
+$$
+
+At the end we can just plug in this optimal $\mu$ to the objective to get the value of our scoring function.

parse/train/hhU9TEvB6AF/hhU9TEvB6AF.md

@@ -0,0 +1,273 @@
+# Meta Learning Backpropagation And Improving It
+
+Louis Kirsch1, Jürgen Schmidhuber1,2   
+1The Swiss AI Lab IDSIA, University of Lugano (USI) & SUPSI, Lugano, Switzerland   
+2King Abdullah University of Science and Technology (KAUST), Thuwal, Saudi Arabia {louis, juergen}@idsia.ch
+
+# Abstract
+
+Many concepts have been proposed for meta learning with neural networks (NNs), e.g., NNs that learn to reprogram fast weights, Hebbian plasticity, learned learning rules, and meta recurrent NNs. Our Variable Shared Meta Learning (VSML) unifies the above and demonstrates that simple weight-sharing and sparsity in an NN is sufficient to express powerful learning algorithms (LAs) in a reusable fashion. A simple implementation of VSML where the weights of a neural network are replaced by tiny LSTMs allows for implementing the backpropagation LA solely by running in forward-mode. It can even meta learn new LAs that differ from online backpropagation and generalize to datasets outside of the meta training distribution without explicit gradient calculation. Introspection reveals that our meta learned LAs learn through fast association in a way that is qualitatively different from gradient descent.
+
+# 1 Introduction
+
+The shift from standard machine learning to meta learning involves learning the learning algorithm (LA) itself, reducing the burden on the human designer to craft useful learning algorithms [43]. Recent meta learning has primarily focused on generalization from training tasks to similar test tasks, e.g., few-shot learning [11], or from training environments to similar test environments [17]. This contrasts human-engineered LAs that generalize across a wide range of datasets or environments. Without such generalization, meta learned LAs can not entirely replace human-engineered variants. Recent work demonstrated that meta learning can also successfully generate more general LAs that generalize across wide spectra of environments [20, 1, 31], e.g., from toy environments to Mujoco and Atari. Unfortunately, however, many recent approaches still rely on a large number of human-designed and unmodifiable inner-loop components such as backpropagation.
+
+Is it possible to implement modifiable versions of backpropagation or related algorithms as part of the end-to-end differentiable activation dynamics of a neural net (NN), instead of inserting them as separate fixed routines? Here we propose the Variable Shared Meta Learning (VSML) principle for this purpose. It introduces a novel way of using sparsity and weight-sharing in NNs for meta learning. We build on the arguably simplest neural meta learner, the meta recurrent neural network (Meta RNN) [16, 10, 56], by replacing the weights of a neural network with tiny LSTMs. The resulting system can be viewed as many RNNs passing messages to each other, or as one big RNN with a sparse shared weight matrix, or as a system learning each neuron’s functionality and its LA. VSML generalizes the principle behind end-to-end differentiable fast weight programmers [45, 46, 3, 41], hyper networks [14], learned learning rules [4, 13, 33], and hebbian-like synaptic plasticity [44, 46, 25, 26, 30]. Our mechanism, VSML, can implement backpropagation solely in the forward-dynamics of an RNN. Consequently, it enables meta-optimization of backproplike algorithms. We envision a future where novel methods of credit assignment can be meta learned while still generalizing across vastly different tasks. This may lead to improvements in sample efficiency, memory efficiency, continual learning, and others. As a first step, our system meta learns online LAs from scratch that frequently learn faster than gradient descent and generalize to datasets outside of the meta training distribution (e.g., from MNIST to Fashion MNIST). Our VSML RNN is the first neural meta learner without hard-coded backpropagation that shows such strong generalization.
+
+# 2 Background
+
+Deep learning-based meta learning that does not rely on fixed gradient descent in the inner loop has historically fallen into two categories, 1) Learnable weight update mechanisms that allow for changing the parameters of an NN to implement a learning rule (FWPs / LLRs), and 2) Learning algorithms implemented in black-box models such as recurrent neural networks (Meta RNNs).
+
+Fast weight programmers & Learned learning rules (FWPs / LLRs) In a standard NN, the weights are updated by a fixed LA. This framework can be extended to meta learning by defining an explicit architecture that allows for modifying these weights. This weight-update architecture augments a standard NN architecture. NNs that generate or change the weights of another or the same NN are known as fast weight programmers (FWPs) [44, 45, 46, 3, 41], hypernetworks [14], NNs with synaptic plasticity [25, 26, 30] or learned learning rules [4, 13, 33]. Often these architectures make use of local Hebbian-like update rules or outer-products, and we summarize this category as FWPs / LLRs. In FWPs / LLRs the variables $V _ { L }$ that are subject to learning are the weights of the network, whereas the meta-variables $V _ { M }$ that implement the LA are defined by the weight-update architecture. Note that the dimensionality of $V _ { L }$ and $V _ { M }$ can be defined independently of each other and often $V _ { M }$ are reused in a coordinate-wise fashion for $V _ { L }$ resulting in $| V _ { L } | \gg | V _ { M } |$ , where $| \cdot |$ is the number of elements.
+
+Black-box learning in activations (Meta RNNs) It was shown that an RNN such as LSTM can learn to implement an LA [16] when the reward or error is given as an input [47]. After meta training, the LA is encoded in the weights of this RNN and determines learning during meta testing. The activations serve as the memory used for the LA solution. We refer to this as Meta RNNs [16, 10, 56] (Also sometimes referred to as memory-based meta learning.). They are conceptually simpler than FWPs / LLRs as no additional weight-update rules with many degrees of freedom need to be defined. In Meta RNNs $V _ { L }$ are the RNN activations and $V _ { M }$ are the parameters for the RNN. Note that an RNN with $N$ neurons will yield $| V _ { L } | = O ( N )$ and $| V _ { M } | = \stackrel { \cdot } { O } ( N ^ { 2 } )$ [46]. This means that the LA is largely overparameterized whereas the available memory for learning is very small, making this approach prone to overfitting [20]. As a result, the RNN parameters often encode task-specific solutions instead of generic LAs. Meta learning a simple and generalizing LA would benefit from $| V _ { L } | \gg | V _ { M } |$ . Previous approaches have tried to mend this issue by adding architectural complexity through additional memory mechanisms [53, 29, 40, 27, 42].
+
+# 3 Variable Shared Meta Learning (VSML)
+
+In VSML we build on the simplicity of Meta RNNs while retaining $| V _ { L } | \gg | V _ { M } |$ from FWPs / LLRs. We do this by reusing the same few parameters $V _ { M }$ many times in an RNN (via variable sharing) and introducing sparsity in the connectivity. This yields several interpretations for VSML:
+
+$\textcircled{8}$ VSML as a single Meta RNN with a sparse shared weight matrix (Figure 1a). The most general description.   
+$\textcircled{8}$ VSML as message passing between RNNs (Figure 1b). We choose a simple sharing and sparsity scheme for the weight matrix such that it corresponds to multiple RNNs with shared parameters that exchange information.   
+$©$ VSML as complex neurons with learned updates (Figure 1c). When choosing a specific connectivity between RNNs, states / activations $V _ { L }$ of these RNNs can be interpreted as the weights of a conventional NN, consequently blurring the distinction between a weight and an activation.
+
+Introducing variable sharing to Meta RNNs We begin by formalizing Meta RNNs which often use multiplicative gates such as the LSTM [12, 15] or its variant GRU [6]. For notational simplicity, we consider a vanilla RNN. Let $s \in \mathbb { R } ^ { N }$ be the hidden state of an RNN. The update for an element $j \in \{ 1 , \ldots , N \}$ is given by
+
+![](images/b1ae57af27d23bff08bcfc6f114db04ece9a7f8b38923249b2e9e1b42ad6a50f.jpg)  
+Figure 1: Different perspectives on VSML: (a) A single Meta RNN [16] where entries in the weight matrix are shared or zero. (a) VSML consists of many sub-RNNs with shared parameters $V _ { M }$ passing messages between each other. (c) VSML implements an NN with complex neurons (here 2 neurons). $V _ { M }$ determines the nature of weights, how these are used in the neural computation, and the LA by which those are updated. Each weight $w _ { a b } \in \mathbb { R }$ is represented by the multi-dimensional RNN state ${ s _ { a b } } \in \mathbb { R } ^ { N }$ . Neuron activations correspond to messages $\overrightarrow { m }$ passed between sub-RNNs.
+
+$$
+s _ { j } \gets f _ { \mathrm { R N N } } ( s ) _ { j } = \sigma ( \sum _ { i } s _ { i } W _ { i j } ) ,
+$$
+
+where $\sigma$ is a non-linear activation function, $W \in \mathbb { R } ^ { N \times N }$ , and the bias is omitted for simplicity. We also omit inputs by assuming a subset of $s$ to be externally provided. Each application of Equation 1 reflects a single time tick in the RNN.
+
+We now introduce variable sharing (reusing $W$ ) into the RNN by duplicating the computation along two axes of size $A , B$ (here $A = B$ , which will later be relaxed) giving $\bar { s } \in \mathbb { R } ^ { A \times B \times N }$ . For $a \in \{ 1 , \dotsc , A \} , b \in \{ 1 , \dotsc , B \}$ we have
+
+$$
+s _ { a b j } \gets f _ { \mathrm { R N N } } ( s _ { a b } ) _ { j } = \sigma ( \sum _ { i } s _ { a b i } W _ { i j } ) .
+$$
+
+This can be viewed as multiple RNNs arranged on a 2-dimensional grid, with shared parameters that update independent states. Here, we chose a particular arrangement (two axes) that will facilitate the interpretation $©$ of RNNs as weights.
+
+VSML as message passing between RNNs The computation so far describes $A \cdot B$ independent RNNs. We connect those by passing messages (interpretation $\textcircled{8}$ )
+
+$$
+s _ { a b } \gets f _ { \mathrm { R N N } } ( s _ { a b } , \overrightarrow { m } _ { a } ) ,
+$$
+
+where the message $\begin{array} { r } { \vec { m } _ { b } = \sum _ { a ^ { \prime } } f _ { \vec { m } } ( s _ { a ^ { \prime } b } ) } \end{array}$ with $b \in \{ 1 , \dots , A = B \}$ , $f _ { \overrightarrow { m } } : \mathbb { R } ^ { N }  \mathbb { R } ^ { N ^ { \prime } }$ is fed as an additional input to each RNN. This is related to Graph Neural Networks [51, 58]. Summing over the axis $A$ (elements $a ^ { \prime }$ ) corresponds to an RNN connectivity mimicking those of weights in an NN (to facilitate interpretation $©$ . We emphasise that other schemes based on different kinds of message passing and graph connectivity are possible. For a simple $f _ { \overrightarrow { m } }$ defined by the matrix $C \in \mathbb { R } ^ { N \times N }$ , we may equivalently write
+
+$$
+s _ { a b j } \gets \sigma ( \sum _ { i } s _ { a b i } W _ { i j } + \sum _ { a ^ { \prime } } f _ { \overrightarrow { m } } ( s _ { a ^ { \prime } a } ) ) = \sigma ( \sum _ { i } s _ { a b i } W _ { i j } + \sum _ { a ^ { \prime } , i } s _ { a ^ { \prime } a i } C _ { i j } ) .
+$$
+
+This constitutes the minimal version of VSML with $V _ { M } : = ( W , C )$ and is visualized in Figure 1b.
+
+VSML as a Meta RNN with a sparse shared weight matrix It is trivial to see that with $A = 1$ and $B = 1$ we obtain a single RNN and Equation 4 recovers the original Meta RNN Equation 1. In the general case, we can derive an equivalent formulation that corresponds to a single standard RNN with a single matrix $\tilde { W }$ that has entries of zero and shared entries
+
+$$
+s _ { a b j } \gets \sigma ( \sum _ { c , d , i } s _ { c d i } \tilde { W } _ { c d i a b j } ) ,
+$$
+
+where the six axes can be flattened to obtain the two axes. For Equation 4 and Equation 5 to be equivalent, $\tilde { W }$ must satisfy (derivation in Appendix A)
+
+$$
+\tilde { W } _ { c d i a b j } = \left\{ \begin{array} { l l } { C _ { i j } , } & { \mathrm { i f ~ } d = a \wedge ( d \neq b \vee c \neq a ) . } \\ { W _ { i j } , } & { \mathrm { i f ~ } d \neq a \wedge d = b \wedge c = a . } \\ { C _ { i j } + W _ { i j } , } & { \mathrm { i f ~ } d = a \wedge d = b \wedge c = a . } \\ { 0 , } & { \mathrm { o t h e r w i s e . } } \end{array} \right.
+$$
+
+This corresponds to interpretation $\textcircled{8}$ with the weight matrix visualized in Figure 1a. To distinguish between the single sparse shared RNN and the connected RNNs, we now call the latter sub-RNNs.
+
+VSML as complex neurons with learned updates The arrangement and connectivity of the subRNNs as described in the previous paragraphs corresponds to that of weights in a standard NN. Thus, in interpretation $@$ , VSML can be viewed as defining complex neurons where each sub-RNN corresponds to a weight in a standard NN as visualized in Figure 1c. All these sub-RNNs share the same parameters but have distinct states. The current formulation corresponds to a single NN layer that is run recurrently. We will generalize this to other architectures in the next section. A corresponds to the dimensionality of the inputs and $B$ to that of the outputs in that layer.
+
+The role of weights in a standard neural network is now assigned to the states of RNNs. This allows these RNNs to define both the neural forward computation as well as the learning algorithm that determines how the network is updated (where the mechanism is shared across the network). In the case of backpropagation, this would correspond to the forward and backward passes being implemented purely in the recurrent dynamics. We will demonstrate the practical feasibility of this in Section 3.2. The emergence of
+
+![](images/0ccd0fdb8442f57b99da7d0266c5c9a62738c64d643b90443c68ed18becb66cf.jpg)  
+Figure 2: The neural interpretation of VSML replaces all weights of a standard NN with tiny LSTMs using shared parameters (resembling complex neurons). This allows these LSTMs to define both the neural forward computation as well as the learning algorithm that determines how the network is updated. Information flows forward and backward in the network through multi-dimensional messages $\overrightarrow { m }$ and $\scriptstyle { \overleftarrow { m } }$ , generalizing the dynamics of an NN trained using backpropagation.
+
+RNN states as weights quickly leads to confusing terminology when RNNs have ‘meta weights’.   
+Instead, we simply refer to meta variables $V _ { M }$ and learned variables $V _ { L }$ .
+
+With this interpretation, VSML can be seen as a generalization of learned learning rules [4, 13, 33] and Hebbian-like differentiable mechanisms or fast weights more generally [44, 46, 25, 26] where RNNs replace explicit weight updates. In standard NNs, weights and activations have multiplicative interactions. For VSML RNNs to mimic such computation we require multiplicative interactions between parts of the state $s$ . Fortunately, LSTMs already incorporate this through gating and can be directly used in place of RNNs.
+
+Stacking VSML RNNs and feeding inputs To get a structure similar to one of the non-recurrent deep feed-forward architectures (FNNs), we stack multiple VSML RNNs where their states are untied and their parameters are tied.1 This is visualized with two layers in Figure 2 where the states $s ^ { ( 2 ) }$ of the second column of sub-RNNs are distinct from the first column $\mathbf { \boldsymbol { s } } ^ { ( 1 ) }$ . The parameters $A ^ { ( k ) }$ and $B ^ { ( k ) }$ describing layer sizes can then be varied for each layer $k \in \{ 1 , \ldots , K \}$ constrained by $A ^ { ( k ) } ~ = ~ B ^ { ( k - 1 ) }$ . The updated Equation 3 with distinct layers $k$ is given by $s _ { a b } ^ { ( k ) }  f _ { \mathrm { R N N } } ( s _ { a b } ^ { ( k ) } , \overrightarrow { m } _ { a } ^ { ( k ) } )$ where $\begin{array} { r } { \vec { m } _ { b } ^ { ( k + 1 ) } : = \sum _ { a ^ { \prime } } \bar { f } _ { \vec { m } } ( s _ { a ^ { \prime } b } ^ { ( k ) } ) } \end{array}$ with $b \in \{ 1 , \ldots , B ^ { ( k ) } = A ^ { ( k + 1 ) } \}$
+
+To prevent information from flowing only forward in the network, we use an additional backward message
+
+$$
+s _ { a b } ^ { ( k ) } \gets f _ { R N N } \big ( s _ { a b } ^ { ( k ) } , \overrightarrow { m } _ { a } ^ { ( k ) } , \overleftarrow { m } _ { b } ^ { ( k ) } \big ) ,
+$$
+
+where $\begin{array} { r } { \overleftarrow { m } _ { a } ^ { ( k - 1 ) } : = \sum _ { b ^ { \prime } } f _ { \overleftarrow { m } } ( s _ { a b ^ { \prime } } ^ { ( k ) } ) } \end{array}$ with $a \in$ $\{ 1 , . . . , A ^ { ( k ) } = B ^ { ( k - 1 ) } \}$ (visualized in Figure 3). The backward transformation is given by f←−m : RN → RN 00 .
+
+Similarly, other neural architectures can be explicitly constructed (e.g. convolutional NNs, Section B.2). Some architectures may be learned implicitly if positional information is fed into each sub-RNN (Appendix C). We then update all states $s ^ { ( k ) }$ in sequence $1 , \ldots , K$ to mimic sequential layer execution. We may also apply multiple RNN ticks for each layer $k$ .
+
+![](images/a5613155d304964c2e8b7d7e753eadbc7c640e13696034612df8983dd1ae3ff5.jpg)  
+Figure 3: VSML with forward messages $\overrightarrow { m }$ and backward messages $\scriptstyle { \overleftarrow { m } }$ to form a two-layer NN with shared LSTM parameters but distinct states.
+
+To provide the VSML RNN with data, each time we execute the operations of the first layer, a single new datum $x \in \mathbb { R } ^ { A ( 1 ) }$ (e.g. one flattened image) is distributed across all sub-RNNs. In our present experiments, we match the axis $A ( 1 )$ to the input datum dimensionality such that each dimension (e.g., pixel) is fed to different RNNs. This corresponds to initializing the forward message $\vec { m } _ { a 1 } ^ { ( 1 ) } : = \boldsymbol { x } _ { a }$ dding . Fina $\overrightarrow { m }$ with zeros if nece we feed the error larly, we read the outpuat the output such that $\boldsymbol { \hat { y } } \in \mathbb { R } ^ { B ( K ) }$ from. See $\hat { y } _ { a } : = \overrightarrow { m } _ { a 1 } ^ { ( K + 1 ) }$ $e \in \mathbb { R } ^ { B ( K ) }$ $ _ { b 1 }  : = e _ { b }$ Figure 2 for a visualization. Alternatively, multiple input or output dimensions could be patched together and fed into fewer sub-RNNs.
+
+# 3.1 Meta learning general-purpose learning algorithms from scratch
+
+Having formalized VSML, we can now use end-to-end meta learning to create LAs from scratch in Algorithm 1. We simply optimize the LSTM parameters $V _ { M }$ to minimize the sum of prediction losses over many time steps starting with random states $V _ { L } : = \{ s _ { a b } ^ { ( k ) } \}$ . We focus on meta learning online LAs where one example is fed at a time as done in Meta RNNs [16, 56, 10]. Meta training may be performed using end-to-end gradient descent or gradient-free optimization such as evolutionary strategies [57, 38]. The latter is significantly more efficient on VSML compared to standard NNs due to the small parameter space $V _ { M }$ . Crucially, during meta testing, no explicit gradient descent is used.
+
+# Algorithm 1 VSML: Meta Training
+
+Require: Dataset(s) $D = \{ ( x _ { i } , y _ { i } ) \}$ $V _ { M } \gets$ initialize LSTM parameters while meta loss has not converged do . Outer loop in parallel over datasets $D$ ${ \cal V } _ { L } = \{ s _ { a b } ^ { ( k ) } \} $ initialize LSTM states $\forall a , b , k$ for $( x , y ) ^ { \top } \in \{ ( x _ { 1 } , y _ { 1 } ) , \dotsc , ( x _ { T } , y _ { T } ) \} \subset D$ do $\triangleright$ Inner loop over $T$ examples $ { \vec { m } } _ { a 1 } ^ { ( 1 ) } : = x _ { a }$ ∀a $\triangleright$ Initialize from input image $\mathbf { X }$ for $\bar { k } \in \{ 1 , \ldots , K \}$ do $\triangleright$ Iterating over $K$ layers $s _ { a b } ^ { ( k ) } \gets f _ { R N N } \big ( s _ { a b } ^ { ( k ) } , \overrightarrow { m } _ { a } ^ { ( k ) } , \overleftarrow { m } _ { b } ^ { ( k ) } \big ) \quad \forall a , b$ . Equation 7 ←−m m (k+1)b := Pa0 f−→m (s(k)a0b) (k−1)a := Pb0 f←−m (s(k)ab0 ) ∀a ∀b . Create backward message . Create forward message yˆa := −→m(K+1)a1 ∀a $\triangleright$ Read output e := ∇yˆL(ˆy, y) . Compute error at outputs using loss $L$ ←−m(K)b1 := eb ∀b $\triangleright$ Input errors $\begin{array} { r } { V _ { M } \gets V _ { M } - \alpha \nabla _ { V _ { M } } \sum _ { t = 1 } ^ { T } L ( \hat { y } ( t ) , y ( t ) ) } \end{array}$ , obtaining $\nabla _ { V _ { M } }$ either by • back-propagation through the inner loop • evolution strategies, using a search distribution $p ( V _ { M } )$
+
+# 3.2 Learning to implement backpropagation in RNNs
+
+![](images/c33778dd74e4643cf3ee884dd15c7cd4f5d7da2efc2ed6fb055153758c4435ca.jpg)  
+Figure 4: To implement backpropagation we optimize the VSML RNN to use and update weights $w$ and biases $b$ as part of the state $s _ { a b }$ in each subRNN. Inputs are pre-synaptic $x$ and error $e$ . Outputs are post-synaptic $\hat { y }$ and error $\cdot$ .
+
+An alternative to end-to-end meta learning is to first investigate whether the VSML RNN can implement backpropagation. Due to the algorithm’s ubiquitous use, it seems desirable to be able to meta learn backpropagation-like algorithms. Here we investigate how VSML RNNs can learn to implement backpropagation purely in their recurrent dynamics. We do this by optimizing $V _ { M }$ to (1) store a weight $w$ and bias $b$ as a subset of each state $s _ { a b }$ , (2) compute $y = \operatorname { t a n h } ( x ) w + b$ to implement neural forward computation, and (3) update $w$ and $b$ according to the backpropagation algorithm [23]. We call this process learning algorithm cloning and it is visualized in Figure 4.
+
+We designate an element of each message $\vec { m } _ { a } ^ { ( k ) }$ , $\{ \overline { { m } } _ { b } ^ { ( k ) }$ , $f _ { \vec { m } } ( s _ { a b } ^ { ( k ) } )$ $f _ { \overleftarrow { m } } ( s _ { a b } ^ { ( k ) } )$ as the input $x$ , error $e$ , and output $\hat { y }$ and error $\hat { e } ^ { \prime }$ . Similarly, we set $w : = s _ { a b 1 }$ and $b : = s _ { a b 2 }$ . We then optimize $V _ { M }$ via gradient descent to regress $\hat { y }$ , $\Delta w$ , $\Delta b$ , and $\hat { e } ^ { \prime }$ toward their respective targets. We can either generate the training dataset $D : = \{ ( x , \bar { w } , b , y , e , \bar { e ^ { \prime } } ) _ { i } \}$ randomly or run a ‘shadow’ NN on some supervised problem and fit the VSML RNN to its activations and parameter updates. Multiple iterations in the VSML RNN would then correspond to evaluating the network and updating it via backpropagation. The activations from the forward pass necessary for credit assignment could be memorized as part of the state $s$ or be explicitly stored and fed back. For simplicity, we chose the latter to clone backpropagation. We continuously run the VSML RNN forward, alternately running the layers in order $1 , \ldots , K$ and in reverse order $K , \ldots , 1$ .2
+
+# 4 Experiments
+
+First, we demonstrate the capabilities of the VSML RNN by showing that it can implement neural forward computation and backpropagation in its recurrent dynamics on the MNIST [21] and Fashion MNIST [59] dataset. Then, we show how we can meta learn an LA from scratch on one set of datasets and then successfully apply it to another (out of distribution). Such generalization is enabled by extensive variable sharing where we have very few meta variables $| V _ { M } | ~ \approx ~ 2 , 4 0 0$ and many learned variables $| V _ { L } | \approx 2 5 7 , 2 0 0$ . We also investigate the robustness of the discovered LA. Finally, we introspect the meta learned LA and compare it to gradient descent.
+
+![](images/dbb2f1c0cc8cade0dc1f709d779c51876fa020bd13a4a622b6679683d6100ede.jpg)  
+Figure 5: The VSML RNN is optimized to implement backpropagation in its recurrent dynamics on MNIST, then tested both on MNIST and Fashion MNIST where it performs learning purely by unrolling the LSTM. We test on shallow and deep architectures (single hidden layer of 32 units). Standard deviations are over 6 seeds.
+
+Our implementation uses LSTMs and the message interpretation from Equation 7. Hyperparameters, training details, and additional experiments can be found in the appendix.
+
+# 4.1 VSML RNNs can implement backpropagation
+
+As described in Section 3.2, we optimize the VSML RNN to implement backpropagation. We structure the sub-RNNs to mimic a feed-forward NN with either one hidden layer or no hidden layers. To obtain training targets, we instantiate a standard NN, the shadow network, and feed it MNIST data. After cloning, we then run the LA encoded in the VSML RNN on the MNIST and Fashion MNIST dataset and observe that it performs learning purely in its recurrent dynamics, making explicit gradient calculations unnecessary. Figure 5 shows the learning curve on these two datasets. Notably, learning works both on MNIST (within distribution) and on Fashion MNIST (out of distribution). We observe that the loss is decently minimized, albeit regular gradient descent still outperforms our cloned backpropagation. This may be due to non-zero errors during learning algorithm cloning, in particular when these errors accumulate in the deeper architecture. It is also possible that the VSML states (‘weights’) deviate too far from ranges seen during cloning, in particular in the deep case when the loss starts increasing. We obtain $87 \%$ (deep) and $90 \%$ (shallow) test accuracy on MNIST and $76 \%$ (deep) and $80 \%$ (shallow) on Fashion MNIST (focusing on successful cloning over performance).
+
+# 4.2 Meta learning supervised learning from scratch
+
+In the previous experiments, we have established that VSML is expressive enough to metaoptimize backpropagation-like algorithms. Instead of cloning an LA, we now meta learn from scratch as described in Section 3.1. Here, we use a single layer ( $K = 1$ ) from input to output dimension and run it for two ticks per image with $N = 1 6$ and $N ^ { \prime } = N ^ { \prime \prime } = 8$ . First, the VSML RNN is meta trained end-to-end using evolutionary strategies (ES) [38] on MNIST to minimize the sum of cross-entropies over 500 data points starting from random state initializations. As each image is unique and $V _ { M }$ can not memorize the data, we are implicitly optimizing the VSML RNN to generalize to future inputs given all inputs it has seen so far. We do not pre-train $V _ { M }$ with a human-engineered LA.
+
+![](images/7b033cbe1d2c5cc6f6e774fb5334f6d5b86759ee6986d192914ef27be40db278.jpg)  
+Figure 6: The VSML RNN can be directly meta trained on MNIST to minimize the sum of errors when classifying online starting from a random state initialization. This allows for faster learning during meta testing compared to online gradient descent with Adam on the same dataset and even generalizes to a different dataset (Fashion MNIST). In comparison, a standard Meta RNN [16] strongly overfits in the same setting. Standard deviations are over 128 seeds.
+
+During meta testing on MNIST (Figure 6) we plot the cumulativputs on the y axis $\textstyle { \bigl ( } { \frac { 1 } { T } } \sum _ { t = 1 } ^ { T } c _ { t }$ n all previous after example $T$
+
+indicating prediction correctness). For each example, the prediction when this example was fed to the RNN is used, thus measuring sample efficient learning. This evaluation protocol is similar to the one used in Meta RNNs [56, 10]. We observe that learning is considerably faster compared to the baseline of online gradient descent (no mini batching, the learning rate appropriately tuned). One possibility is that VSML simply overfits to the training distribution. We reject this possibility by meta testing the same unmodified RNN on a different dataset, here Fashion MNIST. Learning still works well, meaning we have meta learned a fairly general LA (although performance at convergence still lacks behind a little). This generalization is achieved without using any hardcoded gradients during meta testing purely by running the RNN forward. In comparison to VSML, a Meta RNN heavily overfits.
+
+# 4.3 Robustness to varying inputs and outputs
+
+A defining property of VSML is that the same parameters $V _ { M }$ can be used to learn on varying input and output sizes. Further, the architecture and thus the meta learned LA is invariant to the order of inputs and outputs. In this experiment, we investigate how robust we are to such changes. We meta train across MNIST with 3, 4, 6, and 7 classes. Likewise, we train across rescaled versions with 14x14, $2 8 \mathbf { x } 2 8$ , and $3 2 \mathrm { x } 3 2$ pixels. We also randomly project all inputs using a linear transformation, with the transforma
+
+![](images/c628948506067fe04ffbb9c085630d6448553be811bf1db3b99f5a94303b235f.jpg)  
+Figure 7: The meta learned learning algorithm is robust to permutations and size changes in the inputs and outputs. All six configurations have not been seen during training and perform comparable to the unchanged reference. Standard deviations are over 32 seeds.
+
+tion fixed for all inner learning steps. In Figure 7 we meta test on 6 configurations that were not seen during meta training. Performance on all of these configurations is comparable to the unchanged reference from the previous section. In particular, the invariance to random projections suggests that we have meta learned a learning algorithm beyond transferring learned representations [compare 11, 54, 55].
+
+![](images/319cf9db2760a541d350ef7249d327ed4957d5292c4dc26af98cc095f61ec93b.jpg)  
+Figure 8: Online learning on various datasets. Cumulative accuracy in $\%$ after having seen $2 \mathrm { k }$ training examples evaluated after each prediction starting with random states (VSML, Meta RNN, HebbianFW, FWMemory) or random parameters (SGD). Standard deviations are over 32 meta test training runs. Meta testing is done on the official test set of each dataset. Meta training is on subsets of datasets excluding the Sum Sign dataset. Unseen tasks, most relevant from a general-purpose LA perspective, are opaque.
+
+# 4.4 Varying datasets
+
+To better understand how different meta training distributions and meta test datasets affect VSML RNNs and our baselines, we present several different combinations in Figure 8. The opaque bars represent tasks that were not seen during meta training and are thus most relevant for this analysis. This includes four additional datasets: (1) Kuzushiji MNIST [7] with 10 classes, (2) EMNIST [9] with 62 classes, (3) A randomly generated classification dataset (Random) with 20 data points that changes with each step in the outer loop, and (4) Sum Sign which generates random inputs and requires classifying the sign of the sum of all inputs. Meta training is done over 500 randomly drawn samples per outer iteration. Each algorithm is meta trained for $1 0 \mathrm { k }$ outer iterations. Inputs are randomly projected as in Section 4.3 (for VSML; the baselines did not benefit from these augmentations). We again report the cumulative accuracy on all data seen since the beginning of meta test training. We compare to SGD with a single layer, matching the architecture of VSML, and a hidden layer, matching the number of weights to the size of $V _ { L }$ in VSML. We also have included a Hebbian fast weight baseline [25] and an external (fast weight) memory approach [42].
+
+We observe that VSML generalizes much better than Meta RNNs, Hebbian fast weights, and the external memory. These baselines overfit to the training environments. Notably, VSML even generalizes to the unseen tasks Random and Sum Sign which have no shared structure with the other datasets. In many cases VSML’s performance is similar to SGD but a little more sample efficient in the beginning of training (learning curves in Appendix B). This suggests that our meta learned LAs are good at quickly associating new inputs with their labels. We further investigate this in the next Section 5.
+
+# 5 Analysis
+
+Given that VSML seems to learn faster than online gradient descent in many cases we would like to qualitatively investigate how learning differs. We first meta train on the full MNIST dataset as before. During meta testing, we plot the output probabilities for each digit against the number of samples seen in Figure 9. We highlight the ground truth input class $\boxed { \begin{array} { r l } \end{array} }$ as well as the predicted class $\bigcirc$ . In this case, our meta test dataset consists of MNIST digits with two examples of each type. The same digit is always repeated twice. This allows us to observe and visualize the effect with only a few examples. We have done the same introspection with the full dataset in Appendix B.
+
+We observe that in VSML almost all failed predictions are followed by the correct prediction with high certainty. In contrast, SGD
+
+![](images/eaac26941486bc755c21019531e0870ec146a660bf3bfc809cb2fca51d5e7b20.jpg)  
+Figure 9: Introspection of how output probabilities change after observing an input and the prediction error when meta testing on MNIST with two examples for each type. We highlight the ground truth class $\boxed { \begin{array} { r l } \end{array} }$ as well as the predicted class $\bigcirc$ . The top plot shows VSML quickly associating the input images with the right label, almost always making the right prediction the second time with high confidence. The bottom plot shows the same dataset processed by SGD with Adam which fails to learn quickly.
+
+makes many incorrect predictions and fails to adapt correctly in only 20 steps. It seems that SGD learns qualitatively different from VSML. The VSML RNN meta learns to quickly associate new inputs with their class whereas SGD fails to do so. We tried several different SGD learning rates and considered multiple steps on the same input. In both cases, SGD does not behave similar to VSML, either learning much slower or forgetting previous examples. As evident from high accuracies in Figure 8, VSML does not only memorize inputs using this strategy of fast association, but the associations generalize to future unseen inputs.
+
+# 6 Related Work
+
+Memory based meta learning (Meta RNNs) Memory-based meta learning in RNNs [16, 10, 56] is a simple neural meta learner (see Section 2). Unfortunately, the LA encoded in the RNN parameters is largely overparameterized which leads to overfitting. VSML demonstrates that weight sharing can address this issue resulting in more general-purpose LAs.
+
+Learned Learning Rules / Fast Weights NNs that generate or change the weights of another or the same NN are known as fast weight programmers [44], hypernetworks [14], NNs with synaptic plasticity [25] or learned learning rules [4] (see Section 2). In VSML we do not require explicit architectures for weight updates as weights are emergent from RNN state updates. In addition to the learning rule, we implicitly learn how the neural forward computation is defined. Concurrent to this work, fast weights have also been used to meta learn more general LAs [39].
+
+Learned gradient-based optimizers Meta learning has been used to find optimizers that update the parameters of a model by taking the loss and gradient with respect to these parameters as an input [34, 2, 22, 24]. In this work, we are interested in meta learning that does not rely on fixed gradient calculation in the inner loop.
+
+Discrete program search An interesting alternative to distributed variable updates in VSML is meta learning via discrete program search [48, 35]. In this paradigm, a separate programming language needs to be defined that gives rise to neural computation when its instructions are combined. This led to the automated rediscovery of backpropagation [35]. In VSML we demonstrate that a symbolic programming language is not required and general-purpose LAs can be discovered and encoded in variable-shared RNNs. Search over neural network parameters is usually easier compared to symbolic program search due to smoothness in the loss landscape.
+
+Multi-agent systems In the reinforcement learning setting multiple agents can be modeled with shared parameters [50, 32, 18], also in the context of meta learning [36]. This is related to the variable sharing in VSML depending on how the agent-environment boundary is drawn. Unlike these works, we demonstrate the advantage of variable sharing in meta learning more general-purpose LAs and present a weight update interpretation.
+
+# 7 Discussion and Limitations
+
+The research community has perfected the art of leveraging backpropagation for learning for a long time. At the same time, there are open questions such as how to minimize memory requirements, effectively learn online and continually, learn sample efficiently, learn without separate backward phases, and others. VSML suggests that instead of building on top of backpropagation as a fixed routine, meta learning offers an alternative to discover general-purpose LAs. Nevertheless, this paper is only a proof of concept—until now we have only investigated small-scale problems and performance does not yet quite match the mini-batched setting with large quantities of data. In particular, we observed premature convergence of the solution at meta test time which calls for further investigations. Scaling our system to harder problems and larger meta task distributions will be important future work.
+
+The computational cost of the current VSML variant is also larger than the one of standard backpropagation. If we run a sub-RNN for each weight in a standard NN with $W$ weights, the cost is in $O ( W N ^ { 2 } )$ , where $N$ is the state size of a sub-RNN. If $N$ is small enough, and our experiments suggest small $N$ may be feasible, this may be an acceptable cost. However, VSML is not bound to the interpretation of a sub-RNN as one weight. Future work may relax this particular choice.
+
+Meta optimization is also prone to local minima. In particular, when the number of ticks between input and feedback increases (e.g. deeper architectures), credit assignment becomes harder. Early experiments suggest that diverse meta task distributions can help mitigate these issues. Additionally, learning horizons are limited when using backprop-based meta optimization. Using ES allowed for training across longer horizons and more stable optimization.
+
+VSML can also be viewed as regularizing the NN weights that encode the LA through a representational bottleneck. It is conceivable that LA generalization as obtained by VSML can also be achieved through other regularization techniques. Unlike most regularizers, VSML also introduces substantial reuse of the same learning principle and permutation invariance through variable sharing.
+
+# 8 Conclusion
+
+We introduced Variable Shared Meta Learning (VSML), a simple principle of weight sharing and sparsity for meta learning powerful learning algorithms (LAs). Our implementation replaces the weights of a neural network with tiny LSTMs that share parameters. We discuss connections to meta recurrent neural networks, fast weight generators (hyper networks), and learned learning rules.
+
+Using learning algorithm cloning, VSML RNNs can learn to implement the backpropagation algorithm and its parameter updates encoded implicitly in the recurrent dynamics. On MNIST it learns to predict well without any human-designed explicit computational graph for gradient calculation.
+
+VSML can meta learn from scratch supervised LAs that do not explicitly rely on gradient computation and that generalize to unseen datasets. Introspection reveals that VSML LAs learn by fast association in a way that is qualitatively different from stochastic gradient descent. This leads to gains in sample efficiency. Future work will focus on reinforcement learning settings, improvements of meta learning, larger task distributions, and learning over longer horizons.
+
+# Acknowledgements
+
+We thank Sjoerd van Steenkiste, Imanol Schlag, Kazuki Irie, and the anonymous reviewers for their comments and feedback. This work was supported by the ERC Advanced Grant (no: 742870) and computational resources by the Swiss National Supercomputing Centre (CSCS, projects $s 9 7 8$ and s1041). We also thank NVIDIA Corporation for donating several DGX machines as part of the Pioneers of AI Research Award, IBM for donating a Minsky machine, and weights & biases [5] for their great experiment tracking software and support.
+
+# References
+
+[1] F. Alet, M. F. Schneider, T. Lozano-Perez, and L. P. Kaelbling. Meta-learning curiosity algorithms. In International Conference on Learning Representations, 2020.   
+[2] M. Andrychowicz, M. Denil, S. G. Colmenarejo, M. W. Hoffman, D. Pfau, T. Schaul, B. Shillingford, and N. De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pages 3988–3996, 6 2016.   
+[3] J. Ba, G. Hinton, V. Mnih, J. Z. Leibo, and C. Ionescu. Using Fast Weights to Attend to the Recent Past. In Advances in Neural Information Processing Systems, pages 4331–4339, 2016.   
+[4] S. Bengio, Y. Bengio, J. Cloutier, and J. Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, pages 6–8, 1992.   
+[5] L. Biewald. Experiment Tracking with Weights and Biases, 2020. URL https://www.wandb. com/.   
+[6] K. Cho, B. van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation. Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, 6 2014.   
+[7] T. Clanuwat, M. Bober-Irizar, A. Kitamoto, A. Lamb, K. Yamamoto, and D. Ha. Deep Learning for Classical Japanese Literature, 2018.   
+[8] E. F. Codd. Cellular automata. Academic press, 2014.   
+[9] G. Cohen, S. Afshar, J. Tapson, and A. V. Schaik. EMNIST: Extending MNIST to handwritten letters. 2017 International Joint Conference on Neural Networks (IJCNN), 2017. doi: 10.1109/ ijcnn.2017.7966217.   
+[10] Y. Duan, J. Schulman, X. Chen, P. L. Bartlett, I. Sutskever, and P. Abbeel. RLˆ2: Fast Reinforcement Learning via Slow Reinforcement Learning. arXiv preprint arXiv:1611.02779, 2016.   
+[11] C. Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1126–1135, 2017.   
+[12] F. A. Gers, J. Schmidhuber, and F. Cummins. Learning to Forget: Continual Prediction with LSTM. Neural Computation, 12(10):2451–2471, 2000.   
+[13] K. Gregor. Finding online neural update rules by learning to remember. arXiv preprint arXiv:2003.03124, 3 2020.   
+[14] D. Ha, A. Dai, and Q. V. Le. HyperNetworks. In International Conference on Learning Representations, 2016.   
+[15] S. Hochreiter and J. Schmidhuber. Long Short-Term Memory. Neural Computation, 9(8): 1735–1780, 1997.   
+[16] S. Hochreiter, A. S. Younger, and P. R. Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, 2001.   
+[17] R. Houthooft, R. Y. Chen, P. Isola, B. C. Stadie, F. Wolski, J. Ho, and P. Abbeel. Evolved Policy Gradients. In Advances in Neural Information Processing Systems, pages 5400–5409, 2018.   
+[18] W. Huang, I. Mordatch, and D. Pathak. One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control. In International Conference on Machine Learning, 2020.   
+[19] L. Kirsch, J. Kunze, and D. Barber. Modular Networks: Learning to Decompose Neural Computation. Advances in Neural Information Processing Systems, 2018.   
+[20] L. Kirsch, S. van Steenkiste, and J. Schmidhuber. Improving Generalization in Meta Reinforcement Learning using Learned Objectives. In International Conference on Learning Representations, 2020.   
+[21] Y. LeCun, C. Cortes, and C. J. Burges. MNIST handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   
+[22] K. Li and J. Malik. Learning to Optimize. arXiv preprint arXiv:1606.01885, 2016.   
+[23] S. Linnainmaa. The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors. PhD thesis, Univ. Helsinki, 1970.   
+[24] L. Metz, N. Maheswaranathan, C. D. Freeman, B. Poole, and J. Sohl-Dickstein. Tasks, stability, architecture, and compute: Training more effective learned optimizers, and using them to train themselves. arXiv preprint arXiv:2009.11243, 9 2020.   
+[25] T. Miconi, J. Clune, and K. O. Stanley. Differentiable plasticity: training plastic neural networks with backpropagation. In International Conference on Machine Learning, 2018.   
+[26] T. Miconi, A. Rawal, J. Clune, and K. O. Stanley. Backpropamine: training self-modifying neural networks with differentiable neuromodulated plasticity. In International Conference on Learning Representations, 2019.   
+[27] N. Mishra, M. Rohaninejad, and X. U. Chen Pieter Abbeel Berkeley. A Simple Neural Attentive Meta-Learner. In International Conference on Learning Representations, 2018.   
+[28] A. Mordvintsev, E. Randazzo, E. Niklasson, and M. Levin. Growing neural cellular automata. Distill, 5(2):e23, 2020.   
+[29] M. C. Mozer and S. Das. A connectionist symbol manipulator that discovers the structure of context-free languages. In Advances in neural information processing systems, pages 863–870, 1993.   
+[30] E. Najarro and S. Risi. Meta-Learning through Hebbian Plasticity in Random Networks. Advances in Neural Information Processing Systems, 2020.   
+[31] J. Oh, M. Hessel, W. M. Czarnecki, Z. Xu, H. van Hasselt, S. Singh, and D. Silver. Discovering Reinforcement Learning Algorithms. arXiv preprint arXiv:2007.08794, 2020.   
+[32] D. Pathak, C. Lu, T. Darrell, P. Isola, and A. A. Efros. Learning to Control Self-Assembling Morphologies: A Study of Generalization via Modularity. In Advances in Neural Information Processing Systems, 2019.   
+[33] E. Randazzo, E. Niklasson, and A. Mordvintsev. MPLP: Learning a Message Passing Learning Protocol. arXiv preprint arXiv:2007.00970, 2020.   
+[34] S. Ravi and H. Larochelle. Optimization as a model for few-shot learning. In International Conference on Learning Representations, 2016.   
+[35] E. Real, C. Liang, D. R. So, and Q. V. Le. AutoML-Zero: Evolving Machine Learning Algorithms From Scratch. In International Conference on Machine Learning, pages 8007–8019, 2020.   
+[36] M. Rosa, O. Afanasjeva, S. Andersson, J. Davidson, N. Guttenberg, P. Hlubucek, M. Poliak, ˇ J. Vítku, and J. Feyereisl. BADGER: Learning to (Learn [Learning Algorithms] through Multi-Agent Communication). arXiv preprint arXiv:1912.01513, 2019.   
+[37] C. Rosenbaum, T. Klinger, and M. Riemer. Routing Networks: Adaptive Selection of NonLinear Functions for Multi-Task Learning. In International Conference on Learning Representations, 2018.   
+[38] T. Salimans, J. Ho, X. Chen, S. Sidor, and I. Sutskever. Evolution Strategies as a Scalable Alternative to Reinforcement Learning. arXiv preprint arXiv:1703.03864, 3 2017. ISSN ISSN 0302-9743. doi: 10.1.1.51.6328.   
+[39] M. Sandler, M. Vladymyrov, A. Zhmoginov, N. Miller, A. Jackson, T. Madams, and others. Meta-Learning Bidirectional Update Rules. arXiv preprint arXiv:2104.04657, 2021.   
+[40] A. Santoro, S. Bartunov, M. Botvinick, D. Wierstra, and T. Lillicrap. Meta-Learning with Memory-Augmented Neural Networks. In International conference on machine learning, pages 1842–1850, 2016.   
+[41] I. Schlag and J. Schmidhuber. Gated Fast Weights for On-The-Fly Neural Program Generation. In NIPS Metalearning Workshop, 2017.   
+[42] I. Schlag, T. Munkhdalai, and J. Schmidhuber. Learning Associative Inference Using Fast Weight Memory. In International Conference on Learning Representations, 2021.   
+[43] J. Schmidhuber. Evolutionary principles in self-referential learning. Diploma thesis, Institut für Informatik, Technische Universität München, 1987.   
+[44] J. Schmidhuber. Learning to Control Fast-Weight Memories: An Alternative to Recurrent Nets. Technical Report FKI-147-91, Institut für Informatik, Technische Universität München, 3 1991.   
+[45] J. Schmidhuber. Learning to Control Fast-Weight Memories: An Alternative to Dynamic Recurrent Networks. Neural Computation, 4(1):131–139, 1992. ISSN 0899-7667. doi: 10.1162/neco.1992.4.1.131.   
+[46] J. Schmidhuber. Reducing the ratio between learning complexity and number of time varying variables in fully recurrent nets. In International Conference on Artificial Neural Networks, pages 460–463. Springer, 1993.   
+[47] J. Schmidhuber. A self-referential weight matrix. In Proceedings of the International Conference on Artificial Neural Networks, Amsterdam, pages 446–451. Springer, 1993.   
+[48] J. Schmidhuber. Discovering Problem Solutions with Low Kolmogorov Complexity and High Generalization Capability. Technical Report FKI-194-94, Fakultät für Informatik, Technische Universität München, 1994.   
+[49] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean. Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer. arXiv preprint arXiv:1701.06538, 2017.   
+[50] Sims, Karl. Evolving Virtual Creatures. ACM SIGGRAPH, 1994.   
+[51] A. Sperduti. Encoding labeled graphs by labeling raam. Advances in Neural Information Processing Systems, pages 1125–1125, 1994.   
+[52] S. Sudhakaran, D. Grbic, S. Li, A. Katona, E. Najarro, C. Glanois, and S. Risi. Growing 3d artefacts and functional machines with neural cellular automata. arXiv preprint arXiv:2103.08737, 2021.   
+[53] G. Z. Sun. Neural networks with external memeory stack that learn context-free grammars from examples. In Proceedings of the Conference on Information Science and Systems, 1991, pages 649–653. Princeton University, 1991.   
+[54] E. Triantafillou, T. Zhu, V. Dumoulin, P. Lamblin, U. Evci, K. Xu, R. Goroshin, C. Gelada, K. Swersky, P.-A. Manzagol, and H. Larochelle. Meta-Dataset: A Dataset of Datasets for Learning to Learn from Few Examples. 3 2019.   
+[55] H.-Y. Tseng, H.-Y. Lee, J.-B. Huang, and M.-H. Yang. Cross-domain few-shot classification via learned feature-wise transformation. arXiv preprint arXiv:2001.08735, 2020.   
+[56] J. X. Wang, Z. Kurth-Nelson, D. Tirumala, H. Soyer, J. Z. Leibo, R. Munos, C. Blundell, D. Kumaran, and M. Botvinick. Learning to reinforcement learn. arXiv preprint arXiv:1611.05763, 2016.   
+[57] D. Wierstra, T. Schaul, J. Peters, and J. Schmidhuber. Natural Evolution Strategies. In 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), pages 3381–3387, 2008.   
+[58] Z. Wu, S. Pan, F. Chen, G. Long, C. Zhang, and S. Y. Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020.   
+[59] H. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. CoRR, abs/1708.0, 2017.

parse/train/hhU9TEvB6AF/hhU9TEvB6AF_content_list.json

@@ -0,0 +1,1193 @@
+[
+    {
+        "type": "text",
+        "text": "Meta Learning Backpropagation And Improving It ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            122,
+            808,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Louis Kirsch1, Jürgen Schmidhuber1,2   \n1The Swiss AI Lab IDSIA, University of Lugano (USI) & SUPSI, Lugano, Switzerland   \n2King Abdullah University of Science and Technology (KAUST), Thuwal, Saudi Arabia {louis, juergen}@idsia.ch ",
+        "bbox": [
+            210,
+            199,
+            789,
+            258
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            310
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many concepts have been proposed for meta learning with neural networks (NNs), e.g., NNs that learn to reprogram fast weights, Hebbian plasticity, learned learning rules, and meta recurrent NNs. Our Variable Shared Meta Learning (VSML) unifies the above and demonstrates that simple weight-sharing and sparsity in an NN is sufficient to express powerful learning algorithms (LAs) in a reusable fashion. A simple implementation of VSML where the weights of a neural network are replaced by tiny LSTMs allows for implementing the backpropagation LA solely by running in forward-mode. It can even meta learn new LAs that differ from online backpropagation and generalize to datasets outside of the meta training distribution without explicit gradient calculation. Introspection reveals that our meta learned LAs learn through fast association in a way that is qualitatively different from gradient descent. ",
+        "bbox": [
+            233,
+            325,
+            766,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            310,
+            535
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The shift from standard machine learning to meta learning involves learning the learning algorithm (LA) itself, reducing the burden on the human designer to craft useful learning algorithms [43]. Recent meta learning has primarily focused on generalization from training tasks to similar test tasks, e.g., few-shot learning [11], or from training environments to similar test environments [17]. This contrasts human-engineered LAs that generalize across a wide range of datasets or environments. Without such generalization, meta learned LAs can not entirely replace human-engineered variants. Recent work demonstrated that meta learning can also successfully generate more general LAs that generalize across wide spectra of environments [20, 1, 31], e.g., from toy environments to Mujoco and Atari. Unfortunately, however, many recent approaches still rely on a large number of human-designed and unmodifiable inner-loop components such as backpropagation. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            688
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Is it possible to implement modifiable versions of backpropagation or related algorithms as part of the end-to-end differentiable activation dynamics of a neural net (NN), instead of inserting them as separate fixed routines? Here we propose the Variable Shared Meta Learning (VSML) principle for this purpose. It introduces a novel way of using sparsity and weight-sharing in NNs for meta learning. We build on the arguably simplest neural meta learner, the meta recurrent neural network (Meta RNN) [16, 10, 56], by replacing the weights of a neural network with tiny LSTMs. The resulting system can be viewed as many RNNs passing messages to each other, or as one big RNN with a sparse shared weight matrix, or as a system learning each neuron’s functionality and its LA. VSML generalizes the principle behind end-to-end differentiable fast weight programmers [45, 46, 3, 41], hyper networks [14], learned learning rules [4, 13, 33], and hebbian-like synaptic plasticity [44, 46, 25, 26, 30]. Our mechanism, VSML, can implement backpropagation solely in the forward-dynamics of an RNN. Consequently, it enables meta-optimization of backproplike algorithms. We envision a future where novel methods of credit assignment can be meta learned while still generalizing across vastly different tasks. This may lead to improvements in sample efficiency, memory efficiency, continual learning, and others. As a first step, our system meta learns online LAs from scratch that frequently learn faster than gradient descent and generalize to datasets outside of the meta training distribution (e.g., from MNIST to Fashion MNIST). Our VSML RNN is the first neural meta learner without hard-coded backpropagation that shows such strong generalization. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            308,
+            183
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning-based meta learning that does not rely on fixed gradient descent in the inner loop has historically fallen into two categories, 1) Learnable weight update mechanisms that allow for changing the parameters of an NN to implement a learning rule (FWPs / LLRs), and 2) Learning algorithms implemented in black-box models such as recurrent neural networks (Meta RNNs). ",
+        "bbox": [
+            174,
+            196,
+            825,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fast weight programmers & Learned learning rules (FWPs / LLRs) In a standard NN, the weights are updated by a fixed LA. This framework can be extended to meta learning by defining an explicit architecture that allows for modifying these weights. This weight-update architecture augments a standard NN architecture. NNs that generate or change the weights of another or the same NN are known as fast weight programmers (FWPs) [44, 45, 46, 3, 41], hypernetworks [14], NNs with synaptic plasticity [25, 26, 30] or learned learning rules [4, 13, 33]. Often these architectures make use of local Hebbian-like update rules or outer-products, and we summarize this category as FWPs / LLRs. In FWPs / LLRs the variables $V _ { L }$ that are subject to learning are the weights of the network, whereas the meta-variables $V _ { M }$ that implement the LA are defined by the weight-update architecture. Note that the dimensionality of $V _ { L }$ and $V _ { M }$ can be defined independently of each other and often $V _ { M }$ are reused in a coordinate-wise fashion for $V _ { L }$ resulting in $| V _ { L } | \\gg | V _ { M } |$ , where $| \\cdot |$ is the number of elements. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Black-box learning in activations (Meta RNNs) It was shown that an RNN such as LSTM can learn to implement an LA [16] when the reward or error is given as an input [47]. After meta training, the LA is encoded in the weights of this RNN and determines learning during meta testing. The activations serve as the memory used for the LA solution. We refer to this as Meta RNNs [16, 10, 56] (Also sometimes referred to as memory-based meta learning.). They are conceptually simpler than FWPs / LLRs as no additional weight-update rules with many degrees of freedom need to be defined. In Meta RNNs $V _ { L }$ are the RNN activations and $V _ { M }$ are the parameters for the RNN. Note that an RNN with $N$ neurons will yield $| V _ { L } | = O ( N )$ and $| V _ { M } | = \\stackrel { \\cdot } { O } ( N ^ { 2 } )$ [46]. This means that the LA is largely overparameterized whereas the available memory for learning is very small, making this approach prone to overfitting [20]. As a result, the RNN parameters often encode task-specific solutions instead of generic LAs. Meta learning a simple and generalizing LA would benefit from $| V _ { L } | \\gg | V _ { M } |$ . Previous approaches have tried to mend this issue by adding architectural complexity through additional memory mechanisms [53, 29, 40, 27, 42]. ",
+        "bbox": [
+            173,
+            446,
+            826,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Variable Shared Meta Learning (VSML) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            643,
+            545,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In VSML we build on the simplicity of Meta RNNs while retaining $| V _ { L } | \\gg | V _ { M } |$ from FWPs / LLRs. We do this by reusing the same few parameters $V _ { M }$ many times in an RNN (via variable sharing) and introducing sparsity in the connectivity. This yields several interpretations for VSML: ",
+        "bbox": [
+            174,
+            675,
+            826,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$\\textcircled{8}$ VSML as a single Meta RNN with a sparse shared weight matrix (Figure 1a). The most general description.   \n$\\textcircled{8}$ VSML as message passing between RNNs (Figure 1b). We choose a simple sharing and sparsity scheme for the weight matrix such that it corresponds to multiple RNNs with shared parameters that exchange information.   \n$©$ VSML as complex neurons with learned updates (Figure 1c). When choosing a specific connectivity between RNNs, states / activations $V _ { L }$ of these RNNs can be interpreted as the weights of a conventional NN, consequently blurring the distinction between a weight and an activation. ",
+        "bbox": [
+            205,
+            728,
+            825,
+            866
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Introducing variable sharing to Meta RNNs We begin by formalizing Meta RNNs which often use multiplicative gates such as the LSTM [12, 15] or its variant GRU [6]. For notational simplicity, we consider a vanilla RNN. Let $s \\in \\mathbb { R } ^ { N }$ be the hidden state of an RNN. The update for an element $j \\in \\{ 1 , \\ldots , N \\}$ is given by ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1ae57af27d23bff08bcfc6f114db04ece9a7f8b38923249b2e9e1b42ad6a50f.jpg",
+        "image_caption": [
+            "Figure 1: Different perspectives on VSML: (a) A single Meta RNN [16] where entries in the weight matrix are shared or zero. (a) VSML consists of many sub-RNNs with shared parameters $V _ { M }$ passing messages between each other. (c) VSML implements an NN with complex neurons (here 2 neurons). $V _ { M }$ determines the nature of weights, how these are used in the neural computation, and the LA by which those are updated. Each weight $w _ { a b } \\in \\mathbb { R }$ is represented by the multi-dimensional RNN state ${ s _ { a b } } \\in \\mathbb { R } ^ { N }$ . Neuron activations correspond to messages $\\overrightarrow { m }$ passed between sub-RNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            87,
+            818,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            339,
+            823,
+            369
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aec312823b19fbd3996491d88091d87c5725063323dbba06de0ca3464831a762.jpg",
+        "text": "$$\ns _ { j } \\gets f _ { \\mathrm { R N N } } ( s ) _ { j } = \\sigma ( \\sum _ { i } s _ { i } W _ { i j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            367,
+            606,
+            401
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is a non-linear activation function, $W \\in \\mathbb { R } ^ { N \\times N }$ , and the bias is omitted for simplicity. We also omit inputs by assuming a subset of $s$ to be externally provided. Each application of Equation 1 reflects a single time tick in the RNN. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now introduce variable sharing (reusing $W$ ) into the RNN by duplicating the computation along two axes of size $A , B$ (here $A = B$ , which will later be relaxed) giving $\\bar { s } \\in \\mathbb { R } ^ { A \\times B \\times N }$ . For $a \\in \\{ 1 , \\dotsc , A \\} , b \\in \\{ 1 , \\dotsc , B \\}$ we have ",
+        "bbox": [
+            173,
+            452,
+            825,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd446ad5b95522b305babefe9b762f10f82ec8bf83cb2ee5e6827d94874df36a.jpg",
+        "text": "$$\ns _ { a b j } \\gets f _ { \\mathrm { R N N } } ( s _ { a b } ) _ { j } = \\sigma ( \\sum _ { i } s _ { a b i } W _ { i j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            502,
+            629,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This can be viewed as multiple RNNs arranged on a 2-dimensional grid, with shared parameters that update independent states. Here, we chose a particular arrangement (two axes) that will facilitate the interpretation $©$ of RNNs as weights. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "VSML as message passing between RNNs The computation so far describes $A \\cdot B$ independent RNNs. We connect those by passing messages (interpretation $\\textcircled{8}$ ) ",
+        "bbox": [
+            173,
+            597,
+            823,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbe020d5af66f40b67afaa6858cc17392b6229b77c392d47d8f437e8f795275d.jpg",
+        "text": "$$\ns _ { a b } \\gets f _ { \\mathrm { R N N } } ( s _ { a b } , \\overrightarrow { m } _ { a } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            631,
+            575,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the message $\\begin{array} { r } { \\vec { m } _ { b } = \\sum _ { a ^ { \\prime } } f _ { \\vec { m } } ( s _ { a ^ { \\prime } b } ) } \\end{array}$ with $b \\in \\{ 1 , \\dots , A = B \\}$ , $f _ { \\overrightarrow { m } } : \\mathbb { R } ^ { N }  \\mathbb { R } ^ { N ^ { \\prime } }$ is fed as an additional input to each RNN. This is related to Graph Neural Networks [51, 58]. Summing over the axis $A$ (elements $a ^ { \\prime }$ ) corresponds to an RNN connectivity mimicking those of weights in an NN (to facilitate interpretation $©$ . We emphasise that other schemes based on different kinds of message passing and graph connectivity are possible. For a simple $f _ { \\overrightarrow { m } }$ defined by the matrix $C \\in \\mathbb { R } ^ { N \\times N }$ , we may equivalently write ",
+        "bbox": [
+            173,
+            655,
+            826,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4fa3ae13d4eb053bd2e1b570e336ff4662b2e762e505e889dc05c1a0c6ebc4a.jpg",
+        "text": "$$\ns _ { a b j } \\gets \\sigma ( \\sum _ { i } s _ { a b i } W _ { i j } + \\sum _ { a ^ { \\prime } } f _ { \\overrightarrow { m } } ( s _ { a ^ { \\prime } a } ) ) = \\sigma ( \\sum _ { i } s _ { a b i } W _ { i j } + \\sum _ { a ^ { \\prime } , i } s _ { a ^ { \\prime } a i } C _ { i j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            748,
+            745,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This constitutes the minimal version of VSML with $V _ { M } : = ( W , C )$ and is visualized in Figure 1b. ",
+        "bbox": [
+            174,
+            787,
+            813,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "VSML as a Meta RNN with a sparse shared weight matrix It is trivial to see that with $A = 1$ and $B = 1$ we obtain a single RNN and Equation 4 recovers the original Meta RNN Equation 1. In the general case, we can derive an equivalent formulation that corresponds to a single standard RNN with a single matrix $\\tilde { W }$ that has entries of zero and shared entries ",
+        "bbox": [
+            173,
+            816,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eeb3ae8d9676dd584d8b30e1f2e7cd87e1831ed2eae316f1470b3cdab7e9006f.jpg",
+        "text": "$$\ns _ { a b j } \\gets \\sigma ( \\sum _ { c , d , i } s _ { c d i } \\tilde { W } _ { c d i a b j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            881,
+            593,
+            915
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the six axes can be flattened to obtain the two axes. For Equation 4 and Equation 5 to be equivalent, $\\tilde { W }$ must satisfy (derivation in Appendix A) ",
+        "bbox": [
+            169,
+            90,
+            823,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aba9ee62d2cb9e4441538f13c5f01b18fd44f40ab8e22078076d3cef95f3da60.jpg",
+        "text": "$$\n\\tilde { W } _ { c d i a b j } = \\left\\{ \\begin{array} { l l } { C _ { i j } , } & { \\mathrm { i f ~ } d = a \\wedge ( d \\neq b \\vee c \\neq a ) . } \\\\ { W _ { i j } , } & { \\mathrm { i f ~ } d \\neq a \\wedge d = b \\wedge c = a . } \\\\ { C _ { i j } + W _ { i j } , } & { \\mathrm { i f ~ } d = a \\wedge d = b \\wedge c = a . } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            131,
+            678,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This corresponds to interpretation $\\textcircled{8}$ with the weight matrix visualized in Figure 1a. To distinguish between the single sparse shared RNN and the connected RNNs, we now call the latter sub-RNNs. ",
+        "bbox": [
+            173,
+            210,
+            825,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "VSML as complex neurons with learned updates The arrangement and connectivity of the subRNNs as described in the previous paragraphs corresponds to that of weights in a standard NN. Thus, in interpretation $@$ , VSML can be viewed as defining complex neurons where each sub-RNN corresponds to a weight in a standard NN as visualized in Figure 1c. All these sub-RNNs share the same parameters but have distinct states. The current formulation corresponds to a single NN layer that is run recurrently. We will generalize this to other architectures in the next section. A corresponds to the dimensionality of the inputs and $B$ to that of the outputs in that layer. ",
+        "bbox": [
+            173,
+            256,
+            826,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The role of weights in a standard neural network is now assigned to the states of RNNs. This allows these RNNs to define both the neural forward computation as well as the learning algorithm that determines how the network is updated (where the mechanism is shared across the network). In the case of backpropagation, this would correspond to the forward and backward passes being implemented purely in the recurrent dynamics. We will demonstrate the practical feasibility of this in Section 3.2. The emergence of ",
+        "bbox": [
+            174,
+            361,
+            356,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ccd0fdb8442f57b99da7d0266c5c9a62738c64d643b90443c68ed18becb66cf.jpg",
+        "image_caption": [
+            "Figure 2: The neural interpretation of VSML replaces all weights of a standard NN with tiny LSTMs using shared parameters (resembling complex neurons). This allows these LSTMs to define both the neural forward computation as well as the learning algorithm that determines how the network is updated. Information flows forward and backward in the network through multi-dimensional messages $\\overrightarrow { m }$ and $\\scriptstyle { \\overleftarrow { m } }$ , generalizing the dynamics of an NN trained using backpropagation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            366,
+            823,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RNN states as weights quickly leads to confusing terminology when RNNs have ‘meta weights’.   \nInstead, we simply refer to meta variables $V _ { M }$ and learned variables $V _ { L }$ . ",
+        "bbox": [
+            173,
+            637,
+            821,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this interpretation, VSML can be seen as a generalization of learned learning rules [4, 13, 33] and Hebbian-like differentiable mechanisms or fast weights more generally [44, 46, 25, 26] where RNNs replace explicit weight updates. In standard NNs, weights and activations have multiplicative interactions. For VSML RNNs to mimic such computation we require multiplicative interactions between parts of the state $s$ . Fortunately, LSTMs already incorporate this through gating and can be directly used in place of RNNs. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            755
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stacking VSML RNNs and feeding inputs To get a structure similar to one of the non-recurrent deep feed-forward architectures (FNNs), we stack multiple VSML RNNs where their states are untied and their parameters are tied.1 This is visualized with two layers in Figure 2 where the states $s ^ { ( 2 ) }$ of the second column of sub-RNNs are distinct from the first column $\\mathbf { \\boldsymbol { s } } ^ { ( 1 ) }$ . The parameters $A ^ { ( k ) }$ and $B ^ { ( k ) }$ describing layer sizes can then be varied for each layer $k \\in \\{ 1 , \\ldots , K \\}$ constrained by $A ^ { ( k ) } ~ = ~ B ^ { ( k - 1 ) }$ . The updated Equation 3 with distinct layers $k$ is given by $s _ { a b } ^ { ( k ) }  f _ { \\mathrm { R N N } } ( s _ { a b } ^ { ( k ) } , \\overrightarrow { m } _ { a } ^ { ( k ) } )$ where $\\begin{array} { r } { \\vec { m } _ { b } ^ { ( k + 1 ) } : = \\sum _ { a ^ { \\prime } } \\bar { f } _ { \\vec { m } } ( s _ { a ^ { \\prime } b } ^ { ( k ) } ) } \\end{array}$ with $b \\in \\{ 1 , \\ldots , B ^ { ( k ) } = A ^ { ( k + 1 ) } \\}$ ",
+        "bbox": [
+            173,
+            771,
+            826,
+            880
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To prevent information from flowing only forward in the network, we use an additional backward message ",
+        "bbox": [
+            173,
+            92,
+            486,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92c1ed6925a96948824b0b65811fe3cd0faa25865ff4b0c03f5daa7040659ab8.jpg",
+        "text": "$$\ns _ { a b } ^ { ( k ) } \\gets f _ { R N N } \\big ( s _ { a b } ^ { ( k ) } , \\overrightarrow { m } _ { a } ^ { ( k ) } , \\overleftarrow { m } _ { b } ^ { ( k ) } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            140,
+            439,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\overleftarrow { m } _ { a } ^ { ( k - 1 ) } : = \\sum _ { b ^ { \\prime } } f _ { \\overleftarrow { m } } ( s _ { a b ^ { \\prime } } ^ { ( k ) } ) } \\end{array}$ with $a \\in$ $\\{ 1 , . . . , A ^ { ( k ) } = B ^ { ( k - 1 ) } \\}$ (visualized in Figure 3). The backward transformation is given by f←−m : RN → RN 00 . ",
+        "bbox": [
+            173,
+            167,
+            485,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similarly, other neural architectures can be explicitly constructed (e.g. convolutional NNs, Section B.2). Some architectures may be learned implicitly if positional information is fed into each sub-RNN (Appendix C). We then update all states $s ^ { ( k ) }$ in sequence $1 , \\ldots , K$ to mimic sequential layer execution. We may also apply multiple RNN ticks for each layer $k$ . ",
+        "bbox": [
+            174,
+            239,
+            485,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5613155d304964c2e8b7d7e753eadbc7c640e13696034612df8983dd1ae3ff5.jpg",
+        "image_caption": [
+            "Figure 3: VSML with forward messages $\\overrightarrow { m }$ and backward messages $\\scriptstyle { \\overleftarrow { m } }$ to form a two-layer NN with shared LSTM parameters but distinct states. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            92,
+            821,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            324,
+            766,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To provide the VSML RNN with data, each time we execute the operations of the first layer, a single new datum $x \\in \\mathbb { R } ^ { A ( 1 ) }$ (e.g. one flattened image) is distributed across all sub-RNNs. In our present experiments, we match the axis $A ( 1 )$ to the input datum dimensionality such that each dimension (e.g., pixel) is fed to different RNNs. This corresponds to initializing the forward message $\\vec { m } _ { a 1 } ^ { ( 1 ) } : = \\boldsymbol { x } _ { a }$ dding . Fina $\\overrightarrow { m }$ with zeros if nece we feed the error larly, we read the outpuat the output such that $\\boldsymbol { \\hat { y } } \\in \\mathbb { R } ^ { B ( K ) }$ from. See $\\hat { y } _ { a } : = \\overrightarrow { m } _ { a 1 } ^ { ( K + 1 ) }$ $e \\in \\mathbb { R } ^ { B ( K ) }$ $ _ { b 1 }  : = e _ { b }$ Figure 2 for a visualization. Alternatively, multiple input or output dimensions could be patched together and fed into fewer sub-RNNs. ",
+        "bbox": [
+            173,
+            344,
+            826,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Meta learning general-purpose learning algorithms from scratch ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            661,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having formalized VSML, we can now use end-to-end meta learning to create LAs from scratch in Algorithm 1. We simply optimize the LSTM parameters $V _ { M }$ to minimize the sum of prediction losses over many time steps starting with random states $V _ { L } : = \\{ s _ { a b } ^ { ( k ) } \\}$ . We focus on meta learning online LAs where one example is fed at a time as done in Meta RNNs [16, 56, 10]. Meta training may be performed using end-to-end gradient descent or gradient-free optimization such as evolutionary strategies [57, 38]. The latter is significantly more efficient on VSML compared to standard NNs due to the small parameter space $V _ { M }$ . Crucially, during meta testing, no explicit gradient descent is used. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 VSML: Meta Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            411,
+            640
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Require: Dataset(s) $D = \\{ ( x _ { i } , y _ { i } ) \\}$ $V _ { M } \\gets$ initialize LSTM parameters while meta loss has not converged do . Outer loop in parallel over datasets $D$ ${ \\cal V } _ { L } = \\{ s _ { a b } ^ { ( k ) } \\} $ initialize LSTM states $\\forall a , b , k$ for $( x , y ) ^ { \\top } \\in \\{ ( x _ { 1 } , y _ { 1 } ) , \\dotsc , ( x _ { T } , y _ { T } ) \\} \\subset D$ do $\\triangleright$ Inner loop over $T$ examples $ { \\vec { m } } _ { a 1 } ^ { ( 1 ) } : = x _ { a }$ ∀a $\\triangleright$ Initialize from input image $\\mathbf { X }$ for $\\bar { k } \\in \\{ 1 , \\ldots , K \\}$ do $\\triangleright$ Iterating over $K$ layers $s _ { a b } ^ { ( k ) } \\gets f _ { R N N } \\big ( s _ { a b } ^ { ( k ) } , \\overrightarrow { m } _ { a } ^ { ( k ) } , \\overleftarrow { m } _ { b } ^ { ( k ) } \\big ) \\quad \\forall a , b$ . Equation 7 ←−m m (k+1)b := Pa0 f−→m (s(k)a0b) (k−1)a := Pb0 f←−m (s(k)ab0 ) ∀a ∀b . Create backward message . Create forward message yˆa := −→m(K+1)a1 ∀a $\\triangleright$ Read output e := ∇yˆL(ˆy, y) . Compute error at outputs using loss $L$ ←−m(K)b1 := eb ∀b $\\triangleright$ Input errors $\\begin{array} { r } { V _ { M } \\gets V _ { M } - \\alpha \\nabla _ { V _ { M } } \\sum _ { t = 1 } ^ { T } L ( \\hat { y } ( t ) , y ( t ) ) } \\end{array}$ , obtaining $\\nabla _ { V _ { M } }$ either by • back-propagation through the inner loop • evolution strategies, using a search distribution $p ( V _ { M } )$ ",
+        "bbox": [
+            165,
+            640,
+            826,
+            902
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Learning to implement backpropagation in RNNs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            92,
+            555,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c33778dd74e4643cf3ee884dd15c7cd4f5d7da2efc2ed6fb055153758c4435ca.jpg",
+        "image_caption": [
+            "Figure 4: To implement backpropagation we optimize the VSML RNN to use and update weights $w$ and biases $b$ as part of the state $s _ { a b }$ in each subRNN. Inputs are pre-synaptic $x$ and error $e$ . Outputs are post-synaptic $\\hat { y }$ and error $\\cdot$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            121,
+            343,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An alternative to end-to-end meta learning is to first investigate whether the VSML RNN can implement backpropagation. Due to the algorithm’s ubiquitous use, it seems desirable to be able to meta learn backpropagation-like algorithms. Here we investigate how VSML RNNs can learn to implement backpropagation purely in their recurrent dynamics. We do this by optimizing $V _ { M }$ to (1) store a weight $w$ and bias $b$ as a subset of each state $s _ { a b }$ , (2) compute $y = \\operatorname { t a n h } ( x ) w + b$ to implement neural forward computation, and (3) update $w$ and $b$ according to the backpropagation algorithm [23]. We call this process learning algorithm cloning and it is visualized in Figure 4. ",
+        "bbox": [
+            383,
+            117,
+            825,
+            268
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We designate an element of each message $\\vec { m } _ { a } ^ { ( k ) }$ , $\\{ \\overline { { m } } _ { b } ^ { ( k ) }$ , $f _ { \\vec { m } } ( s _ { a b } ^ { ( k ) } )$ $f _ { \\overleftarrow { m } } ( s _ { a b } ^ { ( k ) } )$ as the input $x$ , error $e$ , and output $\\hat { y }$ and error $\\hat { e } ^ { \\prime }$ . Similarly, we set $w : = s _ { a b 1 }$ and $b : = s _ { a b 2 }$ . We then optimize $V _ { M }$ via gradient descent to regress $\\hat { y }$ , $\\Delta w$ , $\\Delta b$ , and $\\hat { e } ^ { \\prime }$ toward their respective targets. We can either generate the training dataset $D : = \\{ ( x , \\bar { w } , b , y , e , \\bar { e ^ { \\prime } } ) _ { i } \\}$ randomly or run a ‘shadow’ NN on some supervised problem and fit the VSML RNN to its activations and parameter updates. Multiple iterations in the VSML RNN would then correspond to evaluating the network and updating it via backpropagation. The activations from the forward pass necessary for credit assignment could be memorized as part of the state $s$ or be explicitly stored and fed back. For simplicity, we chose the latter to clone backpropagation. We continuously run the VSML RNN forward, alternately running the layers in order $1 , \\ldots , K$ and in reverse order $K , \\ldots , 1$ .2 ",
+        "bbox": [
+            385,
+            275,
+            825,
+            380
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            381,
+            825,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            312,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, we demonstrate the capabilities of the VSML RNN by showing that it can implement neural forward computation and backpropagation in its recurrent dynamics on the MNIST [21] and Fashion MNIST [59] dataset. Then, we show how we can meta learn an LA from scratch on one set of datasets and then successfully apply it to another (out of distribution). Such generalization is enabled by extensive variable sharing where we have very few meta variables $| V _ { M } | ~ \\approx ~ 2 , 4 0 0$ and many learned variables $| V _ { L } | \\approx 2 5 7 , 2 0 0$ . We also investigate the robustness of the discovered LA. Finally, we introspect the meta learned LA and compare it to gradient descent. ",
+        "bbox": [
+            174,
+            502,
+            485,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbb2f1c0cc8cade0dc1f709d779c51876fa020bd13a4a622b6679683d6100ede.jpg",
+        "image_caption": [
+            "Figure 5: The VSML RNN is optimized to implement backpropagation in its recurrent dynamics on MNIST, then tested both on MNIST and Fashion MNIST where it performs learning purely by unrolling the LSTM. We test on shallow and deep architectures (single hidden layer of 32 units). Standard deviations are over 6 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            482,
+            823,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our implementation uses LSTMs and the message interpretation from Equation 7. Hyperparameters, training details, and additional experiments can be found in the appendix. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 VSML RNNs can implement backpropagation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            534,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As described in Section 3.2, we optimize the VSML RNN to implement backpropagation. We structure the sub-RNNs to mimic a feed-forward NN with either one hidden layer or no hidden layers. To obtain training targets, we instantiate a standard NN, the shadow network, and feed it MNIST data. After cloning, we then run the LA encoded in the VSML RNN on the MNIST and Fashion MNIST dataset and observe that it performs learning purely in its recurrent dynamics, making explicit gradient calculations unnecessary. Figure 5 shows the learning curve on these two datasets. Notably, learning works both on MNIST (within distribution) and on Fashion MNIST (out of distribution). We observe that the loss is decently minimized, albeit regular gradient descent still outperforms our cloned backpropagation. This may be due to non-zero errors during learning algorithm cloning, in particular when these errors accumulate in the deeper architecture. It is also possible that the VSML states (‘weights’) deviate too far from ranges seen during cloning, in particular in the deep case when the loss starts increasing. We obtain $87 \\%$ (deep) and $90 \\%$ (shallow) test accuracy on MNIST and $76 \\%$ (deep) and $80 \\%$ (shallow) on Fashion MNIST (focusing on successful cloning over performance). ",
+        "bbox": [
+            174,
+            787,
+            825,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            826,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Meta learning supervised learning from scratch ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            208,
+            544,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the previous experiments, we have established that VSML is expressive enough to metaoptimize backpropagation-like algorithms. Instead of cloning an LA, we now meta learn from scratch as described in Section 3.1. Here, we use a single layer ( $K = 1$ ) from input to output dimension and run it for two ticks per image with $N = 1 6$ and $N ^ { \\prime } = N ^ { \\prime \\prime } = 8$ . First, the VSML RNN is meta trained end-to-end using evolutionary strategies (ES) [38] on MNIST to minimize the sum of cross-entropies over 500 data points starting from random state initializations. As each image is unique and $V _ { M }$ can not memorize the data, we are implicitly optimizing the VSML RNN to generalize to future inputs given all inputs it has seen so far. We do not pre-train $V _ { M }$ with a human-engineered LA. ",
+        "bbox": [
+            174,
+            234,
+            485,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b033cbe1d2c5cc6f6e774fb5334f6d5b86759ee6986d192914ef27be40db278.jpg",
+        "image_caption": [
+            "Figure 6: The VSML RNN can be directly meta trained on MNIST to minimize the sum of errors when classifying online starting from a random state initialization. This allows for faster learning during meta testing compared to online gradient descent with Adam on the same dataset and even generalizes to a different dataset (Fashion MNIST). In comparison, a standard Meta RNN [16] strongly overfits in the same setting. Standard deviations are over 128 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            232,
+            821,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During meta testing on MNIST (Figure 6) we plot the cumulativputs on the y axis $\\textstyle { \\bigl ( } { \\frac { 1 } { T } } \\sum _ { t = 1 } ^ { T } c _ { t }$ n all previous after example $T$ ",
+        "bbox": [
+            174,
+            476,
+            483,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "indicating prediction correctness). For each example, the prediction when this example was fed to the RNN is used, thus measuring sample efficient learning. This evaluation protocol is similar to the one used in Meta RNNs [56, 10]. We observe that learning is considerably faster compared to the baseline of online gradient descent (no mini batching, the learning rate appropriately tuned). One possibility is that VSML simply overfits to the training distribution. We reject this possibility by meta testing the same unmodified RNN on a different dataset, here Fashion MNIST. Learning still works well, meaning we have meta learned a fairly general LA (although performance at convergence still lacks behind a little). This generalization is achieved without using any hardcoded gradients during meta testing purely by running the RNN forward. In comparison to VSML, a Meta RNN heavily overfits. ",
+        "bbox": [
+            173,
+            520,
+            826,
+            657
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Robustness to varying inputs and outputs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            678,
+            501,
+            691
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A defining property of VSML is that the same parameters $V _ { M }$ can be used to learn on varying input and output sizes. Further, the architecture and thus the meta learned LA is invariant to the order of inputs and outputs. In this experiment, we investigate how robust we are to such changes. We meta train across MNIST with 3, 4, 6, and 7 classes. Likewise, we train across rescaled versions with 14x14, $2 8 \\mathbf { x } 2 8$ , and $3 2 \\mathrm { x } 3 2$ pixels. We also randomly project all inputs using a linear transformation, with the transforma",
+        "bbox": [
+            173,
+            704,
+            419,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c628948506067fe04ffbb9c085630d6448553be811bf1db3b99f5a94303b235f.jpg",
+        "image_caption": [
+            "Figure 7: The meta learned learning algorithm is robust to permutations and size changes in the inputs and outputs. All six configurations have not been seen during training and perform comparable to the unchanged reference. Standard deviations are over 32 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            433,
+            693,
+            825,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "tion fixed for all inner learning steps. In Figure 7 we meta test on 6 configurations that were not seen during meta training. Performance on all of these configurations is comparable to the unchanged reference from the previous section. In particular, the invariance to random projections suggests that we have meta learned a learning algorithm beyond transferring learned representations [compare 11, 54, 55]. ",
+        "bbox": [
+            174,
+            897,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/319cf9db2760a541d350ef7249d327ed4957d5292c4dc26af98cc095f61ec93b.jpg",
+        "image_caption": [
+            "Figure 8: Online learning on various datasets. Cumulative accuracy in $\\%$ after having seen $2 \\mathrm { k }$ training examples evaluated after each prediction starting with random states (VSML, Meta RNN, HebbianFW, FWMemory) or random parameters (SGD). Standard deviations are over 32 meta test training runs. Meta testing is done on the official test set of each dataset. Meta training is on subsets of datasets excluding the Sum Sign dataset. Unseen tasks, most relevant from a general-purpose LA perspective, are opaque. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            826,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            526,
+            825,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Varying datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            328,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To better understand how different meta training distributions and meta test datasets affect VSML RNNs and our baselines, we present several different combinations in Figure 8. The opaque bars represent tasks that were not seen during meta training and are thus most relevant for this analysis. This includes four additional datasets: (1) Kuzushiji MNIST [7] with 10 classes, (2) EMNIST [9] with 62 classes, (3) A randomly generated classification dataset (Random) with 20 data points that changes with each step in the outer loop, and (4) Sum Sign which generates random inputs and requires classifying the sign of the sum of all inputs. Meta training is done over 500 randomly drawn samples per outer iteration. Each algorithm is meta trained for $1 0 \\mathrm { k }$ outer iterations. Inputs are randomly projected as in Section 4.3 (for VSML; the baselines did not benefit from these augmentations). We again report the cumulative accuracy on all data seen since the beginning of meta test training. We compare to SGD with a single layer, matching the architecture of VSML, and a hidden layer, matching the number of weights to the size of $V _ { L }$ in VSML. We also have included a Hebbian fast weight baseline [25] and an external (fast weight) memory approach [42]. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe that VSML generalizes much better than Meta RNNs, Hebbian fast weights, and the external memory. These baselines overfit to the training environments. Notably, VSML even generalizes to the unseen tasks Random and Sum Sign which have no shared structure with the other datasets. In many cases VSML’s performance is similar to SGD but a little more sample efficient in the beginning of training (learning curves in Appendix B). This suggests that our meta learned LAs are good at quickly associating new inputs with their labels. We further investigate this in the next Section 5. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            276,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given that VSML seems to learn faster than online gradient descent in many cases we would like to qualitatively investigate how learning differs. We first meta train on the full MNIST dataset as before. During meta testing, we plot the output probabilities for each digit against the number of samples seen in Figure 9. We highlight the ground truth input class $\\boxed { \\begin{array} { r l } \\end{array} }$ as well as the predicted class $\\bigcirc$ . In this case, our meta test dataset consists of MNIST digits with two examples of each type. The same digit is always repeated twice. This allows us to observe and visualize the effect with only a few examples. We have done the same introspection with the full dataset in Appendix B. ",
+        "bbox": [
+            174,
+            121,
+            356,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We observe that in VSML almost all failed predictions are followed by the correct prediction with high certainty. In contrast, SGD ",
+        "bbox": [
+            173,
+            486,
+            354,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/eaac26941486bc755c21019531e0870ec146a660bf3bfc809cb2fca51d5e7b20.jpg",
+        "image_caption": [
+            "Figure 9: Introspection of how output probabilities change after observing an input and the prediction error when meta testing on MNIST with two examples for each type. We highlight the ground truth class $\\boxed { \\begin{array} { r l } \\end{array} }$ as well as the predicted class $\\bigcirc$ . The top plot shows VSML quickly associating the input images with the right label, almost always making the right prediction the second time with high confidence. The bottom plot shows the same dataset processed by SGD with Adam which fails to learn quickly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            367,
+            116,
+            826,
+            431
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "makes many incorrect predictions and fails to adapt correctly in only 20 steps. It seems that SGD learns qualitatively different from VSML. The VSML RNN meta learns to quickly associate new inputs with their class whereas SGD fails to do so. We tried several different SGD learning rates and considered multiple steps on the same input. In both cases, SGD does not behave similar to VSML, either learning much slower or forgetting previous examples. As evident from high accuracies in Figure 8, VSML does not only memorize inputs using this strategy of fast association, but the associations generalize to future unseen inputs. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            671,
+            321,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Memory based meta learning (Meta RNNs) Memory-based meta learning in RNNs [16, 10, 56] is a simple neural meta learner (see Section 2). Unfortunately, the LA encoded in the RNN parameters is largely overparameterized which leads to overfitting. VSML demonstrates that weight sharing can address this issue resulting in more general-purpose LAs. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            760
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learned Learning Rules / Fast Weights NNs that generate or change the weights of another or the same NN are known as fast weight programmers [44], hypernetworks [14], NNs with synaptic plasticity [25] or learned learning rules [4] (see Section 2). In VSML we do not require explicit architectures for weight updates as weights are emergent from RNN state updates. In addition to the learning rule, we implicitly learn how the neural forward computation is defined. Concurrent to this work, fast weights have also been used to meta learn more general LAs [39]. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learned gradient-based optimizers Meta learning has been used to find optimizers that update the parameters of a model by taking the loss and gradient with respect to these parameters as an input [34, 2, 22, 24]. In this work, we are interested in meta learning that does not rely on fixed gradient calculation in the inner loop. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Discrete program search An interesting alternative to distributed variable updates in VSML is meta learning via discrete program search [48, 35]. In this paradigm, a separate programming language needs to be defined that gives rise to neural computation when its instructions are combined. This led to the automated rediscovery of backpropagation [35]. In VSML we demonstrate that a symbolic programming language is not required and general-purpose LAs can be discovered and encoded in variable-shared RNNs. Search over neural network parameters is usually easier compared to symbolic program search due to smoothness in the loss landscape. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Multi-agent systems In the reinforcement learning setting multiple agents can be modeled with shared parameters [50, 32, 18], also in the context of meta learning [36]. This is related to the variable sharing in VSML depending on how the agent-environment boundary is drawn. Unlike these works, we demonstrate the advantage of variable sharing in meta learning more general-purpose LAs and present a weight update interpretation. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            282,
+            431,
+            300
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The research community has perfected the art of leveraging backpropagation for learning for a long time. At the same time, there are open questions such as how to minimize memory requirements, effectively learn online and continually, learn sample efficiently, learn without separate backward phases, and others. VSML suggests that instead of building on top of backpropagation as a fixed routine, meta learning offers an alternative to discover general-purpose LAs. Nevertheless, this paper is only a proof of concept—until now we have only investigated small-scale problems and performance does not yet quite match the mini-batched setting with large quantities of data. In particular, we observed premature convergence of the solution at meta test time which calls for further investigations. Scaling our system to harder problems and larger meta task distributions will be important future work. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            453
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The computational cost of the current VSML variant is also larger than the one of standard backpropagation. If we run a sub-RNN for each weight in a standard NN with $W$ weights, the cost is in $O ( W N ^ { 2 } )$ , where $N$ is the state size of a sub-RNN. If $N$ is small enough, and our experiments suggest small $N$ may be feasible, this may be an acceptable cost. However, VSML is not bound to the interpretation of a sub-RNN as one weight. Future work may relax this particular choice. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Meta optimization is also prone to local minima. In particular, when the number of ticks between input and feedback increases (e.g. deeper architectures), credit assignment becomes harder. Early experiments suggest that diverse meta task distributions can help mitigate these issues. Additionally, learning horizons are limited when using backprop-based meta optimization. Using ES allowed for training across longer horizons and more stable optimization. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "VSML can also be viewed as regularizing the NN weights that encode the LA through a representational bottleneck. It is conceivable that LA generalization as obtained by VSML can also be achieved through other regularization techniques. Unlike most regularizers, VSML also introduces substantial reuse of the same learning principle and permutation invariance through variable sharing. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            299,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduced Variable Shared Meta Learning (VSML), a simple principle of weight sharing and sparsity for meta learning powerful learning algorithms (LAs). Our implementation replaces the weights of a neural network with tiny LSTMs that share parameters. We discuss connections to meta recurrent neural networks, fast weight generators (hyper networks), and learned learning rules. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Using learning algorithm cloning, VSML RNNs can learn to implement the backpropagation algorithm and its parameter updates encoded implicitly in the recurrent dynamics. On MNIST it learns to predict well without any human-designed explicit computational graph for gradient calculation. ",
+        "bbox": [
+            176,
+            779,
+            821,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "VSML can meta learn from scratch supervised LAs that do not explicitly rely on gradient computation and that generalize to unseen datasets. Introspection reveals that VSML LAs learn by fast association in a way that is qualitatively different from stochastic gradient descent. This leads to gains in sample efficiency. Future work will focus on reinforcement learning settings, improvements of meta learning, larger task distributions, and learning over longer horizons. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            338,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Sjoerd van Steenkiste, Imanol Schlag, Kazuki Irie, and the anonymous reviewers for their comments and feedback. This work was supported by the ERC Advanced Grant (no: 742870) and computational resources by the Swiss National Supercomputing Centre (CSCS, projects $s 9 7 8$ and s1041). We also thank NVIDIA Corporation for donating several DGX machines as part of the Pioneers of AI Research Award, IBM for donating a Minsky machine, and weights & biases [5] for their great experiment tracking software and support. ",
+        "bbox": [
+            173,
+            121,
+            825,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            224,
+            266,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] F. Alet, M. F. Schneider, T. Lozano-Perez, and L. P. Kaelbling. Meta-learning curiosity algorithms. In International Conference on Learning Representations, 2020.   \n[2] M. Andrychowicz, M. Denil, S. G. Colmenarejo, M. W. Hoffman, D. Pfau, T. Schaul, B. Shillingford, and N. De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pages 3988–3996, 6 2016.   \n[3] J. Ba, G. Hinton, V. Mnih, J. Z. Leibo, and C. Ionescu. Using Fast Weights to Attend to the Recent Past. In Advances in Neural Information Processing Systems, pages 4331–4339, 2016.   \n[4] S. Bengio, Y. Bengio, J. Cloutier, and J. Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, pages 6–8, 1992.   \n[5] L. Biewald. Experiment Tracking with Weights and Biases, 2020. URL https://www.wandb. com/.   \n[6] K. Cho, B. van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation. Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, 6 2014.   \n[7] T. Clanuwat, M. Bober-Irizar, A. Kitamoto, A. Lamb, K. Yamamoto, and D. Ha. Deep Learning for Classical Japanese Literature, 2018.   \n[8] E. F. Codd. Cellular automata. Academic press, 2014.   \n[9] G. Cohen, S. Afshar, J. Tapson, and A. V. Schaik. EMNIST: Extending MNIST to handwritten letters. 2017 International Joint Conference on Neural Networks (IJCNN), 2017. doi: 10.1109/ ijcnn.2017.7966217.   \n[10] Y. Duan, J. Schulman, X. Chen, P. L. Bartlett, I. Sutskever, and P. Abbeel. RLˆ2: Fast Reinforcement Learning via Slow Reinforcement Learning. arXiv preprint arXiv:1611.02779, 2016.   \n[11] C. Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1126–1135, 2017.   \n[12] F. A. Gers, J. Schmidhuber, and F. Cummins. Learning to Forget: Continual Prediction with LSTM. Neural Computation, 12(10):2451–2471, 2000.   \n[13] K. Gregor. Finding online neural update rules by learning to remember. arXiv preprint arXiv:2003.03124, 3 2020.   \n[14] D. Ha, A. Dai, and Q. V. Le. HyperNetworks. In International Conference on Learning Representations, 2016.   \n[15] S. Hochreiter and J. Schmidhuber. Long Short-Term Memory. Neural Computation, 9(8): 1735–1780, 1997.   \n[16] S. Hochreiter, A. S. Younger, and P. R. Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, 2001.   \n[17] R. Houthooft, R. Y. Chen, P. Isola, B. C. Stadie, F. Wolski, J. Ho, and P. Abbeel. Evolved Policy Gradients. In Advances in Neural Information Processing Systems, pages 5400–5409, 2018.   \n[18] W. Huang, I. Mordatch, and D. Pathak. One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control. In International Conference on Machine Learning, 2020.   \n[19] L. Kirsch, J. Kunze, and D. Barber. Modular Networks: Learning to Decompose Neural Computation. Advances in Neural Information Processing Systems, 2018.   \n[20] L. Kirsch, S. van Steenkiste, and J. Schmidhuber. Improving Generalization in Meta Reinforcement Learning using Learned Objectives. In International Conference on Learning Representations, 2020.   \n[21] Y. LeCun, C. Cortes, and C. J. Burges. MNIST handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   \n[22] K. Li and J. Malik. Learning to Optimize. arXiv preprint arXiv:1606.01885, 2016.   \n[23] S. Linnainmaa. The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors. PhD thesis, Univ. Helsinki, 1970.   \n[24] L. Metz, N. Maheswaranathan, C. D. Freeman, B. Poole, and J. Sohl-Dickstein. Tasks, stability, architecture, and compute: Training more effective learned optimizers, and using them to train themselves. arXiv preprint arXiv:2009.11243, 9 2020.   \n[25] T. Miconi, J. Clune, and K. O. Stanley. Differentiable plasticity: training plastic neural networks with backpropagation. In International Conference on Machine Learning, 2018.   \n[26] T. Miconi, A. Rawal, J. Clune, and K. O. Stanley. Backpropamine: training self-modifying neural networks with differentiable neuromodulated plasticity. In International Conference on Learning Representations, 2019.   \n[27] N. Mishra, M. Rohaninejad, and X. U. Chen Pieter Abbeel Berkeley. A Simple Neural Attentive Meta-Learner. In International Conference on Learning Representations, 2018.   \n[28] A. Mordvintsev, E. Randazzo, E. Niklasson, and M. Levin. Growing neural cellular automata. Distill, 5(2):e23, 2020.   \n[29] M. C. Mozer and S. Das. A connectionist symbol manipulator that discovers the structure of context-free languages. In Advances in neural information processing systems, pages 863–870, 1993.   \n[30] E. Najarro and S. Risi. Meta-Learning through Hebbian Plasticity in Random Networks. Advances in Neural Information Processing Systems, 2020.   \n[31] J. Oh, M. Hessel, W. M. Czarnecki, Z. Xu, H. van Hasselt, S. Singh, and D. Silver. Discovering Reinforcement Learning Algorithms. arXiv preprint arXiv:2007.08794, 2020.   \n[32] D. Pathak, C. Lu, T. Darrell, P. Isola, and A. A. Efros. Learning to Control Self-Assembling Morphologies: A Study of Generalization via Modularity. In Advances in Neural Information Processing Systems, 2019.   \n[33] E. Randazzo, E. Niklasson, and A. Mordvintsev. MPLP: Learning a Message Passing Learning Protocol. arXiv preprint arXiv:2007.00970, 2020.   \n[34] S. Ravi and H. Larochelle. Optimization as a model for few-shot learning. In International Conference on Learning Representations, 2016.   \n[35] E. Real, C. Liang, D. R. So, and Q. V. Le. AutoML-Zero: Evolving Machine Learning Algorithms From Scratch. In International Conference on Machine Learning, pages 8007–8019, 2020.   \n[36] M. Rosa, O. Afanasjeva, S. Andersson, J. Davidson, N. Guttenberg, P. Hlubucek, M. Poliak, ˇ J. Vítku, and J. Feyereisl. BADGER: Learning to (Learn [Learning Algorithms] through Multi-Agent Communication). arXiv preprint arXiv:1912.01513, 2019.   \n[37] C. Rosenbaum, T. Klinger, and M. Riemer. Routing Networks: Adaptive Selection of NonLinear Functions for Multi-Task Learning. In International Conference on Learning Representations, 2018.   \n[38] T. Salimans, J. Ho, X. Chen, S. Sidor, and I. Sutskever. Evolution Strategies as a Scalable Alternative to Reinforcement Learning. arXiv preprint arXiv:1703.03864, 3 2017. ISSN ISSN 0302-9743. doi: 10.1.1.51.6328.   \n[39] M. Sandler, M. Vladymyrov, A. Zhmoginov, N. Miller, A. Jackson, T. Madams, and others. Meta-Learning Bidirectional Update Rules. arXiv preprint arXiv:2104.04657, 2021.   \n[40] A. Santoro, S. Bartunov, M. Botvinick, D. Wierstra, and T. Lillicrap. Meta-Learning with Memory-Augmented Neural Networks. In International conference on machine learning, pages 1842–1850, 2016.   \n[41] I. Schlag and J. Schmidhuber. Gated Fast Weights for On-The-Fly Neural Program Generation. In NIPS Metalearning Workshop, 2017.   \n[42] I. Schlag, T. Munkhdalai, and J. Schmidhuber. Learning Associative Inference Using Fast Weight Memory. In International Conference on Learning Representations, 2021.   \n[43] J. Schmidhuber. Evolutionary principles in self-referential learning. Diploma thesis, Institut für Informatik, Technische Universität München, 1987.   \n[44] J. Schmidhuber. Learning to Control Fast-Weight Memories: An Alternative to Recurrent Nets. Technical Report FKI-147-91, Institut für Informatik, Technische Universität München, 3 1991.   \n[45] J. Schmidhuber. Learning to Control Fast-Weight Memories: An Alternative to Dynamic Recurrent Networks. Neural Computation, 4(1):131–139, 1992. ISSN 0899-7667. doi: 10.1162/neco.1992.4.1.131.   \n[46] J. Schmidhuber. Reducing the ratio between learning complexity and number of time varying variables in fully recurrent nets. In International Conference on Artificial Neural Networks, pages 460–463. Springer, 1993.   \n[47] J. Schmidhuber. A self-referential weight matrix. In Proceedings of the International Conference on Artificial Neural Networks, Amsterdam, pages 446–451. Springer, 1993.   \n[48] J. Schmidhuber. Discovering Problem Solutions with Low Kolmogorov Complexity and High Generalization Capability. Technical Report FKI-194-94, Fakultät für Informatik, Technische Universität München, 1994.   \n[49] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean. Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer. arXiv preprint arXiv:1701.06538, 2017.   \n[50] Sims, Karl. Evolving Virtual Creatures. ACM SIGGRAPH, 1994.   \n[51] A. Sperduti. Encoding labeled graphs by labeling raam. Advances in Neural Information Processing Systems, pages 1125–1125, 1994.   \n[52] S. Sudhakaran, D. Grbic, S. Li, A. Katona, E. Najarro, C. Glanois, and S. Risi. Growing 3d artefacts and functional machines with neural cellular automata. arXiv preprint arXiv:2103.08737, 2021.   \n[53] G. Z. Sun. Neural networks with external memeory stack that learn context-free grammars from examples. In Proceedings of the Conference on Information Science and Systems, 1991, pages 649–653. Princeton University, 1991.   \n[54] E. Triantafillou, T. Zhu, V. Dumoulin, P. Lamblin, U. Evci, K. Xu, R. Goroshin, C. Gelada, K. Swersky, P.-A. Manzagol, and H. Larochelle. Meta-Dataset: A Dataset of Datasets for Learning to Learn from Few Examples. 3 2019.   \n[55] H.-Y. Tseng, H.-Y. Lee, J.-B. Huang, and M.-H. Yang. Cross-domain few-shot classification via learned feature-wise transformation. arXiv preprint arXiv:2001.08735, 2020.   \n[56] J. X. Wang, Z. Kurth-Nelson, D. Tirumala, H. Soyer, J. Z. Leibo, R. Munos, C. Blundell, D. Kumaran, and M. Botvinick. Learning to reinforcement learn. arXiv preprint arXiv:1611.05763, 2016.   \n[57] D. Wierstra, T. Schaul, J. Peters, and J. Schmidhuber. Natural Evolution Strategies. In 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), pages 3381–3387, 2008.   \n[58] Z. Wu, S. Pan, F. Chen, G. Long, C. Zhang, and S. Y. Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020.   \n[59] H. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. CoRR, abs/1708.0, 2017. ",
+        "bbox": [
+            173,
+            248,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            82,
+            828,
+            868
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rk6H0ZbRb/rk6H0ZbRb.md

@@ -0,0 +1,334 @@
+# INTRIGUING PROPERTIES OF ADVERSARIAL EXAM-PLES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+It is becoming increasingly clear that many machine learning classifiers are vulnerable to adversarial examples. In attempting to explain the origin of adversarial examples, previous studies have typically focused on the fact that neural networks operate on high dimensional data, they overfit, or they are too linear. Here we show that distributions of logit differences have a universal functional form. This functional form is independent of architecture, dataset, and training protocol; nor does it change during training. This leads to adversarial error having a universal scaling, as a power-law, with respect to the size of the adversarial perturbation. We show that this universality holds for a broad range of datasets (MNIST, CIFAR10, ImageNet, and random data), models (including state-of-the-art deep networks, linear models, adversarially trained networks, and networks trained on randomly shuffled labels), and attacks (FGSM, step l.l., PGD). Motivated by these results, we study the effects of reducing prediction entropy on adversarial robustness. Finally, we study the effect of network architectures on adversarial sensitivity. To do this, we use neural architecture search with reinforcement learning to find adversarially robust architectures on CIFAR10. Our resulting architecture is more robust to white and black box attacks compared to previous attempts.
+
+# 1 INTRODUCTION
+
+An intriguing aspect of deep learning models in computer vision is that while they can classify images with high accuracy, they fail catastrophically when those same images are perturbed slightly in an adversarial fashion (Szegedy et al., 2013; Goodfellow et al., 2014). The prevalence of adversarial examples presents challenges to our understanding of how deep networks generalize and pose security risks in real world applications (Papernot et al., 2016a; Kurakin et al., 2016a). Several techniques have been proposed to defend against adversarial examples. Adversarial training (Goodfellow et al., 2014) augments the training data with adversarial examples. It has been shown that using stronger adversarial attacks in adversarial training can increase the robustness to stronger attacks, but at the cost of a decrease in clean accuracy (i.e. accuracy on samples that have not been adversarially perturbed) (Madry et al., 2017). Defensive distillation (Papernot et al., 2016b), feature squeezing (Xu et al., 2017), and Parseval training (Cisse et al., 2017) have also been shown to make models more robust against adversarial attacks.
+
+The goal of this work is to study the common properties of adversarial examples. We calculate the adversarial error, defined as the difference between clean accuracy and adversarial accuracy at a given size of adversarial perturbation (). Surprisingly, adversarial error has a similar dependence on small values of $\epsilon$ for all network models and datasets we studied, including linear, fully-connected, simple convolutional networks, Inception v3 (Szegedy et al., 2016), Inception-ResNet v2, Inception v4 (Szegedy et al., 2017), ResNet v1, ResNet v2 (He et al., 2016), NasNet-A (Zoph & Le, 2016; Zoph et al., 2017), adversarially trained Inception v3 (Kurakin et al., 2016b) and Inception-ResNet v2 (Tramer et al., 2017), and networks trained on randomly shuffled labels of MNIST. Adversarial \` error due to the Fast Gradient Sign Method (FGSM), its L2-norm variant, and Projected Gradient Descent (PGD) attack grows as a power-law like $A \epsilon ^ { B }$ with $B$ between 0.9 and 1.3. By contrast, we find that adversarial error caused by one-step least likely class method (step l.l.) also scales as a power-law where $B$ is between 1.8 and 2.5 for small $\epsilon$ . This observed universality points to a mysterious commonality between these models and datasets, despite the different number of channels, pixels, and classes present. Adversarial error caused by FGSM on the training set of randomly shuffled labels of MNIST (LeCun & Cortes) also has the power-law form where $B = 1 . 2$ , which implies that the universality is not a result of the specific content of these datasets nor the ability of the model to generalize.
+
+To discover the mechanism behind this universality we show how, at small $\epsilon$ , the success of an adversarial attack depends on the input-logit Jacobian of the model and on the logits of the network. We demonstrate that the susceptibility of a model to FGSM and PGD attacks is in large part dictated by the cumulative distribution of the difference between the most likely logit and the second most likely logit. We observe that this cumulative distribution has a universal form among all datasets and models studied, including randomly produced data. Together, we believe these results provide a compelling story regarding the susceptibility of machine learning models to adversarial examples at small $\epsilon$ .
+
+We show that training with single-step adversarial examples offers protection against large $\epsilon$ attacks (between 0.2 and 32), but does not help appreciably at defending against small $\epsilon$ attacks (below 0.2). At $\epsilon = 0 . 2$ , all ImageNet models we studied incur 10 to $2 5 \%$ adversarial error, and surprisingly, vanilla NASNet-A (best clean accuracy in our study) has a lower adversarial error than adversarially trained Inception-ResNet v2 or Inception v3 (Kurakin et al., 2016b) (Fig. 1(a)). In light of these results, we explore a different avenue to adversarial robustness through architecture selection. We perform neural architecture search (NAS) using reinforcement learning (Zoph & Le, 2016; Zoph et al., 2017). These techniques allow us to find several architectures that are especially robust to adversarial perturbations. In addition, by analyzing the adversarial robustness of the tens-of-thousands of architectures constructed by NAS, we gain insights into the relationship between size of a model, its clean accuracy, and its adversarial robustness. In summary, the key contributions of our work are:
+
+• We study the functional form of adversarial error and logit differences across several models and datasets, which turn out to be universal. We analytically derive the commonality in the power-law tails of the logit differences, and show how it leads to the commonality in the form of adversarial error.   
+• We observe that although the qualitative form of logit differences and adversarial error is universal, it can be quantitatively improved with entropy regularization and better network architectures.   
+• We study the dependence of adversarial robustness on the network architecture via NAS. We show that while adversarial accuracy is strongly correlated with clean accuracy, it is only weakly correlated with model size. Our work leads to architectures that are more robust to white-box and black-box attacks on CIFAR10 (Krizhevsky & Hinton, 2009) than previous studies.
+
+# 2 SURPRISING UNIVERSALITY OF ADVERSARIAL ERROR AT SMALL 
+
+FGSM computes adversarial examples as:
+
+$$
+\boldsymbol { x } ^ { \mathrm { a d v } } = \boldsymbol { x } + \epsilon \mathrm { s i g n } \left( \nabla _ { \boldsymbol { x } } L ( \boldsymbol { x } , \boldsymbol { y } ) \right) ,
+$$
+
+where $x$ is the clean image, $y$ is the correct label for that image, $x ^ { \mathrm { a d v } }$ is the adversarial image, $\epsilon$ is the size of the adversarial perturbation, and $L ( x , y )$ is the loss function. $\epsilon$ values are specified in range [0,255]. We only study white-box attacks in this section.
+
+We begin with a preliminary examination of the architectural dependence of adversarial robustness. To that end, in Fig. 1 (a) we plot the test set adversarial error due to an FGSM attack as a function of $\epsilon$ for several models on ImageNet (Russakovsky et al., 2015). We note that for $\epsilon < 0 . 2$ , the adversarial error follows a power law form with an exponent between 0.9 and 1.1 for all models studied. Even adversarially trained models Kurakin et al. (2016b), while adversarially much more robust for larger values of $\epsilon$ , follow a similar form and reach as large as $20 \%$ adversarial error at smaller $\epsilon$ .
+
+In light of the surprising commonality in adversarial error at small- $\epsilon$ , we investigate whether there is any way to get a different form for the adversarial error. To do this, we evaluate the adversarial error due to step l.l. attack, which is computed as:
+
+$$
+x ^ { \mathrm { a d v } } = x - \epsilon \mathrm { s i g n } \left( \nabla _ { x } L ( x , y _ { l . l . } ) \right) ,
+$$
+
+where $y _ { l . l . }$ is least likely class predicted by the network on clean image $x$ (Kurakin et al., 2016b). The adversarial error also follows a power law, however with a larger exponent. The exponents range from 1.8 to 2.2 for ImageNet models (Fig. 1(b)), and 1.8 to 2.5 for models trained on MNIST (Fig. 2(c)) and CIFAR10. Thus, we see that attack protocol can change the exponent of the observed power-law.
+
+![](images/96e44a0d4a3fd367b209184ba9b25c3986431a5b883e6cfe8c25726059b999c8.jpg)  
+Figure 1: Test set adversarial error as a function of $\epsilon$ for models trained on ImageNet due to FGSM and step l.l. attack in (a) and (b), respectively. adv. tr. denotes models that are adversarially trained (Kurakin et al., 2016b). In (b), we also show two of the power law fits with straight lines.
+
+To test the limits of the universality observed in Fig. 1, we perform a number of more extensive tests. First, we investigate the effect of architecture by stochastically sampling thousands of different neural networks and train them on MNIST. We then measure their adversarial error due to FGSM on the test set. The architectures we sample are either fully-connected networks with 1-4 hidden layers and 30-2000 hidden nodes in each layer, or simple convolutional networks with dropout rates between 0-0.5. The adversarial error of representative linear, fully-connected, and convolutional networks are shown in Fig. 2 (a). As above, these models all have the same form of adversarial error with a powerlaw dependence on $\epsilon$ with exponents between 0.9 and 1.2.
+
+See Fig. 9 in the Appendix for a plot with all of the generated networks. We perform the same analysis on a 32-layer ResNet trained on CIFAR10 (He et al., 2016), which achieves a $9 2 . 6 \%$ clean accuracy on the test set. The result is shown in Appendix Fig. 10, where the adversarial error follows a power law with an exponent of 0.99 up to an $\epsilon$ of 1.
+
+Next, we probe the relationship between generalization and adversarial robustness following a similar approach to Zhang et al. (2016). In particular, we train a fully connected network on MNIST with shuffled labels until it reaches perfect accuracy on the training set. The adversarial error on the training set is shown in Fig. 2(b). Once again we see that the adversarial error follows an almost identical power-law form at small $\epsilon$ with an exponent of 1.2.
+
+Finally, we further investigate the dependence of adversarial robustness on attack protocol. We plot in Fig. 2 (c) the adversarial error on MNIST with an $L _ { \infty }$ -normalized FGSM attack, an $L _ { 2 }$ - normalized FGSM attack, and a 20-step projected gradient descent (PGD) attack (Madry et al., 2017). We see that despite the anomalous exponent observed for step-l.l. attacks, the other attack methods display the same universality with exponents of 1.1, 1.2, and 1.3 for L2-norm, FGSM, and PGD attacks, respectively. step-l.l. attack on MNIST has an exponent of 2.3.
+
+# 3 A MEAN-FIELD THEORY OF ADVERSARIAL PERTURBATIONS
+
+# 3.1 LINEAR RESPONSE
+
+We now offer a theoretical explanation for the observed universal behavior of adversarial error. The breadth of these observations shows that adversarial error for small adversarial perturbations does not depend on the specifics of the neural network, which implies that we can understand the small $\epsilon$ regime by making simplifying approximations. We begin by considering the linear response of a neural network to adversarial perturbations. Another approach to adversarial examples that considers the linear response of the network can be found in Nayebi & Ganguli (2017). The effect of margins on adversarial robustness has been brought up in ?.
+
+![](images/71a2d3a2071be278b30c68ebe087ca022a4b5a62472b42ec80cadf2f1fe43425.jpg)  
+Figure 2: Points represent adversarial error as a function of $\epsilon$ for models trained on MNIST. Straight lines are power-law fits. (a) FGSM attack on fully-connected 3-layer network (FC), a linear model, and a convolutional network (b) FGSM attack on FC trained on randomly shuffled labels (evaluated on the training set). (c) Different attacks on FC.
+
+We will study an $L _ { 2 }$ -variant of the FGSM attack. Here, the adversarial perturbation is given by,
+
+$$
+x ^ { \mathrm { a d v } } = x + \epsilon \frac { \nabla _ { x } L } { | | \nabla _ { x } L | | _ { 2 } }
+$$
+
+instead of the more commonly used $\ell _ { \infty }$ variant. As shown above, the form and exponent of adversarial error is qualitatively insensitive to this choice (see Fig. 2(c)). We will now attempt to compute the minimum $\epsilon$ , that we call $\hat { \epsilon } ( x )$ , required before the class assigned to an input, $x$ , changes. Assuming the network was able to perfectly classify clean images, the adversarial error rate will then be $P ( \bar { \hat { \epsilon } } < \epsilon )$ . While perfect classification will not be achieved in practice, the insensitivity of the form of adversarial error to clean accuracy demonstrated above for many systems suggests that this approximation is sound.
+
+Notationally, we will refer to the output of the network as ${ \hat { y } } _ { i } ( x )$ and the corresponding logits as $h _ { i } ( x )$ . The class prediction of the network will then be arg $\operatorname* { m a x } ( \hat { y } ( x ) ) = \operatorname { a r g m a x } ( h ( x ) )$ . For simplicity we will choose an ordering of the logits such that $h _ { 1 } ( x ) \geq h _ { 2 } ( x ) \geq \cdot \cdot \cdot \geq h _ { N } ( x )$ . We can then enumerate a set of logit-differences, $\Delta _ { i j } ( x ) = h _ { i } ( x ) - \dot { h _ { j } } ( x )$ . If an adversarial perturbation is to successfully cause the network to make an erroneous prediction, then it must be true that $h _ { 1 } ( x ^ { \mathrm { a d v } } ) < h _ { j } ( \dot { x } ^ { \mathrm { a d v } } )$ for at least one $j$ .
+
+We calculate the response of the logits to adversarial perturbation. We consider the linearized response of the network and find that in the limit of small $\epsilon$ (see Appendix 6.2.1),
+
+$$
+h ( x ^ { \mathrm { a d v } } ) = h ( x ) + \epsilon \frac { J ^ { T } J \delta } { | | J \delta | | _ { 2 } } + \mathcal { O } ( \epsilon ^ { 2 } )
+$$
+
+where $J _ { i j } = \partial h _ { j } / \partial x _ { i }$ is the input-logit Jacobian of the network and $\delta _ { i } = \partial L / \partial h _ { i }$ is the error of the outputs of the network. For notational convenience we will define $\Gamma ( x ) = J ^ { T } J \delta / | J \delta | | _ { 2 }$ . In this linear model we therefore predict that the logit-differences will scale as follows,
+
+$$
+\Delta _ { i j } ( x ^ { \mathrm { a d v } } ) \approx \Delta _ { i j } ( x ) + \epsilon ( \Gamma _ { i } ( x ) - \Gamma _ { j } ( x ) ) + \mathcal { O } ( \epsilon ^ { 2 } ) .
+$$
+
+Recall that the adversarial perturbation will successfully cause the network to just barely misclassify an input precisely when $\Delta _ { 1 j } ( x ^ { \mathrm { a d v } } ) = 0$ for at least one $j$ . We can predict per-class $\epsilon$ -thresholds beyond which the network will misclassify a given point,
+
+$$
+\hat { \epsilon } _ { j } ( x ) = \frac { \Delta _ { 1 j } ( x ) } { \Gamma _ { j } ( x ) - \Gamma _ { 1 } ( x ) } .
+$$
+
+Together this allows us to compute a linear approximation to $\hat { \epsilon }$ given by $\hat { \epsilon } _ { \mathrm { l i n e a r } } ( x ) = \operatorname* { m i n } _ { j } ( \epsilon _ { j } ( x ) )$
+
+We can confirm that the change in the logits for small changes in the inputs is well-described by this linear model. This is shown in fig. 3 (a) where we see the logits for a single example upon perturbation over a range of $\epsilon$ . In particular, for small $\epsilon$ we see an excellent agreement between the linear approximation and the true logit dynamics. We also see that the $\epsilon$ where the first and second logit cross is well-approximated by the linear prediction. In Fig. 3 (b) we plot $\hat { \epsilon } _ { \mathrm { l i n e a r } } ( x )$ against $\hat { \epsilon } ( x )$ evaluated on every MNIST example in the test set. The white dashed line is the line $\hat { \epsilon } ( x ) = \hat { \epsilon } _ { \mathrm { l i n e a r } } ( x )$ . We see that when $\hat { \epsilon } ( x )$ is small the $\hat { \epsilon } _ { \mathrm { l i n e a r } } ( x )$ concentrate increasingly around the $\hat { \epsilon } ( x )$ . Together these results show that the linear response predictions are valid for small adversarial perturbations.
+
+![](images/85f4e581191d1aa2d9b2fce3b1c7c6baf8327e01427ec09910818f8323319cd2.jpg)  
+Figure 3: Linear approximation for the response of the logits to adversarial perturbation. (a) The dynamics of logits to an adversarial perturbation as a function of size $\epsilon$ for a single training example. Dashed lines show the linear approximation. Colors indicate the ranking of the logit from largest (red) to smallest (blue). (b) The smallest $\epsilon$ needed to fool the network (ˆ) for individual test examples compared with the prediction from the linear theory. (c) Mean field prediction of $\hat { \epsilon }$ .
+
+While the linear model outlined above gives excellent agreement in the $\epsilon  0$ limit, the $\Gamma _ { i } ( x )$ are themselves complicated objects (being functions of the Jacobian). This makes the analytic evaluation of Eq. (6) challenging. We therefore introduce a “mean-field” approximation to Eq. (6) by replacing $\Gamma _ { i } ( x )$ by its average over the dataset, $\langle \Gamma _ { i } ( x ) \rangle$ . Similar independence approximations have previously been successful in analyzing the expressivity and trainability of neural networks (Schoenholz et al., 2016; Poole et al., 2016). Finally, we observe that the vast majority of the time (for example, more than $9 5 \%$ of successful FGSM attacks for $\epsilon < 5 0$ ), it is $\Delta _ { 1 2 } ( x ^ { \mathrm { a d v } } )$ that goes to zero before any of the other $\Delta _ { 1 j }$ . We therefore assume that this will be the dominant failure mode for neural networks and write down a mean-field estimate for $\hat { \epsilon }$ ,
+
+$$
+\hat { \epsilon } _ { \mathrm { M . F . } } = \frac { \Delta _ { 1 2 } ( x ) } { \langle \Gamma _ { 2 } \rangle - \langle \Gamma _ { 1 } \rangle } .
+$$
+
+We show in Fig. 3 (c) that this approximation continues to be strongly correlated with ˆ. Together these results suggest that the adversarial error rate for perturbations of size $\epsilon$ will be
+
+$$
+P ( \hat { \epsilon } \le \epsilon ) \approx P \left[ \Delta _ { 1 2 } \le \epsilon ( \langle \Gamma _ { 2 } \rangle - \langle \Gamma _ { 1 } \rangle ) \right] = P ( \Delta _ { 1 2 } \le \tilde { \epsilon } )
+$$
+
+where we have defined $\tilde { \epsilon } = \epsilon ( \left. \Gamma _ { 2 } \right. - \left. \Gamma _ { 1 } \right. )$ to be a network-specific rescaling of $\epsilon$ . We therefore expect the adversarial error rate at small $\epsilon$ to be dictated by the cumulative distribution of $\Delta _ { 1 2 }$ for attacks that effectively target the second most likely class (e.g. FGSM, PGD ...etc.).
+
+# 3.2 UNIVERSAL PROPERTIES OF THE LOGIT DIFFERENCE DISTRIBUTION
+
+With the results from the preceding section in hand, we now investigate the distribution of logit differences, $P ( \Delta _ { 1 j } )$ . Since we are particularly interested in the small $\epsilon$ regime, we seek to compute $P ( \Delta _ { 1 j } )$ for small $\Delta _ { 1 j }$ . To make progress we will again make a mean field approximation and assume that each of the logits are i.i.d. with arbitrary distribution. With this approximation we find that for small $\Delta _ { 1 j }$ (see Appendix 6.2.2),
+
+$$
+P ( \Delta _ { 1 j } ) = C \Delta _ { 1 j } ^ { j - 2 } + \mathcal { O } ( \Delta _ { 1 j } ^ { j - 1 } )
+$$
+
+where $C$ is a network specific constant. An interesting consequence of this result is that the difference that we are particularly interested in, $P ( \Delta _ { 1 2 } )$ , scales as $\mathcal { O } ( 1 )$ as $\Delta _ { 1 2 }  0$ . This implies that, generically, we expect the most likely logit and second most likely logit to have a finite probability of being arbitrarily close together. We interpret this as an inherent uncertainty in the predictions of neural networks.
+
+While it is not obvious that the assumption of a factorial logit distribution is valid here, we will see that Eq. (9) captures the universal features of the distribution at small values of the logit difference. Indeed, from the previous section we see that the form of Eq. (9) implies that the adversarial error rate should scale as follows
+
+$$
+P ( \hat { \epsilon } < \epsilon ) \approx P ( \Delta _ { 1 2 } < \tilde { \epsilon } ) \approx C \tilde { \epsilon } + \mathcal { O } ( \tilde { \epsilon } ^ { 2 } )
+$$
+
+as was broadly observed in the previous section.
+
+To further test whether or not the mean field approximation is valid, we evaluate $\Delta _ { 1 j }$ for a number of different neural network architectures and datasets. We find that on all datasets and models studied, the $\Delta _ { 1 j }$ distributions have power-law tails. As predicted, $\Delta _ { 1 2 }$ has a power-law tail with an exponent of about 0, and $\Delta _ { 1 j }$ for $j > 2$ have power-law tails with positive exponents increasing with $j$ . We note, however, that the powers are typically not integral for large $j$ . It seems likely that this breakdown is the result of correlations between the logits. In Fig. 4, we compare distribution of $\Delta _ { 1 j }$ with $j = 2 , 3 , 4$ for ImageNet and logits that are independently sampled from a uniform distribution for 5 million samples with 10 classes. In Fig. 6 we see similar results for MNIST. Together these results verify our predictions over a vast set of networks and datasets.
+
+The empirical results above show that adversarial error has a power-law form for well-studied and random datasets, simple full connected networks as well as complicated state-of-the-art models. It follows that the prevalence and commonality of adversarial examples is not due to the depth of the model (for example, see the linear model in Fig. 2 (a)), or the high-dimensionality of the datasets. Rather, they are due to the fact that lots of examples have small $\Delta _ { 1 2 }$ values. This makes it easy to find examples to fool the model at test-time.
+
+It is interesting that the distribution of $\Delta _ { 1 j }$ , at small $\Delta _ { 1 j }$ , for trained models is essentially identical to that of i.i.d. random logits (especially for $j = 2$ ). This suggests that while our training procedures are good at modifying the largest logit in a way that leads to good clean accuracies, these procedures do not induce strong enough correlations between the logits to disrupt the essential scaling uncovered above. This problem is reminiscent of the problem distillation (Hinton et al., 2015) attempts to solve, by incorporating information about ratios of incorrect classes. This might be one of the reasons defensive distillation improves adversarial robustness. It would be interesting to study the distributions of logit differences during training of distillation networks.
+
+![](images/dfac972faeb31b0e791b25975de81e491597615df9ab61798b0539d59233dbbe.jpg)  
+Figure 4: (a) Distribution of $\Delta _ { 1 j }$ of NASNet-A trained on ImageNet. (b) Distribution of $\Delta _ { 1 j }$ for logits that are sampled independently from a uniform random distribution for 5 million samples with 10 classes. $\Delta _ { 1 j }$ of other models are in Appendix Fig. 14
+
+Given the large density of small more robust. Our proposed los $\Delta _ { 1 2 }$ values, we study an entronction can be written as: $\begin{array} { r } { \mathrm { \bar { l o s s } } = \mathrm { o l d } \mathrm { \bar { l o s s } } - \lambda \sum _ { i = 1 } ^ { n } p _ { i } \log p _ { i } } \end{array}$ where is a hyperparameter, $n$ is the number of classes, and $p _ { i }$ are the outputs of the neural network. This regularization term has been used by Miyato et al. (2017) for semi-supervised learning tasks. It aims to increase the confidence of the network on each sample, which is the opposite of previous regularization attempts that penalized confidence to increase generalization accuracy (Pereyra et al.,
+
+2017; Szegedy et al., 2015). By penalizing the entropy of the softmax outputs, we aim to increase the logit differences.
+
+In Fig. 5, we show that entropy regularization with a $\lambda = 4 . 5$ increases the adversarial robustness both for regularly trained networks and step l.l. adversarially trained networks, and both for permutation invariant and regular MNIST. We note that the same qualitative results hold for other values of $\lambda$ we tried. Despite the increase in adversarial accuracy, the permutation invariant MNIST model has $0 . 8 \%$ lower clean accuracy when trained with the entropy penalty. In Appendix Fig. 11, we show that a wide ResNet trained with the entropy regularizer has improved robustness with no loss in clean accuracy.
+
+![](images/c1869225e39aa09f2326fc23af8d98fa31a28439eb1d8da0aed3cd53b95f57fc.jpg)  
+Figure 5: Step l.l. attack adversarial accuracy as a function of $\epsilon$ for CNN and permutation invariant MNIST in (a) and (b), respectively. Regular training (purple), entropy regularization (red), adversarial training (green), and adversarial training with entropy regularization (blue) have been implemented. Adversarial training was done using the step l.l. method. In (c), we show the PGD attack adversarial accuracy on permutation invariant MNIST trained with and without step l.l. adversarial training.
+
+We investigate whether the increased adversarial robustness is due to increased logit differences. In Fig. 6, we plot the distribution of $\Delta _ { 1 j }$ for $j$ up to 4, for two networks trained on permutation invariant MNIST, with and without entropy regularization. As expected, margins are shifted to larger values and density of samples with small $\Delta _ { 1 j }$ are reduced. The tails still follow a power-law form with the same exponents, however there are fewer samples with small margins compared to a regularly trained network. Although entropy regularization made our networks white-box attacks, it did not lead to a significant improvement against black-box attacks. For this reason, we focus on the influence of network architectures on adversarial sensitivity below.
+
+![](images/77dfdc0bb5f0bde75a3a7b36d8a17c63ceb148055a493141d5e6090904603350.jpg)  
+Figure 6: Distribution of $\Delta _ { 1 j }$ up to $j = 5$ for permutation invariant MNIST trained with and without entropy regularization in red and purple, respectively.
+
+# 4 ROLE OF NETWORK ARCHITECTURES IN ADVERSARIAL ROBUSTNESS
+
+Several recent papers observe that larger networks are more robust against adversarial examples, regardless if they are adversarially trained or not (Kurakin et al., 2016b; Madry et al., 2017). However, it is not clear if network architectures play an important role in adversarial robustness. Are larger models more robust because they have more trainable parameters, or simply because they have higher clean accuracy? Is it possible to find more robust network architectures that do not necessarily have more parameters? We run several experiments to answer these questions, as well as to find an adversarially more robust model on CIFAR10. We perform neural architecture search (NAS) with reinforcement learning. Our search space and procedure are almost exactly the same as in Zoph et al. (2017). One difference is that we restrict the search space so that the normal cell must be the same as the reduction cell. This reduces the complexity of the search space as now we have only half as many predictions. Finally, we increase the number of prediction steps from 5 to 7 to slightly gain back the complexity that was lost when we restricted the normal cell to be equal to the reduction cell.
+
+We carry out two experiments:
+
+• Experiment 1: NAS where child models are trained with clean and step l.l. adversarial examples and the reward is computed on the validation set with FGSM adversarial accuracy at $\epsilon = 8$ .   
+• Experiment 2: NAS where child models are trained with clean and PGD adversarial examples and the reward is computed on the validation set with FGSM adversarial accuracy at $\epsilon = 8$ .
+
+In both experiments, child models are trained for 10 epochs on a training set of 25 thousand samples. Child models are trained on mini-batches where half of the samples are adversarially perturbed, following the procedure in (Kurakin et al., 2016b). At the end of each experiment, we pick the child model with the highest FGSM adversarial accuracy at $\epsilon = 8$ on the validation set of 5000 samples, and scale up the number of filters. We train the enlarged models for 100 epochs on the full training set of 45000 samples for 12 different hyperparameter sets, and pick the one with the highest adversarial accuracy on the validation set. Finally, we report below the performance of these models on a held-out test set of 10 thousand samples. To provide a comparison with the results of our two experiments, we also run a vanilla NAS where the reward is clean validation accuracy. We will refer to the best architecture from vanilla NAS as NAS Baseline. When trained using the setup above only on clean examples, NAS Baseline reaches a test set accuracy of $9 5 . 3 \%$ .
+
+![](images/45725418240ff962864ee69771205d42909fa7e90b2d0a5a3159452fdd5e53aa.jpg)  
+Figure 7: (a) step l.l. adversarial accuracy of NAS Baseline trained with and without step l.l. adversarial examples in green and red, respectively. Best model from Experiment 1 is shown in blue. (b) PGD adversarial accuracy of NAS Baseline trained with and without PGD adversarial examples in green and red, respectively. Best model from Experiment 2 is shown in blue.
+
+We present the results of Experiment 1 in Fig 7(a). Here the green curve is the adversarial accuracy NAS Baseline. The blue curve is the adversarial accuracy of a network architecture that was found by Experiment 1. Both of these architectures are trained with the same adversarial training procedure. We try the same sets of hyperparameters and report here the models with best adversarial accuracy at $\epsilon = 8$ on the validation set. Adversarial training reduced the clean accuracy by $0 . 2 \%$ . Adversarially trained models both have clean accuracy of $9 5 . 1 \%$ on the test set, whereas the model that was trained without adversarial training reached $9 5 . 3 \%$ accuracy.
+
+We next use PGD adversarial examples in the training of child models, to find architectures that are more robust to any adversarial attack within an $\epsilon$ ball (Madry et al., 2017). Following the training procedure by Madry et al. (2017), we use 7 steps of size 2, for a total $\epsilon = 8$ . We present the results of Experiment 2 in Fig. 7(b). As was the case in Experiment 1, the architecture found by adversarial NAS leads to a more robust model. At $\epsilon = 8$ , the architecture from Experiment 2 reaches a $17 \%$ higher adversarial accuracy on PGD examples. We compare our results to the results by Madry et al. (2017). Madry et al. (2017) trained only on PGD examples, whereas half of our minibatches are clean examples. Despite this, we match their accuracy on white-box PGD attacks. Against other white- and black-box attacks our model is more robust, and our clean accuracy is $5 . 9 \%$ higher. We also note that NAS Baseline model has 4.9 million trainable parameters, whereas the model from Experiments 1 and 2 have 2.3 million and 3.5 million parameters, respectively. NAS found an adversarially more robust architecture with many fewer parameters. Best architecture from Experiment 2 and NAS Baseline are presented in Appendix Fig. 16. Finally, we study the performance statistics of child models during NAS. In Fig. 8, we report the results for 9360 child models that were trained during Experiment 1. As explained above, these models are only trained for 10 epochs. In Fig. 8(a), we see that the correlation between adversarialy accuracy and the number of trainable parameters of the model is not very strong. On the other hand, adversarial accuracy is strongly correlated with clean accuracy (Fig. 8(b)). We hypothesize that this is the reason both Madry et al. (2017) and Kurakin et al. (2016b) found that making networks larger increased adversarial robustness, because it also increased the clean accuracy. This implies that commonly used architectures, like Inception v3 and ResNet, benefit from having more parameters. This however was not the case for most child models during NAS. On the other hand, having a high clean accuracy is not sufficient for adversarial robustness. As seen in Fig. 8(c), there is a large variance in the adversarial accuracy of models with good clean accuracy. The range of adversarial accuracies in the histogram of models with larger than $85 \%$ clean accuracy is $22 \%$ and the standard deviation is $2 . 6 \%$ . For this reason, our experiments led to more robust architectures than NAS Baseline.
+
+Table 1: Performance of our best architecture from Experiment 2 at $\epsilon = 8$ . Black-box attacks are sourced from a copy of the network independently initialized and trained.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>White-box</td><td rowspan=1 colspan=3>Black-box</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>step 1.1.</td><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>step 1.1.</td><td rowspan=1 colspan=1>PGD</td></tr><tr><td rowspan=1 colspan=1>Madry et al. (2017)</td><td rowspan=1 colspan=1>87.3%</td><td rowspan=1 colspan=1>56.1%</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>50.0%</td><td rowspan=1 colspan=1>67.0 %</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>64.2%</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>93.2%</td><td rowspan=1 colspan=1>63.6%</td><td rowspan=1 colspan=1>77.9%</td><td rowspan=1 colspan=1>50.1%</td><td rowspan=1 colspan=1>78.1 %</td><td rowspan=1 colspan=1>84.9%</td><td rowspan=1 colspan=1>75.0%</td></tr></table>
+
+![](images/0207438d01698c7a498a79f722099d8aa9424e42d55368ce98b83ff84f3350d9.jpg)  
+Figure 8: Performance of child models on the validation set. FGSM adversarial accuracy at $\epsilon = 8$ vs. number of trainable parameters and clean accuracy in (a) and (b), respectively. Black dots represent each child model, purple line is a running average. Figure (c) is the histogram of the adversarial accuracy for models with clean accuracy larger than $85 \%$ .
+
+# 5 CONCLUSION
+
+In this paper we studied common properties of adversarial examples across different models and datasets. We theoretically derived a universality in logit differences and adversarial error of machine learning models. We showed that architecture plays an important role in adversarial robustness, which correlates strongly with clean accuracy.
+
+# REFERENCES
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pp. 854–863, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+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.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016b.
+
+Yann LeCun and Corinna Cortes. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. arXiv preprint arXiv:1704.03976, 2017.
+
+Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. arXiv preprint arXiv:1703.09202, 2017.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016b.
+
+Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017.
+
+Ben Poole, Subhaneil Lahiri, Maithreyi Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in deep neural networks through transient chaos. In Advances In Neural Information Processing Systems, pp. 3360–3368, 2016.
+
+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.
+
+Samuel S Schoenholz, Justin Gilmer, Surya Ganguli, and Jascha Sohl-Dickstein. Deep information propagation. arXiv preprint arXiv:1611.01232, 2016.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble \` adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. arXiv preprint arXiv:1707.07012, 2017.
+
+# 6 APPENDIX
+
+# 6.1 FURTHER EXPERIMENTS
+
+![](images/b670571accf1ec3148d8641417d4a6b43fdf7c353720d8907853cc342b1807d3.jpg)  
+Figure 9: Adversarial error for hundreds of models trained on MNIST, including fully-connected and convolutional models. We only show models with clean accuracy larger than $80 \%$ .
+
+![](images/0cda1546173e20803b367c7e26e3db58e2dabb30fc58a20a86e6556b80a83117.jpg)  
+Figure 10: Points represent the adversarial error due to FGSM as a function of $\epsilon$ for a 32-layer ResNet trained on CIFAR10. Straight line is a power law fit with an exponent of 0.99.
+
+![](images/19c453a2f89cb39d463cccfb8014f80f6dddd6dcf92298ac8ab322959b8de828.jpg)  
+Figure 11: Effect of adding an entropy regularization $( \lambda = 3 . 0 )$ ): step l.l. adversarial accuracy of wide ResNet on CIFAR10, with and without entropy regularization. Both models have a clean accuracy of $9 4 \%$ . They were both trained for 100 epochs with the same hyperparameters.
+
+# 6.2 DERIVATIONS
+
+Here we derive several of the results found in the main text.
+
+# 6.2.1 LINEAR RESPONSE
+
+First, we compute the linear response of the network to the $L _ { 2 }$ FGSM attack. Let, $f : \mathbb { R } ^ { N } \to \mathbb { R } ^ { M }$ be a neural network (or other model) structured such that $f = \operatorname { s o f t m a x } \circ h$ where $h : \mathbb { R } ^ { N } \to \mathbb { R } ^ { M }$ maps inputs to logits. Additionally define a loss $L : \mathbb { R } ^ { M } \to \mathbb { R }$ which can be cross-entropy, $L ^ { 2 }$ , etc.. To generate adversarial examples we start with an input $\boldsymbol { x } \in \mathbb { R } ^ { N }$ and a corresponding target $t \in \mathbb { R } ^ { M }$ such that $t _ { \beta } = 1$ if $\beta = \gamma$ for some $\gamma$ and $t _ { \beta } = 0$ otherwise. We assume our network gets the answer correct so that $h _ { \gamma } > h _ { \beta }$ for all $\beta \neq \gamma$ . Then we apply the adversarial perturbation,
+
+$$
+x _ { \alpha } ^ { \prime } = x _ { \alpha } + \epsilon \frac { \nabla _ { x } L } { | | \nabla _ { x } L | | _ { 2 } } .
+$$
+
+Note that we can write
+
+$$
+\nabla _ { x } L = { \frac { \partial L } { \partial x _ { \alpha } } } = \sum _ { \beta } { \frac { \partial h _ { \beta } } { \partial x _ { \alpha } } } { \frac { \partial L } { \partial h _ { \beta } } } = \sum _ { \beta } J _ { \alpha \beta } { \frac { \partial L } { \partial h _ { \beta } } } = J \delta .
+$$
+
+Where we associate $J _ { \alpha \beta } = \partial h _ { \beta } / \partial x _ { \alpha }$ with the input-to-logit Jacobian linking the inputs to the logits and $\delta = \partial L / \partial h _ { \beta }$ the error of the outputs of the network.
+
+![](images/1d995c793653d9be88818c8a1da8189e47e3b0c071c1153919643df49d15ff93.jpg)  
+Figure 12: Fully connected network trained on MNIST with hinge loss. (a) Distributions of logit differences. (b) Red dots represent the adversarial error when FGSM attack uses the same hinge loss from training. Blue dots represent the adversarial error when FGSM attack uses a cross-entropy loss to create the adversarial examples.The line is a power-law fit with an exponent of 0.98
+
+![](images/917b69d3b380562fee50ab581eb866d83a8e46674d25a3848452158d9ecbe7a4.jpg)  
+Figure 13: Fully connected network trained on MNIST with L2-norm loss. (a) Distributions of logit differences. (b) Black dots represent the adversarial error due to FGSM. The line is a power-law fit with an exponent of 1.02
+
+We can compute the change to the logits of the network due to this perturbation. We find,
+
+$$
+\begin{array} { l } { \displaystyle h ( \boldsymbol { x } ^ { \prime } ) = h ( \boldsymbol { x } + \epsilon \nabla _ { \boldsymbol { x } } L / | | \nabla _ { \boldsymbol { x } } L | | _ { 2 } ) } \\ { \displaystyle h _ { \beta } ^ { \prime } \approx h _ { \beta } + \frac { \epsilon } { | | \nabla _ { \boldsymbol { x } } L | | _ { 2 } } \sum _ { \alpha } \frac { \partial h _ { \beta } } { \partial x _ { \alpha } } \frac { \partial L } { \partial x _ { \alpha } } + \mathcal { O } ( \epsilon ^ { 2 } ) } \\ { \displaystyle ~ = h _ { \beta } + \frac { \epsilon } { | | \nabla _ { \boldsymbol { x } } L | | _ { 2 } } \sum _ { \alpha \delta } \frac { \partial h _ { \beta } } { \partial x _ { \alpha } } \frac { \partial h _ { \delta } } { \partial x _ { \alpha } } \frac { \partial L } { \partial h _ { \delta } } } \end{array}
+$$
+
+where we have plugged in for eq. (11). Expressing the above equation in terms of the Jacobian, it follows that we can write the effect of the adversarial perturbation on the logits by,
+
+$$
+h ^ { \prime } = h + \epsilon \frac { J ^ { T } J \delta } { | | J \delta | | _ { 2 } }
+$$
+
+as postulated.
+
+![](images/c88352a66455538e3ceb30d420cf36b2a3ba9a8e1ccaa6907bbe9c8b2c3f27af.jpg)  
+Figure 14: (a) Distribution of $\Delta _ { 1 N }$ for other ImageNet models.
+
+![](images/0969b6740619fa492073f02b297f60c5b900679948f3b95b0f698427fc978a31.jpg)  
+Figure 15: (a) FGSM adversarial accuracy of NAS Baseline trained with and without step l.l. adversarial examples in green and red, respectively. Best model from Experiment 1 is shown in blue. (b) FGSM adversarial accuracy of NAS Baseline trained with and without PGD adversarial examples in green and red, respectively. Best model from Experiment 2 is shown in blue.
+
+6.2.2 UNIVERSAL PROPERTIES OF THE LOGIT DIFFERENCE DISTRIBUTION
+
+We now show that
+
+$$
+P ( \Delta _ { 1 j } ) = C \Delta _ { 1 j } ^ { j - 2 } + \mathcal { O } ( \Delta _ { 1 j } ^ { j - 1 } ) .
+$$
+
+To make progress we will again make a mean field approximation and assume that each of the logits are i.i.d. with arbitrary distribution $P ( h )$ . We denote the cumulative distribution $F ( h )$ . While it is not obvious that the factorial approximation is valid here, we will see that the resulting distribution of $P ( \Delta _ { 1 j } )$ shares many qualitative similarities with the distribution observed in real networks.
+
+We first change variables from the logits to a sorted version of the logits, $r _ { i }$ . The ranked logits are defined such that $r _ { 1 } = \operatorname* { m a x } ( \{ h _ { i } \} )$ , $r _ { 2 } = \mathrm { m a x } ( \{ h _ { i } \} \backslash \{ r _ { 1 } \} ) , \cdot \cdot \cdot$ . Our first result is to compute the resulting joint distribution between $r _ { 1 }$ and $r _ { j }$ ,
+
+$$
+P _ { j } ( r _ { 1 } , r _ { j } ) = A ( N , j ) F ^ { N - j } ( r _ { j } ) \left[ F ( r _ { 1 } ) - F ( r _ { j } ) \right] ^ { j - 2 } P ( r _ { j } ) P ( r _ { 1 } )
+$$
+
+where $A ( N , j ) = N ( N - 1 ) { \binom { N - 2 } { j - 2 } }$ is a combinatorial factor. Eq. (18) has a simple interpretation. $F ^ { N - j } ( r _ { j } )$ is the probability that there are $N - j$ variables less than $r _ { j }$ ; $[ F ( r _ { 1 } ) - F ( r _ { j } ) ] ^ { j - 2 }$ is the probability that $j - 2$ variables are between $r _ { j }$ and $r _ { 1 }$ ; $P ( r _ { j } ) P ( r _ { 1 } )$ is the probability that there is one variable equal to each of $r _ { 1 }$ and $r _ { j }$ . The combinatorial factor can be understood since there are $N$ ways of selecting $r _ { 1 }$ , $N - 1$ ways of selecting $r _ { j }$ , and $\binom { N - 2 } { j - 2 }$ ways of choosing $j - 2$ variables out of the remaining $N - 2$ to be between $r _ { j }$ and $r _ { 1 }$ .
+
+In terms of eq. (18) we can compute the distribution over $\Delta _ { 1 j }$ to be given by,
+
+$$
+\begin{array} { l } { { P ( \Delta _ { 1 j } ) = \displaystyle \int d r P _ { j } ( r + \Delta _ { 1 j } , r ) } } \\ { { \displaystyle \qquad = A ( N , j ) \int d r F ^ { N - j } ( r ) \left[ F ( r + \Delta _ { 1 j } ) - F ( r ) \right] ^ { j - 2 } P ( r ) P ( r + \Delta _ { 1 j } ) . } } \end{array}
+$$
+
+We can analyze this equation for small $\Delta _ { 1 j }$ . Expanding to lowest order in $\Delta _ { 1 j }$ ,
+
+$$
+\begin{array} { l } { P ( \Delta _ { 1 j } ) \approx A ( N , j ) \displaystyle \int d r { \cal F } ^ { N - j } ( r ) \left[ { \cal F } ( r ) + \Delta _ { 1 j } P ( r ) - { \cal F } ( r ) \right] ^ { j - 2 } P ( r ) \left[ P ( r ) + \Delta _ { 1 j } \frac { d P ( r ) } { d r } \right] } \\ { \displaystyle ~ ( \Delta ( N , j ) \Delta _ { 1 j } ^ { j - 2 } \int d r { \cal F } ^ { N - j } ( r ) P ^ { j } ( r ) + \mathcal { O } ( \Delta _ { 1 j } ^ { j - 1 } ) . ~ } \end{array}
+$$
+
+Since the term in the integral does not depend on $\Delta _ { 1 j }$ the result follows with,
+
+$$
+{ \cal C } = { \cal N } ( N - 1 ) { \binom { N - 2 } { j - 2 } } \int d r F ^ { N - j } ( r ) P ^ { j } ( r ) .
+$$
+
+# 6.2.3 ARCHITECTURES
+
+![](images/156b53fcd92de96aae41c52a10d1da280a0afb23260f06022ef070bf60dba302.jpg)  
+Figure 16: Left: Best architecture from Experiment 1. Right: Architecture of NAS Baseline. We note that the architecture from Experiment 1 is “longer” and “narrower” than previous architectures found by NAS for higher clean accuracy (Zoph & Le, 2016; Zoph et al., 2017).