Add files using upload-large-folder tool

parse/train/BJlxm30cKm/BJlxm30cKm.md

@@ -0,0 +1,314 @@
+# AN EMPIRICAL STUDY OF EXAMPLE FORGETTING DURING DEEP NEURAL NETWORK LEARNING
+
+Mariya Toneva∗† Carnegie Mellon University
+
+Alessandro Sordoni∗ Microsoft Research Montreal
+
+Remi Tachet des Combes∗ Microsoft Research Montreal
+
+Adam Trischler Microsoft Research Montreal
+
+Yoshua Bengio MILA, Universite de Montr ´ eal ´ CIFAR Senior Fellow
+
+Geoffrey J. Gordon Microsoft Research Montreal Carnegie Mellon University
+
+# ABSTRACT
+
+Inspired by the phenomenon of catastrophic forgetting, we investigate the learning dynamics of neural networks as they train on single classification tasks. Our goal is to understand whether a related phenomenon occurs when data does not undergo a clear distributional shift. We define a “forgetting event” to have occurred when an individual training example transitions from being classified correctly to incorrectly over the course of learning. Across several benchmark data sets, we find that: (i) certain examples are forgotten with high frequency, and some not at all; (ii) a data set’s (un)forgettable examples generalize across neural architectures; and (iii) based on forgetting dynamics, a significant fraction of examples can be omitted from the training data set while still maintaining state-of-the-art generalization performance.
+
+# 1 INTRODUCTION
+
+Many machine learning models, in particular neural networks, cannot perform continual learning. They have a tendency to forget previously learnt information when trained on new tasks, a phenomenon usually called catastrophic forgetting (Kirkpatrick et al., 2017; Ritter et al., 2018). One of the hypothesized causes of catastrophic forgetting in neural networks is the shift in the input distribution across different tasks—e.g., a lack of common factors or structure in the inputs of different tasks might lead standard optimization techniques to converge to radically different solutions each time a new task is presented. In this paper, we draw inspiration from this phenomenon and investigate the extent to which a related forgetting process occurs as a model learns examples traditionally considered to belong to the same task.
+
+Similarly to the continual learning setting, in stochastic gradient descent (SGD) optimization, each mini-batch can be considered as a mini-“task” presented to the network sequentially. In this context, we are interested in characterizing the learning dynamics of neural networks by analyzing (catastrophic) example forgetting events. These occur when examples that have been “learnt” (i.e., correctly classified) at some time $t$ in the optimization process are subsequently misclassified — or in other terms forgotten — at a time $t ^ { \prime } > t$ . We thus switch the focus from studying interactions between sequentially presented tasks to studying interactions between sequentially presented dataset examples during SGD optimization. Our starting point is to understand whether there exist examples that are consistently forgotten across subsequent training presentations and, conversely, examples that are never forgotten. We will call the latter unforgettable examples. We hypothesize that specific examples consistently forgotten between subsequent presentations, if they exist, must not share commonalities with other examples from the same task. We therefore analyze the proportion of forgettable/unforgettable examples for a given task and what effects these examples have on a model’s decision boundary and generalization error.
+
+The goal of our investigation is two-fold. First, we attempt to gain insight into the optimization process by analyzing interactions among examples during learning and their influence on the final decision boundary. We are particularly interested in whether we can glean insight on the compressibility of a dataset, and thereby increase data efficiency without compromising generalization accuracy. It is a timely problem that has been the recent focus of few-shot learning approaches via meta-learning (Finn et al., 2017; Ravi & Larochelle, 2017). Second, we aim to characterize whether forgetting statistics can be used to identify “important” samples and detect outliers and examples with noisy labels (John, 1995; Brodley & Friedl, 1999; Sukhbaatar et al., 2014; Jiang et al., 2018).
+
+Identifying important, or most informative examples is an important line of work and was extensively studied in the literature. Techniques of note — among others — are predefined curricula of examples (Bengio & LeCun, 2007), self-paced learning (Kumar et al., 2010), and more recently meta-learning (Fan et al., 2017). These research directions usually define “hardness” or “commonality” of an example as a function of the loss on that particular example at some point during training (or possibly at convergence). They do not consider whether some examples are consistently forgotten throughout learning. Very recently, Chang et al. (2017) consider re-weighting examples by accounting for the variance of their predictive distribution. This is related to our definition of forgetting events, but the authors provide little analysis of the extent to which the phenomenon occurs in their proposed tasks. Our purpose is to study this phenomenon from an empirical standpoint and characterize its prevalence in different datasets and across different model architectures.
+
+Our experimental findings suggest that: a) there exist a large number of unforgettable examples, i.e., examples that are never forgotten once learnt, those examples are stable across seeds and strongly correlated from one neural architecture to another; b) examples with noisy labels are among the most forgotten examples, along with images with “uncommon” features, visually complicated to classify; c) training a neural network on a dataset where a very large fraction of the least forgotten examples have been removed still results in extremely competitive performance on the test set.
+
+# 2 RELATED WORK
+
+Curriculum Learning and Sample Weighting Curriculum learning is a paradigm that favors learning along a curriculum of examples of increasing difficulty (Bengio et al., 2009). This general idea has found success in a variety of areas since its introduction (Kumar et al., 2010; Lee & Grauman, 2011; Schaul et al., 2015). Kumar et al. (2010) implemented their curriculum by considering easy the examples with a small loss. In our experiments, we empirically validate that unforgettable examples can be safely removed without compromising generalization. Zhao & Zhang (2015); Katharopoulos & Fleuret (2018) relate sample importance to the norm of its loss gradient with respect to the parameters of the network. Fan et al. (2017); Kim & Choi (2018); Jiang et al. (2018) learn a curriculum directly from data in order to minimize the task loss. Jiang et al. (2018) also study the robustness of their method in the context of noisy examples. This relates to a rich literature on outlier detection and removal of examples with noisy labels (John, 1995; Brodley & Friedl, 1999; Sukhbaatar et al., 2014; Jiang et al., 2018). We will provide evidence that noisy examples rank higher in terms of number of forgetting events. Koh & Liang (2017) borrow influence functions from robust statistics to evaluate the impact of the training examples on a model’s predictions.
+
+Deep Generalization The study of the generalization properties of deep neural networks when trained by stochastic gradient descent has been the focus of several recent publications (Zhang et al., 2016; Keskar et al., 2016; Chaudhari et al., 2016; Advani & Saxe, 2017). These studies suggest that the generalization error does not depend solely on the complexity of the hypothesis space. For instance, it has been demonstrated that over-parameterized models with many more parameters than training points can still achieve low test error (Huang et al., 2017; Wang et al., 2018) while being complex enough to fit a dataset with completely random labels (Zhang et al., 2016). A possible explanation for this phenomenon is a form of implicit regularization performed by stochastic gradient descent: deep neural networks trained with SGD have been recently shown to converge to the maximum margin solution in the linearly separable case (Soudry et al., 2017; Xu et al., 2018). In our work, we provide empirical evidence that generalization can be maintained when removing a substantial portion of the training examples and without restricting the complexity of the hypothesis class. This goes along the support vector interpretation provided by Soudry et al. (2017).
+
+# 3 DEFINING AND COMPUTING EXAMPLE FORGETTING
+
+Our general case study for example forgetting is a standard classification setting. Given a dataset $\mathbfcal { D } = ( \mathbf { x } _ { i } , y _ { i } ) _ { i }$ of observation/label pairs, we wish to learn the conditional probability distribution $p ( \boldsymbol { y } | \mathbf { x } ; \boldsymbol { \theta } )$ using a deep neural network with parameters $\theta$ . The network is trained to minimize the empirical risk $\begin{array} { r } { R = \frac { 1 } { | \mathcal { D } | } \sum _ { i } L ( p ( y _ { i } | \mathbf { x } _ { i } ; \boldsymbol { \theta } ) , \dot { y _ { i } } ) } \end{array}$ , where $L$ denotes the cross-entropy loss and $y _ { i } \in$ $1 , \ldots k$ . The minimization is performed using variations of stochastic gradient descent, starting from initial random parameters $\mathcal { \dot { \theta } } ^ { 0 }$ , and by sampling examples at random from the dataset $\mathcal { D }$ .
+
+Forgetting and learning events We denote by $\hat { y } _ { i } ^ { t } = \arg \operatorname* { m a x } _ { k } p ( y _ { i k } | \mathbf { x } _ { i } ; \boldsymbol { \theta } ^ { t } )$ the predicted label for example $\mathbf { x } _ { i }$ obtained after $t$ steps of SGD. We also let $\operatorname { a c c } _ { i } ^ { t } = \mathbb { 1 } _ { \hat { y } _ { i } ^ { t } = y _ { i } }$ be a binary variable indicating whether the example is correctly classified at time step $t$ . Example $i$ undergoes a forgetting event when $\operatorname { a c c } _ { i } ^ { t }$ decreases between two consecutive updates: $\operatorname { a c c } _ { i } ^ { t } > \operatorname { a c c } _ { i } ^ { t + 1 }$ . In other words, example $i$ is misclassified at step $t + 1$ after having been correctly classified at step $t$ . Conversely, a learning event has occurred if $\mathrm { a c c } _ { i } ^ { t } < \mathsf { a c c } _ { i } ^ { t + 1 }$ . Statistics that will be of interest in the next sections include the distribution of forgetting events across examples and the first time a learning event occurs.
+
+Classification margin We will also be interested in analyzing the classification margin. Our predictors have the form $p ( y _ { i } | \mathbf { x } _ { i } ; \theta ) = \sigma ( \beta ( \mathbf { x } _ { i } ) )$ , where $\sigma$ is a sigmoid (softmax) activation function in the case of binary (categorical) classification. The classification margin $m$ is defined as the difference between the logit of the correct class and the largest logit among the other classes, i.e. $m = \beta _ { k } - \arg \operatorname* { m a x } _ { k ^ { \prime } \neq k } \beta _ { k ^ { \prime } }$ , where $k$ is the index corresponding to the correct class.
+
+Unforgettable examples We qualify examples as unforgettable if they are learnt at some point and experience no forgetting events during the whole course of training: example $i$ is unforgettable if the first time it is learnt $t ^ { * }$ verifies $t ^ { * } < \infty$ and for all $k \geq t ^ { * }$ , $\mathsf { a c c } _ { i } ^ { k } \bar { = } 1$ . Note that, according to this definition, examples that are never learnt during training do not qualify as unforgettable. We refer to examples that have been forgotten at least once as forgettable.
+
+# 3.1 PROCEDURAL DESCRIPTION AND EXPERIMENTAL SETTING
+
+Following the previous definitions, monitoring forgetting events entails computing the prediction for all examples in the dataset at each model update, which would be prohibitively expensive. In practice, for each example, we subsample the full sequence of forgetting events by computing forgetting statistics only when the example is included in the current mini-batch; that is, we compute forgetting across presentations of the same example in subsequent mini-batches. This gives a lower bound on the number of forgetting events an example undergoes during training.
+
+We train a classifier on a given dataset and record the forgetting events for each example when they are sampled in the current mini-batch. For the purposes of further analysis, we then sort the dataset’s examples based on the number of forgetting events they undergo. Ties are broken at random when sampling from the ordered data. Samples that are never learnt are considered forgotten an infinite number of times for sorting purposes. Note that this estimate of example forgetting is computationally expensive; see Sec. 6 for a discussion of a cheaper method.
+
+We perform our experimental evaluation on three datasets of increasing complexity: MNIST (LeCun et al., 1999), permuted MNIST – a version of MNIST that has the same fixed permutation applied to the pixels of all examples, and CIFAR-10 (Krizhevsky,
+
+<table><tr><td>Algorithm1Computingforgettingstatisti</td></tr><tr><td>initialize prev_acc = O,i ∈ D initialize forgetting T[i] = O,i ∈D while not training done do B~ D # sample a minibatch</td></tr><tr><td>for example i∈ B do compute acci if prev_acc;&gt;acci then</td></tr><tr><td>T[i]=T[]+1 prev_acc = acci</td></tr><tr><td>gradient update classifier on B return T</td></tr></table>
+
+2009). We use various model architectures and training schemes that yield test errors comparable with the current state-of-the-art on the respective datasets. In particular, the MNIST-based experiments use a network comprised of two convolutional layers followed by a fully connected one, trained using SGD with momentum and dropout. This network achieves $0 . 8 \%$ test error. For CIFAR$I O$ , we use a ResNet with cutout (DeVries & Taylor, 2017) trained using SGD and momentum with a particular learning rate schedule. This network achieves a competitive $3 . 9 9 \%$ test error. For full experimentation details, see the Supplementary.
+
+![](images/5a03bcd767bb68daec7c991d4d6695a8ecad1a40539a729950f464239e4bae8f.jpg)  
+Figure 1: Histograms of forgetting events on (from left to right) MNIST, permutedMNIST and CIFAR-10. Insets show the zoomed-in y-axis.
+
+# 4 CHARACTERIZING EXAMPLE FORGETTING
+
+Number of forgetting events We estimate the number of forgetting events of all the training examples for the three different datasets (MNIST, permutedMNIST and CIFAR-10) across 5 random seeds. The histograms of forgetting events computed from one seed are shown in Figure 1. There are 55,012, 45,181 and 15,628 unforgettable examples common across 5 seeds, they represent respectively $9 1 . 7 \%$ , $7 5 . 3 \%$ , and $3 1 . 3 \%$ of the corresponding training sets. Note that datasets with less complexity and diversity of examples, such as MNIST, seem to contain significantly more unforgettable examples. permutedMNIST exhibits a complexity balanced between MNIST (easiest) and CIFAR-10 (hardest). This finding seems to suggest a correlation between forgetting statistics and the intrinsic dimension of the learning problem, as recently formalized by Li et al. (2018).
+
+Stability across seeds To test the stability of our metric with respect to the variance generated by stochastic gradient descent, we compute the number of forgetting events per example for 10 different random seeds and measure their correlation. From one seed to another, the average Pearson correlation is $8 9 . 2 \%$ . When randomly splitting the 10 different seeds into two sets of 5, the cumulated number of forgetting events within those two sets shows a high correlation of $9 7 . 6 \%$ . We also ran the original experiment on 100 seeds to devise $9 5 \%$ confidence bounds on the average (over 5 seeds) number of forgetting events per example (see Appendix 13). The confidence interval of the least forgotten examples is tight, confirming that examples with a small number of forgetting events can be ranked confidently.
+
+Forgetting by chance In order to quantify the possibility of forgetting occurring by chance, we additionally analyze the distribution of forgetting events obtained under the regime of random update steps instead of the true SGD steps. In order to maintain the statistics of the random updates similar to those encountered during SGD, random updates are obtained by shuffling the gradients produced by standard SGD on a main network (more details are provided in Appendix 12). We report the histogram of chance forgetting events in Supplementary Figure 13: examples are being forgotten by chance a small number of time, at most twice and most of the time less than once. The observed stability across seeds, low number of chance forgetting events and the tight confidence bounds suggest that it is unlikely for the ordering produced by the metric to be the by-product of another unrelated random cause.
+
+First learning events We investigate whether unforgettable and forgettable examples need to be presented different numbers of times in order to be learnt for the first time (i.e. for the first learning event to occur, as defined in Section 3). The distributions of the presentation numbers at which first learning events occur across all datasets can be seen in Supplemental Figure 8. We observe that, while both unforgettable and forgettable sets contain many examples that are learnt during the first 3-4 presentations, the forgettable examples contain a larger number of examples that are first learnt later in training. The Spearman rank correlation between the first learning event presentations and the number of forgetting events across all training examples is 0.56, indicating a moderate relationship.
+
+![](images/52d8fc501f8a2f5ad67add3dbc30c97b89d36824664c752f3a81cbebdf27415e.jpg)  
+Figure 2: Pictures of unforgettable (Top) and forgettable examples (Bottom) of every CIFAR-10 class. Forgettable examples seem to exhibit peculiar or uncommon features. Additional examples are available in Supplemental Figure 15.
+
+![](images/9c52d8bc2ae4475b951870675a51dadacfd8a6b6f88483c03bdf697fcfc9cd16.jpg)  
+Figure 3: Distributions of forgetting events across training examples in CIFAR-10 when $2 0 \%$ of labels are randomly changed. Left. Comparison of forgetting events between examples with noisy and original labels. The most forgotten examples are those with noisy labels. No noisy examples are unforgettable. Right. Comparison of forgetting events between examples with noisy labels and the same examples with original labels. Examples exhibit more forgetting when their labels are changed.
+
+Misclassification margin The definition of forgetting events is binary and as such fairly crude compared to more sophisticated estimators of example relevance (Zhao & Zhang, 2015; Chang et al., 2017). In order to qualify its validity, we compute the misclassification margin of forgetting events. The misclassification margin of an example is defined as the mean classification margin (defined in Section 3) over all its forgetting events, a negative quantity by definition. The Spearman rank correlation between an example’s number of forgetting events and its mean misclassification margin is -0.74 (computed over 5 seeds, see corresponding 2D-histogram in Supplemental Figure 9). These results suggest that examples which are frequently forgotten have a large misclassification margin.
+
+Visual inspection We visualize some of the unforgettable examples in Figure 2 along with some examples that have been most forgotten in the CIFAR-10 dataset. Unforgettable samples are easily recognizable and contain the most obvious class attributes or centered objects, e.g., a plane on a clear sky. On the other hand, the most forgotten examples exhibit more ambiguous characteristics (as in the center image, a truck on a brown background) that may not align with the learning signal common to other examples from the same class.
+
+Detection of noisy examples We further investigate the observation that the most forgettable examples seem to exhibit atypical characteristics. We would expect that if highly forgettable examples have atypical class characteristics, then noisily-labeled examples will undergo more forgetting events. We randomly change the labels of $2 0 \%$ of CIFAR-10 and record the number of forgetting events of both the noisy and regular examples through training. The distributions of forgetting events across noisy and regular examples are shown in Figure 3. We observe that the most forgotten examples are those with noisy labels and that no noisy examples are unforgettable. We also compare the forgetting events of the noisy examples to that of the same set of examples with original labels and observe a much higher degree of forgetting in the noisy case. The results of these synthetic experiments support the hypothesis that highly forgettable examples exhibit atypical class characteristics.
+
+![](images/287d6dcf4880b6293bde08d1d57bc47a87b14dc2b28efdb75ee7dcafe9b2c9d1.jpg)  
+Figure 4: Synthetic continual learning setup for CIFAR-10. Background color in each column indicates the training partition, curves track performance on both partitions during interleaved training. Solids lines represent the average of 5 runs and dashed lines represent the standard error. The figure highlights that examples that have been forgotten at least once can “support” those that have never been forgotten, as shown in (c.2) and (b.3).
+
+# 4.1 CONTINUAL LEARNING SETUP
+
+We observed that in harder tasks such as CIFAR-10, a significant portion of examples are forgotten at least once during learning. This leads us to believe that catastrophic forgetting may be observed, to some extent, even when considering examples coming from the same task distribution. To test this hypothesis, we perform an experiment inspired by the standard continual learning setup (McCloskey & Cohen, 1989; Kirkpatrick et al., 2017). We create two tasks by randomly sampling 10k examples from the CIFAR-10 training set and dividing them in two equally-sized partitions $5 \mathrm { k }$ examples each). We treat each partition as a separate ”task” even though they should follow the same distribution. We then train a classifier for 20 epochs on each partition in an alternating fashion, while tracking performance on both partitions. The results are reported in Figure 4 (a). The background color represents which of the two partitions is currently used for training. We observe some forgetting of the second task when we only train on the first task (panel (a.2)). This is somewhat surprising as the two tasks contain examples from the same underlying distribution.
+
+We contrast the results from training on random partitions of examples with ones obtained by partitioning the examples based on forgetting statistics (Figure 4 (b)). That is, we first compute the forgetting events for all examples based on Algorithm 1 and we create our tasks by sampling 5k examples that have zero forgetting events (named f0) and 5k examples that have non-zero forgetting events (named fN). We observe that examples that have been forgotten at least once suffer a more drastic form of forgetting than those included in a random split (compare (a.2) with (b.2)). In panel (b.3) and (c.2) we can observe that examples from task f0 suffer very mild forgetting when training on task fN. This suggests that examples that have been forgotten at least once may be able to “support” those that have never been forgotten. We observe the same pattern when we investigate the opposite alternating sequence of tasks in Figure 4 (b, right).
+
+# 5 REMOVING UNFORGETTABLE EXAMPLES
+
+As shown in the previous section, learning on examples that have been forgotten at least once minimally impacts performance on those that are unforgettable. This appears to indicate that unforgettable examples are less informative than others, and, more generally, that the more an example is forgotten during training, the more useful it may be to the classification task. This seems to align with the observations in Chang et al. (2017), where the authors re-weight training examples by accounting for the variance of their predictive distribution. Here, we test whether it is possible to completely remove a given subset of examples during training.
+
+![](images/38d0869069c29705ba3fbed213eddb271e760d9a3e3cc5ac9fb0633f0eefb772.jpg)  
+Figure 5: Left Generalization performance on CIFAR-10 of ResNet18 where increasingly larger subsets of the training set are removed (mean $+ / -$ std error of 5 seeds). When the removed examples are selected at random, performance drops very fast. Selecting the examples according to our ordering can reduce the training set significantly without affecting generalization. The vertical line indicates the point at which all unforgettable examples are removed from the training set. Right Difference in generalization performance when contiguous chunks of 5000 increasingly forgotten examples are removed from the training set. Most important examples tend to be those that are forgotten the most.
+
+In Fig. 5 $( L e f t )$ , we show the evolution of the generalization performance in CIFAR-10 when we artificially remove examples from the training dataset. We choose the examples to remove by increasing number of forgetting events. Each point in the figure corresponds to retraining the model from scratch on an increasingly smaller subset of the training data (with the same hyper-parameters as the base model). We observe that when removing a random subset of the dataset, performance rapidly decreases. Comparatively, by removing examples ordered by number of forgetting events, $3 0 \%$ of the dataset can be removed while maintaining comparable generalization performance as the base model trained on the full dataset, and up to $3 5 \%$ can be removed with marginal degradation (less than $0 . 2 \%$ ). The results on the other datasets are similar: a large fraction of training examples can be ignored without hurting the final generalization performance of the classifiers (Figure 6).
+
+In Figure 5 (Right), we show the evolution of the generalization error when we remove from the dataset 5,000 examples with increasing forgetting statistics. Each point in the figure corresponds to the generalization error of a model trained on the full dataset minus 5,000 examples as a function of the average number of forgetting events in those 5,000 examples. As can be seen, removing the same number of examples with increasingly more forgetting events results in worse generalization for most of the curve. It is interesting to notice the rightmost part of the curve moving up, suggesting that some of the most forgotten examples actually hurt performance. Those could correspond to outliers or mislabeled examples (see Sec. 4). Finding a way to separate those points from very informative ones is an ancient but still active area of research (John, 1995; Jiang et al., 2018).
+
+Support vectors Various explanations of the implicit generalization of deep neural networks (Zhang et al., 2016) have been offered: flat minima generalize better and stochastic gradient descent converges towards them (Hochreiter & Schmidhuber, 1997; Kleinberg et al., 2018), gradient descent protects against overfitting (Advani & Saxe, 2017; Tachet et al., 2018), deep networks’ structure biases learning towards simple functions (Neyshabur et al., 2014; Perez et al., 2018). But it remains a poorly understood phenomenon. An interesting direction of research is to study the convergence properties of gradient descent in terms of maximum margin classifiers. It has been shown recently (Soudry et al., 2017) that on separable data, a linear network will learn such a maximum margin classifier. This supports the idea that stochastic gradient descent implicitly converges to solutions that maximally separate the dataset, and additionally, that some data points are more relevant than others to the decision boundary learnt by the classifier. Those points play a part equivalent to support vectors in the support vector machine paradigm. Our results confirm that a significant portion of training data points have little to no influence on the generalization performance when the decision function is learnt with SGD. Forgettable training points may be considered as analogs to support vectors, important for the generalization performance of the model. The number of forgetting events of an example is a relevant metric to detect such support vectors. It also correlates well with the misclassification margin (see Sec.4) which is a proxy for the distance to the decision boundary.
+
+![](images/c9af5214bb1d0390f3042139c897b6c7ef5e367f89e43bb10c88ed18c72c76a7.jpg)  
+Figure 6: Decrease in generalization performance when fractions of the training sets are removed. When the subsets are selected appropriately, performance is maintained after removing up to $3 0 \%$ of CIFAR-10, $5 0 \%$ of permutedMNIST, and $\bar { 8 0 \% }$ of MNIST. Vertical black line indicates the point at which all unforgettable examples are removed from CIFAR-10. Right is a zoomed in version of Left.
+
+![](images/bdc145c23458b9c518e604d55a4223dc724bbf37980bde1f6e317882fc2ee5d2.jpg)  
+Figure 7: Left. Ranking of examples by forgotten events stabilizes after 75 epochs in CIFAR-10. Middle. Precision and recall of retrieving the unforgettable examples of ResNet18, using the example ordering of a simpler convolutional neural network. Right. Generalization performance on CIFAR-10 of a WideResNet using the example ordering of ResNet18.
+
+Intrinsic dataset dimension As mentioned above, the datasets we study have various fractions of unforgettable events $( 9 1 . 7 \%$ for MNIST, $7 5 . 3 \%$ for permutedMNIST and $3 1 . 3 \%$ for CIFAR-10). We also see in Figure 6 that performance on those datasets starts to degrade at different fractions of removed examples: the number of support vectors varies from one dataset to the other, based on the complexity of the underlying data distribution. If we assume that we are in fact detecting analogs of support vectors, we can put these results in perspective with the intrinsic dataset dimension defined by Li et al. (2018) as the codimension in the parameter space of the solution set: for a given architecture, the higher the intrinsic dataset dimension, the larger the number of support vectors, and the fewer the number of unforgettable examples.
+
+# 6 TRANSFERABLE FORGETTING EVENTS
+
+Forgetting events rely on training a given architecture, with a given optimizer, for a given number of epochs. We investigate to what extent the forgetting statistics of examples depend on those factors.
+
+Throughout training We compute the Spearman rank correlation between the ordering obtained at the end of training (200 epochs) and the ordering after various number of epochs. As seen in Fig. 7 (Left), the ordering is very stable after 75 epochs, and we found a reasonable number of epochs to get a good correlation to be 25 (see the Supplementary Materials for precision-recall plots).
+
+Between architectures A limitation of our method is that it requires computing the ordering from a previous run. An interesting question is whether that ordering could be obtained from a simpler architecture than residual networks. We train a network with two convolutional layers followed by two fully connected ones (see the Supplementary for the full architecture) and compare the resulting ordering with the one obtained with ResNet18. Figure 7 (Middle) shows a precision-recall plot of the unforgettable examples computed with the residual network. We see a reasonably strong agreement between the unforgettable examples of the convolutional neural network and the ones of the ResNet18. Finally, we train a WideResNet (Zagoruyko & Komodakis, 2016) on truncated data sets using the example ordering from ResNet18. Using the same computing power (one Titan X GPU), Resnet18 requires 2 hours to train whereas WideResNet requires 8 – estimating the forgetting statistics of WideResNet via ResNet18 can save up to 6 hours of training time if the estimate is accurate. We plot WideResNet’s generalization performance using the ordering obtained by ResNet18 in Figure 7 (Right): the network still performs near optimally with $3 0 \%$ of the dataset removed. This opens up promising avenues of computing forgetting statistics with smaller architectures.
+
+# 7 CONCLUSION AND FUTURE WORK
+
+In this paper, inspired by the phenomenon of catastrophic forgetting, we investigate the learning dynamics of neural networks when training on single classification tasks. We show that catastrophic forgetting can occur in the context of what is usually considered to be a single task. Inspired by this result, we find that some examples within a task are more prone to being forgotten, while others are consistently unforgettable. We also find that forgetting statistics seem to be fairly stable with respect to the various characteristics of training, suggesting that they actually uncover intrinsic properties of the data rather than idiosyncrasies of the training schemes. Furthermore, the unforgettable examples seem to play little part in the final performance of the classifier as they can be removed from the training set without hurting generalization. This supports recent research interpreting deep neural networks as max margin classifiers in the linear case. Future work involves understanding forgetting events better from a theoretical perspective, exploring potential applications to other areas of supervised learning, such as speech or text and to reinforcement learning where forgetting is prevalent due to the continual shift of the underlying distribution.
+
+# 8 ACKNOWLEDGMENTS
+
+We acknowledge the anonymous reviewers for their insightful suggestions.
+
+# REFERENCES
+
+Madhu S. Advani and Andrew M. Saxe. High-dimensional dynamics of generalization error in neural networks. CoRR, abs/1710.03667, 2017.   
+Yoshua Bengio and Yann LeCun. Scaling learning algorithms towards AI. In Large Scale Kernel Machines. MIT Press, 2007.   
+Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ Proceedings of the 26th annual international conference on machine learning, pp. 41–48. ACM, 2009.   
+Carla E Brodley and Mark A Friedl. Identifying mislabeled training data. Journal of artificial intelligence research, 11:131–167, 1999.   
+Haw-Shiuan Chang, Erik Learned-Miller, and Andrew McCallum. Active Bias: Training More Accurate Neural Networks by Emphasizing High Variance Samples. In Advances in Neural Information Processing Systems, pp. 1002–1012, 2017.   
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-SGD: Biasing Gradient Descent Into Wide Valleys. ICLR ’17, 2016.   
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Yang Fan, Fei Tian, Tao Qin, and Jiang Bian. Learning What Data to Learn. 2017.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proc. of ICML, 2017.
+
+S. Hochreiter and J. Schmidhuber. Flat minima. Neural Computation, 9(1):1��42, 1997.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely Connected Convolutional Networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4700–4708, 2017.
+
+Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. MentorNet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In Proceedings of the 35th International Conference on Machine Learning. PMLR, 2018.
+
+George H John. Robust decision trees: removing outliers from databases. In Proceedings of the First International Conference on Knowledge Discovery and Data Mining, pp. 174–179. AAAI Press, 1995.
+
+Angelos Katharopoulos and Franois Fleuret. Not all samples are created equal: Deep learning with importance sampling. In Jennifer G. Dy and Andreas Krause (eds.), ICML, volume 80 of JMLR Workshop and Conference Proceedings, pp. 2530–2539. JMLR.org, 2018. URL http: //dblp.uni-trier.de/db/conf/icml/icml2018.html#KatharopoulosF18.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Tae-Hoon Kim and Jonghyun Choi. Screenernet: Learning curriculum for neural networks. CoRR, abs/1801.00904, 2018. URL http://dblp.uni-trier.de/db/journals/ corr/corr1801.html#abs-1801-00904.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014. URL http: //arxiv.org/abs/1412.6980. cite arxiv:1412.6980Comment: Published as a conference paper at the 3rd International Conference for Learning Representations, San Diego, 2015.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, and Others. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017.
+
+Robert Kleinberg, Yuanzhi Li, and Yang Yuan. An alternative view: When does sgd escape local minima? CoRR, abs/1802.06175, 2018. URL http://dblp.uni-trier.de/db/ journals/corr/corr1802.html#abs-1802-06175.
+
+Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In Doina Precup and Yee Whye Teh (eds.), ICML, volume 70 of JMLR Workshop and Conference Proceedings, pp. 1885–1894. JMLR.org, 2017. URL http://dblp.uni-trier.de/db/ conf/icml/icml2017.html#KohL17.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. URL https: //www.cs.toronto.edu/˜kriz/learning-features-2009-TR.pdf.
+
+M Pawan Kumar, Benjamin Packer, and Daphne Koller. Self-Paced Learning for Latent Variable Models. In Proc. of NIPS, pp. 1–9, 2010.
+
+Y. LeCun, C. Cortes C., and C. Burges. The mnist database of handwritten digits. 1999. URL http://yann.lecun.com/exdb/mnist/.
+
+Yong Jae Lee and Kristen Grauman. Learning the easy things first: Self-paced visual category discovery. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1721–1728. IEEE, 2011.
+
+Chunyuan Li, Heerad Farkhoor, Rosanne Liu, and Jason Yosinski. Measuring the intrinsic dimension of objective landscapes. CoRR, abs/1804.08838, 2018. URL http://dblp.uni-trier. de/db/journals/corr/corr1804.html#abs-1804-08838.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989.
+
+Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. CoRR, abs/1412.6614, 2014. URL http: //dblp.uni-trier.de/db/journals/corr/corr1412.html#NeyshaburTS14.
+
+Guillermo Valle Perez, Chico Q. Camargo, and Ard A. Louis. Deep learning generalizes because the parameter-function map is biased towards simple functions. CoRR, abs/1805.08522, 2018. URL http://dblp.uni-trier.de/db/journals/corr/corr1805.html# abs-1805-08522.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In Proc. of ICLR, 2017.
+
+Hippolyt Ritter, Aleksandar Botev, and David Barber. Online Structured Laplace Approximations For Overcoming Catastrophic Forgetting. 2018. URL http://arxiv.org/abs/1805. 07810.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.
+
+Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The Implicit Bias of Gradient Descent on Separable Data. 2017. URL http://arxiv.org/abs/ 1710.10345.
+
+Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. arXiv preprint arXiv:1406.2080, 2014.
+
+R. Tachet, M. Pezeshki, S. Shabanian, A. Courville, and Y. Bengio. On the learning dynamics of deep neural networks. 2018. doi: arXiv:1809.06848v1. URL https://arxiv.org/abs/ 1809.06848.
+
+Huan Wang, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. Identifying Generalization Properties in Neural Networks. pp. 1–23, 2018. doi: arXiv:1809.07402v1. URL http:// arxiv.org/abs/1809.07402.
+
+Tengyu Xu, Yi Zhou, Kaiyi Ji, and Yingbin Liang. Convergence of sgd in learning relu models with separable data. CoRR, abs/1806.04339, 2018. URL http://dblp.uni-trier.de/db/ journals/corr/corr1806.html#abs-1806-04339.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks, 2016. URL http://arxiv. org/abs/1605.07146. cite arxiv:1605.07146.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+Peilin Zhao and Tong Zhang. Stochastic Optimization with Importance Sampling for Regularized Loss Minimization. In Proc. of ICML, 2015.
+
+# 9 EXPERIMENTATION DETAILS
+
+# Detailed distributions
+
+![](images/40db3260f8868359b0a142e18935ed80deab110b3146ac564a4720b4a08426a7.jpg)  
+Figure 8: From left to right, distributions of the first presentation at which each unforgettable and forgettable example was learned in MNIST, permutedMNIST and CIFAR-10 respectively. Rescaled view where the number of examples have been capped between 0 and 1500 for visualization purposes. Unforgettable examples are generally learnt early during training, thus may be considered as “easy” in the sense of Kumar et al. (2010), i.e. may have a low loss during most of the training.
+
+# Misclassification margin
+
+![](images/346765f78b8c8da6d80b4d9473bd330527ba0ad098006b6151e644efc6afcd48.jpg)  
+Figure 9: Left 2D-histogram of the number of forgetting events and mean misclassification margin across all examples of CIFAR-10. There is significant negative correlation (-0.74, Spearman rank correlation) between mean misclassification margin and the number of forgetting events.
+
+permutedMNIST The permutedMNIST data set is obtained by applying a fixed random permutation of the pixels to all the images of the standard MNIST data set. This typically makes the data set harder to learn for convolutional neural networks as local patterns, e.g. the horizontal bar of the 7, get shuffled. This statement is supported by the two following facts:
+
+• The number of unforgettable examples for permutedMNIST is 45181 versus 55012 for MNIST.   
+• The intrinsic data set dimension (Li et al., 2018) of permutedMNIST is 1400 compared to 290 for the untouched data set.
+
+Network Architectures We use a variety of different architectures in the main text. Below are their specifications.
+
+The architecture for the MNIST and permutedMNIST experiments is the following:
+
+1. a first convolutional layer with 5 by 5 filters and 10 feature maps,   
+2. a second convolutional layer with 5 by 5 filters and 20 feature maps,   
+3. a fully connected layer with 50 hidden units   
+4. the output layer, with 10 logits, one for each class.
+
+We apply ReLU nonlinearities to the feature maps and to the hidden layer. The last layer is passed through a softmax to output probabilities for each class of the data set.
+
+The ResNet18 architecture used for CIFAR-10 is described thoroughly in DeVries & Taylor (2017), its implementation can be found at https://github.com/uoguelph-mlrg/Cutout.
+
+The second one is a WideResNet (Zagoruyko & Komodakis, 2016), with a depth of 28 and a widen factor of 10. We used the implementation found at https://github.com/meliketoy/ wide-resnet.pytorch.
+
+The convolutional architecture used in Section 6 is the following:
+
+1. a first convolutional layer with 5 by 5 filters and 6 feature maps,   
+2. a 2 by 2 max pooling layer   
+3. a second convolutional layer with 5 by 5 filters and 16 feature maps,   
+4. a first fully connected layer with 120 hidden units   
+5. a second fully connected layer with 84 hidden units   
+6. the output layer, with 10 logits, one for each class.
+
+# Optimization
+
+The MNIST networks are trained to minimize the cross-entropy loss using stochastic gradient descent with a learning rate of 0.01 and a momentum of 0.5.
+
+The ResNet18 is trained using cutout, data augmentation and stochastic gradient descent with a 0.9 Nesterov momentum and a learning rate starting at 0.1 and divided by 5 at epochs 60, 120 and 160.
+
+The WideResNet is trained using Adam (Kingma & Ba, 2014) and a learning rate of 0.001.
+
+# 10 STABILITY OF THE FORGETTING EVENTS
+
+In Fig 10, we plot precision-recall diagrams for the unforgettable and most forgotten examples of CIFAR-10 obtained on ResNet18 after 200 epochs and various prior time steps. We see in particular that at 75 epochs, the examples on both side of the spectrum can be retrieved with very high precision and recall.
+
+![](images/d0a4f4da5ca23c1030925e3507e07d66a97018af24260ed0237910e1d8ac6e6c.jpg)  
+Figure 10: Right: precision and recall of retrieving the unforgettable examples from a full run of ResNet18 (200 epochs), using the example ordering after 25, 50, and 75 epochs. The unforgettable examples are retrieved with high precision and recall after 50 epochs. Left: same plot for the $1 7 \mathrm { k }$ examples with the most forgetting events.
+
+# 11 Noising THE DATA SETS
+
+In Section 4, we analyzed the effect of adding label noise on the distribution of forgetting events. Here, we examine the effect of adding pixel noise, i.e. noising the input distribution. We choose to corrupt the inputs with additive Gaussian noise with zero mean and we choose for its standard deviation to be a multiple of channel-wise data standard deviation (i.e., $\sigma _ { \mathrm { n o i s e } } = \lambda \sigma _ { \mathrm { d a t a } } , \lambda \in$ $\{ 0 . 5 , 1 , 2 , 1 0 \} )$ ). Note that we add the noise after applying a channel-wise standard normalization step of the training images, therefore $\sigma _ { \mathrm { { d a t a } } } = 1$ (each channel has zero mean, unit variance, this is a standard pre-processing step and has been applied throughout all the experiments in this paper).
+
+The forgetting distributions obtained by noising all the dataset examples with increasing noise standard deviation are presented in Figure 11. We observe that adding increasing amount of noise decreases the amount of unforgettable examples and increases the amount of examples in the second mode of the forgetting distribution.
+
+![](images/c85d546ee783e0bdf6fbd8db022d9d0074abb33e2162f714b1d5d1390c616da9.jpg)  
+Figure 11: Distribution of forgetting events across all training examples in CIFAR-10 when all training images are augmented with increasing additive Gaussian noise. The presence of increasing amount of noise decreases the amount of unforgettable examples and increases the amount of examples in the second mode of the forgetting distribution.
+
+We follow the noisy-labels experiments of Section 4 and we apply the aforementioned pixel noise to $2 0 \%$ of the training data $( \sigma _ { \mathrm { n o i s e } } = 1 0 $ ). We present the results of comparing the forgetting distribution of the $2 0 \%$ of examples before and after noise was added to the pixels in Figure 12 (Left). For ease of comparison, we report the same results in the case of label noise in Figure 12 (Right). We observe that the forgetting distribution under pixel noise resembles the one under label noise.
+
+![](images/a8aa943972ff1159f256e74be4eed78ea574ea1eb67e479b0ad485910b3ad749.jpg)  
+Figure 12: Distribution of forgetting events across all training examples in CIFAR-10 when random $2 0 \%$ of training examples undergo pixel noise $( \sigma _ { \mathrm { n o i s e } } = 1 0 $ ) (Left) or label noise (Right) (same as Figure 3). We observe that the forgetting distribution under pixel noise resembles the one under label noise.
+
+![](images/66ef88f7b4734f840e5f220706c67153fb836118aade5e3085872472697b01ce.jpg)  
+Figure 13: Histogram of forgetting events under true and random gradient steps. (Right) Zoomed-in version where the number of forgetting events is capped at 3 for visualization.
+
+Forgetting events may happen by “chance”, i.e. some learning/forgetting events may occur even with random gradients. In order to estimate how large the effect of “chance” is, we compute the forgetting events of a classifier obtained by randomizing the update steps. To keep the statistics of the gradients similar to those encountered during SGD, we proceed as follows:
+
+1. Before the beginning of training, clone the “base” classifier into a new “clone” classifier with the same random weights.   
+2. At each training step, shuffle the gradients computed on the base classifier and apply those to the clone (the base classifier is still optimized the same way): this ensures that the statistics of the random updates match the statistics of the true gradients during learning.   
+3. Compute the forgetting events of the clone classifier on the training set exactly as is done with the base classifier.
+
+The results can be found in Fig 13, showing the histogram of forgetting events produced by the clone network, averaged over 5 seeds. This gives an idea of the chance forgetting rate across examples. In this setting, examples are being forgotten by chance at most twice.
+
+# 13 CONFIDENCE ON FORGETTING EVENTS FOR CIFAR-10
+
+In order to establish confidence intervals on the number of forgetting events, we computed them on 100 seeds and formed 20 averages over 5 seeds. In Fig 14, we show the average (in green), the bottom 2.5 percentile (in blue) and top 2.5 percentile (in orange) of those 20 curves.
+
+![](images/4d7bfe4ea1651cd3e62eab8ae61e8d901a6c50ebcc9ce2e997271d7af7f36762.jpg)  
+Figure 14: $9 5 \%$ confidence interval on forgetting events averaged over 5 seeds.
+
+# 14 VISUALIZATION OF FORGETTABLE AND UNFORGETTABLE IMAGES
+
+See Fig 15 for additional pictures of the most unforgettable and forgettable examples of every CIFAR-10 class, when examples are sorted by number of forgetting events (ties are broken randomly).
+
+![](images/26c48e7533031f21b82c5abf702faf01271be63236bc94aaa98a2de018c2d84f.jpg)  
+Figure 15: Additional pictures of the most unforgettable (Left) and forgettable examples (Right) of every CIFAR-10 class, when examples are sorted by number of forgetting events (ties are broken randomly). Forgettable examples seem to exhibit peculiar or uncommon features.
+
+# 15 FORGETTING IN CIFAR-100
+
+![](images/592d9ae138cf5d8e8b5ea0a1841eb664652b4ebd539972bbccd66b40eabb2d88.jpg)  
+Figure 16: Left: distribution of forgetting events in CIFAR-100. Right: distribution of forgetting events in CIFAR-10 when $2 0 \%$ of the labels are changed at random. The distribution of forgetting in CIFAR-100 is much closer to that of forgetting in the noisy CIFAR-10 than it is to forgetting in the original datasets presented in Figure 1.
+
+The distribution of forgetting events in CIFAR-100 is shown in Figure 16. There are 3809 unforgettable examples $( 7 . 6 2 \%$ of the training set). CIFAR-100 is the hardest to classify out all of the presented datasets and exhibits the highest percentage of forgetting events. This finding further supports the idea that there may be a correlation between the forgetting statistics and the intrinsic dimension of the learning problem. Additionally, each CIFAR-100 class contains 10 times fewer examples than in CIFAR-10 or the MNIST datasets, making each image all the more useful for the learning problem.
+
+We also observe that the distribution of forgetting in CIFAR-100 is much closer to that of forgetting in the noisy CIFAR-10 than it is to forgetting in the original datasets presented in Figure 1. Visualizing the most forgotten examples in CIFAR-100 revealed that CIFAR-100 contains several images that appear multiple times in the training set under different labels. In Figure 17, we present the 36 most forgotten examples in CIFAR-100. Note that they are all images that appear under multiple labels (not shown: the ”girl” image also appears under the label ”baby”, the ”mouse” image also appears under ”shrew”, one of the 2 images of ‘oak tree’ appears under ‘willow tree’ and the other under ’maple tree’).
+
+![](images/ed7978d733b2244b5413450009d4bb7a60df4ca0d6383fa95a93dd81606a5722.jpg)  
+Figure 17: The 36 most forgotten examples in CIFAR-100. Note that they are all images that appear under multiple labels (not pictured: the ”girl” image also appears under the label ”baby”, the ”mouse” image also appears under ”shrew”, one of the 2 images of ‘oak tree’ appears under ‘willow tree’ and the other under ’maple tree’.
+
+We perform the same removal experiments we presented in Figure 5 for CIFAR-100. The results are shown in Figure 18. Just like with CIFAR-10, we are able to remove all unforgettable examples ( $8 \%$ of the training set) while maintaining test performance.
+
+![](images/3a54884d456e90cfa222191b9e16175b859ca48687f897b0d17044f4ec6df4e7.jpg)  
+Figure 18: Generalization performance on CIFAR-100 of ResNet18 where increasingly larger subsets of the training set are removed (mean $+ / -$ std error of 5 seeds). When the removed examples are selected at random, performance drops faster. Selecting the examples according to our ordering reduces the training set without affecting generalization.

parse/train/BJlxm30cKm/BJlxm30cKm_content_list.json

@@ -0,0 +1,1738 @@
+[
+    {
+        "type": "text",
+        "text": "AN EMPIRICAL STUDY OF EXAMPLE FORGETTING DURING DEEP NEURAL NETWORK LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mariya Toneva∗† Carnegie Mellon University ",
+        "bbox": [
+            184,
+            170,
+            367,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni∗ Microsoft Research Montreal ",
+        "bbox": [
+            397,
+            170,
+            589,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Remi Tachet des Combes∗ Microsoft Research Montreal ",
+        "bbox": [
+            620,
+            171,
+            813,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adam Trischler Microsoft Research Montreal ",
+        "bbox": [
+            184,
+            219,
+            377,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio MILA, Universite de Montr ´ eal ´ CIFAR Senior Fellow ",
+        "bbox": [
+            397,
+            219,
+            598,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey J. Gordon Microsoft Research Montreal Carnegie Mellon University ",
+        "bbox": [
+            617,
+            219,
+            812,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            299,
+            544,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the phenomenon of catastrophic forgetting, we investigate the learning dynamics of neural networks as they train on single classification tasks. Our goal is to understand whether a related phenomenon occurs when data does not undergo a clear distributional shift. We define a “forgetting event” to have occurred when an individual training example transitions from being classified correctly to incorrectly over the course of learning. Across several benchmark data sets, we find that: (i) certain examples are forgotten with high frequency, and some not at all; (ii) a data set’s (un)forgettable examples generalize across neural architectures; and (iii) based on forgetting dynamics, a significant fraction of examples can be omitted from the training data set while still maintaining state-of-the-art generalization performance. ",
+        "bbox": [
+            233,
+            332,
+            764,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            336,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many machine learning models, in particular neural networks, cannot perform continual learning. They have a tendency to forget previously learnt information when trained on new tasks, a phenomenon usually called catastrophic forgetting (Kirkpatrick et al., 2017; Ritter et al., 2018). One of the hypothesized causes of catastrophic forgetting in neural networks is the shift in the input distribution across different tasks—e.g., a lack of common factors or structure in the inputs of different tasks might lead standard optimization techniques to converge to radically different solutions each time a new task is presented. In this paper, we draw inspiration from this phenomenon and investigate the extent to which a related forgetting process occurs as a model learns examples traditionally considered to belong to the same task. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            699
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Similarly to the continual learning setting, in stochastic gradient descent (SGD) optimization, each mini-batch can be considered as a mini-“task” presented to the network sequentially. In this context, we are interested in characterizing the learning dynamics of neural networks by analyzing (catastrophic) example forgetting events. These occur when examples that have been “learnt” (i.e., correctly classified) at some time $t$ in the optimization process are subsequently misclassified — or in other terms forgotten — at a time $t ^ { \\prime } > t$ . We thus switch the focus from studying interactions between sequentially presented tasks to studying interactions between sequentially presented dataset examples during SGD optimization. Our starting point is to understand whether there exist examples that are consistently forgotten across subsequent training presentations and, conversely, examples that are never forgotten. We will call the latter unforgettable examples. We hypothesize that specific examples consistently forgotten between subsequent presentations, if they exist, must not share commonalities with other examples from the same task. We therefore analyze the proportion of forgettable/unforgettable examples for a given task and what effects these examples have on a model’s decision boundary and generalization error. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            858
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of our investigation is two-fold. First, we attempt to gain insight into the optimization process by analyzing interactions among examples during learning and their influence on the final decision boundary. We are particularly interested in whether we can glean insight on the compressibility of a dataset, and thereby increase data efficiency without compromising generalization accuracy. It is a timely problem that has been the recent focus of few-shot learning approaches via meta-learning (Finn et al., 2017; Ravi & Larochelle, 2017). Second, we aim to characterize whether forgetting statistics can be used to identify “important” samples and detect outliers and examples with noisy labels (John, 1995; Brodley & Friedl, 1999; Sukhbaatar et al., 2014; Jiang et al., 2018). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Identifying important, or most informative examples is an important line of work and was extensively studied in the literature. Techniques of note — among others — are predefined curricula of examples (Bengio & LeCun, 2007), self-paced learning (Kumar et al., 2010), and more recently meta-learning (Fan et al., 2017). These research directions usually define “hardness” or “commonality” of an example as a function of the loss on that particular example at some point during training (or possibly at convergence). They do not consider whether some examples are consistently forgotten throughout learning. Very recently, Chang et al. (2017) consider re-weighting examples by accounting for the variance of their predictive distribution. This is related to our definition of forgetting events, but the authors provide little analysis of the extent to which the phenomenon occurs in their proposed tasks. Our purpose is to study this phenomenon from an empirical standpoint and characterize its prevalence in different datasets and across different model architectures. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our experimental findings suggest that: a) there exist a large number of unforgettable examples, i.e., examples that are never forgotten once learnt, those examples are stable across seeds and strongly correlated from one neural architecture to another; b) examples with noisy labels are among the most forgotten examples, along with images with “uncommon” features, visually complicated to classify; c) training a neural network on a dataset where a very large fraction of the least forgotten examples have been removed still results in extremely competitive performance on the test set. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            343,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Curriculum Learning and Sample Weighting Curriculum learning is a paradigm that favors learning along a curriculum of examples of increasing difficulty (Bengio et al., 2009). This general idea has found success in a variety of areas since its introduction (Kumar et al., 2010; Lee & Grauman, 2011; Schaul et al., 2015). Kumar et al. (2010) implemented their curriculum by considering easy the examples with a small loss. In our experiments, we empirically validate that unforgettable examples can be safely removed without compromising generalization. Zhao & Zhang (2015); Katharopoulos & Fleuret (2018) relate sample importance to the norm of its loss gradient with respect to the parameters of the network. Fan et al. (2017); Kim & Choi (2018); Jiang et al. (2018) learn a curriculum directly from data in order to minimize the task loss. Jiang et al. (2018) also study the robustness of their method in the context of noisy examples. This relates to a rich literature on outlier detection and removal of examples with noisy labels (John, 1995; Brodley & Friedl, 1999; Sukhbaatar et al., 2014; Jiang et al., 2018). We will provide evidence that noisy examples rank higher in terms of number of forgetting events. Koh & Liang (2017) borrow influence functions from robust statistics to evaluate the impact of the training examples on a model’s predictions. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            766
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Generalization The study of the generalization properties of deep neural networks when trained by stochastic gradient descent has been the focus of several recent publications (Zhang et al., 2016; Keskar et al., 2016; Chaudhari et al., 2016; Advani & Saxe, 2017). These studies suggest that the generalization error does not depend solely on the complexity of the hypothesis space. For instance, it has been demonstrated that over-parameterized models with many more parameters than training points can still achieve low test error (Huang et al., 2017; Wang et al., 2018) while being complex enough to fit a dataset with completely random labels (Zhang et al., 2016). A possible explanation for this phenomenon is a form of implicit regularization performed by stochastic gradient descent: deep neural networks trained with SGD have been recently shown to converge to the maximum margin solution in the linearly separable case (Soudry et al., 2017; Xu et al., 2018). In our work, we provide empirical evidence that generalization can be maintained when removing a substantial portion of the training examples and without restricting the complexity of the hypothesis class. This goes along the support vector interpretation provided by Soudry et al. (2017). ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DEFINING AND COMPUTING EXAMPLE FORGETTING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            167,
+            642,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our general case study for example forgetting is a standard classification setting. Given a dataset $\\mathbfcal { D } = ( \\mathbf { x } _ { i } , y _ { i } ) _ { i }$ of observation/label pairs, we wish to learn the conditional probability distribution $p ( \\boldsymbol { y } | \\mathbf { x } ; \\boldsymbol { \\theta } )$ using a deep neural network with parameters $\\theta$ . The network is trained to minimize the empirical risk $\\begin{array} { r } { R = \\frac { 1 } { | \\mathcal { D } | } \\sum _ { i } L ( p ( y _ { i } | \\mathbf { x } _ { i } ; \\boldsymbol { \\theta } ) , \\dot { y _ { i } } ) } \\end{array}$ , where $L$ denotes the cross-entropy loss and $y _ { i } \\in$ $1 , \\ldots k$ . The minimization is performed using variations of stochastic gradient descent, starting from initial random parameters $\\mathcal { \\dot { \\theta } } ^ { 0 }$ , and by sampling examples at random from the dataset $\\mathcal { D }$ . ",
+        "bbox": [
+            173,
+            199,
+            825,
+            286
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Forgetting and learning events We denote by $\\hat { y } _ { i } ^ { t } = \\arg \\operatorname* { m a x } _ { k } p ( y _ { i k } | \\mathbf { x } _ { i } ; \\boldsymbol { \\theta } ^ { t } )$ the predicted label for example $\\mathbf { x } _ { i }$ obtained after $t$ steps of SGD. We also let $\\operatorname { a c c } _ { i } ^ { t } = \\mathbb { 1 } _ { \\hat { y } _ { i } ^ { t } = y _ { i } }$ be a binary variable indicating whether the example is correctly classified at time step $t$ . Example $i$ undergoes a forgetting event when $\\operatorname { a c c } _ { i } ^ { t }$ decreases between two consecutive updates: $\\operatorname { a c c } _ { i } ^ { t } > \\operatorname { a c c } _ { i } ^ { t + 1 }$ . In other words, example $i$ is misclassified at step $t + 1$ after having been correctly classified at step $t$ . Conversely, a learning event has occurred if $\\mathrm { a c c } _ { i } ^ { t } < \\mathsf { a c c } _ { i } ^ { t + 1 }$ . Statistics that will be of interest in the next sections include the distribution of forgetting events across examples and the first time a learning event occurs. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Classification margin We will also be interested in analyzing the classification margin. Our predictors have the form $p ( y _ { i } | \\mathbf { x } _ { i } ; \\theta ) = \\sigma ( \\beta ( \\mathbf { x } _ { i } ) )$ , where $\\sigma$ is a sigmoid (softmax) activation function in the case of binary (categorical) classification. The classification margin $m$ is defined as the difference between the logit of the correct class and the largest logit among the other classes, i.e. $m = \\beta _ { k } - \\arg \\operatorname* { m a x } _ { k ^ { \\prime } \\neq k } \\beta _ { k ^ { \\prime } }$ , where $k$ is the index corresponding to the correct class. ",
+        "bbox": [
+            174,
+            398,
+            823,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unforgettable examples We qualify examples as unforgettable if they are learnt at some point and experience no forgetting events during the whole course of training: example $i$ is unforgettable if the first time it is learnt $t ^ { * }$ verifies $t ^ { * } < \\infty$ and for all $k \\geq t ^ { * }$ , $\\mathsf { a c c } _ { i } ^ { k } \\bar { = } 1$ . Note that, according to this definition, examples that are never learnt during training do not qualify as unforgettable. We refer to examples that have been forgotten at least once as forgettable. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROCEDURAL DESCRIPTION AND EXPERIMENTAL SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            627,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following the previous definitions, monitoring forgetting events entails computing the prediction for all examples in the dataset at each model update, which would be prohibitively expensive. In practice, for each example, we subsample the full sequence of forgetting events by computing forgetting statistics only when the example is included in the current mini-batch; that is, we compute forgetting across presentations of the same example in subsequent mini-batches. This gives a lower bound on the number of forgetting events an example undergoes during training. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We train a classifier on a given dataset and record the forgetting events for each example when they are sampled in the current mini-batch. For the purposes of further analysis, we then sort the dataset’s examples based on the number of forgetting events they undergo. Ties are broken at random when sampling from the ordered data. Samples that are never learnt are considered forgotten an infinite number of times for sorting purposes. Note that this estimate of example forgetting is computationally expensive; see Sec. 6 for a discussion of a cheaper method. ",
+        "bbox": [
+            174,
+            681,
+            516,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We perform our experimental evaluation on three datasets of increasing complexity: MNIST (LeCun et al., 1999), permuted MNIST – a version of MNIST that has the same fixed permutation applied to the pixels of all examples, and CIFAR-10 (Krizhevsky, ",
+        "bbox": [
+            173,
+            840,
+            516,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/72911f78ac9bab499c4e9fc84d4a48ef121d6c4dec74ef214bcb58239d7f2a9c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1Computingforgettingstatisti</td></tr><tr><td>initialize prev_acc = O,i ∈ D initialize forgetting T[i] = O,i ∈D while not training done do B~ D # sample a minibatch</td></tr><tr><td>for example i∈ B do compute acci if prev_acc;&gt;acci then</td></tr><tr><td>T[i]=T[]+1 prev_acc = acci</td></tr><tr><td>gradient update classifier on B return T</td></tr></table>",
+        "bbox": [
+            531,
+            696,
+            823,
+            880
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2009). We use various model architectures and training schemes that yield test errors comparable with the current state-of-the-art on the respective datasets. In particular, the MNIST-based experiments use a network comprised of two convolutional layers followed by a fully connected one, trained using SGD with momentum and dropout. This network achieves $0 . 8 \\%$ test error. For CIFAR$I O$ , we use a ResNet with cutout (DeVries & Taylor, 2017) trained using SGD and momentum with a particular learning rate schedule. This network achieves a competitive $3 . 9 9 \\%$ test error. For full experimentation details, see the Supplementary. ",
+        "bbox": [
+            176,
+            910,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a03bcd767bb68daec7c991d4d6695a8ecad1a40539a729950f464239e4bae8f.jpg",
+        "image_caption": [
+            "Figure 1: Histograms of forgetting events on (from left to right) MNIST, permutedMNIST and CIFAR-10. Insets show the zoomed-in y-axis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            104,
+            810,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            296,
+            825,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 CHARACTERIZING EXAMPLE FORGETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            562,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Number of forgetting events We estimate the number of forgetting events of all the training examples for the three different datasets (MNIST, permutedMNIST and CIFAR-10) across 5 random seeds. The histograms of forgetting events computed from one seed are shown in Figure 1. There are 55,012, 45,181 and 15,628 unforgettable examples common across 5 seeds, they represent respectively $9 1 . 7 \\%$ , $7 5 . 3 \\%$ , and $3 1 . 3 \\%$ of the corresponding training sets. Note that datasets with less complexity and diversity of examples, such as MNIST, seem to contain significantly more unforgettable examples. permutedMNIST exhibits a complexity balanced between MNIST (easiest) and CIFAR-10 (hardest). This finding seems to suggest a correlation between forgetting statistics and the intrinsic dimension of the learning problem, as recently formalized by Li et al. (2018). ",
+        "bbox": [
+            174,
+            434,
+            825,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stability across seeds To test the stability of our metric with respect to the variance generated by stochastic gradient descent, we compute the number of forgetting events per example for 10 different random seeds and measure their correlation. From one seed to another, the average Pearson correlation is $8 9 . 2 \\%$ . When randomly splitting the 10 different seeds into two sets of 5, the cumulated number of forgetting events within those two sets shows a high correlation of $9 7 . 6 \\%$ . We also ran the original experiment on 100 seeds to devise $9 5 \\%$ confidence bounds on the average (over 5 seeds) number of forgetting events per example (see Appendix 13). The confidence interval of the least forgotten examples is tight, confirming that examples with a small number of forgetting events can be ranked confidently. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Forgetting by chance In order to quantify the possibility of forgetting occurring by chance, we additionally analyze the distribution of forgetting events obtained under the regime of random update steps instead of the true SGD steps. In order to maintain the statistics of the random updates similar to those encountered during SGD, random updates are obtained by shuffling the gradients produced by standard SGD on a main network (more details are provided in Appendix 12). We report the histogram of chance forgetting events in Supplementary Figure 13: examples are being forgotten by chance a small number of time, at most twice and most of the time less than once. The observed stability across seeds, low number of chance forgetting events and the tight confidence bounds suggest that it is unlikely for the ordering produced by the metric to be the by-product of another unrelated random cause. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First learning events We investigate whether unforgettable and forgettable examples need to be presented different numbers of times in order to be learnt for the first time (i.e. for the first learning event to occur, as defined in Section 3). The distributions of the presentation numbers at which first learning events occur across all datasets can be seen in Supplemental Figure 8. We observe that, while both unforgettable and forgettable sets contain many examples that are learnt during the first 3-4 presentations, the forgettable examples contain a larger number of examples that are first learnt later in training. The Spearman rank correlation between the first learning event presentations and the number of forgetting events across all training examples is 0.56, indicating a moderate relationship. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/52d8fc501f8a2f5ad67add3dbc30c97b89d36824664c752f3a81cbebdf27415e.jpg",
+        "image_caption": [
+            "Figure 2: Pictures of unforgettable (Top) and forgettable examples (Bottom) of every CIFAR-10 class. Forgettable examples seem to exhibit peculiar or uncommon features. Additional examples are available in Supplemental Figure 15. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c52d8bc2ae4475b951870675a51dadacfd8a6b6f88483c03bdf697fcfc9cd16.jpg",
+        "image_caption": [
+            "Figure 3: Distributions of forgetting events across training examples in CIFAR-10 when $2 0 \\%$ of labels are randomly changed. Left. Comparison of forgetting events between examples with noisy and original labels. The most forgotten examples are those with noisy labels. No noisy examples are unforgettable. Right. Comparison of forgetting events between examples with noisy labels and the same examples with original labels. Examples exhibit more forgetting when their labels are changed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            308,
+            790,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Misclassification margin The definition of forgetting events is binary and as such fairly crude compared to more sophisticated estimators of example relevance (Zhao & Zhang, 2015; Chang et al., 2017). In order to qualify its validity, we compute the misclassification margin of forgetting events. The misclassification margin of an example is defined as the mean classification margin (defined in Section 3) over all its forgetting events, a negative quantity by definition. The Spearman rank correlation between an example’s number of forgetting events and its mean misclassification margin is -0.74 (computed over 5 seeds, see corresponding 2D-histogram in Supplemental Figure 9). These results suggest that examples which are frequently forgotten have a large misclassification margin. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Visual inspection We visualize some of the unforgettable examples in Figure 2 along with some examples that have been most forgotten in the CIFAR-10 dataset. Unforgettable samples are easily recognizable and contain the most obvious class attributes or centered objects, e.g., a plane on a clear sky. On the other hand, the most forgotten examples exhibit more ambiguous characteristics (as in the center image, a truck on a brown background) that may not align with the learning signal common to other examples from the same class. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Detection of noisy examples We further investigate the observation that the most forgettable examples seem to exhibit atypical characteristics. We would expect that if highly forgettable examples have atypical class characteristics, then noisily-labeled examples will undergo more forgetting events. We randomly change the labels of $2 0 \\%$ of CIFAR-10 and record the number of forgetting events of both the noisy and regular examples through training. The distributions of forgetting events across noisy and regular examples are shown in Figure 3. We observe that the most forgotten examples are those with noisy labels and that no noisy examples are unforgettable. We also compare the forgetting events of the noisy examples to that of the same set of examples with original labels and observe a much higher degree of forgetting in the noisy case. The results of these synthetic experiments support the hypothesis that highly forgettable examples exhibit atypical class characteristics. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/287d6dcf4880b6293bde08d1d57bc47a87b14dc2b28efdb75ee7dcafe9b2c9d1.jpg",
+        "image_caption": [
+            "Figure 4: Synthetic continual learning setup for CIFAR-10. Background color in each column indicates the training partition, curves track performance on both partitions during interleaved training. Solids lines represent the average of 5 runs and dashed lines represent the standard error. The figure highlights that examples that have been forgotten at least once can “support” those that have never been forgotten, as shown in (c.2) and (b.3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            116,
+            818,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            348,
+            825,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONTINUAL LEARNING SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            428,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observed that in harder tasks such as CIFAR-10, a significant portion of examples are forgotten at least once during learning. This leads us to believe that catastrophic forgetting may be observed, to some extent, even when considering examples coming from the same task distribution. To test this hypothesis, we perform an experiment inspired by the standard continual learning setup (McCloskey & Cohen, 1989; Kirkpatrick et al., 2017). We create two tasks by randomly sampling 10k examples from the CIFAR-10 training set and dividing them in two equally-sized partitions $5 \\mathrm { k }$ examples each). We treat each partition as a separate ”task” even though they should follow the same distribution. We then train a classifier for 20 epochs on each partition in an alternating fashion, while tracking performance on both partitions. The results are reported in Figure 4 (a). The background color represents which of the two partitions is currently used for training. We observe some forgetting of the second task when we only train on the first task (panel (a.2)). This is somewhat surprising as the two tasks contain examples from the same underlying distribution. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We contrast the results from training on random partitions of examples with ones obtained by partitioning the examples based on forgetting statistics (Figure 4 (b)). That is, we first compute the forgetting events for all examples based on Algorithm 1 and we create our tasks by sampling 5k examples that have zero forgetting events (named f0) and 5k examples that have non-zero forgetting events (named fN). We observe that examples that have been forgotten at least once suffer a more drastic form of forgetting than those included in a random split (compare (a.2) with (b.2)). In panel (b.3) and (c.2) we can observe that examples from task f0 suffer very mild forgetting when training on task fN. This suggests that examples that have been forgotten at least once may be able to “support” those that have never been forgotten. We observe the same pattern when we investigate the opposite alternating sequence of tasks in Figure 4 (b, right). ",
+        "bbox": [
+            173,
+            664,
+            825,
+            803
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 REMOVING UNFORGETTABLE EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            549,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in the previous section, learning on examples that have been forgotten at least once minimally impacts performance on those that are unforgettable. This appears to indicate that unforgettable examples are less informative than others, and, more generally, that the more an example is forgotten during training, the more useful it may be to the classification task. This seems to align with the observations in Chang et al. (2017), where the authors re-weight training examples by accounting for the variance of their predictive distribution. Here, we test whether it is possible to completely remove a given subset of examples during training. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/38d0869069c29705ba3fbed213eddb271e760d9a3e3cc5ac9fb0633f0eefb772.jpg",
+        "image_caption": [
+            "Figure 5: Left Generalization performance on CIFAR-10 of ResNet18 where increasingly larger subsets of the training set are removed (mean $+ / -$ std error of 5 seeds). When the removed examples are selected at random, performance drops very fast. Selecting the examples according to our ordering can reduce the training set significantly without affecting generalization. The vertical line indicates the point at which all unforgettable examples are removed from the training set. Right Difference in generalization performance when contiguous chunks of 5000 increasingly forgotten examples are removed from the training set. Most important examples tend to be those that are forgotten the most. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            118,
+            789,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            416,
+            821,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 5 $( L e f t )$ , we show the evolution of the generalization performance in CIFAR-10 when we artificially remove examples from the training dataset. We choose the examples to remove by increasing number of forgetting events. Each point in the figure corresponds to retraining the model from scratch on an increasingly smaller subset of the training data (with the same hyper-parameters as the base model). We observe that when removing a random subset of the dataset, performance rapidly decreases. Comparatively, by removing examples ordered by number of forgetting events, $3 0 \\%$ of the dataset can be removed while maintaining comparable generalization performance as the base model trained on the full dataset, and up to $3 5 \\%$ can be removed with marginal degradation (less than $0 . 2 \\%$ ). The results on the other datasets are similar: a large fraction of training examples can be ignored without hurting the final generalization performance of the classifiers (Figure 6). ",
+        "bbox": [
+            174,
+            450,
+            825,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5 (Right), we show the evolution of the generalization error when we remove from the dataset 5,000 examples with increasing forgetting statistics. Each point in the figure corresponds to the generalization error of a model trained on the full dataset minus 5,000 examples as a function of the average number of forgetting events in those 5,000 examples. As can be seen, removing the same number of examples with increasingly more forgetting events results in worse generalization for most of the curve. It is interesting to notice the rightmost part of the curve moving up, suggesting that some of the most forgotten examples actually hurt performance. Those could correspond to outliers or mislabeled examples (see Sec. 4). Finding a way to separate those points from very informative ones is an ancient but still active area of research (John, 1995; Jiang et al., 2018). ",
+        "bbox": [
+            174,
+            597,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Support vectors Various explanations of the implicit generalization of deep neural networks (Zhang et al., 2016) have been offered: flat minima generalize better and stochastic gradient descent converges towards them (Hochreiter & Schmidhuber, 1997; Kleinberg et al., 2018), gradient descent protects against overfitting (Advani & Saxe, 2017; Tachet et al., 2018), deep networks’ structure biases learning towards simple functions (Neyshabur et al., 2014; Perez et al., 2018). But it remains a poorly understood phenomenon. An interesting direction of research is to study the convergence properties of gradient descent in terms of maximum margin classifiers. It has been shown recently (Soudry et al., 2017) that on separable data, a linear network will learn such a maximum margin classifier. This supports the idea that stochastic gradient descent implicitly converges to solutions that maximally separate the dataset, and additionally, that some data points are more relevant than others to the decision boundary learnt by the classifier. Those points play a part equivalent to support vectors in the support vector machine paradigm. Our results confirm that a significant portion of training data points have little to no influence on the generalization performance when the decision function is learnt with SGD. Forgettable training points may be considered as analogs to support vectors, important for the generalization performance of the model. The number of forgetting events of an example is a relevant metric to detect such support vectors. It also correlates well with the misclassification margin (see Sec.4) which is a proxy for the distance to the decision boundary. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9af5214bb1d0390f3042139c897b6c7ef5e367f89e43bb10c88ed18c72c76a7.jpg",
+        "image_caption": [
+            "Figure 6: Decrease in generalization performance when fractions of the training sets are removed. When the subsets are selected appropriately, performance is maintained after removing up to $3 0 \\%$ of CIFAR-10, $5 0 \\%$ of permutedMNIST, and $\\bar { 8 0 \\% }$ of MNIST. Vertical black line indicates the point at which all unforgettable examples are removed from CIFAR-10. Right is a zoomed in version of Left. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            106,
+            812,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bdc145c23458b9c518e604d55a4223dc724bbf37980bde1f6e317882fc2ee5d2.jpg",
+        "image_caption": [
+            "Figure 7: Left. Ranking of examples by forgotten events stabilizes after 75 epochs in CIFAR-10. Middle. Precision and recall of retrieving the unforgettable examples of ResNet18, using the example ordering of a simpler convolutional neural network. Right. Generalization performance on CIFAR-10 of a WideResNet using the example ordering of ResNet18. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            375,
+            803,
+            487
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            593,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intrinsic dataset dimension As mentioned above, the datasets we study have various fractions of unforgettable events $( 9 1 . 7 \\%$ for MNIST, $7 5 . 3 \\%$ for permutedMNIST and $3 1 . 3 \\%$ for CIFAR-10). We also see in Figure 6 that performance on those datasets starts to degrade at different fractions of removed examples: the number of support vectors varies from one dataset to the other, based on the complexity of the underlying data distribution. If we assume that we are in fact detecting analogs of support vectors, we can put these results in perspective with the intrinsic dataset dimension defined by Li et al. (2018) as the codimension in the parameter space of the solution set: for a given architecture, the higher the intrinsic dataset dimension, the larger the number of support vectors, and the fewer the number of unforgettable examples. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 TRANSFERABLE FORGETTING EVENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            529,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Forgetting events rely on training a given architecture, with a given optimizer, for a given number of epochs. We investigate to what extent the forgetting statistics of examples depend on those factors. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Throughout training We compute the Spearman rank correlation between the ordering obtained at the end of training (200 epochs) and the ordering after various number of epochs. As seen in Fig. 7 (Left), the ordering is very stable after 75 epochs, and we found a reasonable number of epochs to get a good correlation to be 25 (see the Supplementary Materials for precision-recall plots). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Between architectures A limitation of our method is that it requires computing the ordering from a previous run. An interesting question is whether that ordering could be obtained from a simpler architecture than residual networks. We train a network with two convolutional layers followed by two fully connected ones (see the Supplementary for the full architecture) and compare the resulting ordering with the one obtained with ResNet18. Figure 7 (Middle) shows a precision-recall plot of the unforgettable examples computed with the residual network. We see a reasonably strong agreement between the unforgettable examples of the convolutional neural network and the ones of the ResNet18. Finally, we train a WideResNet (Zagoruyko & Komodakis, 2016) on truncated data sets using the example ordering from ResNet18. Using the same computing power (one Titan X GPU), Resnet18 requires 2 hours to train whereas WideResNet requires 8 – estimating the forgetting statistics of WideResNet via ResNet18 can save up to 6 hours of training time if the estimate is accurate. We plot WideResNet’s generalization performance using the ordering obtained by ResNet18 in Figure 7 (Right): the network still performs near optimally with $3 0 \\%$ of the dataset removed. This opens up promising avenues of computing forgetting statistics with smaller architectures. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            297
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            318,
+            495,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, inspired by the phenomenon of catastrophic forgetting, we investigate the learning dynamics of neural networks when training on single classification tasks. We show that catastrophic forgetting can occur in the context of what is usually considered to be a single task. Inspired by this result, we find that some examples within a task are more prone to being forgotten, while others are consistently unforgettable. We also find that forgetting statistics seem to be fairly stable with respect to the various characteristics of training, suggesting that they actually uncover intrinsic properties of the data rather than idiosyncrasies of the training schemes. Furthermore, the unforgettable examples seem to play little part in the final performance of the classifier as they can be removed from the training set without hurting generalization. This supports recent research interpreting deep neural networks as max margin classifiers in the linear case. Future work involves understanding forgetting events better from a theoretical perspective, exploring potential applications to other areas of supervised learning, such as speech or text and to reinforcement learning where forgetting is prevalent due to the continual shift of the underlying distribution. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            387,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We acknowledge the anonymous reviewers for their insightful suggestions. ",
+        "bbox": [
+            174,
+            579,
+            663,
+            594
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            285,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Madhu S. Advani and Andrew M. Saxe. High-dimensional dynamics of generalization error in neural networks. CoRR, abs/1710.03667, 2017.   \nYoshua Bengio and Yann LeCun. Scaling learning algorithms towards AI. In Large Scale Kernel Machines. MIT Press, 2007.   \nYoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ Proceedings of the 26th annual international conference on machine learning, pp. 41–48. ACM, 2009.   \nCarla E Brodley and Mark A Friedl. Identifying mislabeled training data. Journal of artificial intelligence research, 11:131–167, 1999.   \nHaw-Shiuan Chang, Erik Learned-Miller, and Andrew McCallum. Active Bias: Training More Accurate Neural Networks by Emphasizing High Variance Samples. In Advances in Neural Information Processing Systems, pp. 1002–1012, 2017.   \nPratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-SGD: Biasing Gradient Descent Into Wide Valleys. ICLR ’17, 2016.   \nTerrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017. ",
+        "bbox": [
+            171,
+            635,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yang Fan, Fei Tian, Tao Qin, and Jiang Bian. Learning What Data to Learn. 2017. ",
+        "bbox": [
+            171,
+            103,
+            714,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proc. of ICML, 2017. ",
+        "bbox": [
+            173,
+            128,
+            823,
+            157
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Hochreiter and J. Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            173,
+            167,
+            746,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely Connected Convolutional Networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4700–4708, 2017. ",
+        "bbox": [
+            176,
+            193,
+            826,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. MentorNet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In Proceedings of the 35th International Conference on Machine Learning. PMLR, 2018. ",
+        "bbox": [
+            173,
+            246,
+            826,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George H John. Robust decision trees: removing outliers from databases. In Proceedings of the First International Conference on Knowledge Discovery and Data Mining, pp. 174–179. AAAI Press, 1995. ",
+        "bbox": [
+            173,
+            299,
+            826,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Angelos Katharopoulos and Franois Fleuret. Not all samples are created equal: Deep learning with importance sampling. In Jennifer G. Dy and Andreas Krause (eds.), ICML, volume 80 of JMLR Workshop and Conference Proceedings, pp. 2530–2539. JMLR.org, 2018. URL http: //dblp.uni-trier.de/db/conf/icml/icml2018.html#KatharopoulosF18. ",
+        "bbox": [
+            174,
+            352,
+            825,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tae-Hoon Kim and Jonghyun Choi. Screenernet: Learning curriculum for neural networks. CoRR, abs/1801.00904, 2018. URL http://dblp.uni-trier.de/db/journals/ corr/corr1801.html#abs-1801-00904. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014. URL http: //arxiv.org/abs/1412.6980. cite arxiv:1412.6980Comment: Published as a conference paper at the 3rd International Conference for Learning Representations, San Diego, 2015. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            568
+        ],
+        "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, and Others. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017. ",
+        "bbox": [
+            174,
+            577,
+            826,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robert Kleinberg, Yuanzhi Li, and Yang Yuan. An alternative view: When does sgd escape local minima? CoRR, abs/1802.06175, 2018. URL http://dblp.uni-trier.de/db/ journals/corr/corr1802.html#abs-1802-06175. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            686
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In Doina Precup and Yee Whye Teh (eds.), ICML, volume 70 of JMLR Workshop and Conference Proceedings, pp. 1885–1894. JMLR.org, 2017. URL http://dblp.uni-trier.de/db/ conf/icml/icml2017.html#KohL17. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. URL https: //www.cs.toronto.edu/˜kriz/learning-features-2009-TR.pdf. ",
+        "bbox": [
+            171,
+            763,
+            821,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M Pawan Kumar, Benjamin Packer, and Daphne Koller. Self-Paced Learning for Latent Variable Models. In Proc. of NIPS, pp. 1–9, 2010. ",
+        "bbox": [
+            168,
+            803,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. LeCun, C. Cortes C., and C. Burges. The mnist database of handwritten digits. 1999. URL http://yann.lecun.com/exdb/mnist/. ",
+        "bbox": [
+            169,
+            842,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yong Jae Lee and Kristen Grauman. Learning the easy things first: Self-paced visual category discovery. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1721–1728. IEEE, 2011. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chunyuan Li, Heerad Farkhoor, Rosanne Liu, and Jason Yosinski. Measuring the intrinsic dimension of objective landscapes. CoRR, abs/1804.08838, 2018. URL http://dblp.uni-trier. de/db/journals/corr/corr1804.html#abs-1804-08838. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. CoRR, abs/1412.6614, 2014. URL http: //dblp.uni-trier.de/db/journals/corr/corr1412.html#NeyshaburTS14. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillermo Valle Perez, Chico Q. Camargo, and Ard A. Louis. Deep learning generalizes because the parameter-function map is biased towards simple functions. CoRR, abs/1805.08522, 2018. URL http://dblp.uni-trier.de/db/journals/corr/corr1805.html# abs-1805-08522. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In Proc. of ICLR, 2017. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hippolyt Ritter, Aleksandar Botev, and David Barber. Online Structured Laplace Approximations For Overcoming Catastrophic Forgetting. 2018. URL http://arxiv.org/abs/1805. 07810. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015. ",
+        "bbox": [
+            174,
+            412,
+            823,
+            443
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The Implicit Bias of Gradient Descent on Separable Data. 2017. URL http://arxiv.org/abs/ 1710.10345. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            171,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R. Tachet, M. Pezeshki, S. Shabanian, A. Courville, and Y. Bengio. On the learning dynamics of deep neural networks. 2018. doi: arXiv:1809.06848v1. URL https://arxiv.org/abs/ 1809.06848. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huan Wang, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. Identifying Generalization Properties in Neural Networks. pp. 1–23, 2018. doi: arXiv:1809.07402v1. URL http:// arxiv.org/abs/1809.07402. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tengyu Xu, Yi Zhou, Kaiyi Ji, and Yingbin Liang. Convergence of sgd in learning relu models with separable data. CoRR, abs/1806.04339, 2018. URL http://dblp.uni-trier.de/db/ journals/corr/corr1806.html#abs-1806-04339. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            685
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks, 2016. URL http://arxiv. org/abs/1605.07146. cite arxiv:1605.07146. ",
+        "bbox": [
+            174,
+            694,
+            820,
+            723
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            174,
+            732,
+            821,
+            762
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peilin Zhao and Tong Zhang. Stochastic Optimization with Importance Sampling for Regularized Loss Minimization. In Proc. of ICML, 2015. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "9 EXPERIMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            446,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Detailed distributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            318,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/40db3260f8868359b0a142e18935ed80deab110b3146ac564a4720b4a08426a7.jpg",
+        "image_caption": [
+            "Figure 8: From left to right, distributions of the first presentation at which each unforgettable and forgettable example was learned in MNIST, permutedMNIST and CIFAR-10 respectively. Rescaled view where the number of examples have been capped between 0 and 1500 for visualization purposes. Unforgettable examples are generally learnt early during training, thus may be considered as “easy” in the sense of Kumar et al. (2010), i.e. may have a low loss during most of the training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            170,
+            769,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Misclassification margin ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            341,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/346765f78b8c8da6d80b4d9473bd330527ba0ad098006b6151e644efc6afcd48.jpg",
+        "image_caption": [
+            "Figure 9: Left 2D-histogram of the number of forgetting events and mean misclassification margin across all examples of CIFAR-10. There is significant negative correlation (-0.74, Spearman rank correlation) between mean misclassification margin and the number of forgetting events. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            375,
+            397,
+            620,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "permutedMNIST The permutedMNIST data set is obtained by applying a fixed random permutation of the pixels to all the images of the standard MNIST data set. This typically makes the data set harder to learn for convolutional neural networks as local patterns, e.g. the horizontal bar of the 7, get shuffled. This statement is supported by the two following facts: ",
+        "bbox": [
+            174,
+            604,
+            825,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• The number of unforgettable examples for permutedMNIST is 45181 versus 55012 for MNIST.   \n• The intrinsic data set dimension (Li et al., 2018) of permutedMNIST is 1400 compared to 290 for the untouched data set. ",
+        "bbox": [
+            215,
+            672,
+            825,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Network Architectures We use a variety of different architectures in the main text. Below are their specifications. ",
+        "bbox": [
+            173,
+            747,
+            826,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The architecture for the MNIST and permutedMNIST experiments is the following: ",
+        "bbox": [
+            176,
+            781,
+            718,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. a first convolutional layer with 5 by 5 filters and 10 feature maps,   \n2. a second convolutional layer with 5 by 5 filters and 20 feature maps,   \n3. a fully connected layer with 50 hidden units   \n4. the output layer, with 10 logits, one for each class. ",
+        "bbox": [
+            210,
+            808,
+            681,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We apply ReLU nonlinearities to the feature maps and to the hidden layer. The last layer is passed through a softmax to output probabilities for each class of the data set. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The ResNet18 architecture used for CIFAR-10 is described thoroughly in DeVries & Taylor (2017), its implementation can be found at https://github.com/uoguelph-mlrg/Cutout. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The second one is a WideResNet (Zagoruyko & Komodakis, 2016), with a depth of 28 and a widen factor of 10. We used the implementation found at https://github.com/meliketoy/ wide-resnet.pytorch. ",
+        "bbox": [
+            176,
+            138,
+            825,
+            181
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The convolutional architecture used in Section 6 is the following: ",
+        "bbox": [
+            174,
+            188,
+            602,
+            203
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. a first convolutional layer with 5 by 5 filters and 6 feature maps,   \n2. a 2 by 2 max pooling layer   \n3. a second convolutional layer with 5 by 5 filters and 16 feature maps,   \n4. a first fully connected layer with 120 hidden units   \n5. a second fully connected layer with 84 hidden units   \n6. the output layer, with 10 logits, one for each class. ",
+        "bbox": [
+            210,
+            213,
+            681,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Optimization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            338,
+            269,
+            353
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The MNIST networks are trained to minimize the cross-entropy loss using stochastic gradient descent with a learning rate of 0.01 and a momentum of 0.5. ",
+        "bbox": [
+            176,
+            359,
+            823,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The ResNet18 is trained using cutout, data augmentation and stochastic gradient descent with a 0.9 Nesterov momentum and a learning rate starting at 0.1 and divided by 5 at epochs 60, 120 and 160. ",
+        "bbox": [
+            176,
+            395,
+            825,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The WideResNet is trained using Adam (Kingma & Ba, 2014) and a learning rate of 0.001. ",
+        "bbox": [
+            174,
+            429,
+            771,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "10 STABILITY OF THE FORGETTING EVENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            555,
+            482
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Fig 10, we plot precision-recall diagrams for the unforgettable and most forgotten examples of CIFAR-10 obtained on ResNet18 after 200 epochs and various prior time steps. We see in particular that at 75 epochs, the examples on both side of the spectrum can be retrieved with very high precision and recall. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            553
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0a4f4da5ca23c1030925e3507e07d66a97018af24260ed0237910e1d8ac6e6c.jpg",
+        "image_caption": [
+            "Figure 10: Right: precision and recall of retrieving the unforgettable examples from a full run of ResNet18 (200 epochs), using the example ordering after 25, 50, and 75 epochs. The unforgettable examples are retrieved with high precision and recall after 50 epochs. Left: same plot for the $1 7 \\mathrm { k }$ examples with the most forgetting events. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            570,
+            750,
+            708
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "11 Noising THE DATA SETS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            821,
+            408,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 4, we analyzed the effect of adding label noise on the distribution of forgetting events. Here, we examine the effect of adding pixel noise, i.e. noising the input distribution. We choose to corrupt the inputs with additive Gaussian noise with zero mean and we choose for its standard deviation to be a multiple of channel-wise data standard deviation (i.e., $\\sigma _ { \\mathrm { n o i s e } } = \\lambda \\sigma _ { \\mathrm { d a t a } } , \\lambda \\in$ $\\{ 0 . 5 , 1 , 2 , 1 0 \\} )$ ). Note that we add the noise after applying a channel-wise standard normalization step of the training images, therefore $\\sigma _ { \\mathrm { { d a t a } } } = 1$ (each channel has zero mean, unit variance, this is a standard pre-processing step and has been applied throughout all the experiments in this paper). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The forgetting distributions obtained by noising all the dataset examples with increasing noise standard deviation are presented in Figure 11. We observe that adding increasing amount of noise decreases the amount of unforgettable examples and increases the amount of examples in the second mode of the forgetting distribution. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c85d546ee783e0bdf6fbd8db022d9d0074abb33e2162f714b1d5d1390c616da9.jpg",
+        "image_caption": [
+            "Figure 11: Distribution of forgetting events across all training examples in CIFAR-10 when all training images are augmented with increasing additive Gaussian noise. The presence of increasing amount of noise decreases the amount of unforgettable examples and increases the amount of examples in the second mode of the forgetting distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            357,
+            228,
+            686,
+            406
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We follow the noisy-labels experiments of Section 4 and we apply the aforementioned pixel noise to $2 0 \\%$ of the training data $( \\sigma _ { \\mathrm { n o i s e } } = 1 0 $ ). We present the results of comparing the forgetting distribution of the $2 0 \\%$ of examples before and after noise was added to the pixels in Figure 12 (Left). For ease of comparison, we report the same results in the case of label noise in Figure 12 (Right). We observe that the forgetting distribution under pixel noise resembles the one under label noise. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            569
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8aa943972ff1159f256e74be4eed78ea574ea1eb67e479b0ad485910b3ad749.jpg",
+        "image_caption": [
+            "Figure 12: Distribution of forgetting events across all training examples in CIFAR-10 when random $2 0 \\%$ of training examples undergo pixel noise $( \\sigma _ { \\mathrm { n o i s e } } = 1 0 $ ) (Left) or label noise (Right) (same as Figure 3). We observe that the forgetting distribution under pixel noise resembles the one under label noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            587,
+            810,
+            742
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/66ef88f7b4734f840e5f220706c67153fb836118aade5e3085872472697b01ce.jpg",
+        "image_caption": [
+            "Figure 13: Histogram of forgetting events under true and random gradient steps. (Right) Zoomed-in version where the number of forgetting events is capped at 3 for visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            145,
+            812,
+            299
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Forgetting events may happen by “chance”, i.e. some learning/forgetting events may occur even with random gradients. In order to estimate how large the effect of “chance” is, we compute the forgetting events of a classifier obtained by randomizing the update steps. To keep the statistics of the gradients similar to those encountered during SGD, we proceed as follows: ",
+        "bbox": [
+            174,
+            367,
+            825,
+            424
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. Before the beginning of training, clone the “base” classifier into a new “clone” classifier with the same random weights.   \n2. At each training step, shuffle the gradients computed on the base classifier and apply those to the clone (the base classifier is still optimized the same way): this ensures that the statistics of the random updates match the statistics of the true gradients during learning.   \n3. Compute the forgetting events of the clone classifier on the training set exactly as is done with the base classifier. ",
+        "bbox": [
+            210,
+            435,
+            825,
+            545
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The results can be found in Fig 13, showing the histogram of forgetting events produced by the clone network, averaged over 5 seeds. This gives an idea of the chance forgetting rate across examples. In this setting, examples are being forgotten by chance at most twice. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            599
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "13 CONFIDENCE ON FORGETTING EVENTS FOR CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            663,
+            636
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In order to establish confidence intervals on the number of forgetting events, we computed them on 100 seeds and formed 20 averages over 5 seeds. In Fig 14, we show the average (in green), the bottom 2.5 percentile (in blue) and top 2.5 percentile (in orange) of those 20 curves. ",
+        "bbox": [
+            173,
+            664,
+            500,
+            747
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d7bfe4ea1651cd3e62eab8ae61e8d901a6c50ebcc9ce2e997271d7af7f36762.jpg",
+        "image_caption": [
+            "Figure 14: $9 5 \\%$ confidence interval on forgetting events averaged over 5 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            655,
+            777,
+            789
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "14 VISUALIZATION OF FORGETTABLE AND UNFORGETTABLE IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            851,
+            764,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "See Fig 15 for additional pictures of the most unforgettable and forgettable examples of every CIFAR-10 class, when examples are sorted by number of forgetting events (ties are broken randomly). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/26c48e7533031f21b82c5abf702faf01271be63236bc94aaa98a2de018c2d84f.jpg",
+        "image_caption": [
+            "Figure 15: Additional pictures of the most unforgettable (Left) and forgettable examples (Right) of every CIFAR-10 class, when examples are sorted by number of forgetting events (ties are broken randomly). Forgettable examples seem to exhibit peculiar or uncommon features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            104,
+            813,
+            488
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "15 FORGETTING IN CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            444,
+            592
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/592d9ae138cf5d8e8b5ea0a1841eb664652b4ebd539972bbccd66b40eabb2d88.jpg",
+        "image_caption": [
+            "Figure 16: Left: distribution of forgetting events in CIFAR-100. Right: distribution of forgetting events in CIFAR-10 when $2 0 \\%$ of the labels are changed at random. The distribution of forgetting in CIFAR-100 is much closer to that of forgetting in the noisy CIFAR-10 than it is to forgetting in the original datasets presented in Figure 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            614,
+            812,
+            771
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The distribution of forgetting events in CIFAR-100 is shown in Figure 16. There are 3809 unforgettable examples $( 7 . 6 2 \\%$ of the training set). CIFAR-100 is the hardest to classify out all of the presented datasets and exhibits the highest percentage of forgetting events. This finding further supports the idea that there may be a correlation between the forgetting statistics and the intrinsic dimension of the learning problem. Additionally, each CIFAR-100 class contains 10 times fewer examples than in CIFAR-10 or the MNIST datasets, making each image all the more useful for the learning problem. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We also observe that the distribution of forgetting in CIFAR-100 is much closer to that of forgetting in the noisy CIFAR-10 than it is to forgetting in the original datasets presented in Figure 1. Visualizing the most forgotten examples in CIFAR-100 revealed that CIFAR-100 contains several images that appear multiple times in the training set under different labels. In Figure 17, we present the 36 most forgotten examples in CIFAR-100. Note that they are all images that appear under multiple labels (not shown: the ”girl” image also appears under the label ”baby”, the ”mouse” image also appears under ”shrew”, one of the 2 images of ‘oak tree’ appears under ‘willow tree’ and the other under ’maple tree’). ",
+        "bbox": [
+            173,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed7978d733b2244b5413450009d4bb7a60df4ca0d6383fa95a93dd81606a5722.jpg",
+        "image_caption": [
+            "Figure 17: The 36 most forgotten examples in CIFAR-100. Note that they are all images that appear under multiple labels (not pictured: the ”girl” image also appears under the label ”baby”, the ”mouse” image also appears under ”shrew”, one of the 2 images of ‘oak tree’ appears under ‘willow tree’ and the other under ’maple tree’. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            279,
+            687,
+            599
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We perform the same removal experiments we presented in Figure 5 for CIFAR-100. The results are shown in Figure 18. Just like with CIFAR-10, we are able to remove all unforgettable examples ( $8 \\%$ of the training set) while maintaining test performance. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a54884d456e90cfa222191b9e16175b859ca48687f897b0d17044f4ec6df4e7.jpg",
+        "image_caption": [
+            "Figure 18: Generalization performance on CIFAR-100 of ResNet18 where increasingly larger subsets of the training set are removed (mean $+ / -$ std error of 5 seeds). When the removed examples are selected at random, performance drops faster. Selecting the examples according to our ordering reduces the training set without affecting generalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            313,
+            385,
+            681,
+            569
+        ],
+        "page_idx": 17
+    }
+]

parse/train/HkSZyinVG/HkSZyinVG.md

@@ -0,0 +1,250 @@
+# IMPROVED LEARNING IN CONVOLUTIONAL NEURAL NETWORKS WITH SHIFTED EXPONENTIAL LINEAR UNITS (SHELUS)
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The Exponential Linear Unit (ELU) has been proven to speed up learning and improve the classification performance over activation functions such as ReLU and Leaky ReLU for convolutional neural networks. The reasons behind the improved behavior are that ELU reduces the bias shift, it saturates for large negative inputs and it is continuously differentiable. However, it remains open whether ELU has the optimal shape and we address the quest for a superior activation function.
+
+We use a new formulation to tune a piecewise linear activation function during training, to investigate the above question, and learn the shape of the locally optimal activation function. With this tuned activation function, the classification performance is improved and the resulting, learned activation function shows to be ELU-shaped irrespective if it is initialized as a RELU, LReLU or ELU. Interestingly, the learned activation function does not exactly pass through the origin indicating that a shifted ELU-shaped activation function is preferable. This observation leads us to introduce the Shifted Exponential Linear Unit (ShELU) as a new activation function.
+
+Experiments on Cifar-100 show that the classification performance is further improved when using the ShELU activation function in comparison with ELU. The improvement is achieved when learning an individual bias shift for each neuron.
+
+# 1 INTRODUCTION
+
+The classification accuracy of Convolutional Neural Networks (CNNs) has improved remarkably over the last years. The reason for the improvement is manifold: more sophisticated layer designs (Lin et al., 2013; He et al., 2016), effective regularization techniques reducing overfitting such as dropout (Srivastava et al., 2014) and batch normalization (Ioffe & Szegedy, 2015), new nonlinear activation functions (Clevert et al., 2015; Trottier et al., 2016), improved weight initialization methods (Glorot & Bengio, 2010; He et al., 2016), data augmentation and large scale data as ImageNet (Deng et al., 2009).
+
+In this work, we focus on the nonlinear activation function and its effect on the network learning behavior. Since the introduction of the Rectified Linear Unit (ReLU) (Glorot et al., 2011), it is generally accepted that the activation should be noncontractive to avoid the vanishing gradient problem. The vanishing gradient hampered the learning for the sigmoid and tanh activations. As ReLU is not symmetric, its mean response will be non-negative and will introduce a bias shift for the units in the next layer. The Leaky Rectified Linear Unit (LReLU) (Maas et al., 2013) was proposed to alleviate this bias shift. The LReLU introduces a small linear activation for negative inputs controlled by a constant hyperparameter $\alpha$ .
+
+Centering the activation, i.e. reducing the bias shift, is claimed to speed up learning (Le Cun et al., 1991). When the Exponential Linear Unit (ELU) was introduced by Clevert et al. (2015), one of the reason for its success and fast learning capability was claimed to be that the activation saturates for large negative inputs. ELU is also controlled by a hyperparameter that determines the saturation level. Another activation that is saturated for negative inputs is the Shifted ReLU (SReLU). Its shape is similar to ReLU, but the ”kink” is at -1 instead of 0. This reduces the bias shift while being saturated for negative inputs. ELU learns both faster and better than SReLU (Clevert et al.,
+
+Table 1: Activation functions.   
+
+<table><tr><td>Activation</td><td>x&gt;0</td><td>x≤0</td></tr><tr><td rowspan="3">ReLU LReLU SReLU</td><td>X</td><td>0</td></tr><tr><td>X</td><td>αx</td></tr><tr><td>X</td><td>max(x,-1)</td></tr><tr><td rowspan="3">ELU PELU</td><td>X</td><td>α(exp(x)-1)</td></tr><tr><td>X</td><td>α(exp(β x)-1)</td></tr><tr><td></td><td></td></tr></table>
+
+2015), but it is not obvious which properties of ELU that actually create this improvement. It may be the smooth exponential decay for small negative inputs and/or the fact that it is continuously differentiable. The question also remains whether the shape of ELU is truly the optimal activation function or if there are other shapes, not yet found, that would further speed up and improve learning. And if they exist, how are they to be found. These were the type of issues that we wanted to explore when starting this work.
+
+To improve the learning capabilities for the above mentioned activation functions, tuneable variants of them have been published where the control parameters are tuneable and learned instead of being set as a constant parameter according to their original publications. The Parametric ReLU (PReLU) was introduced by He et al. (2016) where the single control parameter $\alpha$ for LReLU is now learned during training. The Parametric ELU (PELU) was introduced by Trottier et al. (2016), also tuning the control parameters for ELU. Classification results were shown to improve with parameter tuning in both papers. The Scaled ELU (SELU)1 was defined by Klambauer et al. (2017) and is essentially a more simple variant of PELU. The activation functions mentioned so far are defined in Table 1.
+
+Piecewise linear activation functions have previously been used by Agostinelli et al. (2014) to improve the performance compared to LReLU. In this work, we use the same concept with tuneable piecewise linear activation functions, but now with the additional objective to investigate the shape of the learned activation function. We apply this approach for nonlinear regression of the optimal activation function. We initialized the activation as linearized versions of ReLU, LReLU and ELU, and they all resulted in the same shape after tuning the network. The ReLU and LReLU activation functions are tuned into an ELU-shaped function whereas the ELU activation function retains its shape. However, we also noted that the tuned ELU-shaped activation function does not exactly pass through the origin. There is a small shift introduced around the origin while retaining the overall shape of the activation function.
+
+Based on this observation, we introduce a shifted variant of the ELU activation function. In our experiments, we found that a horizontal shift is favorable and we call this new activation function Shifted Exponential Linear Unit (ShELU). The shift is tuneable during training and the shift is individual for each neuron. Experiments show that the classification performance is improved when allowing this shift in the activation function.
+
+Our main contribution is the introduction of the shifted activation function ShELU. The second contribution is a new formulation of a tuneable piecewise linear activation function with constraints to make it continuous. This formulation can be used to explore for other, up to now unseen, shapes of activation functions. The third contribution is experimental support that an ELU-shaped activation function is favorable for learning; the tuneable piecewise linear activation function adapts to an ELU-shape during training, but with a small shift around the origin.
+
+# 2 PIECEWISE LINEAR ACTIVATION FUNCTIONS
+
+Piecewise linear activation functions were first introduced by Agostinelli et al. (2014). In this work, we use the same idea but now with the additional objective to investigate the shape of the learned activation function. If we initialize the activation function as a linearized version of ReLU, LReLU or ELU, how will the shape be changed during training?
+
+Our formulation of a piecewise linear and continuous activation function is different from the one in Agostinelli et al. (2014) and consists of two steps: first a soft histogram is formed as in Felsberg & Granlund (2006), second, a weighted sum of the histogram outputs is computed. The piecewise linear activation functions are learned individually for each neuron.
+
+# 2.1 SOFT HISTOGRAM
+
+As it has been shown by Felsberg & Granlund (2006), a soft histogram can be represented by two components; one offset component and one histogram component. We use $N$ bins for positive input values and another $N$ bins for negative input values. All bins in the histogram have constant and unity width. The bin limits take integer values and the bin centers are at -0.5, 0.5, 1.5 etc. The concept of the soft histogram is illustrated in Figure 1. In the figure, $N$ is equal to 4, but in the experiments we also used more bins like $N = 8$ and 16. Within a certain activation layer, we extract the maximum and the minimum input over a minibatch. We then linearly scale the positive input values to lie in the range $[ 0 \mathrm { N } ]$ and the negative input values to lie in the range $[ - \mathbf { N } \mathbf { \Lambda } 0 ]$ . Now, as an example, consider two units with scaled input values of 2.68 and -1.80, respectively. For the first unit, the histogram component will be 1 for the bin centered at 2.5 and 0 for all other bins. The corresponding offset component will be 0.18, i.e. the signed distance from the bin center. For the second unit, the histogram component will be 1 for the bin centered at -1.5 and 0 for all other bins. The corresponding offset component will be -0.30. The output from the soft histogram for the two units will be
+
+$$
+y ( 2 . 6 8 ) = { \left[ \begin{array} { l l l l l l l l l } { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 . 1 8 } & { 0 } \\ { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 1 } & { 0 } \end{array} \right] }
+$$
+
+$$
+y ( - 1 . 8 0 ) = { \left[ \begin{array} { l l l l l l l l l } { 0 } & { 0 } & { - 0 . 3 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \\ { 0 } & { 0 } & { 1 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \end{array} \right] }
+$$
+
+An analytical formulation of the soft histogram can be given as
+
+$$
+y ( x ) = \left[ { \begin{array} { c } { \left( x - { \mathrm { \mathrm { H o o r } } } ( x ) - 0 . 5 \right) m _ { \nu } ( x ) } \\ { m _ { \nu } ( x ) } \end{array} } \right] _ { 2 \times 2 \mathrm { N } } = \left[ { \begin{array} { c c c c } { o _ { 0 } } & { o _ { 1 } } & { \cdots } & { o _ { 2 \mathrm { N } - 1 } } \\ { h _ { 0 } } & { h _ { 1 } } & { \cdots } & { h _ { 2 \mathrm { N } - 1 } } \end{array} } \right] ,
+$$
+
+where $m _ { \nu } ( x )$ denotes the membership of the respective bins. The membership is 1 if the unit belongs to that bin and 0 for all other bins. The soft histogram output can alternatively be expressed with the offset and histogram components as in the right hand side of (2).
+
+For backpropagation we need to compute the derivative of the soft histogram. In our formulation, we consider the membership $m _ { \nu } ( x )$ to be locally constant. This leads to a particular choice of subgradient that is also used in most implementations of max pooling, and it works well in practice. The derivative is computed as
+
+$$
+{ \frac { d y } { d x } } = \left[ { m _ { \nu } ( x ) } \right] _ { 2 \times 2 \mathrm { N } }
+$$
+
+The output from the soft histogram is independent of the activation function, but any activation function can be represented or approximated by a weighted sum of the histogram output.
+
+# 2.2 WEIGHTED SUM
+
+Different piecewise linear activation functions can now be realized by varying the weights applied to the soft histogram outputs. For each activation layer, we define a matrix $W$ with weights for the
+
+![](images/e4055142f977a15d07dd09dea08b36b690b919c38f7be507119020b1ed4c35b8.jpg)  
+Figure 1: Soft histogram decomposed into rectangular and linear basis functions.
+
+![](images/9a446b0986253b9062618410bd089025f2f6a63688bf2ed163531420c8cc5f01.jpg)  
+Figure 2: Weighted sum examples, ReLU activation (left) and LReLU activation (right).
+
+offset components and the histogram components
+
+$$
+W = \left[ { \begin{array} { l l l l } { w _ { o _ { 0 } } } & { w _ { o _ { 1 } } } & { \cdot \cdot \cdot } & { w _ { o _ { 2 \mathrm { N } - 1 } } } \\ { w _ { h _ { 0 } } } & { w _ { h _ { 1 } } } & { \cdot \cdot \cdot } & { w _ { h _ { 2 \mathrm { N } - 1 } } } \end{array} } \right] \quad .
+$$
+
+To obtain a ReLU activation function, we set all weights to 1 for the offset components on the positive side and 0 for all offset components on the negative side. The weights for the offset components correspond to the slope of the activation function for each linear piece. Further, for a ReLU, we set the weights for the histogram components to 0.5, 1.5, 2.5, etc. on the positive side and to 0 on the negative side. The weights for the histogram components correspond to the bias level at the bin centers of the activation function for each linear piece.
+
+To obtain a LReLU activation function, the weights (slopes) for the negative offset components are set to the value for the hyperparameter $\alpha$ , e.g. to 0.1. The weights for the offset components on the positive side are the same as for ReLU. For $\alpha = 0 . 1$ , the weights for the histogram components on the negative side are set to -0.35, -0.25, -0.15 and -0.05, i.e. the bias level at the bin centers.
+
+To summarize, the weight matrices for the ReLU and LReLU activation functions are defined as
+
+$$
+W _ { \mathrm { R e L U } } = \left[ { \begin{array} { c c c c c c c c } { 0 } & { 0 } & { 0 } & { 0 } & { 1 } & { 1 } & { 1 } & { 1 } \\ { 0 } & { 0 } & { 0 } & { 0 } & { 0 . 5 } & { 1 . 5 } & { 2 . 5 } & { 3 . 5 } \end{array} } \right]
+$$
+
+$$
+W _ { \mathrm { L R e L U } } = \left[ \begin{array} { c c c c c c c c } { { 0 . 1 } } & { { 0 . 1 } } & { { 0 . 1 } } & { { 0 . 1 } } & { { 1 } } & { { 1 } } & { { 1 } } & { { 1 } } \\ { { - 0 . 3 5 } } & { { - 0 . 2 5 } } & { { - 0 . 1 5 } } & { { - 0 . 0 5 } } & { { 0 . 5 } } & { { 1 . 5 } } & { { 2 . 5 } } & { { 3 . 5 } } \end{array} \right] .
+$$
+
+The output for the weighted sum is the sum of an elementwise multiplication of the soft histogram with the weight matrix
+
+$$
+y = \sum _ { \nu } w _ { o _ { \nu } } o _ { \nu } + w _ { h _ { \nu } } h _ { \nu } .
+$$
+
+The weighted sum output for the two example units is illustrated in Figure 2. For the ReLU activation, the outputs will be $2 . 5 \times 1 + 1 \times 0 . 1 8 = 2 . 6 8$ and $0 \times 1 + 0 \times ( - 0 . 3 0 ) = 0$ , respectively. For the LReLU activation, the output for the unit with input value -1.80 will be $- 0 . 1 5 \times 1 + 0 . 1 \times ( - 0 . 3 0 ) =$ -0.18, as desired.
+
+Our formulation will generate a piecewise linear activation function for any values chosen as weights for the offset and histogram components. However, it is obvious that constraints need to be put on the weights if a continuous activation function is to be obtained. The weights (slopes) for the offset components can be set independently but only one weight for the histogram component is independent from the other weights. Assume that $w _ { h _ { 0 } }$ is set as desired. To obtain a continuous linear function, the remaining histogram weights then need to be set as
+
+$$
+\begin{array} { r c l } { { w _ { h _ { 1 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + w _ { o _ { 1 } } ) } } \\ { { w _ { h _ { 2 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + 2 w _ { o _ { 1 } } + w _ { o _ { 2 } } ) } } \\ { { \vdots } } & { { } } & { { } } \\ { { w _ { h _ { 2 N - 1 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + 2 w _ { o _ { 1 } } + \cdots + 2 w _ { o _ { 2 N - 2 } } + w _ { o _ { 2 N - 1 } } ) . } } \end{array}
+$$
+
+The constraints in (7) must be enforced when updating the weights in the backpropagation step.
+
+# 3 SHIFTED ACTIVATION FUNCTIONS
+
+The results presented in section 4.1 show that an ELU-shaped activation function which is shifted around the origin seems favorable to improve learning. Hence, we introduce the ShELU activation function with horizontal shift and the SvELU activation function with vertical shift and define them as in Table 2. The hyperparameter $\alpha$ is considered to be a pre-set constant and it is not tuned during training. In our experiments, we set $\alpha = 1$ . We also define PShELU, a variant of PELU with horizontal shift. The parameters $\alpha$ and $\beta$ for PShELU are learned during training. In the experiments, they were initialized as $\alpha = \beta = 1 . 0$ , i.e. as an original ELU activation.
+
+Table 2: Shifted activation functions.   
+
+<table><tr><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Value</td><td rowspan=1 colspan=1>Region 1</td><td rowspan=1 colspan=1>Value</td><td rowspan=1 colspan=1>Region 2</td></tr><tr><td rowspan=1 colspan=1>ShELUSvELUPShELU</td><td rowspan=1 colspan=1>x+8x+8（c+）</td><td rowspan=1 colspan=1>x+δ&gt;0x&gt;0x+δ&gt;0</td><td rowspan=1 colspan=1>α(exp(x+δ)-1)α(exp(𝑥)-1)+δa（exp(+）-1)</td><td rowspan=1 colspan=1>x+δ≤0x≤0x+δ≤0</td></tr></table>
+
+Note that the introduced shifts $\delta$ in Table 2 are individual for all neurons. As an example, consider the first layers in the Lenet network (LeCun et al., 1998) shown in Figure 3. The input is an image $3 2 \times 3 2 \times 3$ . In the first convolutional layer, there are 192 filters with size $5 \times 5 \times 3$ . The output from the convolutional layer consists of 192 feature maps with size $3 2 \times 3 2$ . The output includes a bias level for each feature map (each large square in the convolutional output), i.e. a total of 192 bias levels. The activation function is applied to the individual neurons resulting in an output with size $3 2 \times 3 2 \times 1 9 2$ . When we say that we introduce individual shifts for all neurons, it means that there is one tuneable shift for each of the $3 2 \times 3 2 \times 1 9 2$ neurons (all small squares in the activation output) where the activation function is applied.
+
+In Goodfellow et al. (2016), chapter 9.5, it is stated that for CNNs it is natural to have shared biases with the same tiling pattern as the convolutional kernels, but that individual biases for each neuron ”would allow the model to correct for differences in the image statistics at different locations”. By introducing the activation function ShELU, with individual shifts for each neuron, we have indirectly created individual biases for the convolutional layer feature map output. Note that a convolutional layer with a shared bias level for each feature map output followed by a ShELU activation is equivalent with a convolutional layer with individual bias levels for each feature map output followed by an ELU activation. This equivalence was verified with experiments presented in section 4.2.1. However, frameworks as Caffe (Jia et al., 2014) and MatConvNet do not allow for individual biases in a convolutional layer but is restricted to shared biases.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENTS WITH PIECEWISE LINEAR ACTIVATION FUNCTIONS
+
+To investigate the behavior of the piecewise linear activation function we made some experiments with the Lenet network and the Cifar-100 dataset (Krizhevsky & Hinton, 2009). We used the implementation of Lenet as provided when downloading the MatConvNet framework. We ran the Lenet network with the ReLU activation function, and also replaced all activation layers with LReLU and
+
+![](images/734540204bd74acae307f75f51cfcd193dab04a035c1cba472aea656ac1a1227.jpg)  
+Figure 3: Bias levels for convolutional layers and shifts for activation function. Biases/shifts can either be shared (large squares) or individual for each neuron (small squares).
+
+Table 3: Top1error on Cifar-100 with Lenet network.   
+
+<table><tr><td>Activation</td><td>Toplerror (%)</td><td>Activation</td><td>Toplerror (%)</td><td>Activation</td><td>Toplerror (%)</td></tr><tr><td>ReLU</td><td>46.58</td><td>LReLU</td><td>45.41</td><td>ELU</td><td>44.96</td></tr><tr><td>Tuned ReLU</td><td>45.92</td><td>Tuned LReLU</td><td>45.18</td><td>Tuned ELU</td><td>44.51</td></tr></table>
+
+ELU. We then exchanged the activation layers with the piecewise linear activation layer. We initialized the layers as a linear version of ReLU, LReLU and ELU respectively. We consistently noticed a slight improvement (a few tenths of a percent) in classification performance when using the tuneable piecewise linear activation function compared to its corresponding fixed activation function, see Table 3. Besides the slight classification improvement, it is also interesting to analyse the shape of the activation functions after tuning, see Figure 4. All three activation functions remain linear and with almost unity slope on the positive side. All three tuned activation functions exhibit a smooth exponential decay for small negative inputs and then remain fairly constant for larger negative inputs. The resulting shape after tuning for all three initializations is close to the ELU shape. However, notice that all tuned activation functions tend to return a variable but negative output for zero input and that they do not pass through the origin. These results suggest that we introduce the Shifted Exponential Linear Unit (ShELU) as an activation function. From the results it is not obvious whether the introduced shift around the origin should be vertical or horizontal. For a horizontal shift, the saturation level remains constant for large negative inputs which may seem more intuitive. For a vertical shift, the saturation level will vary depending on the shift which better matches the achieved results on the Lenet network.
+
+# 4.2 EXPERIMENTS WITH SHIFTED ACTIVATION FUNCTIONS
+
+# 4.2.1 EXPERIMENTS ON CIFAR-100 WITH LENET NETWORK
+
+We now want to evaluate if the classification performance improves with the new activation functions ShELU and SvELU compared to ELU. We start with the Lenet network and replace all ELU activations with either the ShELU or the SvELU activation. The learning rate was set to 0.005 for the first 40 epochs, then lowered by a factor of 10 every 20 epochs, running a total of 80 epochs. The learning rate momentum was set to 0.9 and the weight decay to 0.0005. Image data was preprocessed with global contrast normalization and whitening (Coates et al., 2011). Note that the complete dataset was divided by a factor of 10 (compared to the preprocessing provided with the MatConvNet download) to better match the variance with Xavier initialization. During training the dataset was augmented with random horizontal flipping and by randomly cropping images from the original images zero padded with a frame of width four.
+
+The classification errors for the training and test sets shown in Figure 5 are the average over 8 runs for each activation function. The top1errors in Table 4 are the average over the last 15 epochs for the lowest learning rate. The learning rate for the ShELU and SvELU activation layer weights was set to $2 \%$ of the base learning rate. The results show that there is a small improvement on the top1error using the ShELU and SvELU activation functions compared with the original ELU. Futhermore, the shifted activation function PShELU achieves a slightly better test results than both ELU and PELU.
+
+![](images/7c6f8f84144cd4adfcb451d4df972e59f449870f9218c185c74ca1a34984fe5c.jpg)  
+Figure 4: Initialization (red) and 20, 50 and 80 percentiles for tuned activation functions in last layer; ReLU (left), LReLU (middle) and ELU (right).
+
+![](images/e29872596ebdaae5e48641b096ad683df3bca8a952c9ce7e65594bdc5a32066d.jpg)  
+Figure 5: Training (dashed) and test (solid) errors on Cifar-100 with network Lenet (left). Test errors (final part) for ELU, SvELU and ShELU (middle), and ELU, PELU and PShELU (right).
+
+Table 4: Top1 test errors on Cifar-100 with Lenet and Clevert-11 networks.   
+
+<table><tr><td>Activation</td><td>Lenetnetwork</td><td>Clevert-11 network</td></tr><tr><td>ELU</td><td>44.96</td><td>28.76</td></tr><tr><td>SvELU</td><td>44.70</td><td>28.85</td></tr><tr><td>ShELU</td><td>44.77</td><td>28.57</td></tr><tr><td>PELU</td><td>45.03</td><td>28.78</td></tr><tr><td>PShELU</td><td>44.76</td><td>28.74</td></tr><tr><td>ConvIndBias+ELU</td><td>44.78</td><td>1</td></tr></table>
+
+The training behavior is very similar for all activation functions but the shifted activation functions exhibit a slightly better generalization behavior. However, the significance of these results is limited as Lenet is a rather shallow network.
+
+We also created a network layer named ”ConvIndBias”, which is an identity mapping but it also adds an individually learned bias shift for each neuron. The results in Table 4 confirm that a ShELU activation is equivalent to the combination of a ConvIndBias layer and an ELU activation as was stated in section 3.
+
+# 4.2.2 EXPERIMENTS ON CIFAR-100 WITH CLEVERT-11
+
+To further evaluate the shifted activation functions in comparison with ELU, we built the 11-layer network used by Clevert et al. (2015) to replicate the experiments when ELU was introduced. We denote the network Clevert-11. Parameter settings and weight initializations were as in Clevert et al. (2015). Our results are the average over 9 runs for each activation function. Our classification results with the network Clevert-11 on the Cifar-100 dataset for the activation functions ELU, SvELU, ShELU, PELU and PShELU are presented in Figure 6 and summarized in Table 4. The results in the table are the average top1error over the last 20 epochs for each activation function. The results show that the test error for the ShELU activation function is significantly better than for ELU, whereas the error for SvELU is slightly inferior. The results suggest that a horizontal shift for the activation function is preferable to a vertical shift. The training behavior is almost identical for ELU and
+
+![](images/40c957922144a59f41ee058512fce98772f12a3f23dcad1324081c13d0fdb455.jpg)  
+Figure 6: Training (dashed) and test (solid) errors on Cifar-100 with network Clevert-11 (left). Test errors (final part) for ELU, SvELU and ShELU (middle), and ELU, PELU and PShELU (right).
+
+![](images/0f6b8bcf329be94f581746498dd57ad7c6a25d13c8cb97115a7239cb6f1b043f.jpg)  
+Figure 7: Learned shifts for ShELU activation function, relative frequency (left), kurtosis (middle) and spatial variation (right).
+
+ShELU. We believe that the improved test result can be attributed to that ShELU adaptively learns where to set the reference level between the linear and exponential parts of the activation function.
+
+ELU, PELU and PShELU all show very similar test errors. Note, however, that the training error is by far lower for PELU indicating pronounced overfitting compared to ELU. The training error is lower for PShELU than for ShELU but the test error is inferior. This suggests that PShELU suffers from overfitting when allowed to tune the hyperparameters $\alpha$ and $\beta$ . Note that we were able to almost exactly reproduce the results for ELU achieved in Clevert et al. (2015) who report a top1error of $2 8 . 7 5 \%$ .
+
+# 4.3 LEARNED SHIFTS FOR SHELU
+
+In all experments, we initialized the individual shifts for the ShELU activation from a Gaussian distribution with standard deviation 0.001. The learned shifts after training in the 10 activation layers of the Clevert-11 network are shown as normalized frequency histograms in Figure 7, together with the kurtosis and the spatial variation for the shifts.
+
+The shape of the learned shifts is almost a perfect Gaussian distribution for all layers. This is supported by the computed kurtosis which is close to 3.0. The kurtosis increases slightly for the last three layers where the distribution tends to be somewhat skewed towards the negative side. The standard deviation for the shift is relatively constant for the first nine layers but grows considerably for the last layer.
+
+Figure 7 shows the learned shifts for the first ShELU activation layer where the shifts for the 192 feature maps have been placed as $1 2 \times 1 6$ tiles side by side. Interestingly, the spatial variation for the learned shift seems to be completely random. Any statistical difference spatially over the image cannot be perceived.
+
+# 5 CONCLUSIONS
+
+We use a new formulation to tune a continuous piecewise linear activation function during training and learn the shape of the locally optimal activation function. With this tuned activation function, the classification performance for convolutional neural networks is improved and the resulting, learned activation function shows to be ELU-shaped irrespective whether it is initialized as a RELU, LReLU or ELU activation function. The learned activation function exhibits a variable shift around the origin for each neuron, indicating that a shifted ELU-shaped activation function is preferable. This observation leads us to introduce the Shifted Exponential Linear Unit (ShELU) as a new activation function.
+
+Experiments on Cifar-100 show that the classification performance is further improved when using the ShELU activation function in comparison with ELU. Normally in a convolutional network layer, one shared bias shift is learned for each feature map output. The improvement for the ShELU activation is achieved when learning an individual bias shift for each neuron. The equivalent to the ShELU activation function would be to learn an individual bias shift for each neuron in the convolutional layer output and then apply an ELU activation, which however is not supported by commonly used deep learning frameworks. The implementation of individual biases in the activation function is therefore preferable and leads to the ShELU activation function.
+
+# REFERENCES
+
+Forest Agostinelli, Matthew Hoffman, Peter Sadowski, and Pierre Baldi. Learning activation functions to improve deep neural networks. arXiv preprint arXiv:1412.6830, 2014.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.
+
+Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 215–223, 2011.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Michael Felsberg and Gosta Granlund. P-channels: Robust multivariate m-estimation of large ¨ datasets. In Pattern Recognition, 2006. ICPR 2006. 18th International Conference on, volume 3, pp. 262–267. IEEE, 2006.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 249–256, 2010.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep learning. MIT press, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 448–456, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings. mlr.press/v37/ioffe15.html.
+
+Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014.
+
+Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. arXiv preprint arXiv:1706.02515, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Yann Le Cun, Ido Kanter, and Sara A Solla. Eigenvalues of covariance matrices: Application to neural-network learning. Physical Review Letters, 66(18):2396, 1991.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In Proc. ICML, volume 30, 2013.
+
+MatConvNet. http://www.vlfeat.org/matconvnet/,v.beta-20.
+
+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.
+
+Ludovic Trottier, Philippe Giguere, and Brahim Chaib-draa. Parametric exponential linear unit for \` deep convolutional neural networks. arXiv preprint arXiv:1605.09332, 2016.
+
+# APPENDIX
+
+# DERIVATIVES OF SHELU AND SVELU
+
+For backpropagation, the derivates of ShELU and SvELU with respect to the input $x$ and the shift $\delta$ are computed as
+
+$$
+\begin{array} { r l } & { \frac { d \mathrm { S h E L U } } { d x } = \left\{ 1 , \mathrm { ~ i f ~ } x + \delta > 0 \right. } \\ & { \frac { d \mathrm { S h E L U } } { d \delta } = \left\{ 1 , \mathrm { ~ i f ~ } x + \delta > 0 \right. } \\ & { \frac { d \mathrm { S h E L U } } { d \delta } = \left\{ 1 , \mathrm { ~ i f ~ } x + \delta > 0 \right. } \\ & { \frac { d \mathrm { S v E L U } } { d x } = \left\{ 1 , \mathrm { ~ i f ~ } x > 0 \right. } \\ & { \frac { d \mathrm { S v E L U } } { d \delta } = \left\{ \alpha ( \exp ( x ) ) , \mathrm { i f ~ } x \leq 0 \right. } \\ & { \frac { d \mathrm { S v E L U } } { d \delta } = 1 } \end{array}
+$$
+
+# DERIVATIVES OF PSHELU
+
+For backpropagation, the derivates of PShELU with respect to the input $x$ , the hyperparameters $\alpha$ and $\beta$ , and the shift $\delta$ are computed as
+
+$$
+\begin{array} { r l } & { \frac { d \mathrm { P S h e L U } } { d x } = \left\{ \frac { \alpha } { \beta } , \ \mathrm { i f } \ x + \delta > 0 \right. } \\ & { \frac { d \mathrm { P S h e L U } } { d \alpha } = \left\{ \frac { \alpha + \delta } { \beta } , \ \mathrm { i f } \ x + \delta > 0 \right. } \\ & { \frac { d \mathrm { P S h e L U } } { d \alpha } = \left\{ \frac { \alpha + \delta } { \beta } , \ \mathrm { i f } \ x + \delta > 0 \right. } \\ & { \frac { d \mathrm { P S h e L U } } { d \beta } = \left\{ - \frac { \alpha } { \beta ^ { 2 } } ( x + \delta ) , \ \mathrm { i f } \ x + \delta > 0 \right. } \\ & { \frac { d \mathrm { P S h e L U } } { d \beta } = \left\{ - \frac { \alpha } { \beta ^ { 2 } } ( \exp ( \frac { \alpha + \delta } { \beta } ) ) , \ \mathrm { i f } \ x + \delta \leq 0 \right. } \\ & { \frac { d \mathrm { P S h e L U } } { d \delta } = \left\{ \frac { \alpha } { \beta } , \ \mathrm { i f } \ x + \delta > 0 \right. } \end{array}
+$$

parse/train/HkSZyinVG/HkSZyinVG_content_list.json

@@ -0,0 +1,1289 @@
+[
+    {
+        "type": "text",
+        "text": "IMPROVED LEARNING IN CONVOLUTIONAL NEURAL NETWORKS WITH SHIFTED EXPONENTIAL LINEAR UNITS (SHELUS) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            199,
+            398,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Exponential Linear Unit (ELU) has been proven to speed up learning and improve the classification performance over activation functions such as ReLU and Leaky ReLU for convolutional neural networks. The reasons behind the improved behavior are that ELU reduces the bias shift, it saturates for large negative inputs and it is continuously differentiable. However, it remains open whether ELU has the optimal shape and we address the quest for a superior activation function. ",
+        "bbox": [
+            233,
+            294,
+            764,
+            377
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We use a new formulation to tune a piecewise linear activation function during training, to investigate the above question, and learn the shape of the locally optimal activation function. With this tuned activation function, the classification performance is improved and the resulting, learned activation function shows to be ELU-shaped irrespective if it is initialized as a RELU, LReLU or ELU. Interestingly, the learned activation function does not exactly pass through the origin indicating that a shifted ELU-shaped activation function is preferable. This observation leads us to introduce the Shifted Exponential Linear Unit (ShELU) as a new activation function. ",
+        "bbox": [
+            233,
+            380,
+            764,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Experiments on Cifar-100 show that the classification performance is further improved when using the ShELU activation function in comparison with ELU. The improvement is achieved when learning an individual bias shift for each neuron. ",
+        "bbox": [
+            232,
+            506,
+            766,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The classification accuracy of Convolutional Neural Networks (CNNs) has improved remarkably over the last years. The reason for the improvement is manifold: more sophisticated layer designs (Lin et al., 2013; He et al., 2016), effective regularization techniques reducing overfitting such as dropout (Srivastava et al., 2014) and batch normalization (Ioffe & Szegedy, 2015), new nonlinear activation functions (Clevert et al., 2015; Trottier et al., 2016), improved weight initialization methods (Glorot & Bengio, 2010; He et al., 2016), data augmentation and large scale data as ImageNet (Deng et al., 2009). ",
+        "bbox": [
+            174,
+            603,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on the nonlinear activation function and its effect on the network learning behavior. Since the introduction of the Rectified Linear Unit (ReLU) (Glorot et al., 2011), it is generally accepted that the activation should be noncontractive to avoid the vanishing gradient problem. The vanishing gradient hampered the learning for the sigmoid and tanh activations. As ReLU is not symmetric, its mean response will be non-negative and will introduce a bias shift for the units in the next layer. The Leaky Rectified Linear Unit (LReLU) (Maas et al., 2013) was proposed to alleviate this bias shift. The LReLU introduces a small linear activation for negative inputs controlled by a constant hyperparameter $\\alpha$ . ",
+        "bbox": [
+            174,
+            708,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Centering the activation, i.e. reducing the bias shift, is claimed to speed up learning (Le Cun et al., 1991). When the Exponential Linear Unit (ELU) was introduced by Clevert et al. (2015), one of the reason for its success and fast learning capability was claimed to be that the activation saturates for large negative inputs. ELU is also controlled by a hyperparameter that determines the saturation level. Another activation that is saturated for negative inputs is the Shifted ReLU (SReLU). Its shape is similar to ReLU, but the ”kink” is at -1 instead of 0. This reduces the bias shift while being saturated for negative inputs. ELU learns both faster and better than SReLU (Clevert et al., ",
+        "bbox": [
+            174,
+            827,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/9067019052aac3bfdeffde0d579b575be30ef105781fb73dbad0d697fed9c681.jpg",
+        "table_caption": [
+            "Table 1: Activation functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Activation</td><td>x&gt;0</td><td>x≤0</td></tr><tr><td rowspan=\"3\">ReLU LReLU SReLU</td><td>X</td><td>0</td></tr><tr><td>X</td><td>αx</td></tr><tr><td>X</td><td>max(x,-1)</td></tr><tr><td rowspan=\"3\">ELU PELU</td><td>X</td><td>α(exp(x)-1)</td></tr><tr><td>X</td><td>α(exp(β x)-1)</td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            364,
+            125,
+            627,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2015), but it is not obvious which properties of ELU that actually create this improvement. It may be the smooth exponential decay for small negative inputs and/or the fact that it is continuously differentiable. The question also remains whether the shape of ELU is truly the optimal activation function or if there are other shapes, not yet found, that would further speed up and improve learning. And if they exist, how are they to be found. These were the type of issues that we wanted to explore when starting this work. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            320
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To improve the learning capabilities for the above mentioned activation functions, tuneable variants of them have been published where the control parameters are tuneable and learned instead of being set as a constant parameter according to their original publications. The Parametric ReLU (PReLU) was introduced by He et al. (2016) where the single control parameter $\\alpha$ for LReLU is now learned during training. The Parametric ELU (PELU) was introduced by Trottier et al. (2016), also tuning the control parameters for ELU. Classification results were shown to improve with parameter tuning in both papers. The Scaled ELU (SELU)1 was defined by Klambauer et al. (2017) and is essentially a more simple variant of PELU. The activation functions mentioned so far are defined in Table 1. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Piecewise linear activation functions have previously been used by Agostinelli et al. (2014) to improve the performance compared to LReLU. In this work, we use the same concept with tuneable piecewise linear activation functions, but now with the additional objective to investigate the shape of the learned activation function. We apply this approach for nonlinear regression of the optimal activation function. We initialized the activation as linearized versions of ReLU, LReLU and ELU, and they all resulted in the same shape after tuning the network. The ReLU and LReLU activation functions are tuned into an ELU-shaped function whereas the ELU activation function retains its shape. However, we also noted that the tuned ELU-shaped activation function does not exactly pass through the origin. There is a small shift introduced around the origin while retaining the overall shape of the activation function. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on this observation, we introduce a shifted variant of the ELU activation function. In our experiments, we found that a horizontal shift is favorable and we call this new activation function Shifted Exponential Linear Unit (ShELU). The shift is tuneable during training and the shift is individual for each neuron. Experiments show that the classification performance is improved when allowing this shift in the activation function. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contribution is the introduction of the shifted activation function ShELU. The second contribution is a new formulation of a tuneable piecewise linear activation function with constraints to make it continuous. This formulation can be used to explore for other, up to now unseen, shapes of activation functions. The third contribution is experimental support that an ELU-shaped activation function is favorable for learning; the tuneable piecewise linear activation function adapts to an ELU-shape during training, but with a small shift around the origin. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            752
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PIECEWISE LINEAR ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            580,
+            790
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Piecewise linear activation functions were first introduced by Agostinelli et al. (2014). In this work, we use the same idea but now with the additional objective to investigate the shape of the learned activation function. If we initialize the activation function as a linearized version of ReLU, LReLU or ELU, how will the shape be changed during training? ",
+        "bbox": [
+            174,
+            806,
+            825,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our formulation of a piecewise linear and continuous activation function is different from the one in Agostinelli et al. (2014) and consists of two steps: first a soft histogram is formed as in Felsberg & Granlund (2006), second, a weighted sum of the histogram outputs is computed. The piecewise linear activation functions are learned individually for each neuron. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            897
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 SOFT HISTOGRAM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            150,
+            339,
+            162
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As it has been shown by Felsberg & Granlund (2006), a soft histogram can be represented by two components; one offset component and one histogram component. We use $N$ bins for positive input values and another $N$ bins for negative input values. All bins in the histogram have constant and unity width. The bin limits take integer values and the bin centers are at -0.5, 0.5, 1.5 etc. The concept of the soft histogram is illustrated in Figure 1. In the figure, $N$ is equal to 4, but in the experiments we also used more bins like $N = 8$ and 16. Within a certain activation layer, we extract the maximum and the minimum input over a minibatch. We then linearly scale the positive input values to lie in the range $[ 0 \\mathrm { N } ]$ and the negative input values to lie in the range $[ - \\mathbf { N } \\mathbf { \\Lambda } 0 ]$ . Now, as an example, consider two units with scaled input values of 2.68 and -1.80, respectively. For the first unit, the histogram component will be 1 for the bin centered at 2.5 and 0 for all other bins. The corresponding offset component will be 0.18, i.e. the signed distance from the bin center. For the second unit, the histogram component will be 1 for the bin centered at -1.5 and 0 for all other bins. The corresponding offset component will be -0.30. The output from the soft histogram for the two units will be ",
+        "bbox": [
+            173,
+            175,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb973da921676d3f0f86dabc31221254fde398b5ab35e9a30d537ec0d7f024df.jpg",
+        "text": "$$\ny ( 2 . 6 8 ) = { \\left[ \\begin{array} { l l l l l l l l l } { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 . 1 8 } & { 0 } \\\\ { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 1 } & { 0 } \\end{array} \\right] }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            366,
+            647,
+            401
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/287112913184e20ffae879b80a69248b57b3ed9c01505951a3be3b4a23e428a1.jpg",
+        "text": "$$\ny ( - 1 . 8 0 ) = { \\left[ \\begin{array} { l l l l l l l l l } { 0 } & { 0 } & { - 0 . 3 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \\\\ { 0 } & { 0 } & { 1 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \\end{array} \\right] }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            405,
+            658,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An analytical formulation of the soft histogram can be given as ",
+        "bbox": [
+            178,
+            443,
+            593,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31cc3a789aa4e8e59a3966e1b8a0b2812c1b429c374957b5f399e46218a4f456.jpg",
+        "text": "$$\ny ( x ) = \\left[ { \\begin{array} { c } { \\left( x - { \\mathrm { \\mathrm { H o o r } } } ( x ) - 0 . 5 \\right) m _ { \\nu } ( x ) } \\\\ { m _ { \\nu } ( x ) } \\end{array} } \\right] _ { 2 \\times 2 \\mathrm { N } } = \\left[ { \\begin{array} { c c c c } { o _ { 0 } } & { o _ { 1 } } & { \\cdots } & { o _ { 2 \\mathrm { N } - 1 } } \\\\ { h _ { 0 } } & { h _ { 1 } } & { \\cdots } & { h _ { 2 \\mathrm { N } - 1 } } \\end{array} } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            464,
+            738,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $m _ { \\nu } ( x )$ denotes the membership of the respective bins. The membership is 1 if the unit belongs to that bin and 0 for all other bins. The soft histogram output can alternatively be expressed with the offset and histogram components as in the right hand side of (2). ",
+        "bbox": [
+            174,
+            507,
+            823,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For backpropagation we need to compute the derivative of the soft histogram. In our formulation, we consider the membership $m _ { \\nu } ( x )$ to be locally constant. This leads to a particular choice of subgradient that is also used in most implementations of max pooling, and it works well in practice. The derivative is computed as ",
+        "bbox": [
+            174,
+            556,
+            825,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7149975d3be5ac8d25b1b10a6507803a0384d449e406a171ccd0eaac9e688fb.jpg",
+        "text": "$$\n{ \\frac { d y } { d x } } = \\left[ { m _ { \\nu } ( x ) } \\right] _ { 2 \\times 2 \\mathrm { N } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            612,
+            570,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The output from the soft histogram is independent of the activation function, but any activation function can be represented or approximated by a weighted sum of the histogram output. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            680
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 WEIGHTED SUM",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            328,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Different piecewise linear activation functions can now be realized by varying the weights applied to the soft histogram outputs. For each activation layer, we define a matrix $W$ with weights for the ",
+        "bbox": [
+            174,
+            723,
+            826,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4055142f977a15d07dd09dea08b36b690b919c38f7be507119020b1ed4c35b8.jpg",
+        "image_caption": [
+            "Figure 1: Soft histogram decomposed into rectangular and linear basis functions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            772,
+            807,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a446b0986253b9062618410bd089025f2f6a63688bf2ed163531420c8cc5f01.jpg",
+        "image_caption": [
+            "Figure 2: Weighted sum examples, ReLU activation (left) and LReLU activation (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            88,
+            813,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "offset components and the histogram components ",
+        "bbox": [
+            171,
+            223,
+            501,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f263fcf05a3e245eca7480d53c2b7ea14003cc09864fad747db683bfc258ca13.jpg",
+        "text": "$$\nW = \\left[ { \\begin{array} { l l l l } { w _ { o _ { 0 } } } & { w _ { o _ { 1 } } } & { \\cdot \\cdot \\cdot } & { w _ { o _ { 2 \\mathrm { N } - 1 } } } \\\\ { w _ { h _ { 0 } } } & { w _ { h _ { 1 } } } & { \\cdot \\cdot \\cdot } & { w _ { h _ { 2 \\mathrm { N } - 1 } } } \\end{array} } \\right] \\quad .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            244,
+            622,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To obtain a ReLU activation function, we set all weights to 1 for the offset components on the positive side and 0 for all offset components on the negative side. The weights for the offset components correspond to the slope of the activation function for each linear piece. Further, for a ReLU, we set the weights for the histogram components to 0.5, 1.5, 2.5, etc. on the positive side and to 0 on the negative side. The weights for the histogram components correspond to the bias level at the bin centers of the activation function for each linear piece. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To obtain a LReLU activation function, the weights (slopes) for the negative offset components are set to the value for the hyperparameter $\\alpha$ , e.g. to 0.1. The weights for the offset components on the positive side are the same as for ReLU. For $\\alpha = 0 . 1$ , the weights for the histogram components on the negative side are set to -0.35, -0.25, -0.15 and -0.05, i.e. the bias level at the bin centers. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To summarize, the weight matrices for the ReLU and LReLU activation functions are defined as ",
+        "bbox": [
+            171,
+            436,
+            803,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/94d3b51913ea6f0544875ab12b5bb9dfee0a8c971bdc0a3d68bb4bead8d1e6f7.jpg",
+        "text": "$$\nW _ { \\mathrm { R e L U } } = \\left[ { \\begin{array} { c c c c c c c c } { 0 } & { 0 } & { 0 } & { 0 } & { 1 } & { 1 } & { 1 } & { 1 } \\\\ { 0 } & { 0 } & { 0 } & { 0 } & { 0 . 5 } & { 1 . 5 } & { 2 . 5 } & { 3 . 5 } \\end{array} } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            457,
+            660,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df8485bcfbcc0bce3efc07f341a19cf2b1c5ba0fd91b3ea82ee9ccab41b69d16.jpg",
+        "text": "$$\nW _ { \\mathrm { L R e L U } } = \\left[ \\begin{array} { c c c c c c c c } { { 0 . 1 } } & { { 0 . 1 } } & { { 0 . 1 } } & { { 0 . 1 } } & { { 1 } } & { { 1 } } & { { 1 } } & { { 1 } } \\\\ { { - 0 . 3 5 } } & { { - 0 . 2 5 } } & { { - 0 . 1 5 } } & { { - 0 . 0 5 } } & { { 0 . 5 } } & { { 1 . 5 } } & { { 2 . 5 } } & { { 3 . 5 } } \\end{array} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            497,
+            738,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The output for the weighted sum is the sum of an elementwise multiplication of the soft histogram with the weight matrix ",
+        "bbox": [
+            173,
+            535,
+            823,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/967f3ded16d7a5876915fd8cbbf5359621c16a2a35c1635e81266f0f66786023.jpg",
+        "text": "$$\ny = \\sum _ { \\nu } w _ { o _ { \\nu } } o _ { \\nu } + w _ { h _ { \\nu } } h _ { \\nu } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            560,
+            588,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The weighted sum output for the two example units is illustrated in Figure 2. For the ReLU activation, the outputs will be $2 . 5 \\times 1 + 1 \\times 0 . 1 8 = 2 . 6 8$ and $0 \\times 1 + 0 \\times ( - 0 . 3 0 ) = 0$ , respectively. For the LReLU activation, the output for the unit with input value -1.80 will be $- 0 . 1 5 \\times 1 + 0 . 1 \\times ( - 0 . 3 0 ) =$ -0.18, as desired. ",
+        "bbox": [
+            173,
+            594,
+            825,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our formulation will generate a piecewise linear activation function for any values chosen as weights for the offset and histogram components. However, it is obvious that constraints need to be put on the weights if a continuous activation function is to be obtained. The weights (slopes) for the offset components can be set independently but only one weight for the histogram component is independent from the other weights. Assume that $w _ { h _ { 0 } }$ is set as desired. To obtain a continuous linear function, the remaining histogram weights then need to be set as ",
+        "bbox": [
+            174,
+            657,
+            823,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ee6e8cc441563e6e2ea26379349aa23a0ee5887500d89144d04254c4106a85a.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { w _ { h _ { 1 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + w _ { o _ { 1 } } ) } } \\\\ { { w _ { h _ { 2 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + 2 w _ { o _ { 1 } } + w _ { o _ { 2 } } ) } } \\\\ { { \\vdots } } & { { } } & { { } } \\\\ { { w _ { h _ { 2 N - 1 } } } } & { { = } } & { { w _ { h _ { 0 } } + 0 . 5 ( w _ { o _ { 0 } } + 2 w _ { o _ { 1 } } + \\cdots + 2 w _ { o _ { 2 N - 2 } } + w _ { o _ { 2 N - 1 } } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            747,
+            727,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The constraints in (7) must be enforced when updating the weights in the backpropagation step. ",
+        "bbox": [
+            168,
+            829,
+            799,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 SHIFTED ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            488,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results presented in section 4.1 show that an ELU-shaped activation function which is shifted around the origin seems favorable to improve learning. Hence, we introduce the ShELU activation function with horizontal shift and the SvELU activation function with vertical shift and define them as in Table 2. The hyperparameter $\\alpha$ is considered to be a pre-set constant and it is not tuned during training. In our experiments, we set $\\alpha = 1$ . We also define PShELU, a variant of PELU with horizontal shift. The parameters $\\alpha$ and $\\beta$ for PShELU are learned during training. In the experiments, they were initialized as $\\alpha = \\beta = 1 . 0$ , i.e. as an original ELU activation. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d7f31327504eebfd1b0b413649def8bb16cc8bfb0241b5931e3e9e3fe10d7d80.jpg",
+        "table_caption": [
+            "Table 2: Shifted activation functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Value</td><td rowspan=1 colspan=1>Region 1</td><td rowspan=1 colspan=1>Value</td><td rowspan=1 colspan=1>Region 2</td></tr><tr><td rowspan=1 colspan=1>ShELUSvELUPShELU</td><td rowspan=1 colspan=1>x+8x+8（c+）</td><td rowspan=1 colspan=1>x+δ&gt;0x&gt;0x+δ&gt;0</td><td rowspan=1 colspan=1>α(exp(x+δ)-1)α(exp(𝑥)-1)+δa（exp(+）-1)</td><td rowspan=1 colspan=1>x+δ≤0x≤0x+δ≤0</td></tr></table>",
+        "bbox": [
+            251,
+            125,
+            743,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            213,
+            825,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the introduced shifts $\\delta$ in Table 2 are individual for all neurons. As an example, consider the first layers in the Lenet network (LeCun et al., 1998) shown in Figure 3. The input is an image $3 2 \\times 3 2 \\times 3$ . In the first convolutional layer, there are 192 filters with size $5 \\times 5 \\times 3$ . The output from the convolutional layer consists of 192 feature maps with size $3 2 \\times 3 2$ . The output includes a bias level for each feature map (each large square in the convolutional output), i.e. a total of 192 bias levels. The activation function is applied to the individual neurons resulting in an output with size $3 2 \\times 3 2 \\times 1 9 2$ . When we say that we introduce individual shifts for all neurons, it means that there is one tuneable shift for each of the $3 2 \\times 3 2 \\times 1 9 2$ neurons (all small squares in the activation output) where the activation function is applied. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Goodfellow et al. (2016), chapter 9.5, it is stated that for CNNs it is natural to have shared biases with the same tiling pattern as the convolutional kernels, but that individual biases for each neuron ”would allow the model to correct for differences in the image statistics at different locations”. By introducing the activation function ShELU, with individual shifts for each neuron, we have indirectly created individual biases for the convolutional layer feature map output. Note that a convolutional layer with a shared bias level for each feature map output followed by a ShELU activation is equivalent with a convolutional layer with individual bias levels for each feature map output followed by an ELU activation. This equivalence was verified with experiments presented in section 4.2.1. However, frameworks as Caffe (Jia et al., 2014) and MatConvNet do not allow for individual biases in a convolutional layer but is restricted to shared biases. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            326,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTS WITH PIECEWISE LINEAR ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            666,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To investigate the behavior of the piecewise linear activation function we made some experiments with the Lenet network and the Cifar-100 dataset (Krizhevsky & Hinton, 2009). We used the implementation of Lenet as provided when downloading the MatConvNet framework. We ran the Lenet network with the ReLU activation function, and also replaced all activation layers with LReLU and ",
+        "bbox": [
+            174,
+            643,
+            825,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/734540204bd74acae307f75f51cfcd193dab04a035c1cba472aea656ac1a1227.jpg",
+        "image_caption": [
+            "Figure 3: Bias levels for convolutional layers and shifts for activation function. Biases/shifts can either be shared (large squares) or individual for each neuron (small squares). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            726,
+            792,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/4f9b1a474667adfb8a5ada5f6dbe4fc3bfa6e6943016a4a33ddde6d8069df956.jpg",
+        "table_caption": [
+            "Table 3: Top1error on Cifar-100 with Lenet network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Activation</td><td>Toplerror (%)</td><td>Activation</td><td>Toplerror (%)</td><td>Activation</td><td>Toplerror (%)</td></tr><tr><td>ReLU</td><td>46.58</td><td>LReLU</td><td>45.41</td><td>ELU</td><td>44.96</td></tr><tr><td>Tuned ReLU</td><td>45.92</td><td>Tuned LReLU</td><td>45.18</td><td>Tuned ELU</td><td>44.51</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            830,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ELU. We then exchanged the activation layers with the piecewise linear activation layer. We initialized the layers as a linear version of ReLU, LReLU and ELU respectively. We consistently noticed a slight improvement (a few tenths of a percent) in classification performance when using the tuneable piecewise linear activation function compared to its corresponding fixed activation function, see Table 3. Besides the slight classification improvement, it is also interesting to analyse the shape of the activation functions after tuning, see Figure 4. All three activation functions remain linear and with almost unity slope on the positive side. All three tuned activation functions exhibit a smooth exponential decay for small negative inputs and then remain fairly constant for larger negative inputs. The resulting shape after tuning for all three initializations is close to the ELU shape. However, notice that all tuned activation functions tend to return a variable but negative output for zero input and that they do not pass through the origin. These results suggest that we introduce the Shifted Exponential Linear Unit (ShELU) as an activation function. From the results it is not obvious whether the introduced shift around the origin should be vertical or horizontal. For a horizontal shift, the saturation level remains constant for large negative inputs which may seem more intuitive. For a vertical shift, the saturation level will vary depending on the shift which better matches the achieved results on the Lenet network. ",
+        "bbox": [
+            173,
+            200,
+            825,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS WITH SHIFTED ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            443,
+            593,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 EXPERIMENTS ON CIFAR-100 WITH LENET NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            601,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now want to evaluate if the classification performance improves with the new activation functions ShELU and SvELU compared to ELU. We start with the Lenet network and replace all ELU activations with either the ShELU or the SvELU activation. The learning rate was set to 0.005 for the first 40 epochs, then lowered by a factor of 10 every 20 epochs, running a total of 80 epochs. The learning rate momentum was set to 0.9 and the weight decay to 0.0005. Image data was preprocessed with global contrast normalization and whitening (Coates et al., 2011). Note that the complete dataset was divided by a factor of 10 (compared to the preprocessing provided with the MatConvNet download) to better match the variance with Xavier initialization. During training the dataset was augmented with random horizontal flipping and by randomly cropping images from the original images zero padded with a frame of width four. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The classification errors for the training and test sets shown in Figure 5 are the average over 8 runs for each activation function. The top1errors in Table 4 are the average over the last 15 epochs for the lowest learning rate. The learning rate for the ShELU and SvELU activation layer weights was set to $2 \\%$ of the base learning rate. The results show that there is a small improvement on the top1error using the ShELU and SvELU activation functions compared with the original ELU. Futhermore, the shifted activation function PShELU achieves a slightly better test results than both ELU and PELU. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            724
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c6f8f84144cd4adfcb451d4df972e59f449870f9218c185c74ca1a34984fe5c.jpg",
+        "image_caption": [
+            "Figure 4: Initialization (red) and 20, 50 and 80 percentiles for tuned activation functions in last layer; ReLU (left), LReLU (middle) and ELU (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            750,
+            800,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e29872596ebdaae5e48641b096ad683df3bca8a952c9ce7e65594bdc5a32066d.jpg",
+        "image_caption": [
+            "Figure 5: Training (dashed) and test (solid) errors on Cifar-100 with network Lenet (left). Test errors (final part) for ELU, SvELU and ShELU (middle), and ELU, PELU and PShELU (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            99,
+            799,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/26923b26fef1b824843d90480e49e2def8053dc01cd651d8b60681eaa0fc7843.jpg",
+        "table_caption": [
+            "Table 4: Top1 test errors on Cifar-100 with Lenet and Clevert-11 networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Activation</td><td>Lenetnetwork</td><td>Clevert-11 network</td></tr><tr><td>ELU</td><td>44.96</td><td>28.76</td></tr><tr><td>SvELU</td><td>44.70</td><td>28.85</td></tr><tr><td>ShELU</td><td>44.77</td><td>28.57</td></tr><tr><td>PELU</td><td>45.03</td><td>28.78</td></tr><tr><td>PShELU</td><td>44.76</td><td>28.74</td></tr><tr><td>ConvIndBias+ELU</td><td>44.78</td><td>1</td></tr></table>",
+        "bbox": [
+            289,
+            313,
+            704,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The training behavior is very similar for all activation functions but the shifted activation functions exhibit a slightly better generalization behavior. However, the significance of these results is limited as Lenet is a rather shallow network. ",
+        "bbox": [
+            176,
+            439,
+            821,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also created a network layer named ”ConvIndBias”, which is an identity mapping but it also adds an individually learned bias shift for each neuron. The results in Table 4 confirm that a ShELU activation is equivalent to the combination of a ConvIndBias layer and an ELU activation as was stated in section 3. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 EXPERIMENTS ON CIFAR-100 WITH CLEVERT-11 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            566,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further evaluate the shifted activation functions in comparison with ELU, we built the 11-layer network used by Clevert et al. (2015) to replicate the experiments when ELU was introduced. We denote the network Clevert-11. Parameter settings and weight initializations were as in Clevert et al. (2015). Our results are the average over 9 runs for each activation function. Our classification results with the network Clevert-11 on the Cifar-100 dataset for the activation functions ELU, SvELU, ShELU, PELU and PShELU are presented in Figure 6 and summarized in Table 4. The results in the table are the average top1error over the last 20 epochs for each activation function. The results show that the test error for the ShELU activation function is significantly better than for ELU, whereas the error for SvELU is slightly inferior. The results suggest that a horizontal shift for the activation function is preferable to a vertical shift. The training behavior is almost identical for ELU and ",
+        "bbox": [
+            173,
+            585,
+            825,
+            726
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/40c957922144a59f41ee058512fce98772f12a3f23dcad1324081c13d0fdb455.jpg",
+        "image_caption": [
+            "Figure 6: Training (dashed) and test (solid) errors on Cifar-100 with network Clevert-11 (left). Test errors (final part) for ELU, SvELU and ShELU (middle), and ELU, PELU and PShELU (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            751,
+            799,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f6b8bcf329be94f581746498dd57ad7c6a25d13c8cb97115a7239cb6f1b043f.jpg",
+        "image_caption": [
+            "Figure 7: Learned shifts for ShELU activation function, relative frequency (left), kurtosis (middle) and spatial variation (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            101,
+            802,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ShELU. We believe that the improved test result can be attributed to that ShELU adaptively learns where to set the reference level between the linear and exponential parts of the activation function. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ELU, PELU and PShELU all show very similar test errors. Note, however, that the training error is by far lower for PELU indicating pronounced overfitting compared to ELU. The training error is lower for PShELU than for ShELU but the test error is inferior. This suggests that PShELU suffers from overfitting when allowed to tune the hyperparameters $\\alpha$ and $\\beta$ . Note that we were able to almost exactly reproduce the results for ELU achieved in Clevert et al. (2015) who report a top1error of $2 8 . 7 5 \\%$ . ",
+        "bbox": [
+            174,
+            309,
+            825,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 LEARNED SHIFTS FOR SHELU ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            412,
+            424,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In all experments, we initialized the individual shifts for the ShELU activation from a Gaussian distribution with standard deviation 0.001. The learned shifts after training in the 10 activation layers of the Clevert-11 network are shown as normalized frequency histograms in Figure 7, together with the kurtosis and the spatial variation for the shifts. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The shape of the learned shifts is almost a perfect Gaussian distribution for all layers. This is supported by the computed kurtosis which is close to 3.0. The kurtosis increases slightly for the last three layers where the distribution tends to be somewhat skewed towards the negative side. The standard deviation for the shift is relatively constant for the first nine layers but grows considerably for the last layer. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows the learned shifts for the first ShELU activation layer where the shifts for the 192 feature maps have been placed as $1 2 \\times 1 6$ tiles side by side. Interestingly, the spatial variation for the learned shift seems to be completely random. Any statistical difference spatially over the image cannot be perceived. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            328,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use a new formulation to tune a continuous piecewise linear activation function during training and learn the shape of the locally optimal activation function. With this tuned activation function, the classification performance for convolutional neural networks is improved and the resulting, learned activation function shows to be ELU-shaped irrespective whether it is initialized as a RELU, LReLU or ELU activation function. The learned activation function exhibits a variable shift around the origin for each neuron, indicating that a shifted ELU-shaped activation function is preferable. This observation leads us to introduce the Shifted Exponential Linear Unit (ShELU) as a new activation function. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experiments on Cifar-100 show that the classification performance is further improved when using the ShELU activation function in comparison with ELU. Normally in a convolutional network layer, one shared bias shift is learned for each feature map output. The improvement for the ShELU activation is achieved when learning an individual bias shift for each neuron. The equivalent to the ShELU activation function would be to learn an individual bias shift for each neuron in the convolutional layer output and then apply an ELU activation, which however is not supported by commonly used deep learning frameworks. The implementation of individual biases in the activation function is therefore preferable and leads to the ShELU activation function. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Forest Agostinelli, Matthew Hoffman, Peter Sadowski, and Pierre Baldi. Learning activation functions to improve deep neural networks. arXiv preprint arXiv:1412.6830, 2014. ",
+        "bbox": [
+            174,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015. ",
+        "bbox": [
+            171,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 215–223, 2011. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            169,
+            251,
+            825,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Felsberg and Gosta Granlund. P-channels: Robust multivariate m-estimation of large ¨ datasets. In Pattern Recognition, 2006. ICPR 2006. 18th International Conference on, volume 3, pp. 262–267. IEEE, 2006. ",
+        "bbox": [
+            173,
+            289,
+            823,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 249–256, 2010. ",
+        "bbox": [
+            174,
+            339,
+            823,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep learning. MIT press, 2016. ",
+        "bbox": [
+            171,
+            441,
+            754,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 448–456, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings. mlr.press/v37/ioffe15.html. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. arXiv preprint arXiv:1706.02515, 2017. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            684,
+            821,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann Le Cun, Ido Kanter, and Sara A Solla. Eigenvalues of covariance matrices: Application to neural-network learning. Physical Review Letters, 66(18):2396, 1991. ",
+        "bbox": [
+            176,
+            708,
+            823,
+            737
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            744,
+            823,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013. ",
+        "bbox": [
+            174,
+            782,
+            821,
+            811
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In Proc. ICML, volume 30, 2013. ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MatConvNet. http://www.vlfeat.org/matconvnet/,v.beta-20. ",
+        "bbox": [
+            173,
+            858,
+            696,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "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": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ludovic Trottier, Philippe Giguere, and Brahim Chaib-draa. Parametric exponential linear unit for \\` deep convolutional neural networks. arXiv preprint arXiv:1605.09332, 2016. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            159,
+            264,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "DERIVATIVES OF SHELU AND SVELU ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            189,
+            444,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For backpropagation, the derivates of ShELU and SvELU with respect to the input $x$ and the shift $\\delta$ are computed as ",
+        "bbox": [
+            173,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/959834cbc674d10c8a5d22d8290d74019130fdc968f7f39b2bb291e9a7973374.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\frac { d \\mathrm { S h E L U } } { d x } = \\left\\{ 1 , \\mathrm { ~ i f ~ } x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { S h E L U } } { d \\delta } = \\left\\{ 1 , \\mathrm { ~ i f ~ } x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { S h E L U } } { d \\delta } = \\left\\{ 1 , \\mathrm { ~ i f ~ } x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { S v E L U } } { d x } = \\left\\{ 1 , \\mathrm { ~ i f ~ } x > 0 \\right. } \\\\ & { \\frac { d \\mathrm { S v E L U } } { d \\delta } = \\left\\{ \\alpha ( \\exp ( x ) ) , \\mathrm { i f ~ } x \\leq 0 \\right. } \\\\ & { \\frac { d \\mathrm { S v E L U } } { d \\delta } = 1 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            252,
+            638,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "DERIVATIVES OF PSHELU ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            361,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For backpropagation, the derivates of PShELU with respect to the input $x$ , the hyperparameters $\\alpha$ and $\\beta$ , and the shift $\\delta$ are computed as ",
+        "bbox": [
+            173,
+            436,
+            821,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9db2b47c4cd181edffa4a7a654fca6a5c96d99f21acfaf96eed4f22d1006a74a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\frac { d \\mathrm { P S h e L U } } { d x } = \\left\\{ \\frac { \\alpha } { \\beta } , \\ \\mathrm { i f } \\ x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { P S h e L U } } { d \\alpha } = \\left\\{ \\frac { \\alpha + \\delta } { \\beta } , \\ \\mathrm { i f } \\ x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { P S h e L U } } { d \\alpha } = \\left\\{ \\frac { \\alpha + \\delta } { \\beta } , \\ \\mathrm { i f } \\ x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { P S h e L U } } { d \\beta } = \\left\\{ - \\frac { \\alpha } { \\beta ^ { 2 } } ( x + \\delta ) , \\ \\mathrm { i f } \\ x + \\delta > 0 \\right. } \\\\ & { \\frac { d \\mathrm { P S h e L U } } { d \\beta } = \\left\\{ - \\frac { \\alpha } { \\beta ^ { 2 } } ( \\exp ( \\frac { \\alpha + \\delta } { \\beta } ) ) , \\ \\mathrm { i f } \\ x + \\delta \\leq 0 \\right. } \\\\ & { \\frac { d \\mathrm { P S h e L U } } { d \\delta } = \\left\\{ \\frac { \\alpha } { \\beta } , \\ \\mathrm { i f } \\ x + \\delta > 0 \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            470,
+            650,
+            643
+        ],
+        "page_idx": 9
+    }
+]

parse/train/SJiHXGWAZ/SJiHXGWAZ.md

@@ -0,0 +1,373 @@
+# DIFFUSION CONVOLUTIONAL RECURRENT NEURAL NETWORK: DATA-DRIVEN TRAFFIC FORECASTING
+
+Yaguang $\mathbf { L i } ^ { \dagger }$ , Rose $\mathbf { V } \mathbf { u } ^ { \ddag }$ , Cyrus Shahabi†, Yan Liu† † University of Southern California, ‡ California Institute of Technology † {yaguang, shahabi, yanliu.cs}@usc.edu, ‡ rose@caltech.edu
+
+# ABSTRACT
+
+Spatiotemporal forecasting has various applications in neuroscience, climate and transportation domain. Traffic forecasting is one canonical example of such learning task. The task is challenging due to (1) complex spatial dependency on road networks, (2) non-linear temporal dynamics with changing road conditions and (3) inherent difficulty of long-term forecasting. To address these challenges, we propose to model the traffic flow as a diffusion process on a directed graph and introduce Diffusion Convolutional Recurrent Neural Network (DCRNN), a deep learning framework for traffic forecasting that incorporates both spatial and temporal dependency in the traffic flow. Specifically, DCRNN captures the spatial dependency using bidirectional random walks on the graph, and the temporal dependency using the encoder-decoder architecture with scheduled sampling. We evaluate the framework on two real-world large scale road network traffic datasets and observe consistent improvement of $1 2 \% - 1 5 \%$ over state-of-the-art baselines.
+
+# 1 INTRODUCTION
+
+Spatiotemporal forecasting is a crucial task for a learning system that operates in a dynamic environment. It has a wide range of applications from autonomous vehicles operations, to energy and smart grid optimization, to logistics and supply chain management. In this paper, we study one important task: traffic forecasting on road networks, the core component of the intelligent transportation systems. The goal of traffic forecasting is to predict the future traffic speeds of a sensor network given historic traffic speeds and the underlying road networks.
+
+This task is challenging mainly due to the complex spatiotemporal dependencies and inherent difficulty in the long term forecasting. On the one hand, traffic time series demonstrate strong temporal dynamics. Recurring incidents such as rush hours or accidents can cause nonstationarity, making it difficult to forecast longterm. On the other hand, sensors on the road network contain complex yet unique spatial correlations. Figure 1 illustrates an example. Road 1 and road 2 are correlated, while road 1 and road 3 are not. Although road 1 and road 3 are close in the Euclidean space, they demonstrate very different behaviors. Moreover, the future traffic speed is influenced more by the downstream traffic than the upstream one. This means that the spatial structure in traffic is nonEuclidean and directional.
+
+![](images/a52a2d9f91fcd760118256e52884cd0555ef88f1d13abd6b36decb7b19560b73.jpg)  
+Figure 1: Spatial correlation is dominated by road network structure. (1) Traffic speed in road 1 are similar to road 2 as they locate in the same highway. (2) Road 1 and road 3 locate in the opposite directions of the highway. Though close to each other in the Euclidean space, their road network distance is large, and their traffic speeds differ significantly.
+
+Traffic forecasting has been studied for decades, falling into two main categories: knowledge
+
+driven approach and data-driven approach. In transportation and operational research, knowledgedriven methods usually apply queuing theory and simulate user behaviors in traffic (Cascetta, 2013). In time series community, data-driven methods such as Auto-Regressive Integrated Moving Average (ARIMA) model and Kalman filtering remain popular (Liu et al., 2011; Lippi et al., 2013). However, simple time series models usually rely on the stationarity assumption, which is often violated by the traffic data. Most recently, deep learning models for traffic forecasting have been developed in Lv et al. (2015); Yu et al. (2017b), but without considering the spatial structure. Wu & Tan (2016) and Ma et al. (2017) model the spatial correlation with Convolutional Neural Networks (CNN), but the spatial structure is in the Euclidean space (e.g., 2D images). Bruna et al. (2014), Defferrard et al. (2016) studied graph convolution, but only for undirected graphs.
+
+In this work, we represent the pair-wise spatial correlations between traffic sensors using a directed graph whose nodes are sensors and edge weights denote proximity between the sensor pairs measured by the road network distance. We model the dynamics of the traffic flow as a diffusion process and propose the diffusion convolution operation to capture the spatial dependency. We further propose Diffusion Convolutional Recurrent Neural Network (DCRNN) that integrates diffusion convolution, the sequence to sequence architecture and the scheduled sampling technique. When evaluated on realworld traffic datasets, DCRNN consistently outperforms state-of-the-art traffic forecasting baselines by a large margin. In summary:
+
+• We study the traffic forecasting problem and model the spatial dependency of traffic as a diffusion process on a directed graph. We propose diffusion convolution, which has an intuitive interpretation and can be computed efficiently.   
+We propose Diffusion Convolutional Recurrent Neural Network (DCRNN), a holistic approach that captures both spatial and temporal dependencies among time series using diffusion convolution and the sequence to sequence learning framework together with scheduled sampling. DCRNN is not limited to transportation and is readily applicable to other spatiotemporal forecasting tasks.   
+We conducted extensive experiments on two large-scale real-world datasets, and the proposed approach obtains significant improvement over state-of-the-art baseline methods.
+
+# 2 METHODOLOGY
+
+We formalize the learning problem of spatiotemporal traffic forecasting and describe how to model the dependency structures using diffusion convolutional recurrent neural network.
+
+# 2.1 TRAFFIC FORECASTING PROBLEM
+
+The goal of traffic forecasting is to predict the future traffic speed given previously observed traffic flow from $N$ correlated sensors on the road network. We can represent the sensor network as a weighted directed graph $\mathcal { G } = ( \nu , \mathcal { E } , W )$ , where $\nu$ is a set of nodes $| \nu | = N$ , $\mathcal { E }$ is a set of edges and $\pmb { W } \in \mathbb { R } ^ { N \times N }$ is a weighted adjacency matrix representing the nodes proximity (e.g., a function of their road network distance). Denote the traffic flow observed on $\mathcal { G }$ as a graph signal $\pmb { X } \in \mathbb { R } ^ { N \times P }$ , where $P$ is the number of features of each node (e.g., velocity, volume). Let $\bar { X } ^ { ( t ) }$ represent the graph signal observed at time $t$ , the traffic forecasting problem aims to learn a function $h ( \cdot )$ that maps $T ^ { \prime }$ historical graph signals to future $T$ graph signals, given a graph $\mathcal { G }$ :
+
+$$
+[ \pmb { X } ^ { ( t - T ^ { \prime } + 1 ) } , \allowbreak \cdot \cdot \ , \pmb { X } ^ { ( t ) } ; \mathcal { G } ] \xrightarrow { h ( \cdot ) } [ \pmb { X } ^ { ( t + 1 ) } , \allowbreak \cdot \cdot \ , \pmb { X } ^ { ( t + T ) } ]
+$$
+
+# 2.2 SPATIAL DEPENDENCY MODELING
+
+We model the spatial dependency by relating traffic flow to a diffusion process, which explicitly captures the stochastic nature of traffic dynamics. This diffusion process is characterized by a random walk on $\mathcal { G }$ with restart probability $\alpha \in [ 0 , 1 ]$ , and a state transition matrix $D _ { O } ^ { - 1 } W$ . Here $D _ { O } = \mathrm { d i a g } ( W 1 )$ is the out-degree diagonal matrix, and $\mathbf { 1 } \in \mathbb { R } ^ { N }$ denotes the all one vector. After many time steps, such Markov process converges to a stationary distribution $\pmb { \mathcal { P } } \in \mathbb { R } ^ { N \times N }$ whose $i$ th row $\mathbf { \bar { \mathcal { P } } } _ { i , : } \in \mathbb { R } ^ { \bar { N } }$ represents the likelihood of diffusion from node $v _ { i } \in \mathcal V$ , hence the proximity w.r.t. the node $v _ { i }$ . The following Lemma provides a closed form solution for the stationary distribution.
+
+Lemma 2.1. (Teng et al., 2016) The stationary distribution of the diffusion process can be represented as a weighted combination of infinite random walks on the graph, and be calculated in closed form:
+
+$$
+\mathcal { P } = \sum _ { k = 0 } ^ { \infty } \alpha ( 1 - \alpha ) ^ { k } \left( D _ { \mathcal { O } } ^ { - 1 } W \right) ^ { k }
+$$
+
+where $k$ is the diffusion step. In practice, we use a finite $K$ -step truncation of the diffusion process and assign a trainable weight to each step. We also include the reversed direction diffusion process,
+
+such that the bidirectional diffusion offers the model more flexibility to capture the influence from both the upstream and the downstream traffic.
+
+Diffusion Convolution The resulted diffusion convolution operation over a graph signal $\boldsymbol { x } \in$ $\mathbb { R } ^ { N \times P }$ and a filter $f _ { \theta }$ is defined as:
+
+$$
+\displaystyle { X _ { : , p } \star _ { \mathcal { G } } } \ f _ { \theta } = \sum _ { k = 0 } ^ { K - 1 } \left( \theta _ { k , 1 } \left( D _ { O } ^ { - 1 } W \right) ^ { k } + \theta _ { k , 2 } \left( D _ { I } ^ { - 1 } W ^ { \top } \right) ^ { k } \right) X _ { : , p } \quad \mathrm { f o r } p \in \{ 1 , \cdots , P \}
+$$
+
+where $\pmb \theta \in \mathbb R ^ { K \times 2 }$ are the parameters for the filter and $D _ { O } ^ { - 1 } W , D _ { I } ^ { - 1 } W ^ { \intercal }$ represent the transition matrices of the diffusion process and the reverse one, respectively. In general, computing the convolution can be expensive. However, if $\mathcal { G }$ is sparse, Equation 2 can be calculated efficiently using $O ( K )$ recursive sparse-dense matrix multiplication with total time complexity $O ( K | \mathcal { E } | ) \ll \dot { O } ( N ^ { 2 } )$ . See Appendix $\mathbf { B }$ for more detail.
+
+Diffusion Convolutional Layer With the convolution operation defined in Equation 2, we can build a diffusion convolutional layer that maps $P$ -dimensional features to $Q$ -dimensional outputs. Denote the parameter tensor as $\dot { \pmb { \Theta } } \in \mathbb { R } ^ { Q \times P \times \dot { \bf K } \times 2 } = [ \pmb { \theta } ] _ { q , p }$ , where $\Theta _ { q , p , : , : } \doteq \mathbb { R } ^ { K \times 2 }$ parameterizes the convolutional filter for the pth input and the qth output. The diffusion convolutional layer is thus:
+
+$$
+H _ { : , q } = a \left( \sum _ { p = 1 } ^ { P } X _ { : , p } \star _ { \mathcal { G } } f _ { \Theta _ { q , p ; : } } \right) \qquad { \mathrm { f o r ~ } } q \in \{ 1 , \cdots , Q \}
+$$
+
+where $\pmb { X } \in \mathbb { R } ^ { N \times P }$ is the input, $H \in \mathbb { R } ^ { N \times Q }$ is the output, $\{ f _ { \Theta _ { q , p , , : } } \}$ are the filters and $\textbf { \em a }$ is the activation function (e.g., ReLU, Sigmoid). Diffusion convolutional layer learns the representations for graph structured data and we can train it using stochastic gradient based method.
+
+Relation with Spectral Graph Convolution Diffusion convolution is defined on both directed and undirected graphs. When applied to undirected graphs, we show that many existing graph structured convolutional operations including the popular spectral graph convolution, i.e., ChebNet (Defferrard et al., 2016), can be considered as a special case of diffusion convolution (up to a similarity transformation). Let $_ D$ denote the degree matrix, and $L = D ^ { - { \frac { 1 } { 2 } } } ( D - W ) D ^ { - { \frac { 1 } { 2 } } }$ be the normalized graph Laplacian, the following Proposition demonstrates the connection.
+
+Proposition 2.2. The spectral graph convolution defined as
+
+$$
+X _ { : , p } \star _ { \mathcal { G } } f _ { \theta } = \Phi \ F ( \pmb \theta ) \ \Phi ^ { \intercal } X _ { : , p }
+$$
+
+with eigenvalue decomposition diffusion convolution up to a sim ${ \pmb { L } } = \pmb { \Phi } \pmb { \Lambda } \pmb { \Phi } ^ { \intercal }$ and rmat $\begin{array} { r } { F ( \pmb \theta ) = \sum _ { 0 } ^ { K - 1 } \theta _ { k } \pmb \Lambda ^ { k } } \end{array}$ , is equivalent to graphs undirected. $\mathcal { G }$
+
+Proof. See Appendix C.
+
+2.3 TEMPORAL DYNAMICS MODELING
+
+We leverage the recurrent neural networks (RNNs) to model the temporal dependency. In particular, we use Gated Recurrent Units (GRU) (Chung et al., 2014), which is a simple yet powerful variant of RNNs. We replace the matrix multiplications in GRU with the diffusion convolution, which leads to our proposed $D$ iffusion Convolutional Gated Recurrent Unit (DCGRU).
+
+$$
+\begin{array} { r l r l } & { r ^ { ( t ) } = } & { \sigma ( \Theta _ { r } \star _ { \mathcal { G } } \big [ X ^ { ( t ) } , ~ H ^ { ( t - 1 ) } \big ] + b _ { r } ) } & { u ^ { ( t ) } = \sigma \big ( \Theta _ { u } \star _ { \mathcal { G } } \big [ X ^ { ( t ) } , ~ H ^ { ( t - 1 ) } \big ] + b _ { u } \big ) } \\ & { \varsigma ^ { ( t ) } = } & { \mathrm { t a n h } \big ( \Theta _ { C } \star _ { \mathcal { G } } \big [ X ^ { ( t ) } , ~ ( r ^ { ( t ) } \odot H ^ { ( t - 1 ) } ) \big ] + b _ { c } \big ) } & { H ^ { ( t ) } = u ^ { ( t ) } \odot H ^ { ( t - 1 ) } + \big ( 1 - u ^ { ( t ) } \big ) \odot C ^ { ( t ) } } \end{array}
+$$
+
+where $\mathbf { \boldsymbol { X } } ^ { ( t ) } , \mathbf { \boldsymbol { H } } ^ { ( t ) }$ denote the input and output of at time $t$ $\mathbf { \boldsymbol { r } } ^ { ( t ) } , \mathbf { \boldsymbol { u } } ^ { ( t ) }$ are reset gate and update gate at time $t$ , respectively. $\star _ { \mathcal { G } }$ denotes the diffusion convolution defined in Equation 2 and $\Theta _ { r } , \Theta _ { u } , \Theta _ { C }$ are parameters for the corresponding filters. Similar to GRU, DCGRU can be used to build recurrent neural network layers and be trained using backpropagation through time.
+
+In multiple step ahead forecasting, we employ the Sequence to Sequence architecture (Sutskever et al., 2014). Both the encoder and the decoder are recurrent neural networks with DCGRU. During training, we feed the historical time series into the encoder and use its final states to initialize the decoder. The decoder generates predictions given previous ground truth observations. At testing time, ground truth observations are replaced by predictions generated by the model itself. The discrepancy between the input distributions of training and testing can cause degraded performance. To mitigate this issue, we integrate scheduled sampling (Bengio et al., 2015) into the model, where we feed the model with either the ground truth observation with probability $\epsilon _ { i }$ or the prediction by the model with probability $1 - \epsilon _ { i }$ at the ith iteration. During the training process, $\epsilon _ { i }$ gradually decreases to 0 to allow the model to learn the testing distribution.
+
+![](images/eb10031718635a4605b29be131deb2827920cbffeb6514644c957a88e17991b3.jpg)  
+Figure 2: System architecture for the Diffusion Convolutional Recurrent Neural Network designed for spatiotemporal traffic forecasting. The historical time series are fed into an encoder whose final states are used to initialize the decoder. The decoder makes predictions based on either previous ground truth or the model output.
+
+With both spatial and temporal modeling, we build a Diffusion Convolutional Recurrent Neural Network (DCRNN). The model architecture of DCRNN is shown in Figure 2. The entire network is trained by maximizing the likelihood of generating the target future time series using backpropagation through time. DCRNN is able to capture spatiotemporal dependencies among time series and can be applied to various spatiotemporal forecasting problems.
+
+# 3 RELATED WORK
+
+Traffic forecasting is a classic problem in transportation and operational research which are primarily based on queuing theory and simulations (Drew, 1968). Data-driven approaches for traffic forecasting have received considerable attention, and more details can be found in a recent survey paper (Vlahogianni et al., 2014) and the references therein. However, existing machine learning models either impose strong stationary assumptions on the data (e.g., auto-regressive model) or fail to account for highly non-linear temporal dependency (e.g., latent space model Yu et al. (2016); Deng et al. (2016)). Deep learning models deliver new promise for time series forecasting problem. For example, in Yu et al. (2017b); Laptev et al. (2017), the authors study time series forecasting using deep Recurrent Neural Networks (RNN). Convolutional Neural Networks (CNN) have also been applied to traffic forecasting. Zhang et al. (2016; 2017) convert the road network to a regular 2-D grid and apply traditional CNN to predict crowd flow. Cheng et al. (2017) propose DeepTransport which models the spatial dependency by explicitly collecting upstream and downstream neighborhood roads for each individual road and then conduct convolution on these neighborhoods respectively.
+
+Recently, CNN has been generalized to arbitrary graphs based on the spectral graph theory. Graph convolutional neural networks (GCN) are first introduced in Bruna et al. (2014), which bridges the spectral graph theory and deep neural networks. Defferrard et al. (2016) propose ChebNet which improves GCN with fast localized convolutions filters. Kipf & Welling (2017) simplify ChebNet and achieve state-of-the-art performance in semi-supervised classification tasks. Seo et al. (2016) combine ChebNet with Recurrent Neural Networks (RNN) for structured sequence modeling. Yu et al. (2017a) model the sensor network as a undirected graph and applied ChebNet and convolutional sequence model (Gehring et al., 2017) to do forecasting. One limitation of the mentioned spectral based convolutions is that they generally require the graph to be undirected to calculate meaningful spectral decomposition. Going from spectral domain to vertex domain, Atwood & Towsley (2016) propose diffusion-convolutional neural network (DCNN) which defines convolution as a diffusion process across each node in a graph-structured input. Hechtlinger et al. (2017) propose GraphCNN to generalize convolution to graph by convolving every node with its $p$ nearest neighbors. However, both these methods do not consider the temporal dynamics and mainly deal with static graph settings.
+
+Table 1: Performance comparison of different approaches for traffic speed forecasting. DCRNN achieves the best performance with all three metrics for all forecasting horizons, and the advantage becomes more evident with the increase of the forecasting horizon.   
+
+<table><tr><td></td><td>T</td><td>Metric</td><td>HA</td><td>ARIMAKal</td><td>VAR</td><td>SVR</td><td>FNN</td><td>FC-LSTM</td><td>DCRNN</td></tr><tr><td rowspan="4">PATIIA</td><td>15 min</td><td>MAE RMSE</td><td>4.16 7.80</td><td>3.99 8.21</td><td>4.42 7.89</td><td>3.99 8.45</td><td>3.99 7.94</td><td>3.44 6.30</td><td>2.77 5.38</td></tr><tr><td></td><td>MAPE MAE</td><td>13.0% 4.16</td><td>9.6% 5.15</td><td>10.2% 5.41</td><td>9.3% 5.05</td><td>9.9% 4.23</td><td>9.6% 3.77</td><td>7.3% 3.15</td></tr><tr><td>30 min</td><td>RMSE MAPE MAE</td><td>7.80 13.0% 4.16</td><td>10.45 12.7% 6.90</td><td>9.13 12.7% 6.52</td><td>10.87 12.1% 6.72</td><td>8.17 12.9% 4.49</td><td>7.23 10.9% 4.37</td><td>6.45 8.8% 3.60</td></tr><tr><td>1 hour</td><td>RMSE MAPE</td><td>7.80 13.0%</td><td>13.23 17.4%</td><td>10.11 15.8%</td><td>13.76 16.7%</td><td>8.69 14.0%</td><td>8.69 13.2%</td><td>7.59 10.5%</td></tr><tr><td rowspan="4">PPP-PPAA</td><td>15 min</td><td>MAE RMSE MAPE</td><td>2.88 5.59 6.8%</td><td>1.62 3.30 3.5%</td><td>1.74 3.16 3.6%</td><td>1.85 3.59 3.8%</td><td>2.20 4.42 5.19%</td><td>2.05 4.19</td><td>1.38 2.95</td></tr><tr><td>30 min</td><td>MAE RMSE MAPE</td><td>2.88 5.59 6.8%</td><td>2.33 4.76</td><td>2.32 4.25</td><td>2.48 5.18</td><td>2.30 4.63</td><td>4.8% 2.20 4.55</td><td>2.9% 1.74 3.97</td></tr><tr><td>1 hour</td><td>MAE RMSE</td><td>2.88 5.59</td><td>5.4% 3.38 6.50</td><td>5.0% 2.93 5.44</td><td>5.5% 3.28 7.08</td><td>5.43% 2.46</td><td>5.2% 2.37</td><td>3.9% 2.07</td></tr><tr><td></td><td>MAPE</td><td>6.8%</td><td>8.3%</td><td>6.5%</td><td>8.0%</td><td>4.98 5.89%</td><td>4.96 5.7%</td><td>4.74 4.9%</td></tr></table>
+
+Our approach is different from all those methods due to both the problem settings and the formulation of the convolution on the graph. We model the sensor network as a weighted directed graph which is more realistic than grid or undirected graph. Besides, the proposed convolution is defined using bidirectional graph random walk and is further integrated with the sequence to sequence learning framework as well as the scheduled sampling to model the long-term temporal dependency.
+
+# 4 EXPERIMENTS
+
+We conduct experiments on two real-world large-scale datasets: (1) METR-LA This traffic dataset contains traffic information collected from loop detectors in the highway of Los Angeles County (Jagadish et al., 2014). We select 207 sensors and collect 4 months of data ranging from Mar 1st 2012 to Jun 30th 2012 for the experiment. (2) PEMS-BAY This traffic dataset is collected by California Transportation Agencies (CalTrans) Performance Measurement System (PeMS). We select 325 sensors in the Bay Area and collect 6 months of data ranging from Jan 1st 2017 to May 31th 2017 for the experiment. The sensor distributions of both datasets are visualized in Figure 8 in the Appendix.
+
+In both of those datasets, we aggregate traffic speed readings into 5 minutes windows, and apply Z-Score normalization. $70 \%$ of data is used for training, $20 \%$ are used for testing while the remaining $10 \%$ for validation. To construct the sensor graph, we compute the pairwise road network distances between sensors and build the adjacency matrix using thresholded Gaussian kernel (Shuman et al., 2013). $\begin{array} { r } { W _ { i j } = \exp \left( { - \frac { \mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \sigma ^ { 2 } } } \right) } \end{array}$ if $\mathrm { d i s t } ( v _ { i } , v _ { j } ) \le \kappa$ , otherwise 0, where $W _ { i j }$ represents the edge weight between sensor $v _ { i }$ and sensor $v _ { j }$ , $\mathrm { d i s t } ( v _ { i } , v _ { j } )$ denotes the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ . $\sigma$ is the standard deviation of distances and $\kappa$ is the threshold.
+
+# 4.1 EXPERIMENTAL SETTINGS
+
+Baselines We compare DCRNN1 with widely used time series regression models, including (1) HA: Historical Average, which models the traffic flow as a seasonal process, and uses weighted average of previous seasons as the prediction; (2) $\mathbf { A R I M A } _ { k a l }$ : Auto-Regressive Integrated Moving Average model with Kalman filter which is widely used in time series prediction; (3) VAR: Vector Auto-Regression (Hamilton, 1994). (4) SVR: Support Vector Regression which uses linear support vector machine for the regression task; The following deep neural network based approaches are also included: (5) Feed forward Neural network (FNN): Feed forward neural network with two hidden layers and L2 regularization. (6) Recurrent Neural Network with fully connected LSTM hidden units (FC-LSTM) (Sutskever et al., 2014).
+
+![](images/9c9781eeaafb772cc2e0c3e6403d04ad2122425790950273f62aeca104ebbc22.jpg)  
+Figure 3: Learning curve for DCRNN and DCRNN without diffusion convolution. Removing diffusion convolution results in much higher validation error. Moreover, DCRNN with bidirectional random walk achieves the lowest validation error.
+
+![](images/f13335bea7036c2e54e7045e8a2a27506d7cd7cdc37e77bb6c60c3ccbc6d61da.jpg)  
+Figure 4: Effects of K and the number of units in each layer of DCRNN. K corresponds to the reception field width of the filter, and the number of units corresponds to the number of filters.
+
+All neural network based approaches are implemented using Tensorflow (Abadi et al., 2016), and trained using the Adam optimizer with learning rate annealing. The best hyperparameters are chosen using the Tree-structured Parzen Estimator (TPE) (Bergstra et al., 2011) on the validation dataset. Detailed parameter settings for DCRNN as well as baselines are available in Appendix E.
+
+# 4.2 TRAFFIC FORECASTING PERFORMANCE COMPARISON
+
+Table 1 shows the comparison of different approaches for 15 minutes, 30 minutes and 1 hour ahead forecasting on both datasets. These methods are evaluated based on three commonly used metrics in traffic forecasting, including (1) Mean Absolute Error (MAE), (2) Mean Absolute Percentage Error (MAPE), and (3) Root Mean Squared Error (RMSE). Missing values are excluded in calculating these metrics. Detailed formulations of these metrics are provided in Appendix E.2. We observe the following phenomenon in both of these datasets. (1) RNN-based methods, including FC-LSTM and DCRNN, generally outperform other baselines which emphasizes the importance of modeling the temporal dependency. (2) DCRNN achieves the best performance regarding all the metrics for all forecasting horizons, which suggests the effectiveness of spatiotemporal dependency modeling. (3) Deep neural network based methods including FNN, FC-LSTM and DCRNN, tend to have better performance than linear baselines for long-term forecasting, e.g., 1 hour ahead. This is because the temporal dependency becomes increasingly non-linear with the growth of the horizon. Besides, as the historical average method does not depend on short-term data, its performance is invariant to the small increases in the forecasting horizon.
+
+Note that, traffic forecasting on the METR-LA (Los Angeles, which is known for its complicated traffic conditions) dataset is more challenging than that in the PEMS-BAY (Bay Area) dataset. Thus we use METR-LA as the default dataset for following experiments.
+
+# 4.3 EFFECT OF SPATIAL DEPENDENCY MODELING
+
+To further investigate the effect of spatial dependency modeling, we compare DCRNN with the following variants: (1) DCRNN-NoConv, which ignores spatial dependency by replacing the transition matrices in the diffusion convolution (Equation 2) with identity matrices. This essentially means the forecasting of a sensor can be only be inferred from its own historical readings; (2) DCRNN-UniConv, which only uses the forward random walk transition matrix for diffusion convolution; Figure 3 shows the learning curves of these three models with roughly the same number of parameters. Without diffusion convolution, DCRNN-NoConv has much higher validation error. Moreover, DCRNN achieves the lowest validation error which shows the effectiveness of using bidirectional random walk. The intuition is that the bidirectional random walk gives the model the ability and flexibility to capture the influence from both the upstream and the downstream traffic.
+
+Table 2: Performance comparison for DCRNN and GCRNN on the METRA-LA dataset.   
+
+<table><tr><td></td><td colspan="3">15 min</td><td colspan="3">30 min</td><td colspan="3">1 hour</td></tr><tr><td></td><td>MAE</td><td>RMSE</td><td>MAPE</td><td>MAE</td><td>RMSE</td><td>MAPE</td><td>MAE</td><td>RMSE</td><td>MAPE</td></tr><tr><td>DCRNN</td><td>2.77</td><td>5.38</td><td>7.3%</td><td>3.15</td><td>6.45</td><td>8.8%</td><td>3.60</td><td>7.60</td><td>10.5%</td></tr><tr><td>GCRNN</td><td>2.80</td><td>5.51</td><td>7.5%</td><td>3.24</td><td>6.74</td><td>9.0%</td><td>3.81</td><td>8.16</td><td>10.9%</td></tr></table>
+
+![](images/8ca14f6afd328fb45111fa2bfa69e5ec0f337d843fd8d947a11946b48c3c105c.jpg)  
+Figure 5: Performance comparison for different DCRNN variants. DCRNN, with the sequence to sequence framework and scheduled sampling, achieves the lowest MAE on the validation dataset. The advantage becomes more clear with the increase of the forecasting horizon.
+
+![](images/0c77030ae0577be7bc3acfde78cd715a48811a60c489898910c4424f1232ec52.jpg)  
+Figure 6: Traffic time series forecasting visualization. DCRNN generates smooth prediction and is usually better at predict the start and end of peak hours.
+
+To investigate the effect of graph construction, we construct a undirected graph by setting $\widehat { W } _ { i j } =$ $\widehat { W } _ { j i } = \operatorname* { m a x } ( W _ { i j } , W _ { j i } )$ , where $\widehat { W }$ is the new symmetric weight matrix. Then we develop a variant of DCRNN denotes GCRNN, which uses the sequence to sequence learning with ChebNet graph convolution (Equation 5) with roughly the same amount of parameters. Table 2 shows the comparison between DCRNN and GCRNN in the METR-LA dataset. DCRNN consistently outperforms GCRNN. The intuition is that directed graph better captures the asymmetric correlation between traffic sensors. Figure 4 shows the effects of different parameters. $K$ roughly corresponds to the size of filters’ reception fields while the number of units corresponds to the number of filters. Larger $K$ enables the model to capture broader spatial dependency at the cost of increasing learning complexity. We observe that with the increase of $K$ , the error on the validation dataset first quickly decrease, and then slightly increase. Similar behavior is observed for varying the number of units.
+
+# 4.4 EFFECT OF TEMPORAL DEPENDENCY MODELING
+
+To evaluate the effect of temporal modeling including the sequence to sequence framework as well as the scheduled sampling mechanism, we further design three variants of DCRNN: (1) DCNN: in which we concatenate the historical observations as a fixed length vector and feed it into stacked diffusion convolutional layers to predict the future time series. We train a single model for one step ahead prediction, and feed the previous prediction into the model as input to perform multiple steps ahead prediction. (2) DCRNN-SEQ: which uses the encoder-decoder sequence to sequence learning framework to perform multiple steps ahead forecasting. (3) DCRNN: similar to DCRNN-SEQ except for adding scheduled sampling.
+
+![](images/d2999efa3103b73cef388357cbb4742384fd04bd2b01b04718f2aba8b264f2ac.jpg)  
+Figure 7: Visualization of learned localized filters centered at different nodes with $K = 3$ on the METR-LA dataset. The star denotes the center, and the colors represent the weights. We observe that weights are localized around the center, and diffuse alongside the road network.
+
+Figure 5 shows the comparison of those four methods with regards to MAE for different forecasting horizons. We observe that: (1) DCRNN-SEQ outperforms DCNN by a large margin which conforms the importance of modeling temporal dependency. (2) DCRNN achieves the best result, and its superiority becomes more evident with the increase of the forecasting horizon. This is mainly because the model is trained to deal with its mistakes during multiple steps ahead prediction and thus suffers less from the problem of error propagation. We also train a model that always been fed its output as input for multiple steps ahead prediction. However, its performance is much worse than all the three variants which emphasizes the importance of scheduled sampling.
+
+# 4.5 MODEL INTERPRETATION
+
+To better understand the model, we visualize forecasting results as well as learned filters. Figure 6 shows the visualization of 1 hour ahead forecasting. We have the following observations: (1) DCRNN generates smooth prediction of the mean when small oscillation exists in the traffic speeds (Figure 6(a)). This reflects the robustness of the model. (2) DCRNN is more likely to accurately predict abrupt changes in the traffic speed than baseline methods (e.g., FC-LSTM). As shown in Figure 6(b), DCRNN predicts the start and the end of the peak hours. This is because DCRNN captures the spatial dependency, and is able to utilize the speed changes in neighborhood sensors for more accurate forecasting. Figure 7 visualizes examples of learned filters centered at different nodes. The star denotes the center, and colors denote the weights. We can observe that (1) weights are well localized around the center, and (2) the weights diffuse based on road network distance. More visualizations are provided in Appendix F.
+
+# 5 CONCLUSION
+
+In this paper, we formulated the traffic prediction on road network as a spatiotemporal forecasting problem, and proposed the diffusion convolutional recurrent neural network that captures the spatiotemporal dependencies. Specifically, we use bidirectional graph random walk to model spatial dependency and recurrent neural network to capture the temporal dynamics. We further integrated the encoder-decoder architecture and the scheduled sampling technique to improve the performance for long-term forecasting. When evaluated on two large-scale real-world traffic datasets, our approach obtained significantly better prediction than baselines. For future work, we will investigate the following two aspects (1) applying the proposed model to other spatial-temporal forecasting tasks; (2) modeling the spatiotemporal dependency when the underlying graph structure is evolving, e.g., the K nearest neighbor graph for moving objects.
+
+# ACKNOWLEDGMENTS
+
+This research has been funded in part by NSF grants CNS-1461963, IIS-1254206, IIS-1539608, Caltrans-65A0533, the USC Integrated Media Systems Center (IMSC), and the USC METRANS Transportation Center. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of any of the sponsors such as NSF. Also, the authors would like to thank Shang-Hua Teng, Dehua Cheng and Siyang Li for helpful discussions and comments.
+
+# REFERENCES
+
+Mart´ın Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
+
+James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In NIPS, pp. 1171–1179, 2015.
+
+James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in Neural Information Processing Systems, pp. 2546–2554, 2011.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. In ICLR, 2014.
+
+Pinlong Cai, Yunpeng Wang, Guangquan Lu, Peng Chen, Chuan Ding, and Jianping Sun. A spatiotemporal correlative k-nearest neighbor model for short-term traffic multistep forecasting. Transportation Research Part C: Emerging Technologies, 62:21–34, 2016.
+
+Ennio Cascetta. Transportation systems engineering: theory and methods, volume 49. Springer Science & Business Media, 2013.
+
+Dehua Cheng, Yu Cheng, Yan Liu, Richard Peng, and Shang-Hua Teng. Efficient sampling for gaussian graphical models via spectral sparsification. In Conference on Learning Theory, pp. 364–390, 2015.
+
+Xingyi Cheng, Ruiqing Zhang, Jie Zhou, and Wei Xu. Deeptransport: Learning spatial-temporal dependency for traffic condition forecasting. arXiv preprint arXiv:1709.09585, 2017.
+
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In NIPS, pp. 3837–3845, 2016.
+
+Dingxiong Deng, Cyrus Shahabi, Ugur Demiryurek, Linhong Zhu, Rose Yu, and Yan Liu. Latent space model for road networks to predict time-varying traffic. In SIGKDD, pp. 1525–1534, 2016.
+
+Donald R Drew. Traffic flow theory and control. Technical report, 1968.
+
+Gaetano Fusco, Chiara Colombaroni, and Natalia Isaenko. Short-term speed predictions exploiting big data on large urban road networks. Transportation Research Part C: Emerging Technologies, 73:183–201, 2016.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In ICML, 2017.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016.
+
+James Douglas Hamilton. Time series analysis, volume 2. Princeton university press Princeton, 1994.
+
+Yotam Hechtlinger, Purvasha Chakravarti, and Jining Qin. A generalization of convolutional neural networks to graph-structured data. arXiv preprint arXiv:1704.08165, 2017.
+
+H. V. Jagadish, Johannes Gehrke, Alexandros Labrinidis, Yannis Papakonstantinou, Jignesh M. Patel, Raghu Ramakrishnan, and Cyrus Shahabi. Big data and its technical challenges. Commun. ACM, 57(7):86–94, July 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Nikolay Laptev, Jason Yosinski, Li Erran Li, and Slawek Smyl. Time-series extreme event forecasting with neural networks at Uber. In Int. Conf. on Machine Learning Time Series Workshop, 2017.
+
+Marco Lippi, Marco Bertini, and Paolo Frasconi. Short-term traffic flow forecasting: An experimental comparison of time-series analysis and supervised learning. ITS, IEEE Transactions on, 14(2): 871–882, 2013.
+
+Wei Liu, Yu Zheng, Sanjay Chawla, Jing Yuan, and Xie Xing. Discovering spatio-temporal causal interactions in traffic data streams. In SIGKDD, pp. 1010–1018. ACM, 2011.
+
+Yisheng Lv, Yanjie Duan, Wenwen Kang, Zhengxi Li, and Fei-Yue Wang. Traffic flow prediction with big data: A deep learning approach. ITS, IEEE Transactions on, 16(2):865–873, 2015.
+
+Xiaolei Ma, Zhuang Dai, Zhengbing He, Jihui Ma, Yong Wang, and Yunpeng Wang. Learning traffic as images: a deep convolutional neural network for large-scale transportation network speed prediction. Sensors, 17(4):818, 2017.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Youngjoo Seo, Michael Defferrard, Pierre Vandergheynst, and Xavier Bresson. Structured sequence ¨ modeling with graph convolutional recurrent networks. arXiv preprint arXiv:1612.07659, 2016.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, pp. 3104–3112, 2014.
+
+Shang-Hua Teng et al. Scalable algorithms for data and network analysis. Foundations and Trends $\textsuperscript { \textregistered }$ in Theoretical Computer Science, 12(1–2):1–274, 2016.
+
+Eleni I Vlahogianni, Matthew G Karlaftis, and John C Golias. Short-term traffic forecasting: Where we are and where were going. Transportation Research Part C: Emerging Technologies, 43:3–19, 2014.
+
+Yuankai Wu and Huachun Tan. Short-term traffic flow forecasting with spatial-temporal correlation in a hybrid deep learning framework. arXiv preprint arXiv:1612.01022, 2016.
+
+Yuanchang Xie, Kaiguang Zhao, Ying Sun, and Dawei Chen. Gaussian processes for short-term traffic volume forecasting. Transportation Research Record: Journal of the Transportation Research Board, (2165):69–78, 2010.
+
+Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional neural network: A deep learning framework for traffic forecasting. arXiv preprint arXiv:1709.04875, 2017a.
+
+Hsiang-Fu Yu, Nikhil Rao, and Inderjit S Dhillon. Temporal regularized matrix factorization for high-dimensional time series prediction. In Advances in Neural Information Processing Systems, pp. 847–855, 2016.
+
+Rose Yu, Yaguang Li, Cyrus Shahabi, Ugur Demiryurek, and Yan Liu. Deep learning: A generic approach for extreme condition traffic forecasting. In SIAM International Conference on Data Mining (SDM), 2017b.
+
+Junbo Zhang, Yu Zheng, Dekang Qi, Ruiyuan Li, and Xiuwen Yi. Dnn-based prediction model for spatio-temporal data. In Proceedings of the 24th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, pp. 92. ACM, 2016.
+
+Junbo Zhang, Yu Zheng, and Dekang Qi. Deep spatio-temporal residual networks for citywide crowd flows prediction. In AAAI, pp. 1655–1661, 2017.
+
+# APPENDIX
+
+A NOTATION
+
+Table 3: Notation   
+
+<table><tr><td>Name g</td><td>a graph</td></tr><tr><td>V,Ui m W,Wij, D,D1,Do L Φ,△</td><td>nodes of a graph,|V|= N and the i-th node. edges of a graph weight matrix of a graph and its entries undirected degree matrix, In-degree/out-degree matrix normalized graphLaplacian eigen-vector matrix and eigen-value matrix of L X,X∈RN×P a graph signal,and the predicted graph signal. a graph signal at time t. output of the diffusion convolutional layer.</td></tr></table>
+
+Table 3 summarizes the main notations used in the paper.
+
+# B EFFICIENT CALCULATION OF EQUATION 2
+
+Equation 2 can be decomposed into two parts with the same time complexity, i.e., one part with $D _ { O } ^ { - 1 } W$ and the other part with $D _ { I } ^ { - 1 } W ^ { \boldsymbol { \mathsf { T } } }$ . Thus we will only show the time complexity of the first part.
+
+Let $T _ { k } ( { \pmb x } ) = \left( { \pmb D } _ { O } ^ { - 1 } { \pmb W } \right) ^ { k } { \pmb x }$ , The first part of Equation 2 can be rewritten as
+
+$$
+\sum _ { k = 0 } ^ { K - 1 } \theta _ { k } T _ { k } ( X _ { : , p } )
+$$
+
+As $T _ { k + 1 } ( { \pmb x } ) = D _ { O } ^ { - 1 } { \pmb W } T _ { k } ( { \pmb x } )$ and $D _ { O } ^ { - 1 } W$ is sparse, it is easy to see that Equation 4 can be calculated using ${ \cal { O } } \breve { ( } K )$ recursive sparse-dense matrix multiplication each with time complexity $O ( | \mathcal { E } | )$ . Consequently, the time complexities of both Equation 2 and Equation 4 are $O ( K | \bar { \mathcal { E } } | )$ . For dense graph, we may use spectral sparsification (Cheng et al., 2015) to make it sparse.
+
+# C RELATION WITH SPECTRAL GRAPH CONVOLUTION
+
+Proof. The spectral graph convolution utilizes the concept of normalized graph Laplacian $L =$ $D ^ { - { \frac { 1 } { 2 } } } ( D - \bar { W } ) D ^ { - { \frac { 1 } { 2 } } } = \Phi \Lambda \Phi ^ { \intercal }$ . ChebNet parametrizes $f _ { \theta }$ to be a $K$ order polynomial of $\pmb { \Lambda }$ , and calculates it using stable Chebyshev polynomial basis.
+
+$$
+{ \cal X } _ { : , p } \star _ { \mathscr G } f _ { \theta } = \Phi \left( \sum _ { k = 0 } ^ { K - 1 } \theta _ { k } { \bf A } ^ { k } \right) \Phi ^ { \intercal } { \cal X } _ { : , p } = \sum _ { k = 0 } ^ { K - 1 } \theta _ { k } { \cal L } ^ { k } { \pmb X } _ { : , p } = \sum _ { k = 0 } ^ { K - 1 } \tilde { \theta } _ { k } T _ { k } ( { \tilde { \cal L } } ) { \pmb X } _ { : , p }
+$$
+
+where $T _ { 0 } ( x ) = 1 , T _ { 1 } ( x ) = x , T _ { k } ( x ) = x T _ { k - 1 } ( x ) - T _ { k - 2 } ( x )$ are the basis of the Cheyshev polynomial. Let $\lambda _ { m a x }$ denote the largest eigenvalue of $\pmb { L }$ , and $\begin{array} { r } { \tilde { \pmb { L } } = \frac { 2 } { \lambda _ { m a x } } \pmb { L } - \pmb { I } } \end{array}$ represents a rescaling of the graph Laplacian that maps the eigenvalues from $[ 0 , \lambda _ { m a x } ]$ to $[ - 1 , 1 ]$ since Chebyshev polynomial forms an orthogonal basis in $[ - 1 , 1 ]$ . Equation 5 can be considered as a polynomial of $\tilde { L }$ and we will show that the output of ChebNet Convolution is similar to the output of diffusion convolution up to constant scaling factor. Assume $\lambda _ { m a x } = 2$ and ${ \cal D } _ { I } = { \cal D } _ { O } = { \cal D }$ for undirected graph.
+
+$$
+\tilde { L } = D ^ { - \frac { 1 } { 2 } } ( D - W ) D ^ { - \frac { 1 } { 2 } } - I = - D ^ { - \frac { 1 } { 2 } } W D ^ { - \frac { 1 } { 2 } } \sim - D ^ { - 1 } W
+$$
+
+$\tilde { L }$ is similar to the negative random walk transition matrix, thus the output of Equation 5 is also similar to the output of Equation 2 up to constant scaling factor. □
+
+![](images/62960aa48867d2808dbc58d1790eafab631251035be24e20ae7b19ea1d9e802b.jpg)  
+Figure 8: Sensor distribution of the METR-LA and PEMS-BAY dataset.
+
+D MORE RELATED WORK AND DISCUSSION
+
+Xie et al. (2010) introduce a Gaussian processes (GPs) based method. GPs are hard to scale to the large dataset and are generally not suitable for relatively long-term traffic prediction like 1 hour (i.e.,12 steps ahead), as the variance can be accumulated and becomes extremely large.
+
+Cai et al. (2016) propose to use spatiotemporal nearest neighbor for traffic forecasting (ST-KNN). Though ST-KNN considers both the spatial and the temporal dependencies, it has the following drawbacks. As shown in Fusco et al. (2016), ST-KNN performs independent forecasting for each individual road. The prediction of a road is a weighted combination of its own historical traffic speeds. This makes it hard for ST-KNN to fully utilize information from neighbors. Besides, ST-KNN is a non-parametric approach and each road is modeled and calculated separately (Cai et al., 2016), which makes it hard to generalize to unseen situations and to scale to large datasets. Finally, in ST-KNN, all the similarities are calculated using hand-designed metrics with few learnable parameters, and this may limit its representational power.
+
+Cheng et al. (2017) propose DeepTransport which models the spatial dependency by explicitly collecting certain number of upstream and downstream roads for each individual road and then conduct convolution on these roads respectively. Comparing with Cheng et al. (2017), DCRNN models the spatial dependency in a more systematic way, i.e., generalizing convolution to the traffic sensor graph based on the diffusion nature of traffic. Besides, we derive DCRNN from the property of random walk and show that the popular spectral convolution ChebNet is a special case of our method.
+
+The proposed approach is also related to graph embedding techniques, e.g., Deepwalk (Perozzi et al., 2014), node2vec (Grover & Leskovec, 2016) which learn a low dimension representation for each node in the graph. DCRNN also learns a representation for each node. The learned representations capture both the spatial and the temporal dependency and at the same time are optimized with regarding to the objective, e.g., future traffic speeds.
+
+# E DETAILED EXPERIMENTAL SETTINGS
+
+HA Historical Average, which models the traffic flow as a seasonal process, and uses weighted average of previous seasons as the prediction. The period used is 1 week, and the prediction is based on aggregated data from previous weeks. For example, the prediction for this Wednesday is the averaged traffic speeds from last four Wednesdays. As the historical average method does not depend on short-term data, its performance is invariant to the small increases in the forecasting horizon
+
+$\mathbf { A R I M A } _ { k a l }$ : Auto-Regressive Integrated Moving Average model with Kalman filter. The orders are (3, 0, 1), and the model is implemented using the statsmodel python package.
+
+VAR Vector Auto-regressive model (Hamilton, 1994). The number of lags is set to 3, and the model is implemented using the statsmodel python package.
+
+SVR Linear Support Vector Regression, the penalty term $C = 0 . 1$ , the number of historical observation is 5.
+
+The following deep neural network based approaches are also included.
+
+FNN Feed forward neural network with two hidden layers, each layer contains 256 units. The initial learning rate is $1 e ^ { - 3 }$ , and reduces to $\frac { 1 } { 1 0 }$ every 20 epochs starting at the 50th epochs. In addition, for all hidden layers, dropout with ratio 0.5 and L2 weight decay $1 e ^ { - 2 }$ is used. The model is trained with batch size 64 and MAE as the loss function. Early stop is performed by monitoring the validation error.
+
+FC-LSTM The Encoder-decoder framework using LSTM with peephole (Sutskever et al., 2014). Both the encoder and the decoder contain two recurrent layers. In each recurrent layer, there are 256 LSTM units, L1 weight decay is $2 e ^ { - 5 }$ , L2 weight decay $5 e ^ { - 4 }$ . The model is trained with batch size 64 and loss function MAE. The initial learning rate is 1e-4 and reduces to 110 every 10 epochs starting from the 20th epochs. Early stop is performed by monitoring the validation error.
+
+DCRNN : Diffusion Convolutional Recurrent Neural Network. Both encoder and decoder contain two recurrent layers. In each recurrent layer, there are 64 units, the initial learning rate is $1 e ^ { - 2 }$ , and reduces to $\frac { 1 } { 1 0 }$ every 10 epochs starting at the 20th epoch and early stopping on the validation dataset is used. Besides, the maximum steps of random walks, i.e., $K$ , is set to 3. For scheduled sampling, the thresholded inverse sigmoid function is used as the probability decay:
+
+$$
+\epsilon _ { i } = \frac { \tau } { \tau + \exp \left( i / \tau \right) }
+$$
+
+where $i$ is the number of iterations while $\tau$ are parameters to control the speed of convergence. $\tau$ is set to 3,000 in the experiments. The implementation is available in https://github.com/ liyaguang/DCRNN.
+
+# E.1 DATASET
+
+We conduct experiments on two real-world large-scale datasets:
+
+• METR-LA This traffic dataset contains traffic information collected from loop detectors in the highway of Los Angeles County (Jagadish et al., 2014). We select 207 sensors and collect 4 months of data ranging from Mar 1st 2012 to Jun 30th 2012 for the experiment. The total number of observed traffic data points is 6,519,002.   
+PEMS-BAY This traffic dataset is collected by California Transportation Agencies (CalTrans) Performance Measurement System (PeMS). We select 325 sensors in the Bay Area and collect 6 months of data ranging from Jan 1st 2017 to May 31th 2017 for the experiment. The total number of observed traffic data points is 16,937,179.
+
+The sensor distributions of both datasets are visualized in Figure 8.
+
+In both of those datasets, we aggregate traffic speed readings into 5 minutes windows, and apply Z-Score normalization. $70 \%$ of data is used for training, $20 \%$ are used for testing while the remaining $10 \%$ for validation. To construct the sensor graph, we compute the pairwise road network distances between sensors and build the adjacency matrix using thresholded Gaussian kernel (Shuman et al., 2013).
+
+$$
+W _ { i j } = \exp \left( - \frac { \mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \sigma ^ { 2 } } \right) \quad \mathrm { i f ~ } \mathrm { d i s t } ( v _ { i } , v _ { j } ) \leq \kappa , \mathrm { o t h e r w i s e ~ } 0
+$$
+
+where $W _ { i j }$ represents the edge weight between sensor $v _ { i }$ and sensor $v _ { j }$ , $\mathrm { d i s t } ( v _ { i } , v _ { j } )$ denotes the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ . $\sigma$ is the standard deviation of distances and $\kappa$ is the threshold.
+
+# E.2 METRICS
+
+Suppose $\pmb { x } = x _ { 1 } , \cdots , x _ { n }$ represents the ground truth, $\hat { \pmb x } = \hat { x } _ { 1 } , \cdots , \hat { x } _ { n }$ represents the predicted values, and $\Omega$ denotes the indices of observed samples, the metrics are defined as follows.
+
+Root Mean Square Error (RMSE)
+
+$$
+\mathrm { R M S E } ( { \pmb x } , \hat { \pmb x } ) = \sqrt { \frac { 1 } { | { \pmb \Omega } | } \sum _ { i \in \Omega } ( x _ { i } - \hat { x } _ { i } ) ^ { 2 } }
+$$
+
+Mean Absolute Percentage Error (MAPE)
+
+$$
+\mathrm { M A P E } ( \pmb { x } , \hat { \pmb { x } } ) = \frac { 1 } { | \pmb { \Omega } | } \sum _ { i \in \Omega } \left| \frac { x _ { i } - \hat { x } _ { i } } { x _ { i } } \right|
+$$
+
+Mean Absolute Error (MAE)
+
+$$
+\mathrm { M A E } ( { \pmb x } , \hat { \pmb x } ) = \frac { 1 } { | \pmb { \Omega } | } \sum _ { i \in \pmb { \Omega } } | x _ { i } - \hat { x } _ { i } |
+$$
+
+F MODEL VISUALIZATION
+
+![](images/b2aa0dcd43a41cbf7dc306a60997a58af83cf306db959dd2637f12504f5df574.jpg)  
+Figure 9: Sensor correlations between the center sensor and its neighborhoods for different forecasting horizons. The correlations are estimated using regularized VAR. We observe that the correlations are localized and closer neighborhoods usually have larger relevance, and the magnitude of correlation quickly decay with the increase of distance which is consistent with the diffusion process on the graph.
+
+![](images/31bdbfa746c2cd8ce1cc9ecbcfe3cd80f190ce51206ec301436e295f4a5a4e04.jpg)  
+Figure 10: Traffic time series forecasting visualization.
+
+![](images/7a6dba74782b6e903be82f579ad03fc305e95eb3093473263a5a95fc641af710.jpg)  
+Figure 11: Traffic time series forecasting visualization.

parse/train/SJiHXGWAZ/SJiHXGWAZ_content_list.json

@@ -0,0 +1,1959 @@
+[
+    {
+        "type": "text",
+        "text": "DIFFUSION CONVOLUTIONAL RECURRENT NEURAL NETWORK: DATA-DRIVEN TRAFFIC FORECASTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yaguang $\\mathbf { L i } ^ { \\dagger }$ , Rose $\\mathbf { V } \\mathbf { u } ^ { \\ddag }$ , Cyrus Shahabi†, Yan Liu† † University of Southern California, ‡ California Institute of Technology † {yaguang, shahabi, yanliu.cs}@usc.edu, ‡ rose@caltech.edu ",
+        "bbox": [
+            184,
+            169,
+            732,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            233,
+            544,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spatiotemporal forecasting has various applications in neuroscience, climate and transportation domain. Traffic forecasting is one canonical example of such learning task. The task is challenging due to (1) complex spatial dependency on road networks, (2) non-linear temporal dynamics with changing road conditions and (3) inherent difficulty of long-term forecasting. To address these challenges, we propose to model the traffic flow as a diffusion process on a directed graph and introduce Diffusion Convolutional Recurrent Neural Network (DCRNN), a deep learning framework for traffic forecasting that incorporates both spatial and temporal dependency in the traffic flow. Specifically, DCRNN captures the spatial dependency using bidirectional random walks on the graph, and the temporal dependency using the encoder-decoder architecture with scheduled sampling. We evaluate the framework on two real-world large scale road network traffic datasets and observe consistent improvement of $1 2 \\% - 1 5 \\%$ over state-of-the-art baselines. ",
+        "bbox": [
+            233,
+            253,
+            766,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            458,
+            336,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spatiotemporal forecasting is a crucial task for a learning system that operates in a dynamic environment. It has a wide range of applications from autonomous vehicles operations, to energy and smart grid optimization, to logistics and supply chain management. In this paper, we study one important task: traffic forecasting on road networks, the core component of the intelligent transportation systems. The goal of traffic forecasting is to predict the future traffic speeds of a sensor network given historic traffic speeds and the underlying road networks. ",
+        "bbox": [
+            174,
+            479,
+            826,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This task is challenging mainly due to the complex spatiotemporal dependencies and inherent difficulty in the long term forecasting. On the one hand, traffic time series demonstrate strong temporal dynamics. Recurring incidents such as rush hours or accidents can cause nonstationarity, making it difficult to forecast longterm. On the other hand, sensors on the road network contain complex yet unique spatial correlations. Figure 1 illustrates an example. Road 1 and road 2 are correlated, while road 1 and road 3 are not. Although road 1 and road 3 are close in the Euclidean space, they demonstrate very different behaviors. Moreover, the future traffic speed is influenced more by the downstream traffic than the upstream one. This means that the spatial structure in traffic is nonEuclidean and directional. ",
+        "bbox": [
+            174,
+            569,
+            485,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a52a2d9f91fcd760118256e52884cd0555ef88f1d13abd6b36decb7b19560b73.jpg",
+        "image_caption": [
+            "Figure 1: Spatial correlation is dominated by road network structure. (1) Traffic speed in road 1 are similar to road 2 as they locate in the same highway. (2) Road 1 and road 3 locate in the opposite directions of the highway. Though close to each other in the Euclidean space, their road network distance is large, and their traffic speeds differ significantly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            583,
+            815,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traffic forecasting has been studied for decades, falling into two main categories: knowledge",
+        "bbox": [
+            174,
+            827,
+            485,
+            854
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "driven approach and data-driven approach. In transportation and operational research, knowledgedriven methods usually apply queuing theory and simulate user behaviors in traffic (Cascetta, 2013). In time series community, data-driven methods such as Auto-Regressive Integrated Moving Average (ARIMA) model and Kalman filtering remain popular (Liu et al., 2011; Lippi et al., 2013). However, simple time series models usually rely on the stationarity assumption, which is often violated by the traffic data. Most recently, deep learning models for traffic forecasting have been developed in Lv et al. (2015); Yu et al. (2017b), but without considering the spatial structure. Wu & Tan (2016) and Ma et al. (2017) model the spatial correlation with Convolutional Neural Networks (CNN), but the spatial structure is in the Euclidean space (e.g., 2D images). Bruna et al. (2014), Defferrard et al. (2016) studied graph convolution, but only for undirected graphs. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we represent the pair-wise spatial correlations between traffic sensors using a directed graph whose nodes are sensors and edge weights denote proximity between the sensor pairs measured by the road network distance. We model the dynamics of the traffic flow as a diffusion process and propose the diffusion convolution operation to capture the spatial dependency. We further propose Diffusion Convolutional Recurrent Neural Network (DCRNN) that integrates diffusion convolution, the sequence to sequence architecture and the scheduled sampling technique. When evaluated on realworld traffic datasets, DCRNN consistently outperforms state-of-the-art traffic forecasting baselines by a large margin. In summary: ",
+        "bbox": [
+            173,
+            180,
+            825,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We study the traffic forecasting problem and model the spatial dependency of traffic as a diffusion process on a directed graph. We propose diffusion convolution, which has an intuitive interpretation and can be computed efficiently.   \nWe propose Diffusion Convolutional Recurrent Neural Network (DCRNN), a holistic approach that captures both spatial and temporal dependencies among time series using diffusion convolution and the sequence to sequence learning framework together with scheduled sampling. DCRNN is not limited to transportation and is readily applicable to other spatiotemporal forecasting tasks.   \nWe conducted extensive experiments on two large-scale real-world datasets, and the proposed approach obtains significant improvement over state-of-the-art baseline methods. ",
+        "bbox": [
+            215,
+            301,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            341,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We formalize the learning problem of spatiotemporal traffic forecasting and describe how to model the dependency structures using diffusion convolutional recurrent neural network. ",
+        "bbox": [
+            174,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 TRAFFIC FORECASTING PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            452,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of traffic forecasting is to predict the future traffic speed given previously observed traffic flow from $N$ correlated sensors on the road network. We can represent the sensor network as a weighted directed graph $\\mathcal { G } = ( \\nu , \\mathcal { E } , W )$ , where $\\nu$ is a set of nodes $| \\nu | = N$ , $\\mathcal { E }$ is a set of edges and $\\pmb { W } \\in \\mathbb { R } ^ { N \\times N }$ is a weighted adjacency matrix representing the nodes proximity (e.g., a function of their road network distance). Denote the traffic flow observed on $\\mathcal { G }$ as a graph signal $\\pmb { X } \\in \\mathbb { R } ^ { N \\times P }$ , where $P$ is the number of features of each node (e.g., velocity, volume). Let $\\bar { X } ^ { ( t ) }$ represent the graph signal observed at time $t$ , the traffic forecasting problem aims to learn a function $h ( \\cdot )$ that maps $T ^ { \\prime }$ historical graph signals to future $T$ graph signals, given a graph $\\mathcal { G }$ : ",
+        "bbox": [
+            173,
+            530,
+            826,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ad7e05ff24691bd19de44880bcf873fe7546502fa22cf66194e838fd5069353.jpg",
+        "text": "$$\n[ \\pmb { X } ^ { ( t - T ^ { \\prime } + 1 ) } , \\allowbreak \\cdot \\cdot \\ , \\pmb { X } ^ { ( t ) } ; \\mathcal { G } ] \\xrightarrow { h ( \\cdot ) } [ \\pmb { X } ^ { ( t + 1 ) } , \\allowbreak \\cdot \\cdot \\ , \\pmb { X } ^ { ( t + T ) } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            646,
+            681,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 SPATIAL DEPENDENCY MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            457,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We model the spatial dependency by relating traffic flow to a diffusion process, which explicitly captures the stochastic nature of traffic dynamics. This diffusion process is characterized by a random walk on $\\mathcal { G }$ with restart probability $\\alpha \\in [ 0 , 1 ]$ , and a state transition matrix $D _ { O } ^ { - 1 } W$ . Here $D _ { O } = \\mathrm { d i a g } ( W 1 )$ is the out-degree diagonal matrix, and $\\mathbf { 1 } \\in \\mathbb { R } ^ { N }$ denotes the all one vector. After many time steps, such Markov process converges to a stationary distribution $\\pmb { \\mathcal { P } } \\in \\mathbb { R } ^ { N \\times N }$ whose $i$ th row $\\mathbf { \\bar { \\mathcal { P } } } _ { i , : } \\in \\mathbb { R } ^ { \\bar { N } }$ represents the likelihood of diffusion from node $v _ { i } \\in \\mathcal V$ , hence the proximity w.r.t. the node $v _ { i }$ . The following Lemma provides a closed form solution for the stationary distribution. ",
+        "bbox": [
+            173,
+            709,
+            825,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2.1. (Teng et al., 2016) The stationary distribution of the diffusion process can be represented as a weighted combination of infinite random walks on the graph, and be calculated in closed form: ",
+        "bbox": [
+            171,
+            811,
+            821,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5404a940bec632b62408cc8779a769e5de420e116f8446795a04d52e7934f45.jpg",
+        "text": "$$\n\\mathcal { P } = \\sum _ { k = 0 } ^ { \\infty } \\alpha ( 1 - \\alpha ) ^ { k } \\left( D _ { \\mathcal { O } } ^ { - 1 } W \\right) ^ { k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            844,
+            606,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $k$ is the diffusion step. In practice, we use a finite $K$ -step truncation of the diffusion process and assign a trainable weight to each step. We also include the reversed direction diffusion process, ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "such that the bidirectional diffusion offers the model more flexibility to capture the influence from both the upstream and the downstream traffic. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Convolution The resulted diffusion convolution operation over a graph signal $\\boldsymbol { x } \\in$ $\\mathbb { R } ^ { N \\times P }$ and a filter $f _ { \\theta }$ is defined as: ",
+        "bbox": [
+            171,
+            146,
+            825,
+            175
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba93ac59a3a2d8c72d493e051e520c7f24953e4fb202d51374fd328178aa3816.jpg",
+        "text": "$$\n\\displaystyle { X _ { : , p } \\star _ { \\mathcal { G } } } \\ f _ { \\theta } = \\sum _ { k = 0 } ^ { K - 1 } \\left( \\theta _ { k , 1 } \\left( D _ { O } ^ { - 1 } W \\right) ^ { k } + \\theta _ { k , 2 } \\left( D _ { I } ^ { - 1 } W ^ { \\top } \\right) ^ { k } \\right) X _ { : , p } \\quad \\mathrm { f o r } p \\in \\{ 1 , \\cdots , P \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            180,
+            781,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb \\theta \\in \\mathbb R ^ { K \\times 2 }$ are the parameters for the filter and $D _ { O } ^ { - 1 } W , D _ { I } ^ { - 1 } W ^ { \\intercal }$ represent the transition matrices of the diffusion process and the reverse one, respectively. In general, computing the convolution can be expensive. However, if $\\mathcal { G }$ is sparse, Equation 2 can be calculated efficiently using $O ( K )$ recursive sparse-dense matrix multiplication with total time complexity $O ( K | \\mathcal { E } | ) \\ll \\dot { O } ( N ^ { 2 } )$ . See Appendix $\\mathbf { B }$ for more detail. ",
+        "bbox": [
+            173,
+            231,
+            826,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Convolutional Layer With the convolution operation defined in Equation 2, we can build a diffusion convolutional layer that maps $P$ -dimensional features to $Q$ -dimensional outputs. Denote the parameter tensor as $\\dot { \\pmb { \\Theta } } \\in \\mathbb { R } ^ { Q \\times P \\times \\dot { \\bf K } \\times 2 } = [ \\pmb { \\theta } ] _ { q , p }$ , where $\\Theta _ { q , p , : , : } \\doteq \\mathbb { R } ^ { K \\times 2 }$ parameterizes the convolutional filter for the pth input and the qth output. The diffusion convolutional layer is thus: ",
+        "bbox": [
+            173,
+            316,
+            826,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/468f28b432d056a1f641c46c878f502b676a787e4708540ebdfcd3e3681077ae.jpg",
+        "text": "$$\nH _ { : , q } = a \\left( \\sum _ { p = 1 } ^ { P } X _ { : , p } \\star _ { \\mathcal { G } } f _ { \\Theta _ { q , p ; : } } \\right) \\qquad { \\mathrm { f o r ~ } } q \\in \\{ 1 , \\cdots , Q \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            380,
+            692,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { X } \\in \\mathbb { R } ^ { N \\times P }$ is the input, $H \\in \\mathbb { R } ^ { N \\times Q }$ is the output, $\\{ f _ { \\Theta _ { q , p , , : } } \\}$ are the filters and $\\textbf { \\em a }$ is the activation function (e.g., ReLU, Sigmoid). Diffusion convolutional layer learns the representations for graph structured data and we can train it using stochastic gradient based method. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Relation with Spectral Graph Convolution Diffusion convolution is defined on both directed and undirected graphs. When applied to undirected graphs, we show that many existing graph structured convolutional operations including the popular spectral graph convolution, i.e., ChebNet (Defferrard et al., 2016), can be considered as a special case of diffusion convolution (up to a similarity transformation). Let $_ D$ denote the degree matrix, and $L = D ^ { - { \\frac { 1 } { 2 } } } ( D - W ) D ^ { - { \\frac { 1 } { 2 } } }$ be the normalized graph Laplacian, the following Proposition demonstrates the connection. ",
+        "bbox": [
+            173,
+            488,
+            826,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2.2. The spectral graph convolution defined as ",
+        "bbox": [
+            173,
+            578,
+            566,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2ee6232be1dbbfe1dba4bd30289c0c17f0adf9e45592c522aa4add28d018121.jpg",
+        "text": "$$\nX _ { : , p } \\star _ { \\mathcal { G } } f _ { \\theta } = \\Phi \\ F ( \\pmb \\theta ) \\ \\Phi ^ { \\intercal } X _ { : , p }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            599,
+            601,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with eigenvalue decomposition diffusion convolution up to a sim ${ \\pmb { L } } = \\pmb { \\Phi } \\pmb { \\Lambda } \\pmb { \\Phi } ^ { \\intercal }$ and rmat $\\begin{array} { r } { F ( \\pmb \\theta ) = \\sum _ { 0 } ^ { K - 1 } \\theta _ { k } \\pmb \\Lambda ^ { k } } \\end{array}$ , is equivalent to graphs undirected. $\\mathcal { G }$ ",
+        "bbox": [
+            174,
+            622,
+            826,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proof. See Appendix C. ",
+        "bbox": [
+            174,
+            669,
+            334,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 TEMPORAL DYNAMICS MODELING ",
+        "bbox": [
+            174,
+            691,
+            459,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We leverage the recurrent neural networks (RNNs) to model the temporal dependency. In particular, we use Gated Recurrent Units (GRU) (Chung et al., 2014), which is a simple yet powerful variant of RNNs. We replace the matrix multiplications in GRU with the diffusion convolution, which leads to our proposed $D$ iffusion Convolutional Gated Recurrent Unit (DCGRU). ",
+        "bbox": [
+            173,
+            708,
+            828,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e900aa8a4184d20d2cee9e662449f27b632f7dc773923f6b1aff2df88519513.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { r ^ { ( t ) } = } & { \\sigma ( \\Theta _ { r } \\star _ { \\mathcal { G } } \\big [ X ^ { ( t ) } , ~ H ^ { ( t - 1 ) } \\big ] + b _ { r } ) } & { u ^ { ( t ) } = \\sigma \\big ( \\Theta _ { u } \\star _ { \\mathcal { G } } \\big [ X ^ { ( t ) } , ~ H ^ { ( t - 1 ) } \\big ] + b _ { u } \\big ) } \\\\ & { \\varsigma ^ { ( t ) } = } & { \\mathrm { t a n h } \\big ( \\Theta _ { C } \\star _ { \\mathcal { G } } \\big [ X ^ { ( t ) } , ~ ( r ^ { ( t ) } \\odot H ^ { ( t - 1 ) } ) \\big ] + b _ { c } \\big ) } & { H ^ { ( t ) } = u ^ { ( t ) } \\odot H ^ { ( t - 1 ) } + \\big ( 1 - u ^ { ( t ) } \\big ) \\odot C ^ { ( t ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            770,
+            839,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\boldsymbol { X } } ^ { ( t ) } , \\mathbf { \\boldsymbol { H } } ^ { ( t ) }$ denote the input and output of at time $t$ $\\mathbf { \\boldsymbol { r } } ^ { ( t ) } , \\mathbf { \\boldsymbol { u } } ^ { ( t ) }$ are reset gate and update gate at time $t$ , respectively. $\\star _ { \\mathcal { G } }$ denotes the diffusion convolution defined in Equation 2 and $\\Theta _ { r } , \\Theta _ { u } , \\Theta _ { C }$ are parameters for the corresponding filters. Similar to GRU, DCGRU can be used to build recurrent neural network layers and be trained using backpropagation through time. ",
+        "bbox": [
+            173,
+            816,
+            826,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In multiple step ahead forecasting, we employ the Sequence to Sequence architecture (Sutskever et al., 2014). Both the encoder and the decoder are recurrent neural networks with DCGRU. During training, we feed the historical time series into the encoder and use its final states to initialize the decoder. The decoder generates predictions given previous ground truth observations. At testing time, ground truth observations are replaced by predictions generated by the model itself. The discrepancy between the input distributions of training and testing can cause degraded performance. To mitigate this issue, we integrate scheduled sampling (Bengio et al., 2015) into the model, where we feed the model with either the ground truth observation with probability $\\epsilon _ { i }$ or the prediction by the model with probability $1 - \\epsilon _ { i }$ at the ith iteration. During the training process, $\\epsilon _ { i }$ gradually decreases to 0 to allow the model to learn the testing distribution. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb10031718635a4605b29be131deb2827920cbffeb6514644c957a88e17991b3.jpg",
+        "image_caption": [
+            "Figure 2: System architecture for the Diffusion Convolutional Recurrent Neural Network designed for spatiotemporal traffic forecasting. The historical time series are fed into an encoder whose final states are used to initialize the decoder. The decoder makes predictions based on either previous ground truth or the model output. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            99,
+            782,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With both spatial and temporal modeling, we build a Diffusion Convolutional Recurrent Neural Network (DCRNN). The model architecture of DCRNN is shown in Figure 2. The entire network is trained by maximizing the likelihood of generating the target future time series using backpropagation through time. DCRNN is able to capture spatiotemporal dependencies among time series and can be applied to various spatiotemporal forecasting problems. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            344,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Traffic forecasting is a classic problem in transportation and operational research which are primarily based on queuing theory and simulations (Drew, 1968). Data-driven approaches for traffic forecasting have received considerable attention, and more details can be found in a recent survey paper (Vlahogianni et al., 2014) and the references therein. However, existing machine learning models either impose strong stationary assumptions on the data (e.g., auto-regressive model) or fail to account for highly non-linear temporal dependency (e.g., latent space model Yu et al. (2016); Deng et al. (2016)). Deep learning models deliver new promise for time series forecasting problem. For example, in Yu et al. (2017b); Laptev et al. (2017), the authors study time series forecasting using deep Recurrent Neural Networks (RNN). Convolutional Neural Networks (CNN) have also been applied to traffic forecasting. Zhang et al. (2016; 2017) convert the road network to a regular 2-D grid and apply traditional CNN to predict crowd flow. Cheng et al. (2017) propose DeepTransport which models the spatial dependency by explicitly collecting upstream and downstream neighborhood roads for each individual road and then conduct convolution on these neighborhoods respectively. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recently, CNN has been generalized to arbitrary graphs based on the spectral graph theory. Graph convolutional neural networks (GCN) are first introduced in Bruna et al. (2014), which bridges the spectral graph theory and deep neural networks. Defferrard et al. (2016) propose ChebNet which improves GCN with fast localized convolutions filters. Kipf & Welling (2017) simplify ChebNet and achieve state-of-the-art performance in semi-supervised classification tasks. Seo et al. (2016) combine ChebNet with Recurrent Neural Networks (RNN) for structured sequence modeling. Yu et al. (2017a) model the sensor network as a undirected graph and applied ChebNet and convolutional sequence model (Gehring et al., 2017) to do forecasting. One limitation of the mentioned spectral based convolutions is that they generally require the graph to be undirected to calculate meaningful spectral decomposition. Going from spectral domain to vertex domain, Atwood & Towsley (2016) propose diffusion-convolutional neural network (DCNN) which defines convolution as a diffusion process across each node in a graph-structured input. Hechtlinger et al. (2017) propose GraphCNN to generalize convolution to graph by convolving every node with its $p$ nearest neighbors. However, both these methods do not consider the temporal dynamics and mainly deal with static graph settings. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/f3f918929c2194ea92ce51a5ad92eeb3fe8115c302e4f3b004558f5cb054d12d.jpg",
+        "table_caption": [
+            "Table 1: Performance comparison of different approaches for traffic speed forecasting. DCRNN achieves the best performance with all three metrics for all forecasting horizons, and the advantage becomes more evident with the increase of the forecasting horizon. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>T</td><td>Metric</td><td>HA</td><td>ARIMAKal</td><td>VAR</td><td>SVR</td><td>FNN</td><td>FC-LSTM</td><td>DCRNN</td></tr><tr><td rowspan=\"4\">PATIIA</td><td>15 min</td><td>MAE RMSE</td><td>4.16 7.80</td><td>3.99 8.21</td><td>4.42 7.89</td><td>3.99 8.45</td><td>3.99 7.94</td><td>3.44 6.30</td><td>2.77 5.38</td></tr><tr><td></td><td>MAPE MAE</td><td>13.0% 4.16</td><td>9.6% 5.15</td><td>10.2% 5.41</td><td>9.3% 5.05</td><td>9.9% 4.23</td><td>9.6% 3.77</td><td>7.3% 3.15</td></tr><tr><td>30 min</td><td>RMSE MAPE MAE</td><td>7.80 13.0% 4.16</td><td>10.45 12.7% 6.90</td><td>9.13 12.7% 6.52</td><td>10.87 12.1% 6.72</td><td>8.17 12.9% 4.49</td><td>7.23 10.9% 4.37</td><td>6.45 8.8% 3.60</td></tr><tr><td>1 hour</td><td>RMSE MAPE</td><td>7.80 13.0%</td><td>13.23 17.4%</td><td>10.11 15.8%</td><td>13.76 16.7%</td><td>8.69 14.0%</td><td>8.69 13.2%</td><td>7.59 10.5%</td></tr><tr><td rowspan=\"4\">PPP-PPAA</td><td>15 min</td><td>MAE RMSE MAPE</td><td>2.88 5.59 6.8%</td><td>1.62 3.30 3.5%</td><td>1.74 3.16 3.6%</td><td>1.85 3.59 3.8%</td><td>2.20 4.42 5.19%</td><td>2.05 4.19</td><td>1.38 2.95</td></tr><tr><td>30 min</td><td>MAE RMSE MAPE</td><td>2.88 5.59 6.8%</td><td>2.33 4.76</td><td>2.32 4.25</td><td>2.48 5.18</td><td>2.30 4.63</td><td>4.8% 2.20 4.55</td><td>2.9% 1.74 3.97</td></tr><tr><td>1 hour</td><td>MAE RMSE</td><td>2.88 5.59</td><td>5.4% 3.38 6.50</td><td>5.0% 2.93 5.44</td><td>5.5% 3.28 7.08</td><td>5.43% 2.46</td><td>5.2% 2.37</td><td>3.9% 2.07</td></tr><tr><td></td><td>MAPE</td><td>6.8%</td><td>8.3%</td><td>6.5%</td><td>8.0%</td><td>4.98 5.89%</td><td>4.96 5.7%</td><td>4.74 4.9%</td></tr></table>",
+        "bbox": [
+            176,
+            155,
+            823,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            455,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our approach is different from all those methods due to both the problem settings and the formulation of the convolution on the graph. We model the sensor network as a weighted directed graph which is more realistic than grid or undirected graph. Besides, the proposed convolution is defined using bidirectional graph random walk and is further integrated with the sequence to sequence learning framework as well as the scheduled sampling to model the long-term temporal dependency. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            328,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on two real-world large-scale datasets: (1) METR-LA This traffic dataset contains traffic information collected from loop detectors in the highway of Los Angeles County (Jagadish et al., 2014). We select 207 sensors and collect 4 months of data ranging from Mar 1st 2012 to Jun 30th 2012 for the experiment. (2) PEMS-BAY This traffic dataset is collected by California Transportation Agencies (CalTrans) Performance Measurement System (PeMS). We select 325 sensors in the Bay Area and collect 6 months of data ranging from Jan 1st 2017 to May 31th 2017 for the experiment. The sensor distributions of both datasets are visualized in Figure 8 in the Appendix. ",
+        "bbox": [
+            173,
+            637,
+            826,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In both of those datasets, we aggregate traffic speed readings into 5 minutes windows, and apply Z-Score normalization. $70 \\%$ of data is used for training, $20 \\%$ are used for testing while the remaining $10 \\%$ for validation. To construct the sensor graph, we compute the pairwise road network distances between sensors and build the adjacency matrix using thresholded Gaussian kernel (Shuman et al., 2013). $\\begin{array} { r } { W _ { i j } = \\exp \\left( { - \\frac { \\mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \\sigma ^ { 2 } } } \\right) } \\end{array}$ if $\\mathrm { d i s t } ( v _ { i } , v _ { j } ) \\le \\kappa$ , otherwise 0, where $W _ { i j }$ represents the edge weight between sensor $v _ { i }$ and sensor $v _ { j }$ , $\\mathrm { d i s t } ( v _ { i } , v _ { j } )$ denotes the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ . $\\sigma$ is the standard deviation of distances and $\\kappa$ is the threshold. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            853,
+            400,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare DCRNN1 with widely used time series regression models, including (1) HA: Historical Average, which models the traffic flow as a seasonal process, and uses weighted average of previous seasons as the prediction; (2) $\\mathbf { A R I M A } _ { k a l }$ : Auto-Regressive Integrated Moving Average model with Kalman filter which is widely used in time series prediction; (3) VAR: Vector Auto-Regression (Hamilton, 1994). (4) SVR: Support Vector Regression which uses linear support vector machine for the regression task; The following deep neural network based approaches are also included: (5) Feed forward Neural network (FNN): Feed forward neural network with two hidden layers and L2 regularization. (6) Recurrent Neural Network with fully connected LSTM hidden units (FC-LSTM) (Sutskever et al., 2014). ",
+        "bbox": [
+            174,
+            869,
+            825,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c9781eeaafb772cc2e0c3e6403d04ad2122425790950273f62aeca104ebbc22.jpg",
+        "image_caption": [
+            "Figure 3: Learning curve for DCRNN and DCRNN without diffusion convolution. Removing diffusion convolution results in much higher validation error. Moreover, DCRNN with bidirectional random walk achieves the lowest validation error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            108,
+            465,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f13335bea7036c2e54e7045e8a2a27506d7cd7cdc37e77bb6c60c3ccbc6d61da.jpg",
+        "image_caption": [
+            "Figure 4: Effects of K and the number of units in each layer of DCRNN. K corresponds to the reception field width of the filter, and the number of units corresponds to the number of filters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            119,
+            790,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All neural network based approaches are implemented using Tensorflow (Abadi et al., 2016), and trained using the Adam optimizer with learning rate annealing. The best hyperparameters are chosen using the Tree-structured Parzen Estimator (TPE) (Bergstra et al., 2011) on the validation dataset. Detailed parameter settings for DCRNN as well as baselines are available in Appendix E. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRAFFIC FORECASTING PERFORMANCE COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            588,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the comparison of different approaches for 15 minutes, 30 minutes and 1 hour ahead forecasting on both datasets. These methods are evaluated based on three commonly used metrics in traffic forecasting, including (1) Mean Absolute Error (MAE), (2) Mean Absolute Percentage Error (MAPE), and (3) Root Mean Squared Error (RMSE). Missing values are excluded in calculating these metrics. Detailed formulations of these metrics are provided in Appendix E.2. We observe the following phenomenon in both of these datasets. (1) RNN-based methods, including FC-LSTM and DCRNN, generally outperform other baselines which emphasizes the importance of modeling the temporal dependency. (2) DCRNN achieves the best performance regarding all the metrics for all forecasting horizons, which suggests the effectiveness of spatiotemporal dependency modeling. (3) Deep neural network based methods including FNN, FC-LSTM and DCRNN, tend to have better performance than linear baselines for long-term forecasting, e.g., 1 hour ahead. This is because the temporal dependency becomes increasingly non-linear with the growth of the horizon. Besides, as the historical average method does not depend on short-term data, its performance is invariant to the small increases in the forecasting horizon. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that, traffic forecasting on the METR-LA (Los Angeles, which is known for its complicated traffic conditions) dataset is more challenging than that in the PEMS-BAY (Bay Area) dataset. Thus we use METR-LA as the default dataset for following experiments. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF SPATIAL DEPENDENCY MODELING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            851,
+            531,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To further investigate the effect of spatial dependency modeling, we compare DCRNN with the following variants: (1) DCRNN-NoConv, which ignores spatial dependency by replacing the transition matrices in the diffusion convolution (Equation 2) with identity matrices. This essentially means the forecasting of a sensor can be only be inferred from its own historical readings; (2) DCRNN-UniConv, which only uses the forward random walk transition matrix for diffusion convolution; Figure 3 shows the learning curves of these three models with roughly the same number of parameters. Without diffusion convolution, DCRNN-NoConv has much higher validation error. Moreover, DCRNN achieves the lowest validation error which shows the effectiveness of using bidirectional random walk. The intuition is that the bidirectional random walk gives the model the ability and flexibility to capture the influence from both the upstream and the downstream traffic. ",
+        "bbox": [
+            176,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/2db3218d531b3208e011889d4d952dff09e81b8d74b80510621fa522a5038481.jpg",
+        "table_caption": [
+            "Table 2: Performance comparison for DCRNN and GCRNN on the METRA-LA dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">15 min</td><td colspan=\"3\">30 min</td><td colspan=\"3\">1 hour</td></tr><tr><td></td><td>MAE</td><td>RMSE</td><td>MAPE</td><td>MAE</td><td>RMSE</td><td>MAPE</td><td>MAE</td><td>RMSE</td><td>MAPE</td></tr><tr><td>DCRNN</td><td>2.77</td><td>5.38</td><td>7.3%</td><td>3.15</td><td>6.45</td><td>8.8%</td><td>3.60</td><td>7.60</td><td>10.5%</td></tr><tr><td>GCRNN</td><td>2.80</td><td>5.51</td><td>7.5%</td><td>3.24</td><td>6.74</td><td>9.0%</td><td>3.81</td><td>8.16</td><td>10.9%</td></tr></table>",
+        "bbox": [
+            225,
+            127,
+            772,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ca14f6afd328fb45111fa2bfa69e5ec0f337d843fd8d947a11946b48c3c105c.jpg",
+        "image_caption": [
+            "Figure 5: Performance comparison for different DCRNN variants. DCRNN, with the sequence to sequence framework and scheduled sampling, achieves the lowest MAE on the validation dataset. The advantage becomes more clear with the increase of the forecasting horizon. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            215,
+            452,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c77030ae0577be7bc3acfde78cd715a48811a60c489898910c4424f1232ec52.jpg",
+        "image_caption": [
+            "Figure 6: Traffic time series forecasting visualization. DCRNN generates smooth prediction and is usually better at predict the start and end of peak hours. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            483,
+            223,
+            808,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            521,
+            825,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To investigate the effect of graph construction, we construct a undirected graph by setting $\\widehat { W } _ { i j } =$ $\\widehat { W } _ { j i } = \\operatorname* { m a x } ( W _ { i j } , W _ { j i } )$ , where $\\widehat { W }$ is the new symmetric weight matrix. Then we develop a variant of DCRNN denotes GCRNN, which uses the sequence to sequence learning with ChebNet graph convolution (Equation 5) with roughly the same amount of parameters. Table 2 shows the comparison between DCRNN and GCRNN in the METR-LA dataset. DCRNN consistently outperforms GCRNN. The intuition is that directed graph better captures the asymmetric correlation between traffic sensors. Figure 4 shows the effects of different parameters. $K$ roughly corresponds to the size of filters’ reception fields while the number of units corresponds to the number of filters. Larger $K$ enables the model to capture broader spatial dependency at the cost of increasing learning complexity. We observe that with the increase of $K$ , the error on the validation dataset first quickly decrease, and then slightly increase. Similar behavior is observed for varying the number of units. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 EFFECT OF TEMPORAL DEPENDENCY MODELING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            550,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effect of temporal modeling including the sequence to sequence framework as well as the scheduled sampling mechanism, we further design three variants of DCRNN: (1) DCNN: in which we concatenate the historical observations as a fixed length vector and feed it into stacked diffusion convolutional layers to predict the future time series. We train a single model for one step ahead prediction, and feed the previous prediction into the model as input to perform multiple steps ahead prediction. (2) DCRNN-SEQ: which uses the encoder-decoder sequence to sequence learning framework to perform multiple steps ahead forecasting. (3) DCRNN: similar to DCRNN-SEQ except for adding scheduled sampling. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2999efa3103b73cef388357cbb4742384fd04bd2b01b04718f2aba8b264f2ac.jpg",
+        "image_caption": [
+            "Figure 7: Visualization of learned localized filters centered at different nodes with $K = 3$ on the METR-LA dataset. The star denotes the center, and the colors represent the weights. We observe that weights are localized around the center, and diffuse alongside the road network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            109,
+            812,
+            190
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows the comparison of those four methods with regards to MAE for different forecasting horizons. We observe that: (1) DCRNN-SEQ outperforms DCNN by a large margin which conforms the importance of modeling temporal dependency. (2) DCRNN achieves the best result, and its superiority becomes more evident with the increase of the forecasting horizon. This is mainly because the model is trained to deal with its mistakes during multiple steps ahead prediction and thus suffers less from the problem of error propagation. We also train a model that always been fed its output as input for multiple steps ahead prediction. However, its performance is much worse than all the three variants which emphasizes the importance of scheduled sampling. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 MODEL INTERPRETATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            392,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To better understand the model, we visualize forecasting results as well as learned filters. Figure 6 shows the visualization of 1 hour ahead forecasting. We have the following observations: (1) DCRNN generates smooth prediction of the mean when small oscillation exists in the traffic speeds (Figure 6(a)). This reflects the robustness of the model. (2) DCRNN is more likely to accurately predict abrupt changes in the traffic speed than baseline methods (e.g., FC-LSTM). As shown in Figure 6(b), DCRNN predicts the start and the end of the peak hours. This is because DCRNN captures the spatial dependency, and is able to utilize the speed changes in neighborhood sensors for more accurate forecasting. Figure 7 visualizes examples of learned filters centered at different nodes. The star denotes the center, and colors denote the weights. We can observe that (1) weights are well localized around the center, and (2) the weights diffuse based on road network distance. More visualizations are provided in Appendix F. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            623,
+            318,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we formulated the traffic prediction on road network as a spatiotemporal forecasting problem, and proposed the diffusion convolutional recurrent neural network that captures the spatiotemporal dependencies. Specifically, we use bidirectional graph random walk to model spatial dependency and recurrent neural network to capture the temporal dynamics. We further integrated the encoder-decoder architecture and the scheduled sampling technique to improve the performance for long-term forecasting. When evaluated on two large-scale real-world traffic datasets, our approach obtained significantly better prediction than baselines. For future work, we will investigate the following two aspects (1) applying the proposed model to other spatial-temporal forecasting tasks; (2) modeling the spatiotemporal dependency when the underlying graph structure is evolving, e.g., the K nearest neighbor graph for moving objects. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            326,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This research has been funded in part by NSF grants CNS-1461963, IIS-1254206, IIS-1539608, Caltrans-65A0533, the USC Integrated Media Systems Center (IMSC), and the USC METRANS Transportation Center. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of any of the sponsors such as NSF. Also, the authors would like to thank Shang-Hua Teng, Dehua Cheng and Siyang Li for helpful discussions and comments. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016. ",
+        "bbox": [
+            171,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016. ",
+        "bbox": [
+            169,
+            164,
+            825,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In NIPS, pp. 1171–1179, 2015. ",
+        "bbox": [
+            171,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in Neural Information Processing Systems, pp. 2546–2554, 2011. ",
+        "bbox": [
+            171,
+            239,
+            825,
+            270
+        ],
+        "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": [
+            171,
+            279,
+            823,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pinlong Cai, Yunpeng Wang, Guangquan Lu, Peng Chen, Chuan Ding, and Jianping Sun. A spatiotemporal correlative k-nearest neighbor model for short-term traffic multistep forecasting. Transportation Research Part C: Emerging Technologies, 62:21–34, 2016. ",
+        "bbox": [
+            174,
+            316,
+            825,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ennio Cascetta. Transportation systems engineering: theory and methods, volume 49. Springer Science & Business Media, 2013. ",
+        "bbox": [
+            173,
+            369,
+            823,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dehua Cheng, Yu Cheng, Yan Liu, Richard Peng, and Shang-Hua Teng. Efficient sampling for gaussian graphical models via spectral sparsification. In Conference on Learning Theory, pp. 364–390, 2015. ",
+        "bbox": [
+            173,
+            407,
+            826,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xingyi Cheng, Ruiqing Zhang, Jie Zhou, and Wei Xu. Deeptransport: Learning spatial-temporal dependency for traffic condition forecasting. arXiv preprint arXiv:1709.09585, 2017. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In NIPS, pp. 3837–3845, 2016. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dingxiong Deng, Cyrus Shahabi, Ugur Demiryurek, Linhong Zhu, Rose Yu, and Yan Liu. Latent space model for road networks to predict time-varying traffic. In SIGKDD, pp. 1525–1534, 2016. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Donald R Drew. Traffic flow theory and control. Technical report, 1968. ",
+        "bbox": [
+            174,
+            613,
+            648,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gaetano Fusco, Chiara Colombaroni, and Natalia Isaenko. Short-term speed predictions exploiting big data on large urban road networks. Transportation Research Part C: Emerging Technologies, 73:183–201, 2016. ",
+        "bbox": [
+            174,
+            637,
+            826,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In ICML, 2017. ",
+        "bbox": [
+            166,
+            689,
+            825,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            173,
+            727,
+            826,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Douglas Hamilton. Time series analysis, volume 2. Princeton university press Princeton, 1994. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yotam Hechtlinger, Purvasha Chakravarti, and Jining Qin. A generalization of convolutional neural networks to graph-structured data. arXiv preprint arXiv:1704.08165, 2017. ",
+        "bbox": [
+            171,
+            804,
+            825,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "H. V. Jagadish, Johannes Gehrke, Alexandros Labrinidis, Yannis Papakonstantinou, Jignesh M. Patel, Raghu Ramakrishnan, and Cyrus Shahabi. Big data and its technical challenges. Commun. ACM, 57(7):86–94, July 2014. ",
+        "bbox": [
+            173,
+            843,
+            826,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nikolay Laptev, Jason Yosinski, Li Erran Li, and Slawek Smyl. Time-series extreme event forecasting with neural networks at Uber. In Int. Conf. on Machine Learning Time Series Workshop, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marco Lippi, Marco Bertini, and Paolo Frasconi. Short-term traffic flow forecasting: An experimental comparison of time-series analysis and supervised learning. ITS, IEEE Transactions on, 14(2): 871–882, 2013. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Liu, Yu Zheng, Sanjay Chawla, Jing Yuan, and Xie Xing. Discovering spatio-temporal causal interactions in traffic data streams. In SIGKDD, pp. 1010–1018. ACM, 2011. ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yisheng Lv, Yanjie Duan, Wenwen Kang, Zhengxi Li, and Fei-Yue Wang. Traffic flow prediction with big data: A deep learning approach. ITS, IEEE Transactions on, 16(2):865–873, 2015. ",
+        "bbox": [
+            171,
+            229,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolei Ma, Zhuang Dai, Zhengbing He, Jihui Ma, Yong Wang, and Yunpeng Wang. Learning traffic as images: a deep convolutional neural network for large-scale transportation network speed prediction. Sensors, 17(4):818, 2017. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Youngjoo Seo, Michael Defferrard, Pierre Vandergheynst, and Xavier Bresson. Structured sequence ¨ modeling with graph convolutional recurrent networks. arXiv preprint arXiv:1612.07659, 2016. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, pp. 3104–3112, 2014. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shang-Hua Teng et al. Scalable algorithms for data and network analysis. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Theoretical Computer Science, 12(1–2):1–274, 2016. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eleni I Vlahogianni, Matthew G Karlaftis, and John C Golias. Short-term traffic forecasting: Where we are and where were going. Transportation Research Part C: Emerging Technologies, 43:3–19, 2014. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuankai Wu and Huachun Tan. Short-term traffic flow forecasting with spatial-temporal correlation in a hybrid deep learning framework. arXiv preprint arXiv:1612.01022, 2016. ",
+        "bbox": [
+            174,
+            587,
+            821,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuanchang Xie, Kaiguang Zhao, Ying Sun, and Dawei Chen. Gaussian processes for short-term traffic volume forecasting. Transportation Research Record: Journal of the Transportation Research Board, (2165):69–78, 2010. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional neural network: A deep learning framework for traffic forecasting. arXiv preprint arXiv:1709.04875, 2017a. ",
+        "bbox": [
+            169,
+            676,
+            823,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hsiang-Fu Yu, Nikhil Rao, and Inderjit S Dhillon. Temporal regularized matrix factorization for high-dimensional time series prediction. In Advances in Neural Information Processing Systems, pp. 847–855, 2016. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rose Yu, Yaguang Li, Cyrus Shahabi, Ugur Demiryurek, and Yan Liu. Deep learning: A generic approach for extreme condition traffic forecasting. In SIAM International Conference on Data Mining (SDM), 2017b. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junbo Zhang, Yu Zheng, Dekang Qi, Ruiyuan Li, and Xiuwen Yi. Dnn-based prediction model for spatio-temporal data. In Proceedings of the 24th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, pp. 92. ACM, 2016. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junbo Zhang, Yu Zheng, and Dekang Qi. Deep spatio-temporal residual networks for citywide crowd flows prediction. In AAAI, pp. 1655–1661, 2017. ",
+        "bbox": [
+            176,
+            869,
+            821,
+            898
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            264,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A NOTATION ",
+        "bbox": [
+            174,
+            132,
+            277,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/9636ecbc2e00d30948085c95a162764de04397f4b8ee70f24ac9df4a96549c36.jpg",
+        "table_caption": [
+            "Table 3: Notation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name g</td><td>a graph</td></tr><tr><td>V,Ui m W,Wij, D,D1,Do L Φ,△</td><td>nodes of a graph,|V|= N and the i-th node. edges of a graph weight matrix of a graph and its entries undirected degree matrix, In-degree/out-degree matrix normalized graphLaplacian eigen-vector matrix and eigen-value matrix of L X,X∈RN×P a graph signal,and the predicted graph signal. a graph signal at time t. output of the diffusion convolutional layer.</td></tr></table>",
+        "bbox": [
+            246,
+            190,
+            746,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 3 summarizes the main notations used in the paper. ",
+        "bbox": [
+            173,
+            391,
+            545,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B EFFICIENT CALCULATION OF EQUATION 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            496,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Equation 2 can be decomposed into two parts with the same time complexity, i.e., one part with $D _ { O } ^ { - 1 } W$ and the other part with $D _ { I } ^ { - 1 } W ^ { \\boldsymbol { \\mathsf { T } } }$ . Thus we will only show the time complexity of the first part. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            492
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Let $T _ { k } ( { \\pmb x } ) = \\left( { \\pmb D } _ { O } ^ { - 1 } { \\pmb W } \\right) ^ { k } { \\pmb x }$ , The first part of Equation 2 can be rewritten as ",
+        "bbox": [
+            176,
+            498,
+            666,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3241845d1db442bc992ab23c7f5c009084401da41e2774fb6120af36cde395e4.jpg",
+        "text": "$$\n\\sum _ { k = 0 } ^ { K - 1 } \\theta _ { k } T _ { k } ( X _ { : , p } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            523,
+            555,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "As $T _ { k + 1 } ( { \\pmb x } ) = D _ { O } ^ { - 1 } { \\pmb W } T _ { k } ( { \\pmb x } )$ and $D _ { O } ^ { - 1 } W$ is sparse, it is easy to see that Equation 4 can be calculated using ${ \\cal { O } } \\breve { ( } K )$ recursive sparse-dense matrix multiplication each with time complexity $O ( | \\mathcal { E } | )$ . Consequently, the time complexities of both Equation 2 and Equation 4 are $O ( K | \\bar { \\mathcal { E } } | )$ . For dense graph, we may use spectral sparsification (Cheng et al., 2015) to make it sparse. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C RELATION WITH SPECTRAL GRAPH CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            646,
+            560,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof. The spectral graph convolution utilizes the concept of normalized graph Laplacian $L =$ $D ^ { - { \\frac { 1 } { 2 } } } ( D - \\bar { W } ) D ^ { - { \\frac { 1 } { 2 } } } = \\Phi \\Lambda \\Phi ^ { \\intercal }$ . ChebNet parametrizes $f _ { \\theta }$ to be a $K$ order polynomial of $\\pmb { \\Lambda }$ , and calculates it using stable Chebyshev polynomial basis. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7e6de6cb8090a893ae334c2efc824a3b8d40a3af33d1f53d2d67df0a0dcf6f6.jpg",
+        "text": "$$\n{ \\cal X } _ { : , p } \\star _ { \\mathscr G } f _ { \\theta } = \\Phi \\left( \\sum _ { k = 0 } ^ { K - 1 } \\theta _ { k } { \\bf A } ^ { k } \\right) \\Phi ^ { \\intercal } { \\cal X } _ { : , p } = \\sum _ { k = 0 } ^ { K - 1 } \\theta _ { k } { \\cal L } ^ { k } { \\pmb X } _ { : , p } = \\sum _ { k = 0 } ^ { K - 1 } \\tilde { \\theta } _ { k } T _ { k } ( { \\tilde { \\cal L } } ) { \\pmb X } _ { : , p }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            722,
+            759,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $T _ { 0 } ( x ) = 1 , T _ { 1 } ( x ) = x , T _ { k } ( x ) = x T _ { k - 1 } ( x ) - T _ { k - 2 } ( x )$ are the basis of the Cheyshev polynomial. Let $\\lambda _ { m a x }$ denote the largest eigenvalue of $\\pmb { L }$ , and $\\begin{array} { r } { \\tilde { \\pmb { L } } = \\frac { 2 } { \\lambda _ { m a x } } \\pmb { L } - \\pmb { I } } \\end{array}$ represents a rescaling of the graph Laplacian that maps the eigenvalues from $[ 0 , \\lambda _ { m a x } ]$ to $[ - 1 , 1 ]$ since Chebyshev polynomial forms an orthogonal basis in $[ - 1 , 1 ]$ . Equation 5 can be considered as a polynomial of $\\tilde { L }$ and we will show that the output of ChebNet Convolution is similar to the output of diffusion convolution up to constant scaling factor. Assume $\\lambda _ { m a x } = 2$ and ${ \\cal D } _ { I } = { \\cal D } _ { O } = { \\cal D }$ for undirected graph. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            863
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36767e8f419e515fdb38a56528d15cc38fd6ae2c267dda3fefb954de01c7be98.jpg",
+        "text": "$$\n\\tilde { L } = D ^ { - \\frac { 1 } { 2 } } ( D - W ) D ^ { - \\frac { 1 } { 2 } } - I = - D ^ { - \\frac { 1 } { 2 } } W D ^ { - \\frac { 1 } { 2 } } \\sim - D ^ { - 1 } W\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            867,
+            712,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$\\tilde { L }$ is similar to the negative random walk transition matrix, thus the output of Equation 5 is also similar to the output of Equation 2 up to constant scaling factor. □ ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/62960aa48867d2808dbc58d1790eafab631251035be24e20ae7b19ea1d9e802b.jpg",
+        "image_caption": [
+            "Figure 8: Sensor distribution of the METR-LA and PEMS-BAY dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            111,
+            812,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D MORE RELATED WORK AND DISCUSSION ",
+        "bbox": [
+            174,
+            371,
+            493,
+            385
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xie et al. (2010) introduce a Gaussian processes (GPs) based method. GPs are hard to scale to the large dataset and are generally not suitable for relatively long-term traffic prediction like 1 hour (i.e.,12 steps ahead), as the variance can be accumulated and becomes extremely large. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cai et al. (2016) propose to use spatiotemporal nearest neighbor for traffic forecasting (ST-KNN). Though ST-KNN considers both the spatial and the temporal dependencies, it has the following drawbacks. As shown in Fusco et al. (2016), ST-KNN performs independent forecasting for each individual road. The prediction of a road is a weighted combination of its own historical traffic speeds. This makes it hard for ST-KNN to fully utilize information from neighbors. Besides, ST-KNN is a non-parametric approach and each road is modeled and calculated separately (Cai et al., 2016), which makes it hard to generalize to unseen situations and to scale to large datasets. Finally, in ST-KNN, all the similarities are calculated using hand-designed metrics with few learnable parameters, and this may limit its representational power. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            575
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cheng et al. (2017) propose DeepTransport which models the spatial dependency by explicitly collecting certain number of upstream and downstream roads for each individual road and then conduct convolution on these roads respectively. Comparing with Cheng et al. (2017), DCRNN models the spatial dependency in a more systematic way, i.e., generalizing convolution to the traffic sensor graph based on the diffusion nature of traffic. Besides, we derive DCRNN from the property of random walk and show that the popular spectral convolution ChebNet is a special case of our method. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            666
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The proposed approach is also related to graph embedding techniques, e.g., Deepwalk (Perozzi et al., 2014), node2vec (Grover & Leskovec, 2016) which learn a low dimension representation for each node in the graph. DCRNN also learns a representation for each node. The learned representations capture both the spatial and the temporal dependency and at the same time are optimized with regarding to the objective, e.g., future traffic speeds. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "E DETAILED EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            462,
+            784
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "HA Historical Average, which models the traffic flow as a seasonal process, and uses weighted average of previous seasons as the prediction. The period used is 1 week, and the prediction is based on aggregated data from previous weeks. For example, the prediction for this Wednesday is the averaged traffic speeds from last four Wednesdays. As the historical average method does not depend on short-term data, its performance is invariant to the small increases in the forecasting horizon ",
+        "bbox": [
+            174,
+            799,
+            825,
+            869
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { A R I M A } _ { k a l }$ : Auto-Regressive Integrated Moving Average model with Kalman filter. The orders are (3, 0, 1), and the model is implemented using the statsmodel python package. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "VAR Vector Auto-regressive model (Hamilton, 1994). The number of lags is set to 3, and the model is implemented using the statsmodel python package. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SVR Linear Support Vector Regression, the penalty term $C = 0 . 1$ , the number of historical observation is 5. ",
+        "bbox": [
+            174,
+            147,
+            825,
+            176
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The following deep neural network based approaches are also included. ",
+        "bbox": [
+            174,
+            183,
+            642,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "FNN Feed forward neural network with two hidden layers, each layer contains 256 units. The initial learning rate is $1 e ^ { - 3 }$ , and reduces to $\\frac { 1 } { 1 0 }$ every 20 epochs starting at the 50th epochs. In addition, for all hidden layers, dropout with ratio 0.5 and L2 weight decay $1 e ^ { - 2 }$ is used. The model is trained with batch size 64 and MAE as the loss function. Early stop is performed by monitoring the validation error. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "FC-LSTM The Encoder-decoder framework using LSTM with peephole (Sutskever et al., 2014). Both the encoder and the decoder contain two recurrent layers. In each recurrent layer, there are 256 LSTM units, L1 weight decay is $2 e ^ { - 5 }$ , L2 weight decay $5 e ^ { - 4 }$ . The model is trained with batch size 64 and loss function MAE. The initial learning rate is 1e-4 and reduces to 110 every 10 epochs starting from the 20th epochs. Early stop is performed by monitoring the validation error. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            372
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "DCRNN : Diffusion Convolutional Recurrent Neural Network. Both encoder and decoder contain two recurrent layers. In each recurrent layer, there are 64 units, the initial learning rate is $1 e ^ { - 2 }$ , and reduces to $\\frac { 1 } { 1 0 }$ every 10 epochs starting at the 20th epoch and early stopping on the validation dataset is used. Besides, the maximum steps of random walks, i.e., $K$ , is set to 3. For scheduled sampling, the thresholded inverse sigmoid function is used as the probability decay: ",
+        "bbox": [
+            173,
+            387,
+            825,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45b825196d2a67adcf2ebd0f526be91721b98174762fb38adbb1d952ddbdfffb.jpg",
+        "text": "$$\n\\epsilon _ { i } = \\frac { \\tau } { \\tau + \\exp \\left( i / \\tau \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            463,
+            566,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $i$ is the number of iterations while $\\tau$ are parameters to control the speed of convergence. $\\tau$ is set to 3,000 in the experiments. The implementation is available in https://github.com/ liyaguang/DCRNN. ",
+        "bbox": [
+            174,
+            501,
+            826,
+            544
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            281,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on two real-world large-scale datasets: ",
+        "bbox": [
+            174,
+            583,
+            589,
+            599
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• METR-LA This traffic dataset contains traffic information collected from loop detectors in the highway of Los Angeles County (Jagadish et al., 2014). We select 207 sensors and collect 4 months of data ranging from Mar 1st 2012 to Jun 30th 2012 for the experiment. The total number of observed traffic data points is 6,519,002.   \nPEMS-BAY This traffic dataset is collected by California Transportation Agencies (CalTrans) Performance Measurement System (PeMS). We select 325 sensors in the Bay Area and collect 6 months of data ranging from Jan 1st 2017 to May 31th 2017 for the experiment. The total number of observed traffic data points is 16,937,179. ",
+        "bbox": [
+            215,
+            614,
+            826,
+            737
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The sensor distributions of both datasets are visualized in Figure 8. ",
+        "bbox": [
+            173,
+            752,
+            611,
+            767
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In both of those datasets, we aggregate traffic speed readings into 5 minutes windows, and apply Z-Score normalization. $70 \\%$ of data is used for training, $20 \\%$ are used for testing while the remaining $10 \\%$ for validation. To construct the sensor graph, we compute the pairwise road network distances between sensors and build the adjacency matrix using thresholded Gaussian kernel (Shuman et al., 2013). ",
+        "bbox": [
+            174,
+            775,
+            826,
+            843
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ce0bbb1d47891b0f6953861d6e71a3963ed3a812ea620c080a78bad815b2927.jpg",
+        "text": "$$\nW _ { i j } = \\exp \\left( - \\frac { \\mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \\sigma ^ { 2 } } \\right) \\quad \\mathrm { i f ~ } \\mathrm { d i s t } ( v _ { i } , v _ { j } ) \\leq \\kappa , \\mathrm { o t h e r w i s e ~ } 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            843,
+            712,
+            878
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { i j }$ represents the edge weight between sensor $v _ { i }$ and sensor $v _ { j }$ , $\\mathrm { d i s t } ( v _ { i } , v _ { j } )$ denotes the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ . $\\sigma$ is the standard deviation of distances and $\\kappa$ is the threshold. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E.2 METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            282,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Suppose $\\pmb { x } = x _ { 1 } , \\cdots , x _ { n }$ represents the ground truth, $\\hat { \\pmb x } = \\hat { x } _ { 1 } , \\cdots , \\hat { x } _ { n }$ represents the predicted values, and $\\Omega$ denotes the indices of observed samples, the metrics are defined as follows. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            156
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Root Mean Square Error (RMSE) ",
+        "bbox": [
+            174,
+            162,
+            397,
+            178
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b31b4fbbf2f5d5b002ceb5957370a0f241bbb6387c9200d9e67f229f4d593bc8.jpg",
+        "text": "$$\n\\mathrm { R M S E } ( { \\pmb x } , \\hat { \\pmb x } ) = \\sqrt { \\frac { 1 } { | { \\pmb \\Omega } | } \\sum _ { i \\in \\Omega } ( x _ { i } - \\hat { x } _ { i } ) ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            184,
+            625,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Mean Absolute Percentage Error (MAPE) ",
+        "bbox": [
+            176,
+            239,
+            452,
+            255
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfefb86c341eb11a1424227e538ba83329a0706b637c1b12055054209af7be90.jpg",
+        "text": "$$\n\\mathrm { M A P E } ( \\pmb { x } , \\hat { \\pmb { x } } ) = \\frac { 1 } { | \\pmb { \\Omega } | } \\sum _ { i \\in \\Omega } \\left| \\frac { x _ { i } - \\hat { x } _ { i } } { x _ { i } } \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            261,
+            614,
+            300
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Mean Absolute Error (MAE) ",
+        "bbox": [
+            174,
+            314,
+            367,
+            329
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9d1bff5ef2e6cf3bab1871cf66eca36db5e28e8317d626d8f38871a450db9e8.jpg",
+        "text": "$$\n\\mathrm { M A E } ( { \\pmb x } , \\hat { \\pmb x } ) = \\frac { 1 } { | \\pmb { \\Omega } | } \\sum _ { i \\in \\pmb { \\Omega } } | x _ { i } - \\hat { x } _ { i } |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            335,
+            607,
+            372
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F MODEL VISUALIZATION ",
+        "bbox": [
+            174,
+            387,
+            370,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2aa0dcd43a41cbf7dc306a60997a58af83cf306db959dd2637f12504f5df574.jpg",
+        "image_caption": [
+            "Figure 9: Sensor correlations between the center sensor and its neighborhoods for different forecasting horizons. The correlations are estimated using regularized VAR. We observe that the correlations are localized and closer neighborhoods usually have larger relevance, and the magnitude of correlation quickly decay with the increase of distance which is consistent with the diffusion process on the graph. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            417,
+            692,
+            618
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/31bdbfa746c2cd8ce1cc9ecbcfe3cd80f190ce51206ec301436e295f4a5a4e04.jpg",
+        "image_caption": [
+            "Figure 10: Traffic time series forecasting visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            92,
+            751,
+            950
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a6dba74782b6e903be82f579ad03fc305e95eb3093473263a5a95fc641af710.jpg",
+        "image_caption": [
+            "Figure 11: Traffic time series forecasting visualization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            93,
+            754,
+            954
+        ],
+        "page_idx": 15
+    }
+]

parse/train/SyevYxHtDB/SyevYxHtDB.md

@@ -0,0 +1,369 @@
+# PREDICTION POISONING: TOWARDS DEFENSES AGAINST DNN MODEL STEALING ATTACKS
+
+Tribhuvanesh Orekondy1, Bernt Schiele1, Mario Fritz2
+
+1 Max Planck Institute for Informatics   
+2 CISPA Helmholtz Center for Information Security   
+Saarland Informatics Campus, Germany   
+{orekondy, schiele}@mpi-inf.mpg.de, fritz@cispa.saarland
+
+# ABSTRACT
+
+High-performance Deep Neural Networks (DNNs) are increasingly deployed in many real-world applications e.g., cloud prediction APIs. Recent advances in model functionality stealing attacks via black-box access (i.e., inputs in, predictions out) threaten the business model of such applications, which require a lot of time, money, and effort to develop. Existing defenses take a passive role against stealing attacks, such as by truncating predicted information. We find such passive defenses ineffective against DNN stealing attacks. In this paper, we propose the first defense which actively perturbs predictions targeted at poisoning the training objective of the attacker. We find our defense effective across a wide range of challenging datasets and DNN model stealing attacks, and additionally outperforms existing defenses. Our defense is the first that can withstand highly accurate model stealing attacks for tens of thousands of queries, amplifying the attacker’s error rate up to a factor of $8 5 \times$ with minimal impact on the utility for benign users.
+
+# 1 INTRODUCTION
+
+Effectiveness of state-of-the-art DNN models at a variety of predictive tasks has encouraged their usage in a variety of real-world applications e.g., home assistants, autonomous vehicles, commercial cloud APIs. Models in such applications are valuable intellectual property of their creators, as developing them for commercial use is a product of intense labour and monetary effort. Hence, it is vital to preemptively identify and control threats from an adversarial lens focused at such models. In this work we address model stealing, which involves an adversary attempting to counterfeit the functionality of a target victim ML model by exploiting black-box access (query inputs in, posterior predictions out).
+
+Stealing attacks dates back to Lowd & Meek (2005), who addressed reverse-engineering linear spam classification models. Recent literature predominantly focus on DNNs (specifically CNN image classifiers), and are shown to be highly effective (Tramer et al., 2016) on complex models (Orekondy \` et al., 2019), even without knowledge of the victim’s architecture (Papernot et al., 2017b) nor the training data distribution. The attacks have also been shown to be highly effective at replicating pay-per-query image prediction APIs, for as little as $\$ 30$ (Orekondy et al., 2019).
+
+Defending against stealing attacks however has received little attention and is lacking. Existing defense strategies aim to either detect stealing query patterns (Juuti et al., 2019), or degrade quality of predicted posterior via perturbation. Since detection makes strong assumptions on the attacker’s query distribution (e.g., small $L _ { 2 }$ distances between successive queries), our focus is on the more popular perturbation-based defenses. A common theme among such defenses is accuracypreserving posterior perturbation: the posterior distribution is manipulated while retaining the top-1 label. For instance, rounding decimals (Tramer et al., 2016), revealing only high-confidence predic- \` tions (Orekondy et al., 2019), and introducing ambiguity at the tail end of the posterior distribution (Lee et al., 2018). Such strategies benefit from preserving the accuracy metric of the defender. However, in line with previous works (Tramer et al., 2016; Orekondy et al., 2019; Lee et al., 2018), we \` find models can be effectively stolen using just the top-1 predicted label returned by the black-box. Specifically, in many cases we observe ${ < } 1 \%$ difference between attacks that use the full range of posteriors (blue line in Fig. 1) to train stolen models and the top-1 label (orange line) alone. In this paper, we work towards effective defenses (red line in Fig. 1) against DNN stealing attacks with minimal impact to defender’s accuracy.
+
+The main insight to our approach is that unlike a benign user, a model stealing attacker additionally uses the predictions to train a replica model. By introducing controlled perturbations to predictions, our approach targets poisoning the training objective (see Fig. 2). Our approach allows for a utility-preserving defense, as well as trading-off a marginal utility cost to significantly degrade attacker’s performance. As a practical benefit, the defense involves a single hyperparameter (perturbation utility budget) and can be used with minimal overhead to any classification model without retraining or modifications.
+
+We rigorously evaluate our approach by defending six victim models, against four recent and effective DNN stealing attack strategies (Papernot et al., 2017b; Juuti et al., 2019; Orekondy et al., 2019). Our defense consistently mitigates all stealing attacks and further shows improvements over multiple baselines. In particular, we find our defenses degrades the attacker’s query sample efficiency by 1-2 orders of magnitude. Our approach significantly reduces the attacker’s performance (e.g., $30 \%$ reduction on MNIST and 13- $28 \%$ on CUB200) at a marginal cost $( 1 - 2 \% )$ to defender’s test accuracy. Furthermore, our approach can achieve the same level of mitigation as baseline defenses, but by introducing significantly lesser perturbation.
+
+![](images/bff97c754b1d4700fefabc6824e8d22acec35a2800990729045a6beb9463423c.jpg)  
+Figure 1: We find existing defenses (orange line) ineffective against recent attacks. Our defense (red line) in contrast significantly mitigates the attacks.
+
+Contributions. (i) We propose the first utility-constrained defense against DNN model stealing attacks; (ii) We present the first active defense which poisons the attacker’s training objective by introducing bounded perturbations; and (iii) Through extensive experiments, we find our approach consistently mitigate various attacks and additionally outperform baselines.
+
+![](images/7cb8f869085e7ca9b774c9b54e00d567678b3bca65d41bb38c3727bb68920ca2.jpg)  
+Figure 2: We perturb posterior predictions $\tilde { \pmb { y } } = \pmb { y } + \pmb { \delta }$ , with an objective of poisoning the adversary’s gradient signal.
+
+# 2 RELATED LITERATURE
+
+Model stealing attacks (also referred to as ‘extraction’ or ‘reverse-engineering’) in literature aim to infer hyperparameters (Oh et al., 2018; Wang & Gong, 2018), recover exact parameters (Lowd & Meek, 2005; Tramer et al., 2016; Milli et al., 2018), or extract the functionality (Correia-Silva et al., \` 2018; Orekondy et al., 2019) of a target black-box ML model. In some cases, the extracted model information is optionally used to perform evasion attacks (Lowd & Meek, 2005; Nelson et al., 2010; Papernot et al., 2017b). The focus of our work is model functionality stealing, where the attacker’s yardstick is test-set accuracy of the stolen model. Initial works on stealing simple linear models (Lowd & Meek, 2005) have been recently succeeded by attacks shown to be effective on complex CNNs (Papernot et al., 2017b; Correia-Silva et al., 2018; Orekondy et al., 2019) (see Appendix B for an exhaustive list). In this work, we works towards defenses targeting the latter line of DNN model stealing attacks.
+
+Since ML models are often deployed in untrusted environments, a long line of work exists on guaranteeing certain (often orthogonal) properties to safeguard against malicious users. The properties include security (e.g., robustness towards adversarial evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014; Madry et al., 2018)) and integrity (e.g., running in untrusted environments (Tramer & Boneh, 2019)). To prevent leakage of private attributes (e.g., identities) specific to training data in the resulting ML model, differential privacy (DP) methods (Dwork et al., 2014) introduce randomization during training (Abadi et al., 2016; Papernot et al., 2017a). In contrast, our defense objective is to provide confidentiality and protect the functionality (intellectual property) of the ML model against illicit duplication.
+
+Model stealing defenses are limited. Existing works (which is primarily in multiclass classification settings) aim to either detect stealing attacks (Juuti et al., 2019; Kesarwani et al., 2018; Nelson et al., 2009; Zheng et al., 2019) or perturb the posterior prediction. We focus on the latter since detection involves making strong assumptions on adversarial query patterns. Perturbation-based defenses are predominantly non-randomized and accuracy-preserving (i.e., top-1 label is unchanged). Approaches include revealing probabilities only of confident classes (Orekondy et al., 2019), rounding probabilities (Tramer et al., 2016), or introducing ambiguity in posteriors (Lee et al., 2018). None \` of the existing defenses claim to mitigate model stealing, but rather they only marginally delay the attack by increasing the number of queries. Our work focuses on presenting an effective defense, significantly decreasing the attacker’s query sample efficiency within a principled utility-constrained framework.
+
+# 3 PRELIMINARIES
+
+Model Functionality Stealing. Model stealing attacks are cast as an interaction between two parties: a victim/defender $V$ (‘teacher’ model) and an attacker $A$ (‘student’ model). The only means of communication between the parties are via black-box queries: attacker queries inputs $\textbf { \em x } \in ~ \mathcal { X }$ and defender returns a posterior probability distribution $\dot { \pmb { y } } \in \Delta ^ { K } = P ( \pmb { y } | \pmb { x } ) = \dot { F _ { V } } ( \pmb { x } )$ , where $\Delta ^ { K } = \{ \pmb { y } \subseteq 0 , \mathbf { 1 } ^ { T } \pmb { y } = \overset { \cdot } { 1 } \}$ is the probability simplex over $K$ classes (we use $K$ instead of $K - 1$ for notational convenience). The attack occurs in two (sometimes overlapping) phases: (i) querying: the attacker uses the black-box as an oracle labeler on a set of inputs to construct a ‘transfer set’ of input-prediction pairs $\mathcal { D } ^ { \mathrm { t r a n s f e r } } = \{ ( \pmb { x } _ { i } , \pmb { y } _ { i } ) \} _ { i = 1 } ^ { B }$ ; and (ii) training: the attacker trains a model $F _ { A }$ to minimize the empirical risk on $\mathcal { D } ^ { \mathrm { t r a n s f e r } }$ . The end-goal of the attacker is to maximize accuracy on a held-out test-set (considered the same as that of the victim for evaluation purposes).
+
+Knowledge-limited Attacker. In model stealing, attackers justifiably lack complete knowledge of the victim model $F _ { V }$ . Of specific interest are the model architecture and the input data distribution to train the victim model $P _ { V } ( X )$ that are not known to the attacker. Since prior work (Hinton et al., 2015; Papernot et al., 2016; Orekondy et al., 2019) indicates functionality largely transfers across architecture choices, we now focus on the query data used by the attacker. Existing attacks can be broadly categorized based on inputs $\{ x \sim P _ { A } ( X ) \}$ used to query the black-box: (a) independent distribution: (Tramer et al., 2016; Correia-Silva et al., 2018; Orekondy et al., 2019) samples inputs \` from some distribution (e.g., ImageNet for images, uniform noise) independent to input data used to train the victim model; and (b) synthetic set: (Papernot et al., 2017b; Juuti et al., 2019) augment a limited set of seed data by adaptively querying perturbations (e.g., using FGSM) of existing inputs. We address both attack categories in our paper.
+
+Defense Objectives. We perturb predictions in a controlled setting: $\tilde { \pmb { y } } = F _ { V } ^ { \delta } ( \pmb { x } ) = \pmb { y } + \delta$ s.t. $\tilde { y } , y \in \Delta ^ { K }$ . The defender has two (seemingly conflicting) objectives: (i) utility: such that perturbed predictions remain useful to a benign user. We consider two utility measures: (a) $\mathsf { A c c } ( \dot { F } _ { V } ^ { \delta } , \mathcal { D } ^ { \mathrm { t e s t } } )$ : accuracy of defended model on test examples; and (b) $\mathrm { d i s t } ( { \pmb y } , \tilde { \pmb y } ) = | | { \pmb y } - \tilde { \pmb y } | | _ { p } = \epsilon$ to measure perturbation. (ii) non-replicability: to reduce the test accuracy of an attacker (denoted as $\mathsf { A c c } ( F _ { A } , \mathcal { D } ^ { \mathrm { t e s t } } ) )$ who exploits the predictions to train a replica $F _ { A }$ on $\mathcal { D } ^ { \mathrm { t r a n s f e r } }$ . For consistency, we evaluate both the defender’s and attacker’s stolen model accuracies on the same set of test examples $\mathcal { D } ^ { \mathrm { t e s t } }$ .
+
+Defender’s Assumptions. We closely mimic an assumption-free scenario similar to existing perturbation-based defenses. The scenario entails the knowledge-limited defender: (a) unaware whether a query is malicious or benign; (b) lacking prior knowledge of the strategy used by an attacker; and (c) perturbing each prediction independently (hence circumventing Sybil attacks). For added rigor, we also study attacker’s countermeasures to our defense in Section 5.
+
+# 4 APPROACH: MAXIMIZING ANGULAR DEVIATION BETWEEN GRADIENTS
+
+Motivation: Targeting First-order Approximations. We identify that the attacker eventually optimizes parameters of a stolen model $F ( \cdot ; w )$ (we drop the subscript $\cdot _ { A }$ for readability) to minimize the loss on training examples $\{ ( \pmb { x } _ { i } , \tilde { \pmb { y } } _ { i } ) \}$ . Common to a majority of optimization algorithms is estimating the first-order approximation of the empirical loss, by computing the gradient of the loss
+
+w.r.t. the model parameters ${ \pmb w } \in \mathbb { R } ^ { D }$ :
+
+$$
+\pmb { u } = - \nabla _ { \pmb { w } } L ( F ( \pmb { x } ; \pmb { w } ) , \pmb { y } )
+$$
+
+Maximizing Angular Deviation (MAD). The core idea of our approach is to perturb the posterior probabilities $\textbf {  { y } }$ which results in an adversarial gradient signal that maximally deviates (see Fig. 2) from the original gradient (Eq. 1). More formally, we add targeted noise to the posteriors which results in a gradient direction:
+
+$$
+\pmb { a } = - \nabla _ { \pmb { w } } L ( F ( \pmb { x } ; \pmb { w } ) , \tilde { \pmb { y } } )
+$$
+
+to maximize the angular deviation between the original and the poisoned gradient signals:
+
+$$
+\operatorname* { m a x } _ { \mathbf { a } } \ 2 ( 1 - \cos \angle ( \mathbf { a } , \boldsymbol { u } ) ) = \operatorname* { m a x } _ { \hat { \mathbf { a } } } \ | | \hat { \boldsymbol { a } } - \hat { \boldsymbol { u } } | | _ { 2 } ^ { 2 } \qquad \quad ( \hat { \boldsymbol { a } } = \boldsymbol { a } / | | \boldsymbol { a } | | _ { 2 } , \hat { \boldsymbol { u } } = \boldsymbol { u } / | | \boldsymbol { u } | | _ { 2 } )
+$$
+
+Given that the attacker model is trained to match the posterior predictions, such as by minimizing the cross-entropy loss $\begin{array} { r } { L ( \pmb { y } , \tilde { \pmb { y } } ) = - \sum _ { k } \tilde { y } _ { k } \log y _ { k } } \end{array}$ we rewrite Equation (2) as:
+
+$$
+a = - \nabla _ { w } L ( F ( x ; w ) , \tilde { y } ) = \nabla _ { w } \sum _ { k } \tilde { y } _ { k } \log F ( x ; w ) _ { k } = \sum _ { k } \tilde { y } _ { k } \nabla _ { w } \log F ( x ; w ) _ { k } = G ^ { T } \tilde { y } _ { k } \log F ( x ; w ) _ { k } .
+$$
+
+where $G \in \mathbb { R } ^ { K \times D }$ represents the Jacobian over log-likelihood predictions $F ( \pmb { x } ; \pmb { w } )$ over $K$ classes w.r.t. parameters ${ \pmb w } \in \mathbb { R } ^ { D }$ . By similarly rewriting Equation (1), substituting them in Equation (3) and including the constraints, we arrive at our poisoning objective (Eq. 4-7) of our approach which we refer to as MAD. We can optionally enforce preserving accuracy of poisoned prediction via constraint (8), which will be discussed shortly.
+
+$$
+\begin{array} { r l r } { \underset { \tilde { y } } { \operatorname* { m a x } } } & { \left\| \frac { \boldsymbol { G } ^ { T } \tilde { \boldsymbol { y } } } { | | \boldsymbol { G } ^ { T } \tilde { \boldsymbol { y } } | | _ { 2 } } - \frac { \boldsymbol { G } ^ { T } \boldsymbol { y } } { | | \boldsymbol { G } ^ { T } \boldsymbol { y } | | _ { 2 } } \right\| _ { 2 } ^ { 2 } } \\ { \mathrm { w h e r e } } & { \boldsymbol { G } = \nabla _ { w } \log \boldsymbol { F } ( \boldsymbol { x } ; \boldsymbol { w } ) } & { ( \boldsymbol { G } \in \mathbb { R } ^ { K \times D } ) } \\ { \mathrm { s . t } } & { \boldsymbol { \tilde { y } } \in \Delta ^ { K } } & { ( \mathrm { S i m p l e x ~ c o n s t r a i n t } ) } \\ & { \mathrm { d i s t } ( \boldsymbol { y } , \boldsymbol { \tilde { y } } ) \le \epsilon } & { ( \mathrm { U i l i t y ~ c o n s t r a i n t } ) } \\ & { \mathrm { ~ a r g ~ } _ { k } } & { \mathrm { ~ ( F o r ~ v a r i a n t ~ } \mathsf { M A D - a r g m a x } ) } \end{array}
+$$
+
+The above presents a challenge of black-box optimization problem for the defense since the defender justifiably lacks access to the attacker model $F$ (Eq. 5). Apart from addressing this challenge in the next few paragraphs, we also discuss (a) solving a non-standard and non-convex constrained maximization objective; and (b) preserving accuracy of predictions via constraint (8).
+
+Estimating $G$ . Since we lack access to adversary’s model $F$ , we estimate the jacobian ${ \pmb G } =$ $\nabla _ { \boldsymbol { w } } \log F _ { \mathrm { s u r } } ( \boldsymbol { x } ; \boldsymbol { w } )$ (Eq. 5) per input query $_ { \textbf { \em x } }$ using a surrogate model $F _ { \mathrm { s u r } }$ . We empirically determined (details in Appendix E.1) choice of architecture of $F _ { \mathrm { s u r } }$ robust to choices of adversary’s architecture $F$ . However, the initialization of $F _ { \mathrm { s u r } }$ plays a crucial role, with best results on a fixed randomly initialized model. We conjecture this occurs due to surrogate models with a high loss provide better gradient signals to guide the defender.
+
+Heuristic Solver. Gradient-based strategies to optimize objective (Eq. 4) often leads to poor local maxima. This is in part due to the objective increasing in all directions around point $\textbf {  { y } }$ (assuming $G$ is full-rank), making optimization sensitive to initialization. Consequently, we resort to a heuristic to solve for $\tilde { y }$ . Our approach is motivated by Hoffman (1981), who show that the maximum of a convex function over a compact convex set occurs at the extreme points of the set. Hence, our two-step solver: (i) searches for a maximizer $\boldsymbol { y } ^ { * }$ for (4) by iterating over the $K$ extremes ${ \bf { \nabla } } _ { \bf { { y } } _ { k } }$ (where $y _ { k } { = } 1 \rangle$ ) of the probability simplex $\Delta ^ { K }$ ; and (ii) then computes a perturbed posterior $\tilde { y }$ as a linear interpolation of the original posteriors $\textbf {  { y } }$ and the maximizer $\pmb { y } ^ { * } \colon \bar { \pmb { y } } = ( 1 - \bar { \alpha } ) \pmb { y } + \alpha \pmb { y } ^ { * }$ , where $\alpha$ is selected such that the utility constraint (Eq. 7) is satisfied. We further elaborate on the solver and present a pseudocode in Appendix C.
+
+Variant: MAD-argmax. Within our defense formulation, we encode an additional constraint (Eq. 8) to preserve the accuracy of perturbed predictions. MAD-argmax variant helps us perform accuracy-preserving perturbations similar to prior work. But in contrast, the perturbations are constrained (Eq. 7) and are specifically introduced to maximize the MAD objective. We enforce the accuracy-preserving constraint in our solver by iterating over extremes of intersection of sets Eq.(6) and (8): $\begin{array} { r } { \dot { \Delta { \phi } } _ { k } ^ { K } = \{ { \pmb y } ^ { \top } { } \subseteq 0 , { \bf 1 } ^ { T } { \pmb y } = 1 , y _ { k } \geq y _ { j } , k \} \not = j \} \subseteq \breve { \Delta } ^ { K } . } \end{array}$ .
+
+# 5 EXPERIMENTAL RESULTS
+
+# 5.1 EXPERIMENTAL SETUP
+
+Victim Models and Datasets. We set up six victim models (see column ${ } ^ { \bullet } F _ { V }$ ’ in Table 1), each model trained on a popular image classification dataset. All models are trained using SGD $\mathrm { L R } =$ 0.1) with momentum (0.5) for 30 (LeNet) or 100 epochs (VGG16), with a LR decay of 0.1 performed every 50 epochs. We train and evaluate each victim model on their respective train and test sets.
+
+Attack Strategies. We hope to broadly address all DNN model stealing strategies during our defense evaluation. To achieve this, we consider attacks that vary in query data distributions (independent and synthetic; see Section 3) and strategies (random and adaptive). Specifically, in our experiments we use the following attack models: (i) Jacobian-based Data Augmentation ‘JBDA’ (Papernot et al., 2017b);
+
+Table 1: Victim models and Accuracies. All accuracies are w.r.t undefended victim model.   
+
+<table><tr><td>Fv</td><td>Acc(Fv)</td><td colspan="4">Acc(FA)</td></tr><tr><td></td><td></td><td>jbda</td><td>jbself</td><td>jbtop3</td><td>k.off</td></tr><tr><td>MNIST (LeNet)</td><td>99.4</td><td>89.2</td><td>89.4</td><td>87.3</td><td>99.1</td></tr><tr><td>FashionMNIST(LeNet)</td><td>92.0</td><td>38.7</td><td>45.8</td><td>68.7</td><td>69.2</td></tr><tr><td>CIFAR10 (VGG16)</td><td>92.0</td><td>28.6</td><td>20.7</td><td>73.8</td><td>78.7</td></tr><tr><td>CIFAR100 (VGG16)</td><td>72.2</td><td>5.3</td><td>2.9</td><td>39.2</td><td>51.9</td></tr><tr><td>CUB200 (VGG16)</td><td>80.4</td><td>6.8</td><td>3.9</td><td>21.5</td><td>65.1</td></tr><tr><td>Caltech256 (VGG16)</td><td>80.0</td><td>12.5</td><td>16.0</td><td>29.5</td><td>74.6</td></tr></table>
+
+(ii,iii) ‘JB-self’ and ‘JB-top3’ (Juuti et al., 2019); and (iv) Knockoff Nets ‘knockoff’ (Orekondy et al., 2019); We follow the default configurations of the attacks where possible. A recap and implementation details of the attack models are available in Appendix D.
+
+In all attack strategies, the adversary trains a model $F _ { A }$ to minimize the cross-entropy loss on a transfer set $( \mathcal { D } ^ { \mathrm { t r a n s f e r } } = \{ ( \pmb { x } _ { i } , \tilde { \pmb { y } } _ { i } ) \} _ { i = 1 } ^ { B } )$ obtained by using the victim model $F _ { V }$ to pseudo-label inputs $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ (sampled or adaptively synthesized). By default, we use $B { = } 5 0 \mathrm { K }$ queries, which achieves reasonable performance for all attacks and additionally makes defense evaluation tractable. The size of the resulting transfer set $\scriptstyle B = 5 0 \mathrm { K }$ examples) is comparable (e.g., $1 \times$ for CIFAR10/100, $2 . 1 \times$ for Caltech256) to size of victim’s training set. In line with prior work (Papernot et al., 2016; Orekondy et al., 2019), we too find (Section 5.2.3) attack and defense performances are unaffected by choice of architectures, and hence use the victim architecture for the stolen model $F _ { A }$ . Due to the complex parameterization of VGG-16 $( 1 0 0 \mathbf { M } + )$ , we initialize the weights from a pretrained TinyImageNet or ImageNet model (except for the last FC layer, which is trained from scratch). All stolen models are trained using SGD $\scriptstyle \mathrm { ( L R = 0 . 1 }$ ) with momentum (0.5) for 30 epochs (LeNet) and 100 epochs (VGG16). We find choices of attacker’s architecture and optimization does not undermine the defense (discussed in Section 5.2.3).
+
+Effectiveness of Attacks. We evaluate accuracy of resulting stolen models from the attack strategies as-is on the victim’s test set, thereby allowing for a fair head-to-head comparison with the victim model (additional details in Appendix A and D). The stolen model test accuracies, along with undefended victim model $F _ { V }$ accuracies are reported in Table 1. We observe for all six victim models, using just 50K black-box queries, attacks are able to significantly extract victim’s functionality e.g., ${ > } 8 7 \%$ on MNIST. We find the knockoff attack to be the strongest, exhibiting reasonable performance even on complex victim models e.g., $7 4 . 6 \%$ ${ \mathsf { 0 . 9 3 } } { \times } \mathsf { A c c } ( F _ { V } ) )$ on Caltech256.
+
+How Good are Existing Defenses? Most existing defenses in literature (Tramer et al., 2016; \` Orekondy et al., 2019; Lee et al., 2018) perform some form of information truncation on the posterior probabilities e.g., rounding, returning top- $k$ labels; all strategies preserve the rank of the most confident label. We now evaluate model stealing attacks on the extreme end of information truncation, wherein the defender returns just the top-1 ‘argmax’ label. This strategy illustrates a rough lower bound on the strength of the attacker when using existing defenses. Specific to knockoff, we observe the attacker is minimally impacted on simpler datasets (e.g., $0 . 2 \%$ accuracy drop on CIFAR10; see Fig. A5 in Appendix). While this has a larger impact on more complex datasets involving numerous classes (e.g., a maximum of $2 3 . 4 \%$ drop observed on CUB200), the strategy also introduces a significant perturbation $( L _ { 1 } { = } 1 { \pm } 0 . 5 )$ to the posteriors. The results suggest existing defenses, which largely the top-1 label, are largely ineffective at mitigating model stealing attacks.
+
+Defenses: Evaluation. We evaluate all defenses on a non-replicability vs. utility curve at various operating points $\epsilon$ of the defense. We furthermore evaluate the defenses for a large query budget (50K). We use as non-replicability the accuracy of the stolen model on held-out test data $\mathcal { D } ^ { \mathrm { t e s t } }$ .
+
+![](images/91902f56490f283742cc7262836c7485569b2f806b9fd672b6ec55533ca1969d.jpg)  
+Figure 3: Attackers vs. Our Defense. Curves are obtained by varying degree of perturbation $\epsilon$ (Eq. 7) in our defense. $\uparrow$ denotes higher numbers are better and $\downarrow$ , lower numbers are better. Non-replicability objective is presented on the $x -$ -axis and utility on the $y$ -axis.
+
+We use two utility metrics: (a) accuracy: test-accuracy of the defended model producing perturbed predictions on $\mathcal { D } ^ { \mathrm { t e s t } }$ ; and (b) perturbation magnitude $\epsilon$ : measured as $L _ { 1 }$ distance $| | \pmb { y } - \tilde { \pmb { y } } | | _ { 1 }$ .
+
+Defense: Baselines. We compare our approaches against three methods: (i) reverse-sigmoid (Lee et al., 2018): which softens the posterior distribution and introduces ambiguity among nonargmax probabilities. For this method, we evaluate non-replicability and utility metrics for the defense operating at various choices of their hyperparameter $\bar { \boldsymbol { \beta } } \in [ 0 , 1 ]$ , while keeping their datasetspecific hyperparameter $\gamma$ fixed (MNIST: 0.2, FashionMNIST: 0.4, CIFAR10: 0.1, rest: 0.2). (ii) random noise: For controlled random-noise, we add uniform random noise $\delta _ { z }$ on the logit prediction scores $\tilde { z } = z + \delta _ { z }$ , where $\begin{array} { r } { z = \log ( \frac { y } { 1 - y } ) } \end{array}$ ), enforce utility by projecting $\delta _ { z }$ to an $\epsilon _ { z }$ -ball (Duchi et al., 2008), and renormalize probabilities $\begin{array} { r } { \tilde { y } = \frac { 1 } { 1 + e ^ { - \tilde { z } } } } \end{array}$ 11+e−z˜ . (iii) dp-sgd: while our method and previous two baselines perturbs predictions, we also compare against introducing randomization to victim model parameters by training with the DP-SGD algorithm (Abadi et al., 2016). DP is a popular technique to protect the model against training data inference attacks. This baseline allows us to verify whether the same protection extends to model functionality.
+
+# 5.2 RESULTS
+
+In the follow sections, we demonstrate the effectiveness of our defense rigorously evaluated across a wide range of complex datasets, attack models, defense baselines, query, and utility budgets. For readability, we first evaluate the defense against attack models, proceed to comparing the defense against strong baselines and then provide an analysis of the defense.
+
+# 5.2.1 MAD DEFENSE VS. ATTACKS
+
+Figure 3 presents evaluation of our defenses MAD (Eq. 4-7) and MAD-argmax (Eq. 4-8) against the four attack models. To successfully mitigate attacks as a defender, we want the defense curves (colored solid lines with operating points denoted by thin crosses) to move away from undefended accuracies (denoted by circular discs, where $\scriptstyle \epsilon = 0 . 0$ ) to ideal defense performances (cyan cross, where $\mathsf { A c c } ( \mathsf { D e f } . )$ is unchanged and $\mathsf { A c c } ( \mathsf { A t t } . )$ is chance-level).
+
+We observe from Figure 3 that by employing an identical defense across all datasets and attacks, the effectiveness of the attacker can be greatly reduced. Across all models, we find MAD provides reasonable operating points (above the diagonal), where defender achieves significantly higher test accuracies compared to the attacker. For instance, on MNIST, for ${ < } 1 \%$ drop in defender’s accuracy, our defense simultaneously reduces accuracy of the jbtop3 attacker by $52 \%$ $8 7 . 3 \% \to 3 5 . 7 \% )$ and knockoff by $29 \%$ $9 9 . 1 \%  6 9 . 8 \%$ ). We find similar promising results even on high-dimensional complex datasets e.g., on CUB200, a $23 \%$ $6 5 . 1 \%  4 1 . 9 \%$ ) performance drop of knockoff for $2 \%$ drop in defender’s test performance. Our results indicate effective defenses are achievable, where the defender can trade-off a marginal utility cost to drastically impede the attacker.
+
+# 5.2.2 MAD DEFENSE VS. BASELINE DEFENSES
+
+We now study how our approach compares to baseline defenses, by evaluating the defenses against the knockoff attack (which resulted in the strongest attack in our experiments). From Figure 4, we observe:
+
+![](images/1d2ec43c3846141fb8b809ed815df6405eafd30d5faf23ad174841aaccc16b44.jpg)  
+Figure 4: Knockoff attack vs. Ours $^ +$ Baseline Defenses (best seen magnified). Non-replicability is presented on the $x$ -axis. On $_ y$ -axis, we present two utility measures: (a) top: Utility $= L _ { 1 }$ distance (b) bottom: Utility $=$ Defender’s accuracy. Region above the diagonal indicates instances where defender outperforms the attacker.
+
+![](images/0870ed4a1d860ee9030cadd9e6e6bebfb275032ad733501dad3a5b9c6d49c025.jpg)  
+Figure 5: Attacker argmax. Follow-up to Figure 4b (CIFAR10), but with attacker using only the argmax label.
+
+![](images/1e4ed37a96023b47935fd50b2b4ad45e9c890c037f8d35f43163e188853ebcbd.jpg)  
+Figure 6: Histogram of Angular Deviations. Presented for MAD attack on CIFAR10 with various choices of $\epsilon$ .
+
+![](images/77d45239807b214d6e4752bb3dfc61dc7e8cf93fdf014052bc588c4d45b83eba.jpg)  
+Figure 7: Test loss. Visualized during training. Colours and lines correspond to $\epsilon$ values in Fig. 6.
+
+(i) Utility objective $\mathbf { \Phi } = L _ { 1 }$ distance (Fig. 4a): Although random-noise and reverse-sigmoid reduce attacker’s accuracy, the strategies in most cases involves larger perturbations. In contrast, MAD and MAD-argmax provides similar non-replicability (i.e., $\mathsf { A c c } ( \mathsf { A t t . } ) )$ with significantly lesser perturbation, especially at lower magnitudes. For instance, on MNIST (first column), MAD $( L _ { 1 } = 0 . 9 5 )$ ) reduces the accuracy of the attacker to under $80 \%$ with $0 . 6 3 \times$ the perturbation as that of reversesigmoid and random-noise $( L _ { 1 } \approx 1 . 5 )$ .
+
+(ii) Utility objective $=$ argmax-preserving (Fig. 4b): By setting a hard constraint on retaining the label of the predictions, we find the accuracy-preserving defenses MAD-argmax and reverse-sigmoid successfully reduce the performance of the attacker by at least $20 \%$ across all datasets. In most cases, we find MAD-argmax in addition achieves this objective by introducing lesser distortion to the predictions compared to reverse-sigmoid. For instance, in Fig. 4a, we find MAD-argmax consistently reduce the attacker accuracy to the same amount at lesser $L _ { 1 }$ distances. In reversesigmoid, we attribute the large $L _ { 1 }$ perturbations to a shift in posteriors towards a uniform distribution e.g., mean entropy of perturbed predictions is $3 . 0 2 \pm 0 . 1 6$ (max-entropy $= 3 . 3 2 )$ at $L _ { 1 } { = } 1 . 0$ for MNIST; in contrast, MAD-argmax displays a mean entropy of $1 . 7 9 \pm 0 . 1 1$ . However, common to accuracy-preserving strategies is a pitfall that the top-1 label is retained. In Figure 5 (see overlapping red and yellow cross-marks), we present the results of training the attacker using only the top-1 label. In line with previous discussions, we find that the attacker is able to significantly recover the original performance of the stolen model for accuracy-preserving defenses MAD-argmax and reverse-sigmoid.
+
+(iii) Non-replicability vs. utility trade-off (Fig. 4b): We now compare our defense MAD (blue lines) with baselines (rand-noise and $\mathtt { d p \mathrm { - s g d ) } }$ which trade-off utility to mitigate model stealing. Our results indicate MAD offers a better defense (lower attacker accuracies for similar defender accuracies). For instance, to reduce the attacker’s accuracy to ${ < } 7 0 \%$ , while the defender’s accuracy significantly degrades using dp-sgd $( 3 9 \% )$ and rand-noise $( 5 6 . 4 \% )$ , MAD involves a marginal decrease of $1 \%$ .
+
+![](images/5446cf701717e6223542aa63f0e7a86ef717ea541222b0c763898d51347ed44d.jpg)  
+Figure 8: MAD Ablation experiments. Utility $=$ (left) $L _ { 1 }$ distance (right) defender test accuracy.
+
+![](images/29eeb46cfec4e89f9b656b9fba6d6e761c3a9f3b84c5207b05b216b883c097f8.jpg)  
+Figure 9: Subverting the Defense.
+
+# 5.2.3 ANALYSIS
+
+How much angular deviation does MAD introduce? To obtain insights on the angular deviation induced between the true and the perturbed gradient, we conduct an experiment by tracking the true gradient direction (which was unknown so far) at each training step. We simulate this by training an attacker model using online SGD $\mathrm { { L R } } { = } 0 . 0 0 1$ ) over $N$ iterations using $B$ distinct images to query and a batch size of 1. At each step $t$ of training, the attacker queries a randomly sampled input $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ to the defender model and backpropogates the loss resulting from $\tilde { \mathbf { y } } _ { t }$ . In this particular experiment, the perturbation $\tilde { \mathbf { y } } _ { t }$ is crafted having exact knowledge of the attacker’s parameters. We evaluate the angular deviation between gradients with $\mathbf { \Pi } ( a )$ and without $( \pmb { u } )$ the perturbation.
+
+In Figure 6, we visualize a histogram of deviations: $\begin{array} { r } { \theta = \operatorname { a r c c o s } { \frac { { \mathbf { \em u } } \cdot { \mathbf { \boldsymbol { a } } } } { | | { \mathbf { \em u } } | | | | | { \mathbf { \boldsymbol { a } } } | | } } } \end{array}$ , where $\pmb { u } = \nabla _ { \pmb { w } } L ( \pmb { w } _ { t } , \pmb { y } , \cdot )$ and $\pmb { a } = \nabla _ { \pmb { w } } L ( \pmb { w } _ { t } , \tilde { \pmb { y } } , \cdot )$ . We observe: (i) although our perturbation space is severely restricted (a low-dimensional probability simplex), we can introduce surprisingly high deviations $( 0 - 1 1 5 ^ { \circ } )$ in the high-dimensional parameter space of the VGG16; (ii) for $\epsilon$ values at reasonable operating points which preserves the defender’s accuracy within $10 \%$ of the undefended accuracy (e.g., $\epsilon \in [ 0 . 9 5$ , 0.99] for CIFAR10), we see deviations with mean $2 4 . 9 ^ { \circ }$ (yellow bars in Fig. 6). This indicates that the perturbed gradient on an average leads to a slower decrease in loss function; (iii) on the extreme end, with $\epsilon = \epsilon _ { \mathrm { m a x } } = 2$ , on an average, we find the perturbations successfully flips $( > 9 0 ^ { \circ } )$ the gradient direction leading to an increase on the test loss, as seen in Figure 7 (blue line). We also find the above observations reasonably transfers to a black-box attacker setting (see Appendix F.4), where the perturbations are crafted without knowledge of the attacker’s parameters. Overall, we find our approach considerably corrupts the attacker’s gradient direction.
+
+Ablative Analysis. We present an ablation analysis of our approach in Figure 8. In this experiment, we compare our approach MAD and MAD-argmax to: (a) $G = I$ : We substitute the jacobian $G$ (Eq. 5) with a $K \times K$ identity matrix; and (b) $\mathbf { \boldsymbol { y } } ^ { * } =$ rand: Inner maximization term (Eq. 4) returns a random extreme of the simplex. Note that both (a) and (b) do not use the gradient information to perturb the posteriors.
+
+From Figure 8, we observe: (i) poor performance of $\mathbf { \boldsymbol { y } } ^ { * } =$ rand, indicating random untargeted perturbations of the posterior probability is a poor strategy; (ii) $G = I$ , where the angular deviation is maximized between the posterior probability vectors is a slightly better strategy; (ii) MAD outperforms the above approaches. Consequently, we find using the gradient information (although a proxy to the attacker’s gradient signal) within our formulation (Equation 4) is crucial to providing better model stealing defenses.
+
+Subverting the Defense. We now explore various strategies an attacker can use to circumvent the defense. To this end, we evaluate the following strategies: (a) argmax: attacker uses only the most-confident label during training; (b) arch- $^ *$ : attacker trains other choices of architectures; (c) nquery: attacker queries each image multiple times; (d) nquery+aug: same as (c), but with random cropping and horizontal flipping; and (e) opt- $^ *$ : attacker uses an adaptive LR optimizer e.g., ADAM (Kingma & Ba, 2014).
+
+We present results over the subversion strategies in Figure 9. We find our defense robust to above strategies. Our results indicate that the best strategy for the attacker to circumvent our defense is to discard the probabilities and rely only on the most confident label to train the stolen model. In accuracy-preserving defenses (see Fig. 5), this previously resulted in an adversary entirely circumventing the defense (recovering up to $1 . 0 \times$ original performance). In contrast, we find MAD is nonetheless effective in spite of the strategy, maintaining a $9 \%$ absolute accuracy reduction in attacker’s stolen performance.
+
+# 6 CONCLUSION
+
+In this work, we were motivated by limited success of existing defenses against DNN model stealing attacks. While prior work is largely based on passive defenses focusing on information truncation, we proposed the first active defense strategy that attacks the adversary’s training objective. We found our approach effective in defending a variety of victim models and against various attack strategies. In particular, we find our attack can reduce the accuracy of the adversary by up to $65 \%$ , without significantly affecting defender’s accuracy.
+
+Acknowledgement. This research was partially supported by the German Research Foundation (DFG CRC 1223). We thank Paul Swoboda and David Stutz for helpful discussions.
+
+# REFERENCES
+
+Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In CCS, 2016.
+
+Ibrahim M Alabdulmohsin, Xin Gao, and Xiangliang Zhang. Adding robustness to support vector machines against adversarial reverse engineering. In CIKM, 2014.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In ECML PKDD, 2013.
+
+Varun Chandrasekaran, K Chaudhari, Irene Giacomelli, Somesh Jha, and Songbai Yan. Exploring connections between active learning and model extraction. arXiv preprint arXiv:1905.09165, 2019.
+
+Jacson Rodrigues Correia-Silva, Rodrigo F Berriel, Claudine Badue, Alberto F de Souza, and Thiago Oliveira-Santos. Copycat cnn: Stealing knowledge by persuading confession with random nonlabeled data. In IJCNN, 2018.
+
+John Duchi, Shai Shalev-Shwartz, Yoram Singer, and Tushar Chandra. Efficient projections onto the l 1-ball for learning in high dimensions. In ICML, 2008.
+
+Cynthia Dwork, Aaron Roth, et al. The algorithmic foundations of differential privacy. Foundations and Trends $\textsuperscript { \textregistered }$ in Theoretical Computer Science, 2014.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv:1503.02531, 2015.
+
+Karla Leigh Hoffman. A method for globally minimizing concave functions over convex sets. Mathematical Programming, 20(1):22–32, 1981.
+
+Matthew Jagielski, Nicholas Carlini, David Berthelot, Alex Kurakin, and Nicolas Papernot. Highfidelity extraction of neural network models. arXiv preprint arXiv:1909.01838, 2019.
+
+Mika Juuti, Sebastian Szyller, Alexey Dmitrenko, Samuel Marchal, and N Asokan. Prada: Protecting against dnn model stealing attacks. In Euro S&P, 2019.
+
+Manish Kesarwani, Bhaskar Mukhoty, Vijay Arya, and Sameep Mehta. Model extraction warning in mlaas paradigm. In ACSAC, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.
+
+Taesung Lee, Benjamin Edwards, Ian Molloy, and Dong Su. Defending against model stealing attacks using deceptive perturbations. S&P Deep Learning and Security (DLS) Workshop, 2018.
+
+Daniel Lowd and Christopher Meek. Adversarial learning. In KDD, 2005.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Smitha Milli, Ludwig Schmidt, Anca D Dragan, and Moritz Hardt. Model reconstruction from model explanations. arXiv preprint arXiv:1807.05185, 2018.
+
+Blaine Nelson, Marco Barreno, Fuching Jack Chi, Anthony D Joseph, Benjamin IP Rubinstein, Udam Saini, Charles Sutton, JD Tygar, and Kai Xia. Misleading learners: Co-opting your spam filter. In Machine learning in cyber trust. 2009.
+
+Blaine Nelson, Benjamin Rubinstein, Ling Huang, Anthony Joseph, Shing-hon Lau, Steven Lee, Satish Rao, Anthony Tran, and Doug Tygar. Near-optimal evasion of convex-inducing classifiers. In AISTATS, 2010.
+
+Seong Joon Oh, Max Augustin, Bernt Schiele, and Mario Fritz. Towards reverse-engineering blackbox neural networks. In ICLR, 2018.
+
+Tribhuvanesh Orekondy, Bernt Schiele, and Mario Fritz. Knockoff nets: Stealing functionality of black-box models. In CVPR, 2019.
+
+Soham Pal, Yash Gupta, Aditya Shukla, Aditya Kanade, Shirish Shevade, and Vinod Ganapathy. A framework for the extraction of deep neural networks by leveraging public data. arXiv preprint arXiv:1905.09165, 2019.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016.
+
+Nicolas Papernot, Mart´ın Abadi, Ulfar Erlingsson, Ian Goodfellow, and Kunal Talwar. Semisupervised knowledge transfer for deep learning from private training data. In ICLR, 2017a.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Asia CCS, 2017b.
+
+Florian Tramer and Dan Boneh. Slalom: Fast, verifiable and private execution of neural networks in trusted hardware. In ICLR, 2019.
+
+Florian Tramer, Fan Zhang, Ari Juels, Michael K Reiter, and Thomas Ristenpart. Stealing machine \` learning models via prediction apis. In USENIX Security, 2016.
+
+Binghui Wang and Neil Zhenqiang Gong. Stealing hyperparameters in machine learning. In S&P, 2018.
+
+Huadi Zheng, Qingqing Ye, Haibo Hu, Chengfang Fang, and Jie Shi. Bdpl: A boundary differentially private layer against machine learning model extraction attacks. In ESORICS, 2019.
+
+# Appendix
+
+A OVERVIEW AND NOTATION
+
+![](images/9c8cea255bdfab207e7ac96356b3570b150eece1642e7cede0bc1ad2d2e93433.jpg)  
+Figure A1: Overview of Attack, Defense, and Evaluation Metrics. We consider an attacker $A$ who exploits black-box access to defended model $F _ { V } ^ { \delta }$ to train a stolen model $F _ { A }$ . In this paper, we take the role of the defender who intends to minimize replicability (i.e., $\mathsf { A c c } ( F _ { A } , { \mathcal { D } } ^ { \mathrm { t e s t } } ) )$ , while maintaining utility of the predictions. We consider two notions of utility: (1) minimizing perturbations in predictions, measured here using $L _ { 1 }$ distance; and (2) maintaining accuracy of the defended model on test set $\mathrm { A c c } ( F _ { V } ^ { \delta } , { \mathcal { D } } ^ { \mathrm { t e s t } } )$ . Note that for a fair head-to-head comparison, we use the same held-out test set $\mathcal { D } ^ { \mathrm { t e s t } }$ to evaluate accuracies of both the defended model $F _ { V } ^ { \delta }$ and stolen model $F _ { A }$ . Similar to all prior work, we assume $\mathcal { D } ^ { \mathrm { t r a i n } }$ , $\mathcal { D } ^ { \mathrm { t e s t } }$ are drawn i.i.d from the same (victim) distribution $\mathcal { D } _ { V }$ . Notation used in the above figure is further elaborated in Table A1.
+
+Table A1: Notation   
+
+<table><tr><td></td><td>x</td><td>Inputs (images ∈ RC×H×W)</td></tr><tr><td></td><td>y,y</td><td>Original, perturbed posterior predictions</td></tr><tr><td></td><td>AR</td><td>Probability simplex overK vertices</td></tr><tr><td>Attacker A</td><td>PA(X)</td><td>Attacker&#x27;s input data distribution</td></tr><tr><td></td><td>Dtransfer</td><td>Transfer set (= {(xi,yi)},where xi ~ PA(X),yi = Fv(xi))</td></tr><tr><td></td><td>FA</td><td>Attacker&#x27;s (stolen) model trained on Dtransfer</td></tr><tr><td>Victim/DefenderV</td><td>Pv(X)</td><td>Victim&#x27;s input data distribution</td></tr><tr><td></td><td>Dtrain</td><td>Training data (= {(xi,yi)},where xi ~ Pv(X))</td></tr><tr><td></td><td>Fv</td><td>Undefended model trained on Dtrain</td></tr><tr><td></td><td>F</td><td>Defended model</td></tr><tr><td></td><td>Dtest</td><td>Test set(= {(xi, yi)},where xi~Pv(X))</td></tr></table>
+
+B RELATED WORK: EXTENSION
+
+A summary of existing model stealing attacks and defenses is presented in Table A2.
+
+# C DETAILED ALGORITHM
+
+We present a detailed algorithm (see Algorithm 1) for our approach described in Section 4.
+
+The algorithm roughly follows four steps:
+
+(i) Predict $\mathbf { ( L } 2 )$ : Obtains posterior probability predictions $\textbf {  { y } }$ for input $_ { \textbf { \em x } }$ using a victim model $F _ { V } ( { \pmb x } ; { \pmb w } _ { V } )$ .
+
+Table A2: Existing DNN Attacks and Defenses. Complements the discussion in Section 2. $\mathbf { \Gamma } _ { \mathbf { C N N } } { } ^ { * }$ ’: Complex ImageNet-like CNN. $\cdot \cdot \cdot$ : Both. ‘P/D’: Perturbation/Detection. ‘AP’: Accuracy preserving (i.e., maintains top-1 labels of predictions). ‘AC’: Attacks considered.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Black-box type</td><td colspan="2">Proposed Attack</td><td colspan="4">Proposed Defense</td></tr><tr><td>Input Query Data</td><td>Adapt.?</td><td>Strategy</td><td>P/D?</td><td>AP?</td><td>AC</td></tr><tr><td>1.Lowd &amp; Meek (2005)</td><td>Linear</td><td>Random Noise</td><td>√</td><td></td><td>-</td><td>-</td><td>-</td></tr><tr><td>2.Nelson et al. (2009)</td><td>Linear</td><td>Labeled Data</td><td>X</td><td>Rejection</td><td>D</td><td>X</td><td>1</td></tr><tr><td>3.Nelson et al. (2010)</td><td>Linear</td><td>Random Noise</td><td></td><td></td><td>-</td><td></td><td></td></tr><tr><td>4. Alabdulmohsin et al. (2014)</td><td>Linear</td><td>Random Noise</td><td>√</td><td>Ensembling</td><td>P</td><td>X</td><td>4</td></tr><tr><td>5.Tramer et al.(2016)</td><td>Linear, NN</td><td>Random Noise</td><td>+</td><td>Rounding</td><td>P</td><td>√</td><td>5</td></tr><tr><td>6.Milli et al. (2018)</td><td>Linear, NN</td><td>Random Noise</td><td></td><td>=</td><td>-</td><td></td><td>-</td></tr><tr><td>7.Kesarwani et al. (2018)</td><td>Decision Tree</td><td></td><td></td><td>Detection</td><td>D</td><td>√</td><td>5</td></tr><tr><td>8.Chandrasekaran et al. (2019)</td><td>Linear</td><td>Random Noise</td><td>√</td><td>Random Pert.</td><td>P</td><td>X</td><td>-</td></tr><tr><td>9.Papernot et al.(2017b)</td><td>CNN</td><td>Synth. Data</td><td>√</td><td></td><td>-</td><td></td><td>-</td></tr><tr><td>10. Correia-Silva et al. (2018)</td><td>CNN</td><td>Unlabeled Data</td><td>X</td><td></td><td></td><td>=</td><td></td></tr><tr><td>11.Pal et al. (2019)</td><td>CNN</td><td>Unlabeled Data</td><td>+</td><td></td><td>-</td><td>=</td><td>1</td></tr><tr><td>12. Orekondy et al. (2019)</td><td>CNN*</td><td>Unlabeled Data</td><td></td><td>Rounding, Top-k</td><td>P</td><td>√</td><td>12</td></tr><tr><td>13.Jagielski et al. (2019)</td><td>CNN*</td><td>Unlabeled Data</td><td>√</td><td></td><td>1</td><td>-</td><td>-</td></tr><tr><td>14. Juuti et al. (2019)</td><td>CNN</td><td>Synth. Data</td><td>√</td><td>Detection</td><td>D</td><td>√</td><td>9,14</td></tr><tr><td>15.Lee et al. (2018)</td><td>CNN</td><td></td><td></td><td>Reverse sigmoid</td><td>P</td><td>√</td><td>9</td></tr><tr><td>16. Ours</td><td>CNN*</td><td>=</td><td></td><td>Targeted Pert.</td><td>P</td><td>+</td><td>9,12,14</td></tr></table>
+
+Algorithm 1: MAD Defense. To supplement approach in Section 4
+
+(ii) Estimate Jacobian $G$ (L3): We estimate a $\mathbb { R } ^ { K \times D }$ jacobian matrix on a surrogate model $F$ . By default, we use as $F$ a randomly initialized model (more details in Appendix E.1). Each row of $G$ represents the gradient direction (in parameter space $\mathbb { R } ^ { D }$ ) over log likelihood of class $k$ .
+
+(iii) Maximize MAD Objective (L4): We find the optimal direction $\boldsymbol { y } ^ { * }$ which maximizes the MAD objective (Eq. 3). To compute the arg max, we iterative over the $K$ extremes of the probability simplex $\Delta ^ { K }$ to find ${ \pmb y } ^ { * }$ which maximizes the objective. The extreme ${ \pmb y } _ { k }$ denotes a probability vector with $y _ { k } = 1$ .
+
+(iv) Enforce Utility Constraint (L5-7): We enforce the perturbation utility constraint (Eq. 7) by considering a linear interpolation of ${ \pmb y } ^ { * }$ and $\textbf {  { y } }$ . The resulting interpolation probability vector $\tilde { \pmb y } : = h ( \alpha ^ { * } )$ represents the utility-constrained perturbed prediction that is returned instead of $\textbf {  { y } }$ .
+
+1 Function PerturbedPredict-MAD $( { \pmb x } )$ : Input: Input data $_ { \textbf { \em x } }$ , model to defend $F _ { V } ( \bf { \cdot } ; \mu \ v { v } _ { V } )$ , proxy attacker model $F ( \cdot ; w )$ Output: Perturbed posterior probability $\tilde { \pmb { y } } \in \Delta ^ { K }$ s.t. $\mathrm { d i s t } ( \tilde { \pmb { y } } , \pmb { y } ) \le \epsilon$   
+2 ${ \pmb y } : = F _ { V } ( { \pmb x } ; { \pmb w } _ { V } )$ // Obtain $K$ -dim posteriors   
+3 $\pmb { G } : = \nabla _ { \pmb { w } } \log F ( \pmb { x } ; \pmb { w } )$ // Pre-compute $\left( \mathbb { K } \texttt { x D } \right)$ ) Jacobian GT yk GT y 2   
+4 y∗ := arg maxyk∈ext(∆K) ||GT yk||2 ||GT y||2 
+5 Define $h ( \alpha ) = ( 1 - \alpha ) \pmb { y } + \alpha \pmb { y } ^ { \ast }$   
+6 $\begin{array} { r } { \alpha ^ { * } : = \arg \operatorname* { m a x } _ { \alpha \in [ 0 , 1 ] , \mathrm { d i s t } ( \cdot ) \leq \epsilon } \ \mathrm { d i s t } ( h ( \alpha ) , \ y ^ { * } ) } \end{array}$ // Find optimal step-size via bisection, or OptStep(.) for $L _ { p }$ norms   
+7 $\tilde { y } : = h ( \alpha ^ { * } )$ // Perturbed probabilities   
+8 return $\tilde { y }$   
+9   
+10 Function OptStep(y, y∗, , p):   
+11 α∗ := max n ||y−y∗||p , 1o   
+12 return $\ b { \alpha } ^ { * }$
+
+# D ATTACK MODELS: RECAP AND IMPLEMENTATION DETAILS
+
+Jacobian Based Data Augmentation (jbda) (Papernot et al., 2017b). The motivation of the approach is to obtain a surrogate of the victim black-box classifier, with an end-goal of performing evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014). We restrict discussions primarily to the first part of constructing the surrogate. To obtain the surrogate (the stolen model), the authors depend on an unlabeled ‘seed’ set, typically from the same distribution as that used to train the victim model. As a result, the attacker assumes (mild) knowledge of the input data distribution and the class-label of the victim.
+
+The key idea behind the approach is to query perturbations of inputs, to obtain a reasonable approximation of the decision boundary of the victim model. The attack strategy involves performing the following steps in a repeated manner: (i) images from the substitute set (initially the seed) $\mathcal { D }$ is labeled by querying the victim model $F _ { V }$ as an oracle labeler; (ii) the surrogate model $F _ { A }$ is trained on the substitute dataset; (iii) the substitute set is augmented using perturbations of existing images: $\mathscr { D } _ { \rho + 1 } = \mathscr { D } _ { \rho } \cup \{ \pmb { x } + \lambda _ { \rho + 1 } \cdot \mathrm { s g n } ( J _ { F } [ F _ { A } ( \pmb { x } ) ] ) : \pmb { x } \in \mathscr { D } _ { \rho } \}$ , where $J$ is the jacobian function.
+
+We use a seed set of: 100 (MNIST and FashionMNIST), 500 (CIFAR10, CUB200, Caltech256) and 1000 (CIFAR100). We use the default set of hyperparameters of Papernot et al. (2017b) in other respects.
+
+Jacobian Based $\{ \mathbf { s e l f } , \mathbf { t o p } { \mathbf { - } } \mathbf { k } \}$ (jbself, jbtop3) (Juuti et al., 2019) . The authors generalize the above approach, by extending the manner in which the synthetic samples are produced. In jbself, the jacobian is calculated w.r.t to $k$ nearest classes and in jb-self, w.r.t the maximum a posterior class predicted by $F _ { A }$ .
+
+Knockoff Nets (knockoff) (Orekondy et al., 2019) . Knockoff is a recent attack model, which demonstrated model stealing can be performed without access to seed samples. Rather, the queries to the black-box involve natural images (which can be unrelated to the training data of the victim model) sampled from a large independent data source e.g., ImageNet1K. Consequently, no knowledge of the input data distribution nor the class-label space of the victim model is required to perform model stealing. The paper proposes two strategies on how to sample images to query: random and adaptive. We use the random strategy in the paper, since adaptive resulted in marginal increases in an open-world setup (which we have).
+
+As the independent data sources in our knockoff attacks, we use: EMNIST-Letters (when stealing MNIST victim model), EMNIST (FashionMNIST), CIFAR100 (CIFAR10), CIFAR10 (CIFAR100), ImageNet1k (CUB200, Caltech256). Overlap between query images and the training data of the victim models are purely co-incidental.
+
+We use the code from the project’s public github repository.
+
+Evaluating Attacks. The resulting replica model $F _ { A }$ from all the above attack strategies are evaluated on a held-out test set. We remark that the replica model is evaluated as-is, without additional finetuning or modifications. Similar to prior work, we evaluate the accuracies of $F _ { A }$ on the victim’s held-out test set. Evaluating both stolen and the victim model on the same test set allows for fair head-to-head comparison.
+
+# E SUPPLEMENTARY ANALYSIS
+
+In this section, we present additional analysis to supplement Section 5.2.3.
+
+# E.1 ESTIMATING $G$
+
+Central to our defense is estimating the jacobian matrix $\boldsymbol { G } = \nabla _ { w } \log \boldsymbol { F } ( \boldsymbol { x } ; \boldsymbol { w } )$ (Eq. 5), where $F ( \cdot ; w )$ is the attacker’s model. However, a defender with black-box attacker knowledge (where $F$ is unknown) requires determining $G$ by instead using a surrogate model $F _ { \mathrm { s u r } }$ . We determine choice of $F _ { \mathrm { s u r } }$ empirically by studying two factors: (a) architecture of $F _ { s u r }$ : choice of defender’s surrogate architecture robust to varying attacker architectures (see Fig. A2); and (b) initialization of $F _ { s u r }$ : initialization of the surrogate model parameters plays a crucial role in providing a better defense. We consider four choices of initialization: $\{$ ‘rand’, ‘early’, ‘mid’, ‘late $\}$ which exhibits approximately {chance-level $2 5 \%$ , $50 \%$ , $7 5 \% \}$ test accuracies respectively. We observe (see Fig. A3) that a randomly initialized model, which is far from convergence, provides better gradient signals in crafting perturbations.
+
+![](images/153ac1308928aa6c767d311403df37674d0d28f28f63d471fd8c6e311822d091.jpg)  
+Figure A2: Influence of attacker architecture choices on a fixed surrogate.
+
+![](images/9f9dfe314f17b55b6e6cd891bc699dc96d3b17b415a70a5a64a55af790a3daf0.jpg)  
+Figure A3: Influence of Initialization of a VGG16 Surrogate Model. ‘rand’ $=$ random initialization, (‘early’, ’mid’, ’late’) $= \sim ( 2 5 , 5 0 , 7 5 ) \%$ test accuracy of surrogate on test set.
+
+<table><tr><td></td><td>Undefended</td><td>MAD</td></tr><tr><td>MNIST</td><td>0.88 ± 14.41</td><td>6.47 ±12.25</td></tr><tr><td>FashionMNIST</td><td>0.89 ±15.76</td><td>6.65 ± 14.16</td></tr><tr><td>CIFAR10</td><td>1.93 ±13.02</td><td>8.58 ±15.02</td></tr><tr><td>CIFAR100</td><td>2.15 ± 18.82</td><td>69.26 ± 21.4</td></tr><tr><td>CUBS200</td><td>4.45 ± 9.66</td><td>446.93 ± 23.87</td></tr><tr><td>Caltech256</td><td>4.93 ± 21.25</td><td>815.97 ± 30.3</td></tr></table>
+
+Table A3: Run times (in ms). We report the mean and standard deviation of predictions of undefended and defended models, computed over 10K predictions.
+
+# E.2 RUN-TIME ANALYSIS
+
+We present the run-times of our defended and undefended models in Table A3. The reported numbers were summarized over 10K unique predictions performed on an Nvidia Tesla V100. We find our optimization procedure Eq. (4-7) for all models take under a second, with at most 0.8s in the case of Caltech256. The primary computational bottleneck of our defense implementation is estimating matrix $G \in \mathbb { R } ^ { K \times D }$ in Eq. 5, which currently requires performing $K$ (i.e., number of output classes) backward passes through the surrogate model. Consequently, we find that our inference times on Caltech256 can be further reduced to $0 . 3 \mathrm { s } \pm 0 . 0 4$ by using a more efficient surrogate architecture (e.g., ResNet-34).
+
+# F ADDITIONAL PLOTS
+
+# F.1 ATTACKER EVALUATION
+
+We present evaluation of all attacks considered in the paper on an undefended model in Figure A4. Furthermore, specific to the knockoff attack, we analyze how training using only the top-1 label (instead of complete posterior information) affects the attacker in Figure A5.
+
+# F.2 BUDGET VS. ACCURACY
+
+We plot the budget (i.e., number of distinct black-box attack queries to the defender) vs. the test accuracy of the defender/attacker in Figure A6. The figure supplements Figure 1 and the discussion found in Section 5.2.1 of the main paper.
+
+![](images/968ed9b6fa6cf410d5fe914d5b8e15393feb3e9080191b93fd9d452e5563020c.jpg)  
+Figure A4: Evaluation of all attacks on undefended victim models.
+
+![](images/63bb498a5d948a35bd3a6147ae4418c96ac52a1153e64b56876efc2195d87af2.jpg)  
+Figure A5: Stolen model trained using knockoff strategy on complete posterior information $( y )$ and only the top-1 label of the posteriors (arg $\operatorname* { m a x } _ { k } y _ { k } ,$ ).
+
+![](images/a29287cb397358a8d7eb84c6b41de899159996bb2f98075dde89cadd0bd8a0ed.jpg)  
+Figure A6: Budget vs. Test Accuracy. Supplements Fig. 3c in the main paper.
+
+![](images/cbea626041732899afd7bc150fff641c88d6ec6f05c67a8fe5ad9c4fdcd2d5c3.jpg)  
+Figure A7: Attacker argmax. Supplements Fig. 4 in the main paper.
+
+![](images/814c5ebd205a8b527661505f8785c1172d914ec1f85919f5b6ecca8a93a8ced1.jpg)  
+Figure A8: Histogram of Angular Deviations (Black-box setting). Supplements Fig. 6 in the main paper. The test-loss during of the attacker model for each of the histograms (over multiple $\epsilon$ values) are provided in the bottom row.
+
+# F.3 ATTACKER ARGMAX
+
+In Figure A7, we perform the non-replicability vs. utility evaluation (complementing Fig. 5 in the main paper) under a special situation: the attacker discards the probabilities and only uses the top-1 Black-box s‘argmax’ label to train the stolen model. Relevant discussion can be found in Section 5.2.2.
+
+# F.4 BLACK-BOX ANGULAR DEVIATIONS
+
+In Figure A8, we provide the angular deviations obtained in a black-box setting over the course of training the attack model. We train the attacker model using the transfer set obtained by the knockoff approach (the strongest attacker in our experiments) for 50 epochs using a SGD $( \mathrm { l r } = 0 . 0 1 $ , momentum $= 0 . 5$ ) and a batch size of 64. The experiment compliments our previous discussion in Section 5.2.3 of the main paper under “How much angular deviation does MAD introduce?”. As before, we estimate the angular deviations as: $\begin{array} { r } { \theta = \operatorname { a r c c o s } { \frac { { \mathbf { \em u } } \cdot { \mathbf { \boldsymbol { a } } } } { | | { \mathbf { \boldsymbol { u } } } | | | | | { \mathbf { \boldsymbol { a } } } | | } } } \end{array}$ , where $\pmb { u } = \nabla _ { \pmb { w } } L ( \pmb { w } _ { t } , \pmb { y } , \cdot )$ and $\pmb { a } = \nabla _ { \pmb { w } } L ( \pmb { w } _ { t } , \tilde { \pmb { y } } , \cdot )$ . We observe from Figure A8: (i) the defensive angular deviations introduced by MAD to posterior predictions transfer to a black-box attacker setting, when crafting perturbations without access to the adversary’s model parameters; and (ii) although the setting introduces lower angular deviations at the extreme case of $\epsilon { = } 2 . 0$ (e.g., $1 1 4 . 7 ^ { \circ }  7 6 . 5 ^ { \circ }$ in CIFAR10), we observe the perturbation sufficient to maximize the attacker’s test loss. We find significant angular deviations introduced by our approach in a black-box setting as well.
+
+# F.5 MAD ABLATION EXPERIMENTS
+
+We present the ablation experiments covering all defender models in Figure A9. Relevant discussion is available in Section 5.2.3 of the main paper under “Ablative Analysis”.
+
+![](images/ebbb31ab9a0a9f8937895ef989636c604e4dbcd058782a781ec0012e2eba3820.jpg)  
+Figure A9: MAD ablation experiments. Supplements Fig. 8 in the main paper.

parse/train/SyevYxHtDB/SyevYxHtDB_content_list.json

@@ -0,0 +1,1914 @@
+[
+    {
+        "type": "text",
+        "text": "PREDICTION POISONING: TOWARDS DEFENSES AGAINST DNN MODEL STEALING ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tribhuvanesh Orekondy1, Bernt Schiele1, Mario Fritz2 ",
+        "bbox": [
+            186,
+            169,
+            576,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Max Planck Institute for Informatics   \n2 CISPA Helmholtz Center for Information Security   \nSaarland Informatics Campus, Germany   \n{orekondy, schiele}@mpi-inf.mpg.de, fritz@cispa.saarland ",
+        "bbox": [
+            184,
+            185,
+            665,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            277,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "High-performance Deep Neural Networks (DNNs) are increasingly deployed in many real-world applications e.g., cloud prediction APIs. Recent advances in model functionality stealing attacks via black-box access (i.e., inputs in, predictions out) threaten the business model of such applications, which require a lot of time, money, and effort to develop. Existing defenses take a passive role against stealing attacks, such as by truncating predicted information. We find such passive defenses ineffective against DNN stealing attacks. In this paper, we propose the first defense which actively perturbs predictions targeted at poisoning the training objective of the attacker. We find our defense effective across a wide range of challenging datasets and DNN model stealing attacks, and additionally outperforms existing defenses. Our defense is the first that can withstand highly accurate model stealing attacks for tens of thousands of queries, amplifying the attacker’s error rate up to a factor of $8 5 \\times$ with minimal impact on the utility for benign users. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of state-of-the-art DNN models at a variety of predictive tasks has encouraged their usage in a variety of real-world applications e.g., home assistants, autonomous vehicles, commercial cloud APIs. Models in such applications are valuable intellectual property of their creators, as developing them for commercial use is a product of intense labour and monetary effort. Hence, it is vital to preemptively identify and control threats from an adversarial lens focused at such models. In this work we address model stealing, which involves an adversary attempting to counterfeit the functionality of a target victim ML model by exploiting black-box access (query inputs in, posterior predictions out). ",
+        "bbox": [
+            174,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stealing attacks dates back to Lowd & Meek (2005), who addressed reverse-engineering linear spam classification models. Recent literature predominantly focus on DNNs (specifically CNN image classifiers), and are shown to be highly effective (Tramer et al., 2016) on complex models (Orekondy \\` et al., 2019), even without knowledge of the victim’s architecture (Papernot et al., 2017b) nor the training data distribution. The attacks have also been shown to be highly effective at replicating pay-per-query image prediction APIs, for as little as $\\$ 30$ (Orekondy et al., 2019). ",
+        "bbox": [
+            174,
+            666,
+            823,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Defending against stealing attacks however has received little attention and is lacking. Existing defense strategies aim to either detect stealing query patterns (Juuti et al., 2019), or degrade quality of predicted posterior via perturbation. Since detection makes strong assumptions on the attacker’s query distribution (e.g., small $L _ { 2 }$ distances between successive queries), our focus is on the more popular perturbation-based defenses. A common theme among such defenses is accuracypreserving posterior perturbation: the posterior distribution is manipulated while retaining the top-1 label. For instance, rounding decimals (Tramer et al., 2016), revealing only high-confidence predic- \\` tions (Orekondy et al., 2019), and introducing ambiguity at the tail end of the posterior distribution (Lee et al., 2018). Such strategies benefit from preserving the accuracy metric of the defender. However, in line with previous works (Tramer et al., 2016; Orekondy et al., 2019; Lee et al., 2018), we \\` find models can be effectively stolen using just the top-1 predicted label returned by the black-box. Specifically, in many cases we observe ${ < } 1 \\%$ difference between attacks that use the full range of posteriors (blue line in Fig. 1) to train stolen models and the top-1 label (orange line) alone. In this paper, we work towards effective defenses (red line in Fig. 1) against DNN stealing attacks with minimal impact to defender’s accuracy. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            820,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main insight to our approach is that unlike a benign user, a model stealing attacker additionally uses the predictions to train a replica model. By introducing controlled perturbations to predictions, our approach targets poisoning the training objective (see Fig. 2). Our approach allows for a utility-preserving defense, as well as trading-off a marginal utility cost to significantly degrade attacker’s performance. As a practical benefit, the defense involves a single hyperparameter (perturbation utility budget) and can be used with minimal overhead to any classification model without retraining or modifications. ",
+        "bbox": [
+            174,
+            154,
+            614,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We rigorously evaluate our approach by defending six victim models, against four recent and effective DNN stealing attack strategies (Papernot et al., 2017b; Juuti et al., 2019; Orekondy et al., 2019). Our defense consistently mitigates all stealing attacks and further shows improvements over multiple baselines. In particular, we find our defenses degrades the attacker’s query sample efficiency by 1-2 orders of magnitude. Our approach significantly reduces the attacker’s performance (e.g., $30 \\%$ reduction on MNIST and 13- $28 \\%$ on CUB200) at a marginal cost $( 1 - 2 \\% )$ to defender’s test accuracy. Furthermore, our approach can achieve the same level of mitigation as baseline defenses, but by introducing significantly lesser perturbation. ",
+        "bbox": [
+            174,
+            299,
+            612,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/bff97c754b1d4700fefabc6824e8d22acec35a2800990729045a6beb9463423c.jpg",
+        "image_caption": [
+            "Figure 1: We find existing defenses (orange line) ineffective against recent attacks. Our defense (red line) in contrast significantly mitigates the attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            632,
+            147,
+            820,
+            255
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. (i) We propose the first utility-constrained defense against DNN model stealing attacks; (ii) We present the first active defense which poisons the attacker’s training objective by introducing bounded perturbations; and (iii) Through extensive experiments, we find our approach consistently mitigate various attacks and additionally outperform baselines. ",
+        "bbox": [
+            174,
+            476,
+            612,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/7cb8f869085e7ca9b774c9b54e00d567678b3bca65d41bb38c3727bb68920ca2.jpg",
+        "image_caption": [
+            "Figure 2: We perturb posterior predictions $\\tilde { \\pmb { y } } = \\pmb { y } + \\pmb { \\delta }$ , with an objective of poisoning the adversary’s gradient signal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            340,
+            821,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED LITERATURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            397,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model stealing attacks (also referred to as ‘extraction’ or ‘reverse-engineering’) in literature aim to infer hyperparameters (Oh et al., 2018; Wang & Gong, 2018), recover exact parameters (Lowd & Meek, 2005; Tramer et al., 2016; Milli et al., 2018), or extract the functionality (Correia-Silva et al., \\` 2018; Orekondy et al., 2019) of a target black-box ML model. In some cases, the extracted model information is optionally used to perform evasion attacks (Lowd & Meek, 2005; Nelson et al., 2010; Papernot et al., 2017b). The focus of our work is model functionality stealing, where the attacker’s yardstick is test-set accuracy of the stolen model. Initial works on stealing simple linear models (Lowd & Meek, 2005) have been recently succeeded by attacks shown to be effective on complex CNNs (Papernot et al., 2017b; Correia-Silva et al., 2018; Orekondy et al., 2019) (see Appendix B for an exhaustive list). In this work, we works towards defenses targeting the latter line of DNN model stealing attacks. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since ML models are often deployed in untrusted environments, a long line of work exists on guaranteeing certain (often orthogonal) properties to safeguard against malicious users. The properties include security (e.g., robustness towards adversarial evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014; Madry et al., 2018)) and integrity (e.g., running in untrusted environments (Tramer & Boneh, 2019)). To prevent leakage of private attributes (e.g., identities) specific to training data in the resulting ML model, differential privacy (DP) methods (Dwork et al., 2014) introduce randomization during training (Abadi et al., 2016; Papernot et al., 2017a). In contrast, our defense objective is to provide confidentiality and protect the functionality (intellectual property) of the ML model against illicit duplication. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model stealing defenses are limited. Existing works (which is primarily in multiclass classification settings) aim to either detect stealing attacks (Juuti et al., 2019; Kesarwani et al., 2018; Nelson et al., 2009; Zheng et al., 2019) or perturb the posterior prediction. We focus on the latter since detection involves making strong assumptions on adversarial query patterns. Perturbation-based defenses are predominantly non-randomized and accuracy-preserving (i.e., top-1 label is unchanged). Approaches include revealing probabilities only of confident classes (Orekondy et al., 2019), rounding probabilities (Tramer et al., 2016), or introducing ambiguity in posteriors (Lee et al., 2018). None \\` of the existing defenses claim to mitigate model stealing, but rather they only marginally delay the attack by increasing the number of queries. Our work focuses on presenting an effective defense, significantly decreasing the attacker’s query sample efficiency within a principled utility-constrained framework. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            279,
+            338,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Functionality Stealing. Model stealing attacks are cast as an interaction between two parties: a victim/defender $V$ (‘teacher’ model) and an attacker $A$ (‘student’ model). The only means of communication between the parties are via black-box queries: attacker queries inputs $\\textbf { \\em x } \\in ~ \\mathcal { X }$ and defender returns a posterior probability distribution $\\dot { \\pmb { y } } \\in \\Delta ^ { K } = P ( \\pmb { y } | \\pmb { x } ) = \\dot { F _ { V } } ( \\pmb { x } )$ , where $\\Delta ^ { K } = \\{ \\pmb { y } \\subseteq 0 , \\mathbf { 1 } ^ { T } \\pmb { y } = \\overset { \\cdot } { 1 } \\}$ is the probability simplex over $K$ classes (we use $K$ instead of $K - 1$ for notational convenience). The attack occurs in two (sometimes overlapping) phases: (i) querying: the attacker uses the black-box as an oracle labeler on a set of inputs to construct a ‘transfer set’ of input-prediction pairs $\\mathcal { D } ^ { \\mathrm { t r a n s f e r } } = \\{ ( \\pmb { x } _ { i } , \\pmb { y } _ { i } ) \\} _ { i = 1 } ^ { B }$ ; and (ii) training: the attacker trains a model $F _ { A }$ to minimize the empirical risk on $\\mathcal { D } ^ { \\mathrm { t r a n s f e r } }$ . The end-goal of the attacker is to maximize accuracy on a held-out test-set (considered the same as that of the victim for evaluation purposes). ",
+        "bbox": [
+            173,
+            315,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge-limited Attacker. In model stealing, attackers justifiably lack complete knowledge of the victim model $F _ { V }$ . Of specific interest are the model architecture and the input data distribution to train the victim model $P _ { V } ( X )$ that are not known to the attacker. Since prior work (Hinton et al., 2015; Papernot et al., 2016; Orekondy et al., 2019) indicates functionality largely transfers across architecture choices, we now focus on the query data used by the attacker. Existing attacks can be broadly categorized based on inputs $\\{ x \\sim P _ { A } ( X ) \\}$ used to query the black-box: (a) independent distribution: (Tramer et al., 2016; Correia-Silva et al., 2018; Orekondy et al., 2019) samples inputs \\` from some distribution (e.g., ImageNet for images, uniform noise) independent to input data used to train the victim model; and (b) synthetic set: (Papernot et al., 2017b; Juuti et al., 2019) augment a limited set of seed data by adaptively querying perturbations (e.g., using FGSM) of existing inputs. We address both attack categories in our paper. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Defense Objectives. We perturb predictions in a controlled setting: $\\tilde { \\pmb { y } } = F _ { V } ^ { \\delta } ( \\pmb { x } ) = \\pmb { y } + \\delta$ s.t. $\\tilde { y } , y \\in \\Delta ^ { K }$ . The defender has two (seemingly conflicting) objectives: (i) utility: such that perturbed predictions remain useful to a benign user. We consider two utility measures: (a) $\\mathsf { A c c } ( \\dot { F } _ { V } ^ { \\delta } , \\mathcal { D } ^ { \\mathrm { t e s t } } )$ : accuracy of defended model on test examples; and (b) $\\mathrm { d i s t } ( { \\pmb y } , \\tilde { \\pmb y } ) = | | { \\pmb y } - \\tilde { \\pmb y } | | _ { p } = \\epsilon$ to measure perturbation. (ii) non-replicability: to reduce the test accuracy of an attacker (denoted as $\\mathsf { A c c } ( F _ { A } , \\mathcal { D } ^ { \\mathrm { t e s t } } ) )$ who exploits the predictions to train a replica $F _ { A }$ on $\\mathcal { D } ^ { \\mathrm { t r a n s f e r } }$ . For consistency, we evaluate both the defender’s and attacker’s stolen model accuracies on the same set of test examples $\\mathcal { D } ^ { \\mathrm { t e s t } }$ . ",
+        "bbox": [
+            173,
+            628,
+            825,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Defender’s Assumptions. We closely mimic an assumption-free scenario similar to existing perturbation-based defenses. The scenario entails the knowledge-limited defender: (a) unaware whether a query is malicious or benign; (b) lacking prior knowledge of the strategy used by an attacker; and (c) perturbing each prediction independently (hence circumventing Sybil attacks). For added rigor, we also study attacker’s countermeasures to our defense in Section 5. ",
+        "bbox": [
+            174,
+            739,
+            823,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 APPROACH: MAXIMIZING ANGULAR DEVIATION BETWEEN GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            832,
+            803,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Motivation: Targeting First-order Approximations. We identify that the attacker eventually optimizes parameters of a stolen model $F ( \\cdot ; w )$ (we drop the subscript $\\cdot _ { A }$ for readability) to minimize the loss on training examples $\\{ ( \\pmb { x } _ { i } , \\tilde { \\pmb { y } } _ { i } ) \\}$ . Common to a majority of optimization algorithms is estimating the first-order approximation of the empirical loss, by computing the gradient of the loss ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "w.r.t. the model parameters ${ \\pmb w } \\in \\mathbb { R } ^ { D }$ : ",
+        "bbox": [
+            174,
+            103,
+            419,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8c1a499cc7c7b654ff1e861848761cc42a8cc0c4797caee13dd30ed41ceada7.jpg",
+        "text": "$$\n\\pmb { u } = - \\nabla _ { \\pmb { w } } L ( F ( \\pmb { x } ; \\pmb { w } ) , \\pmb { y } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            119,
+            584,
+            137
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Maximizing Angular Deviation (MAD). The core idea of our approach is to perturb the posterior probabilities $\\textbf {  { y } }$ which results in an adversarial gradient signal that maximally deviates (see Fig. 2) from the original gradient (Eq. 1). More formally, we add targeted noise to the posteriors which results in a gradient direction: ",
+        "bbox": [
+            173,
+            147,
+            825,
+            204
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d0d150154021517cf46f26c68fe14f3dc4302f06c4166aea7d3b72675a8f6a4.jpg",
+        "text": "$$\n\\pmb { a } = - \\nabla _ { \\pmb { w } } L ( F ( \\pmb { x } ; \\pmb { w } ) , \\tilde { \\pmb { y } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            205,
+            584,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "to maximize the angular deviation between the original and the poisoned gradient signals: ",
+        "bbox": [
+            171,
+            223,
+            763,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a47127a58906d27c5c79ffabfb9e0f1c11bedac9a2dec13eb69e0a72521db96b.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\mathbf { a } } \\ 2 ( 1 - \\cos \\angle ( \\mathbf { a } , \\boldsymbol { u } ) ) = \\operatorname* { m a x } _ { \\hat { \\mathbf { a } } } \\ | | \\hat { \\boldsymbol { a } } - \\hat { \\boldsymbol { u } } | | _ { 2 } ^ { 2 } \\qquad \\quad ( \\hat { \\boldsymbol { a } } = \\boldsymbol { a } / | | \\boldsymbol { a } | | _ { 2 } , \\hat { \\boldsymbol { u } } = \\boldsymbol { u } / | | \\boldsymbol { u } | | _ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            238,
+            771,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given that the attacker model is trained to match the posterior predictions, such as by minimizing the cross-entropy loss $\\begin{array} { r } { L ( \\pmb { y } , \\tilde { \\pmb { y } } ) = - \\sum _ { k } \\tilde { y } _ { k } \\log y _ { k } } \\end{array}$ we rewrite Equation (2) as: ",
+        "bbox": [
+            176,
+            270,
+            825,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70c22af265c187c8c78fa1199909333d8f16b93afe436cf9df43a3b1caadfe53.jpg",
+        "text": "$$\na = - \\nabla _ { w } L ( F ( x ; w ) , \\tilde { y } ) = \\nabla _ { w } \\sum _ { k } \\tilde { y } _ { k } \\log F ( x ; w ) _ { k } = \\sum _ { k } \\tilde { y } _ { k } \\nabla _ { w } \\log F ( x ; w ) _ { k } = G ^ { T } \\tilde { y } _ { k } \\log F ( x ; w ) _ { k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            301,
+            799,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $G \\in \\mathbb { R } ^ { K \\times D }$ represents the Jacobian over log-likelihood predictions $F ( \\pmb { x } ; \\pmb { w } )$ over $K$ classes w.r.t. parameters ${ \\pmb w } \\in \\mathbb { R } ^ { D }$ . By similarly rewriting Equation (1), substituting them in Equation (3) and including the constraints, we arrive at our poisoning objective (Eq. 4-7) of our approach which we refer to as MAD. We can optionally enforce preserving accuracy of poisoned prediction via constraint (8), which will be discussed shortly. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e24dc23d9a327f4f00b95286eaea5880f866c88872a95236ce4a81c4bb2212ff.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\underset { \\tilde { y } } { \\operatorname* { m a x } } } & { \\left\\| \\frac { \\boldsymbol { G } ^ { T } \\tilde { \\boldsymbol { y } } } { | | \\boldsymbol { G } ^ { T } \\tilde { \\boldsymbol { y } } | | _ { 2 } } - \\frac { \\boldsymbol { G } ^ { T } \\boldsymbol { y } } { | | \\boldsymbol { G } ^ { T } \\boldsymbol { y } | | _ { 2 } } \\right\\| _ { 2 } ^ { 2 } } \\\\ { \\mathrm { w h e r e } } & { \\boldsymbol { G } = \\nabla _ { w } \\log \\boldsymbol { F } ( \\boldsymbol { x } ; \\boldsymbol { w } ) } & { ( \\boldsymbol { G } \\in \\mathbb { R } ^ { K \\times D } ) } \\\\ { \\mathrm { s . t } } & { \\boldsymbol { \\tilde { y } } \\in \\Delta ^ { K } } & { ( \\mathrm { S i m p l e x ~ c o n s t r a i n t } ) } \\\\ & { \\mathrm { d i s t } ( \\boldsymbol { y } , \\boldsymbol { \\tilde { y } } ) \\le \\epsilon } & { ( \\mathrm { U i l i t y ~ c o n s t r a i n t } ) } \\\\ & { \\mathrm { ~ a r g ~ } _ { k } } & { \\mathrm { ~ ( F o r ~ v a r i a n t ~ } \\mathsf { M A D - a r g m a x } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            407,
+            750,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The above presents a challenge of black-box optimization problem for the defense since the defender justifiably lacks access to the attacker model $F$ (Eq. 5). Apart from addressing this challenge in the next few paragraphs, we also discuss (a) solving a non-standard and non-convex constrained maximization objective; and (b) preserving accuracy of predictions via constraint (8). ",
+        "bbox": [
+            176,
+            530,
+            823,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Estimating $G$ . Since we lack access to adversary’s model $F$ , we estimate the jacobian ${ \\pmb G } =$ $\\nabla _ { \\boldsymbol { w } } \\log F _ { \\mathrm { s u r } } ( \\boldsymbol { x } ; \\boldsymbol { w } )$ (Eq. 5) per input query $_ { \\textbf { \\em x } }$ using a surrogate model $F _ { \\mathrm { s u r } }$ . We empirically determined (details in Appendix E.1) choice of architecture of $F _ { \\mathrm { s u r } }$ robust to choices of adversary’s architecture $F$ . However, the initialization of $F _ { \\mathrm { s u r } }$ plays a crucial role, with best results on a fixed randomly initialized model. We conjecture this occurs due to surrogate models with a high loss provide better gradient signals to guide the defender. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Heuristic Solver. Gradient-based strategies to optimize objective (Eq. 4) often leads to poor local maxima. This is in part due to the objective increasing in all directions around point $\\textbf {  { y } }$ (assuming $G$ is full-rank), making optimization sensitive to initialization. Consequently, we resort to a heuristic to solve for $\\tilde { y }$ . Our approach is motivated by Hoffman (1981), who show that the maximum of a convex function over a compact convex set occurs at the extreme points of the set. Hence, our two-step solver: (i) searches for a maximizer $\\boldsymbol { y } ^ { * }$ for (4) by iterating over the $K$ extremes ${ \\bf { \\nabla } } _ { \\bf { { y } } _ { k } }$ (where $y _ { k } { = } 1 \\rangle$ ) of the probability simplex $\\Delta ^ { K }$ ; and (ii) then computes a perturbed posterior $\\tilde { y }$ as a linear interpolation of the original posteriors $\\textbf {  { y } }$ and the maximizer $\\pmb { y } ^ { * } \\colon \\bar { \\pmb { y } } = ( 1 - \\bar { \\alpha } ) \\pmb { y } + \\alpha \\pmb { y } ^ { * }$ , where $\\alpha$ is selected such that the utility constraint (Eq. 7) is satisfied. We further elaborate on the solver and present a pseudocode in Appendix C. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variant: MAD-argmax. Within our defense formulation, we encode an additional constraint (Eq. 8) to preserve the accuracy of perturbed predictions. MAD-argmax variant helps us perform accuracy-preserving perturbations similar to prior work. But in contrast, the perturbations are constrained (Eq. 7) and are specifically introduced to maximize the MAD objective. We enforce the accuracy-preserving constraint in our solver by iterating over extremes of intersection of sets Eq.(6) and (8): $\\begin{array} { r } { \\dot { \\Delta { \\phi } } _ { k } ^ { K } = \\{ { \\pmb y } ^ { \\top } { } \\subseteq 0 , { \\bf 1 } ^ { T } { \\pmb y } = 1 , y _ { k } \\geq y _ { j } , k \\} \\not = j \\} \\subseteq \\breve { \\Delta } ^ { K } . } \\end{array}$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            419,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            375,
+            150
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Victim Models and Datasets. We set up six victim models (see column ${ } ^ { \\bullet } F _ { V }$ ’ in Table 1), each model trained on a popular image classification dataset. All models are trained using SGD $\\mathrm { L R } =$ 0.1) with momentum (0.5) for 30 (LeNet) or 100 epochs (VGG16), with a LR decay of 0.1 performed every 50 epochs. We train and evaluate each victim model on their respective train and test sets. ",
+        "bbox": [
+            173,
+            165,
+            825,
+            220
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attack Strategies. We hope to broadly address all DNN model stealing strategies during our defense evaluation. To achieve this, we consider attacks that vary in query data distributions (independent and synthetic; see Section 3) and strategies (random and adaptive). Specifically, in our experiments we use the following attack models: (i) Jacobian-based Data Augmentation ‘JBDA’ (Papernot et al., 2017b); ",
+        "bbox": [
+            174,
+            232,
+            450,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d9ffb42883593789253a7cd1d21c5dd2c72b42c204feb9f19c652e8c4da069ab.jpg",
+        "table_caption": [
+            "Table 1: Victim models and Accuracies. All accuracies are w.r.t undefended victim model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Fv</td><td>Acc(Fv)</td><td colspan=\"4\">Acc(FA)</td></tr><tr><td></td><td></td><td>jbda</td><td>jbself</td><td>jbtop3</td><td>k.off</td></tr><tr><td>MNIST (LeNet)</td><td>99.4</td><td>89.2</td><td>89.4</td><td>87.3</td><td>99.1</td></tr><tr><td>FashionMNIST(LeNet)</td><td>92.0</td><td>38.7</td><td>45.8</td><td>68.7</td><td>69.2</td></tr><tr><td>CIFAR10 (VGG16)</td><td>92.0</td><td>28.6</td><td>20.7</td><td>73.8</td><td>78.7</td></tr><tr><td>CIFAR100 (VGG16)</td><td>72.2</td><td>5.3</td><td>2.9</td><td>39.2</td><td>51.9</td></tr><tr><td>CUB200 (VGG16)</td><td>80.4</td><td>6.8</td><td>3.9</td><td>21.5</td><td>65.1</td></tr><tr><td>Caltech256 (VGG16)</td><td>80.0</td><td>12.5</td><td>16.0</td><td>29.5</td><td>74.6</td></tr></table>",
+        "bbox": [
+            470,
+            233,
+            818,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(ii,iii) ‘JB-self’ and ‘JB-top3’ (Juuti et al., 2019); and (iv) Knockoff Nets ‘knockoff’ (Orekondy et al., 2019); We follow the default configurations of the attacks where possible. A recap and implementation details of the attack models are available in Appendix D. ",
+        "bbox": [
+            174,
+            371,
+            826,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In all attack strategies, the adversary trains a model $F _ { A }$ to minimize the cross-entropy loss on a transfer set $( \\mathcal { D } ^ { \\mathrm { t r a n s f e r } } = \\{ ( \\pmb { x } _ { i } , \\tilde { \\pmb { y } } _ { i } ) \\} _ { i = 1 } ^ { B } )$ obtained by using the victim model $F _ { V }$ to pseudo-label inputs $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ (sampled or adaptively synthesized). By default, we use $B { = } 5 0 \\mathrm { K }$ queries, which achieves reasonable performance for all attacks and additionally makes defense evaluation tractable. The size of the resulting transfer set $\\scriptstyle B = 5 0 \\mathrm { K }$ examples) is comparable (e.g., $1 \\times$ for CIFAR10/100, $2 . 1 \\times$ for Caltech256) to size of victim’s training set. In line with prior work (Papernot et al., 2016; Orekondy et al., 2019), we too find (Section 5.2.3) attack and defense performances are unaffected by choice of architectures, and hence use the victim architecture for the stolen model $F _ { A }$ . Due to the complex parameterization of VGG-16 $( 1 0 0 \\mathbf { M } + )$ , we initialize the weights from a pretrained TinyImageNet or ImageNet model (except for the last FC layer, which is trained from scratch). All stolen models are trained using SGD $\\scriptstyle \\mathrm { ( L R = 0 . 1 }$ ) with momentum (0.5) for 30 epochs (LeNet) and 100 epochs (VGG16). We find choices of attacker’s architecture and optimization does not undermine the defense (discussed in Section 5.2.3). ",
+        "bbox": [
+            174,
+            419,
+            825,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of Attacks. We evaluate accuracy of resulting stolen models from the attack strategies as-is on the victim’s test set, thereby allowing for a fair head-to-head comparison with the victim model (additional details in Appendix A and D). The stolen model test accuracies, along with undefended victim model $F _ { V }$ accuracies are reported in Table 1. We observe for all six victim models, using just 50K black-box queries, attacks are able to significantly extract victim’s functionality e.g., ${ > } 8 7 \\%$ on MNIST. We find the knockoff attack to be the strongest, exhibiting reasonable performance even on complex victim models e.g., $7 4 . 6 \\%$ ${ \\mathsf { 0 . 9 3 } } { \\times } \\mathsf { A c c } ( F _ { V } ) )$ on Caltech256. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How Good are Existing Defenses? Most existing defenses in literature (Tramer et al., 2016; \\` Orekondy et al., 2019; Lee et al., 2018) perform some form of information truncation on the posterior probabilities e.g., rounding, returning top- $k$ labels; all strategies preserve the rank of the most confident label. We now evaluate model stealing attacks on the extreme end of information truncation, wherein the defender returns just the top-1 ‘argmax’ label. This strategy illustrates a rough lower bound on the strength of the attacker when using existing defenses. Specific to knockoff, we observe the attacker is minimally impacted on simpler datasets (e.g., $0 . 2 \\%$ accuracy drop on CIFAR10; see Fig. A5 in Appendix). While this has a larger impact on more complex datasets involving numerous classes (e.g., a maximum of $2 3 . 4 \\%$ drop observed on CUB200), the strategy also introduces a significant perturbation $( L _ { 1 } { = } 1 { \\pm } 0 . 5 )$ to the posteriors. The results suggest existing defenses, which largely the top-1 label, are largely ineffective at mitigating model stealing attacks. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Defenses: Evaluation. We evaluate all defenses on a non-replicability vs. utility curve at various operating points $\\epsilon$ of the defense. We furthermore evaluate the defenses for a large query budget (50K). We use as non-replicability the accuracy of the stolen model on held-out test data $\\mathcal { D } ^ { \\mathrm { t e s t } }$ . ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/91902f56490f283742cc7262836c7485569b2f806b9fd672b6ec55533ca1969d.jpg",
+        "image_caption": [
+            "Figure 3: Attackers vs. Our Defense. Curves are obtained by varying degree of perturbation $\\epsilon$ (Eq. 7) in our defense. $\\uparrow$ denotes higher numbers are better and $\\downarrow$ , lower numbers are better. Non-replicability objective is presented on the $x -$ -axis and utility on the $y$ -axis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            823,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use two utility metrics: (a) accuracy: test-accuracy of the defended model producing perturbed predictions on $\\mathcal { D } ^ { \\mathrm { t e s t } }$ ; and (b) perturbation magnitude $\\epsilon$ : measured as $L _ { 1 }$ distance $| | \\pmb { y } - \\tilde { \\pmb { y } } | | _ { 1 }$ . ",
+        "bbox": [
+            174,
+            275,
+            823,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Defense: Baselines. We compare our approaches against three methods: (i) reverse-sigmoid (Lee et al., 2018): which softens the posterior distribution and introduces ambiguity among nonargmax probabilities. For this method, we evaluate non-replicability and utility metrics for the defense operating at various choices of their hyperparameter $\\bar { \\boldsymbol { \\beta } } \\in [ 0 , 1 ]$ , while keeping their datasetspecific hyperparameter $\\gamma$ fixed (MNIST: 0.2, FashionMNIST: 0.4, CIFAR10: 0.1, rest: 0.2). (ii) random noise: For controlled random-noise, we add uniform random noise $\\delta _ { z }$ on the logit prediction scores $\\tilde { z } = z + \\delta _ { z }$ , where $\\begin{array} { r } { z = \\log ( \\frac { y } { 1 - y } ) } \\end{array}$ ), enforce utility by projecting $\\delta _ { z }$ to an $\\epsilon _ { z }$ -ball (Duchi et al., 2008), and renormalize probabilities $\\begin{array} { r } { \\tilde { y } = \\frac { 1 } { 1 + e ^ { - \\tilde { z } } } } \\end{array}$ 11+e−z˜ . (iii) dp-sgd: while our method and previous two baselines perturbs predictions, we also compare against introducing randomization to victim model parameters by training with the DP-SGD algorithm (Abadi et al., 2016). DP is a popular technique to protect the model against training data inference attacks. This baseline allows us to verify whether the same protection extends to model functionality. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            277,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the follow sections, we demonstrate the effectiveness of our defense rigorously evaluated across a wide range of complex datasets, attack models, defense baselines, query, and utility budgets. For readability, we first evaluate the defense against attack models, proceed to comparing the defense against strong baselines and then provide an analysis of the defense. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 MAD DEFENSE VS. ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            437,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 presents evaluation of our defenses MAD (Eq. 4-7) and MAD-argmax (Eq. 4-8) against the four attack models. To successfully mitigate attacks as a defender, we want the defense curves (colored solid lines with operating points denoted by thin crosses) to move away from undefended accuracies (denoted by circular discs, where $\\scriptstyle \\epsilon = 0 . 0$ ) to ideal defense performances (cyan cross, where $\\mathsf { A c c } ( \\mathsf { D e f } . )$ is unchanged and $\\mathsf { A c c } ( \\mathsf { A t t } . )$ is chance-level). ",
+        "bbox": [
+            174,
+            635,
+            825,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observe from Figure 3 that by employing an identical defense across all datasets and attacks, the effectiveness of the attacker can be greatly reduced. Across all models, we find MAD provides reasonable operating points (above the diagonal), where defender achieves significantly higher test accuracies compared to the attacker. For instance, on MNIST, for ${ < } 1 \\%$ drop in defender’s accuracy, our defense simultaneously reduces accuracy of the jbtop3 attacker by $52 \\%$ $8 7 . 3 \\% \\to 3 5 . 7 \\% )$ and knockoff by $29 \\%$ $9 9 . 1 \\%  6 9 . 8 \\%$ ). We find similar promising results even on high-dimensional complex datasets e.g., on CUB200, a $23 \\%$ $6 5 . 1 \\%  4 1 . 9 \\%$ ) performance drop of knockoff for $2 \\%$ drop in defender’s test performance. Our results indicate effective defenses are achievable, where the defender can trade-off a marginal utility cost to drastically impede the attacker. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 MAD DEFENSE VS. BASELINE DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            522,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now study how our approach compares to baseline defenses, by evaluating the defenses against the knockoff attack (which resulted in the strongest attack in our experiments). From Figure 4, we observe: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d2ec43c3846141fb8b809ed815df6405eafd30d5faf23ad174841aaccc16b44.jpg",
+        "image_caption": [
+            "Figure 4: Knockoff attack vs. Ours $^ +$ Baseline Defenses (best seen magnified). Non-replicability is presented on the $x$ -axis. On $_ y$ -axis, we present two utility measures: (a) top: Utility $= L _ { 1 }$ distance (b) bottom: Utility $=$ Defender’s accuracy. Region above the diagonal indicates instances where defender outperforms the attacker. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            825,
+            268
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0870ed4a1d860ee9030cadd9e6e6bebfb275032ad733501dad3a5b9c6d49c025.jpg",
+        "image_caption": [
+            "Figure 5: Attacker argmax. Follow-up to Figure 4b (CIFAR10), but with attacker using only the argmax label. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            332,
+            351,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e4ed37a96023b47935fd50b2b4ad45e9c890c037f8d35f43163e188853ebcbd.jpg",
+        "image_caption": [
+            "Figure 6: Histogram of Angular Deviations. Presented for MAD attack on CIFAR10 with various choices of $\\epsilon$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            372,
+            334,
+            617,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/77d45239807b214d6e4752bb3dfc61dc7e8cf93fdf014052bc588c4d45b83eba.jpg",
+        "image_caption": [
+            "Figure 7: Test loss. Visualized during training. Colours and lines correspond to $\\epsilon$ values in Fig. 6. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            640,
+            349,
+            813,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(i) Utility objective $\\mathbf { \\Phi } = L _ { 1 }$ distance (Fig. 4a): Although random-noise and reverse-sigmoid reduce attacker’s accuracy, the strategies in most cases involves larger perturbations. In contrast, MAD and MAD-argmax provides similar non-replicability (i.e., $\\mathsf { A c c } ( \\mathsf { A t t . } ) )$ with significantly lesser perturbation, especially at lower magnitudes. For instance, on MNIST (first column), MAD $( L _ { 1 } = 0 . 9 5 )$ ) reduces the accuracy of the attacker to under $80 \\%$ with $0 . 6 3 \\times$ the perturbation as that of reversesigmoid and random-noise $( L _ { 1 } \\approx 1 . 5 )$ . ",
+        "bbox": [
+            174,
+            547,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(ii) Utility objective $=$ argmax-preserving (Fig. 4b): By setting a hard constraint on retaining the label of the predictions, we find the accuracy-preserving defenses MAD-argmax and reverse-sigmoid successfully reduce the performance of the attacker by at least $20 \\%$ across all datasets. In most cases, we find MAD-argmax in addition achieves this objective by introducing lesser distortion to the predictions compared to reverse-sigmoid. For instance, in Fig. 4a, we find MAD-argmax consistently reduce the attacker accuracy to the same amount at lesser $L _ { 1 }$ distances. In reversesigmoid, we attribute the large $L _ { 1 }$ perturbations to a shift in posteriors towards a uniform distribution e.g., mean entropy of perturbed predictions is $3 . 0 2 \\pm 0 . 1 6$ (max-entropy $= 3 . 3 2 )$ at $L _ { 1 } { = } 1 . 0$ for MNIST; in contrast, MAD-argmax displays a mean entropy of $1 . 7 9 \\pm 0 . 1 1$ . However, common to accuracy-preserving strategies is a pitfall that the top-1 label is retained. In Figure 5 (see overlapping red and yellow cross-marks), we present the results of training the attacker using only the top-1 label. In line with previous discussions, we find that the attacker is able to significantly recover the original performance of the stolen model for accuracy-preserving defenses MAD-argmax and reverse-sigmoid. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(iii) Non-replicability vs. utility trade-off (Fig. 4b): We now compare our defense MAD (blue lines) with baselines (rand-noise and $\\mathtt { d p \\mathrm { - s g d ) } }$ which trade-off utility to mitigate model stealing. Our results indicate MAD offers a better defense (lower attacker accuracies for similar defender accuracies). For instance, to reduce the attacker’s accuracy to ${ < } 7 0 \\%$ , while the defender’s accuracy significantly degrades using dp-sgd $( 3 9 \\% )$ and rand-noise $( 5 6 . 4 \\% )$ , MAD involves a marginal decrease of $1 \\%$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5446cf701717e6223542aa63f0e7a86ef717ea541222b0c763898d51347ed44d.jpg",
+        "image_caption": [
+            "Figure 8: MAD Ablation experiments. Utility $=$ (left) $L _ { 1 }$ distance (right) defender test accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            109,
+            508,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/29eeb46cfec4e89f9b656b9fba6d6e761c3a9f3b84c5207b05b216b883c097f8.jpg",
+        "image_caption": [
+            "Figure 9: Subverting the Defense. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            102,
+            807,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2.3 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            300,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How much angular deviation does MAD introduce? To obtain insights on the angular deviation induced between the true and the perturbed gradient, we conduct an experiment by tracking the true gradient direction (which was unknown so far) at each training step. We simulate this by training an attacker model using online SGD $\\mathrm { { L R } } { = } 0 . 0 0 1$ ) over $N$ iterations using $B$ distinct images to query and a batch size of 1. At each step $t$ of training, the attacker queries a randomly sampled input $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ to the defender model and backpropogates the loss resulting from $\\tilde { \\mathbf { y } } _ { t }$ . In this particular experiment, the perturbation $\\tilde { \\mathbf { y } } _ { t }$ is crafted having exact knowledge of the attacker’s parameters. We evaluate the angular deviation between gradients with $\\mathbf { \\Pi } ( a )$ and without $( \\pmb { u } )$ the perturbation. ",
+        "bbox": [
+            173,
+            334,
+            825,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we visualize a histogram of deviations: $\\begin{array} { r } { \\theta = \\operatorname { a r c c o s } { \\frac { { \\mathbf { \\em u } } \\cdot { \\mathbf { \\boldsymbol { a } } } } { | | { \\mathbf { \\em u } } | | | | | { \\mathbf { \\boldsymbol { a } } } | | } } } \\end{array}$ , where $\\pmb { u } = \\nabla _ { \\pmb { w } } L ( \\pmb { w } _ { t } , \\pmb { y } , \\cdot )$ and $\\pmb { a } = \\nabla _ { \\pmb { w } } L ( \\pmb { w } _ { t } , \\tilde { \\pmb { y } } , \\cdot )$ . We observe: (i) although our perturbation space is severely restricted (a low-dimensional probability simplex), we can introduce surprisingly high deviations $( 0 - 1 1 5 ^ { \\circ } )$ in the high-dimensional parameter space of the VGG16; (ii) for $\\epsilon$ values at reasonable operating points which preserves the defender’s accuracy within $10 \\%$ of the undefended accuracy (e.g., $\\epsilon \\in [ 0 . 9 5$ , 0.99] for CIFAR10), we see deviations with mean $2 4 . 9 ^ { \\circ }$ (yellow bars in Fig. 6). This indicates that the perturbed gradient on an average leads to a slower decrease in loss function; (iii) on the extreme end, with $\\epsilon = \\epsilon _ { \\mathrm { m a x } } = 2$ , on an average, we find the perturbations successfully flips $( > 9 0 ^ { \\circ } )$ the gradient direction leading to an increase on the test loss, as seen in Figure 7 (blue line). We also find the above observations reasonably transfers to a black-box attacker setting (see Appendix F.4), where the perturbations are crafted without knowledge of the attacker’s parameters. Overall, we find our approach considerably corrupts the attacker’s gradient direction. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablative Analysis. We present an ablation analysis of our approach in Figure 8. In this experiment, we compare our approach MAD and MAD-argmax to: (a) $G = I$ : We substitute the jacobian $G$ (Eq. 5) with a $K \\times K$ identity matrix; and (b) $\\mathbf { \\boldsymbol { y } } ^ { * } =$ rand: Inner maximization term (Eq. 4) returns a random extreme of the simplex. Note that both (a) and (b) do not use the gradient information to perturb the posteriors. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From Figure 8, we observe: (i) poor performance of $\\mathbf { \\boldsymbol { y } } ^ { * } =$ rand, indicating random untargeted perturbations of the posterior probability is a poor strategy; (ii) $G = I$ , where the angular deviation is maximized between the posterior probability vectors is a slightly better strategy; (ii) MAD outperforms the above approaches. Consequently, we find using the gradient information (although a proxy to the attacker’s gradient signal) within our formulation (Equation 4) is crucial to providing better model stealing defenses. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Subverting the Defense. We now explore various strategies an attacker can use to circumvent the defense. To this end, we evaluate the following strategies: (a) argmax: attacker uses only the most-confident label during training; (b) arch- $^ *$ : attacker trains other choices of architectures; (c) nquery: attacker queries each image multiple times; (d) nquery+aug: same as (c), but with random cropping and horizontal flipping; and (e) opt- $^ *$ : attacker uses an adaptive LR optimizer e.g., ADAM (Kingma & Ba, 2014). ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present results over the subversion strategies in Figure 9. We find our defense robust to above strategies. Our results indicate that the best strategy for the attacker to circumvent our defense is to discard the probabilities and rely only on the most confident label to train the stolen model. In accuracy-preserving defenses (see Fig. 5), this previously resulted in an adversary entirely circumventing the defense (recovering up to $1 . 0 \\times$ original performance). In contrast, we find MAD is nonetheless effective in spite of the strategy, maintaining a $9 \\%$ absolute accuracy reduction in attacker’s stolen performance. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            318,
+            210
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we were motivated by limited success of existing defenses against DNN model stealing attacks. While prior work is largely based on passive defenses focusing on information truncation, we proposed the first active defense strategy that attacks the adversary’s training objective. We found our approach effective in defending a variety of victim models and against various attack strategies. In particular, we find our attack can reduce the accuracy of the adversary by up to $65 \\%$ , without significantly affecting defender’s accuracy. ",
+        "bbox": [
+            174,
+            226,
+            825,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement. This research was partially supported by the German Research Foundation (DFG CRC 1223). We thank Paul Swoboda and David Stutz for helpful discussions. ",
+        "bbox": [
+            174,
+            320,
+            821,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            285,
+            385
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In CCS, 2016. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ibrahim M Alabdulmohsin, Xin Gao, and Xiangliang Zhang. Adding robustness to support vector machines against adversarial reverse engineering. In CIKM, 2014. ",
+        "bbox": [
+            173,
+            430,
+            821,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In ECML PKDD, 2013. ",
+        "bbox": [
+            173,
+            470,
+            823,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Varun Chandrasekaran, K Chaudhari, Irene Giacomelli, Somesh Jha, and Songbai Yan. Exploring connections between active learning and model extraction. arXiv preprint arXiv:1905.09165, 2019. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacson Rodrigues Correia-Silva, Rodrigo F Berriel, Claudine Badue, Alberto F de Souza, and Thiago Oliveira-Santos. Copycat cnn: Stealing knowledge by persuading confession with random nonlabeled data. In IJCNN, 2018. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Shai Shalev-Shwartz, Yoram Singer, and Tushar Chandra. Efficient projections onto the l 1-ball for learning in high dimensions. In ICML, 2008. ",
+        "bbox": [
+            171,
+            626,
+            823,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cynthia Dwork, Aaron Roth, et al. The algorithmic foundations of differential privacy. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Theoretical Computer Science, 2014. ",
+        "bbox": [
+            173,
+            665,
+            823,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            171,
+            703,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            741,
+            823,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karla Leigh Hoffman. A method for globally minimizing concave functions over convex sets. Mathematical Programming, 20(1):22–32, 1981. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthew Jagielski, Nicholas Carlini, David Berthelot, Alex Kurakin, and Nicolas Papernot. Highfidelity extraction of neural network models. arXiv preprint arXiv:1909.01838, 2019. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mika Juuti, Sebastian Szyller, Alexey Dmitrenko, Samuel Marchal, and N Asokan. Prada: Protecting against dnn model stealing attacks. In Euro S&P, 2019. ",
+        "bbox": [
+            174,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Manish Kesarwani, Bhaskar Mukhoty, Vijay Arya, and Sameep Mehta. Model extraction warning in mlaas paradigm. In ACSAC, 2018. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014. ",
+        "bbox": [
+            168,
+            103,
+            810,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taesung Lee, Benjamin Edwards, Ian Molloy, and Dong Su. Defending against model stealing attacks using deceptive perturbations. S&P Deep Learning and Security (DLS) Workshop, 2018. ",
+        "bbox": [
+            171,
+            127,
+            821,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Lowd and Christopher Meek. Adversarial learning. In KDD, 2005. ",
+        "bbox": [
+            174,
+            165,
+            663,
+            181
+        ],
+        "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. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            188,
+            820,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Smitha Milli, Ludwig Schmidt, Anca D Dragan, and Moritz Hardt. Model reconstruction from model explanations. arXiv preprint arXiv:1807.05185, 2018. ",
+        "bbox": [
+            171,
+            226,
+            823,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Blaine Nelson, Marco Barreno, Fuching Jack Chi, Anthony D Joseph, Benjamin IP Rubinstein, Udam Saini, Charles Sutton, JD Tygar, and Kai Xia. Misleading learners: Co-opting your spam filter. In Machine learning in cyber trust. 2009. ",
+        "bbox": [
+            176,
+            263,
+            825,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Blaine Nelson, Benjamin Rubinstein, Ling Huang, Anthony Joseph, Shing-hon Lau, Steven Lee, Satish Rao, Anthony Tran, and Doug Tygar. Near-optimal evasion of convex-inducing classifiers. In AISTATS, 2010. ",
+        "bbox": [
+            176,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seong Joon Oh, Max Augustin, Bernt Schiele, and Mario Fritz. Towards reverse-engineering blackbox neural networks. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tribhuvanesh Orekondy, Bernt Schiele, and Mario Fritz. Knockoff nets: Stealing functionality of black-box models. In CVPR, 2019. ",
+        "bbox": [
+            171,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Soham Pal, Yash Gupta, Aditya Shukla, Aditya Kanade, Shirish Shevade, and Vinod Ganapathy. A framework for the extraction of deep neural networks by leveraging public data. arXiv preprint arXiv:1905.09165, 2019. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016. ",
+        "bbox": [
+            173,
+            494,
+            826,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Mart´ın Abadi, Ulfar Erlingsson, Ian Goodfellow, and Kunal Talwar. Semisupervised knowledge transfer for deep learning from private training data. In ICLR, 2017a. ",
+        "bbox": [
+            173,
+            545,
+            821,
+            575
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Asia CCS, 2017b. ",
+        "bbox": [
+            176,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer and Dan Boneh. Slalom: Fast, verifiable and private execution of neural networks in trusted hardware. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Fan Zhang, Ari Juels, Michael K Reiter, and Thomas Ristenpart. Stealing machine \\` learning models via prediction apis. In USENIX Security, 2016. ",
+        "bbox": [
+            173,
+            659,
+            821,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Binghui Wang and Neil Zhenqiang Gong. Stealing hyperparameters in machine learning. In S&P, 2018. ",
+        "bbox": [
+            173,
+            696,
+            821,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huadi Zheng, Qingqing Ye, Haibo Hu, Chengfang Fang, and Jie Shi. Bdpl: A boundary differentially private layer against machine learning model extraction attacks. In ESORICS, 2019. ",
+        "bbox": [
+            174,
+            734,
+            821,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Appendix ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            294,
+            123
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A OVERVIEW AND NOTATION ",
+        "bbox": [
+            176,
+            155,
+            436,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c8cea255bdfab207e7ac96356b3570b150eece1642e7cede0bc1ad2d2e93433.jpg",
+        "image_caption": [
+            "Figure A1: Overview of Attack, Defense, and Evaluation Metrics. We consider an attacker $A$ who exploits black-box access to defended model $F _ { V } ^ { \\delta }$ to train a stolen model $F _ { A }$ . In this paper, we take the role of the defender who intends to minimize replicability (i.e., $\\mathsf { A c c } ( F _ { A } , { \\mathcal { D } } ^ { \\mathrm { t e s t } } ) )$ , while maintaining utility of the predictions. We consider two notions of utility: (1) minimizing perturbations in predictions, measured here using $L _ { 1 }$ distance; and (2) maintaining accuracy of the defended model on test set $\\mathrm { A c c } ( F _ { V } ^ { \\delta } , { \\mathcal { D } } ^ { \\mathrm { t e s t } } )$ . Note that for a fair head-to-head comparison, we use the same held-out test set $\\mathcal { D } ^ { \\mathrm { t e s t } }$ to evaluate accuracies of both the defended model $F _ { V } ^ { \\delta }$ and stolen model $F _ { A }$ . Similar to all prior work, we assume $\\mathcal { D } ^ { \\mathrm { t r a i n } }$ , $\\mathcal { D } ^ { \\mathrm { t e s t } }$ are drawn i.i.d from the same (victim) distribution $\\mathcal { D } _ { V }$ . Notation used in the above figure is further elaborated in Table A1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            193,
+            751,
+            377
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a5181291ea362662af5b5db72507dfe4f84f3eb4d7f1f5818abe18a2b8f46ce3.jpg",
+        "table_caption": [
+            "Table A1: Notation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>x</td><td>Inputs (images ∈ RC×H×W)</td></tr><tr><td></td><td>y,y</td><td>Original, perturbed posterior predictions</td></tr><tr><td></td><td>AR</td><td>Probability simplex overK vertices</td></tr><tr><td>Attacker A</td><td>PA(X)</td><td>Attacker&#x27;s input data distribution</td></tr><tr><td></td><td>Dtransfer</td><td>Transfer set (= {(xi,yi)},where xi ~ PA(X),yi = Fv(xi))</td></tr><tr><td></td><td>FA</td><td>Attacker&#x27;s (stolen) model trained on Dtransfer</td></tr><tr><td>Victim/DefenderV</td><td>Pv(X)</td><td>Victim&#x27;s input data distribution</td></tr><tr><td></td><td>Dtrain</td><td>Training data (= {(xi,yi)},where xi ~ Pv(X))</td></tr><tr><td></td><td>Fv</td><td>Undefended model trained on Dtrain</td></tr><tr><td></td><td>F</td><td>Defended model</td></tr><tr><td></td><td>Dtest</td><td>Test set(= {(xi, yi)},where xi~Pv(X))</td></tr></table>",
+        "bbox": [
+            181,
+            512,
+            816,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B RELATED WORK: EXTENSION ",
+        "bbox": [
+            174,
+            746,
+            459,
+            763
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A summary of existing model stealing attacks and defenses is presented in Table A2. ",
+        "bbox": [
+            174,
+            777,
+            728,
+            794
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C DETAILED ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            406,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We present a detailed algorithm (see Algorithm 1) for our approach described in Section 4. ",
+        "bbox": [
+            169,
+            847,
+            767,
+            863
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The algorithm roughly follows four steps: ",
+        "bbox": [
+            174,
+            868,
+            449,
+            883
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(i) Predict $\\mathbf { ( L } 2 )$ : Obtains posterior probability predictions $\\textbf {  { y } }$ for input $_ { \\textbf { \\em x } }$ using a victim model $F _ { V } ( { \\pmb x } ; { \\pmb w } _ { V } )$ . ",
+        "bbox": [
+            205,
+            895,
+            825,
+            925
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/ce61dcd1003272525a1693e9767fc698aaebb061a5dd4610d2776175f5548e6c.jpg",
+        "table_caption": [
+            "Table A2: Existing DNN Attacks and Defenses. Complements the discussion in Section 2. $\\mathbf { \\Gamma } _ { \\mathbf { C N N } } { } ^ { * }$ ’: Complex ImageNet-like CNN. $\\cdot \\cdot \\cdot$ : Both. ‘P/D’: Perturbation/Detection. ‘AP’: Accuracy preserving (i.e., maintains top-1 labels of predictions). ‘AC’: Attacks considered. "
+        ],
+        "table_footnote": [
+            "Algorithm 1: MAD Defense. To supplement approach in Section 4 "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Black-box type</td><td colspan=\"2\">Proposed Attack</td><td colspan=\"4\">Proposed Defense</td></tr><tr><td>Input Query Data</td><td>Adapt.?</td><td>Strategy</td><td>P/D?</td><td>AP?</td><td>AC</td></tr><tr><td>1.Lowd &amp; Meek (2005)</td><td>Linear</td><td>Random Noise</td><td>√</td><td></td><td>-</td><td>-</td><td>-</td></tr><tr><td>2.Nelson et al. (2009)</td><td>Linear</td><td>Labeled Data</td><td>X</td><td>Rejection</td><td>D</td><td>X</td><td>1</td></tr><tr><td>3.Nelson et al. (2010)</td><td>Linear</td><td>Random Noise</td><td></td><td></td><td>-</td><td></td><td></td></tr><tr><td>4. Alabdulmohsin et al. (2014)</td><td>Linear</td><td>Random Noise</td><td>√</td><td>Ensembling</td><td>P</td><td>X</td><td>4</td></tr><tr><td>5.Tramer et al.(2016)</td><td>Linear, NN</td><td>Random Noise</td><td>+</td><td>Rounding</td><td>P</td><td>√</td><td>5</td></tr><tr><td>6.Milli et al. (2018)</td><td>Linear, NN</td><td>Random Noise</td><td></td><td>=</td><td>-</td><td></td><td>-</td></tr><tr><td>7.Kesarwani et al. (2018)</td><td>Decision Tree</td><td></td><td></td><td>Detection</td><td>D</td><td>√</td><td>5</td></tr><tr><td>8.Chandrasekaran et al. (2019)</td><td>Linear</td><td>Random Noise</td><td>√</td><td>Random Pert.</td><td>P</td><td>X</td><td>-</td></tr><tr><td>9.Papernot et al.(2017b)</td><td>CNN</td><td>Synth. Data</td><td>√</td><td></td><td>-</td><td></td><td>-</td></tr><tr><td>10. Correia-Silva et al. (2018)</td><td>CNN</td><td>Unlabeled Data</td><td>X</td><td></td><td></td><td>=</td><td></td></tr><tr><td>11.Pal et al. (2019)</td><td>CNN</td><td>Unlabeled Data</td><td>+</td><td></td><td>-</td><td>=</td><td>1</td></tr><tr><td>12. Orekondy et al. (2019)</td><td>CNN*</td><td>Unlabeled Data</td><td></td><td>Rounding, Top-k</td><td>P</td><td>√</td><td>12</td></tr><tr><td>13.Jagielski et al. (2019)</td><td>CNN*</td><td>Unlabeled Data</td><td>√</td><td></td><td>1</td><td>-</td><td>-</td></tr><tr><td>14. Juuti et al. (2019)</td><td>CNN</td><td>Synth. Data</td><td>√</td><td>Detection</td><td>D</td><td>√</td><td>9,14</td></tr><tr><td>15.Lee et al. (2018)</td><td>CNN</td><td></td><td></td><td>Reverse sigmoid</td><td>P</td><td>√</td><td>9</td></tr><tr><td>16. Ours</td><td>CNN*</td><td>=</td><td></td><td>Targeted Pert.</td><td>P</td><td>+</td><td>9,12,14</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(ii) Estimate Jacobian $G$ (L3): We estimate a $\\mathbb { R } ^ { K \\times D }$ jacobian matrix on a surrogate model $F$ . By default, we use as $F$ a randomly initialized model (more details in Appendix E.1). Each row of $G$ represents the gradient direction (in parameter space $\\mathbb { R } ^ { D }$ ) over log likelihood of class $k$ . ",
+        "bbox": [
+            204,
+            388,
+            825,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(iii) Maximize MAD Objective (L4): We find the optimal direction $\\boldsymbol { y } ^ { * }$ which maximizes the MAD objective (Eq. 3). To compute the arg max, we iterative over the $K$ extremes of the probability simplex $\\Delta ^ { K }$ to find ${ \\pmb y } ^ { * }$ which maximizes the objective. The extreme ${ \\pmb y } _ { k }$ denotes a probability vector with $y _ { k } = 1$ . ",
+        "bbox": [
+            200,
+            450,
+            825,
+            506
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(iv) Enforce Utility Constraint (L5-7): We enforce the perturbation utility constraint (Eq. 7) by considering a linear interpolation of ${ \\pmb y } ^ { * }$ and $\\textbf {  { y } }$ . The resulting interpolation probability vector $\\tilde { \\pmb y } : = h ( \\alpha ^ { * } )$ represents the utility-constrained perturbed prediction that is returned instead of $\\textbf {  { y } }$ . ",
+        "bbox": [
+            202,
+            512,
+            825,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1 Function PerturbedPredict-MAD $( { \\pmb x } )$ : Input: Input data $_ { \\textbf { \\em x } }$ , model to defend $F _ { V } ( \\bf { \\cdot } ; \\mu \\ v { v } _ { V } )$ , proxy attacker model $F ( \\cdot ; w )$ Output: Perturbed posterior probability $\\tilde { \\pmb { y } } \\in \\Delta ^ { K }$ s.t. $\\mathrm { d i s t } ( \\tilde { \\pmb { y } } , \\pmb { y } ) \\le \\epsilon$   \n2 ${ \\pmb y } : = F _ { V } ( { \\pmb x } ; { \\pmb w } _ { V } )$ // Obtain $K$ -dim posteriors   \n3 $\\pmb { G } : = \\nabla _ { \\pmb { w } } \\log F ( \\pmb { x } ; \\pmb { w } )$ // Pre-compute $\\left( \\mathbb { K } \\texttt { x D } \\right)$ ) Jacobian GT yk GT y 2   \n4 y∗ := arg maxyk∈ext(∆K) ||GT yk||2 ||GT y||2 \r\r2 // Alternatively ext $( \\Delta _ { k } ^ { K } )$ for MAD-argmax   \n5 Define $h ( \\alpha ) = ( 1 - \\alpha ) \\pmb { y } + \\alpha \\pmb { y } ^ { \\ast }$   \n6 $\\begin{array} { r } { \\alpha ^ { * } : = \\arg \\operatorname* { m a x } _ { \\alpha \\in [ 0 , 1 ] , \\mathrm { d i s t } ( \\cdot ) \\leq \\epsilon } \\ \\mathrm { d i s t } ( h ( \\alpha ) , \\ y ^ { * } ) } \\end{array}$ // Find optimal step-size via bisection, or OptStep(.) for $L _ { p }$ norms   \n7 $\\tilde { y } : = h ( \\alpha ^ { * } )$ // Perturbed probabilities   \n8 return $\\tilde { y }$   \n9   \n10 Function OptStep(y, y∗, \u000f, p):   \n11 α∗ := max n \u000f||y−y∗||p , 1o   \n12 return $\\ b { \\alpha } ^ { * }$ ",
+        "bbox": [
+            183,
+            598,
+            816,
+            891
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D ATTACK MODELS: RECAP AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            702,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jacobian Based Data Augmentation (jbda) (Papernot et al., 2017b). The motivation of the approach is to obtain a surrogate of the victim black-box classifier, with an end-goal of performing evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014). We restrict discussions primarily to the first part of constructing the surrogate. To obtain the surrogate (the stolen model), the authors depend on an unlabeled ‘seed’ set, typically from the same distribution as that used to train the victim model. As a result, the attacker assumes (mild) knowledge of the input data distribution and the class-label of the victim. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The key idea behind the approach is to query perturbations of inputs, to obtain a reasonable approximation of the decision boundary of the victim model. The attack strategy involves performing the following steps in a repeated manner: (i) images from the substitute set (initially the seed) $\\mathcal { D }$ is labeled by querying the victim model $F _ { V }$ as an oracle labeler; (ii) the surrogate model $F _ { A }$ is trained on the substitute dataset; (iii) the substitute set is augmented using perturbations of existing images: $\\mathscr { D } _ { \\rho + 1 } = \\mathscr { D } _ { \\rho } \\cup \\{ \\pmb { x } + \\lambda _ { \\rho + 1 } \\cdot \\mathrm { s g n } ( J _ { F } [ F _ { A } ( \\pmb { x } ) ] ) : \\pmb { x } \\in \\mathscr { D } _ { \\rho } \\}$ , where $J$ is the jacobian function. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use a seed set of: 100 (MNIST and FashionMNIST), 500 (CIFAR10, CUB200, Caltech256) and 1000 (CIFAR100). We use the default set of hyperparameters of Papernot et al. (2017b) in other respects. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jacobian Based $\\{ \\mathbf { s e l f } , \\mathbf { t o p } { \\mathbf { - } } \\mathbf { k } \\}$ (jbself, jbtop3) (Juuti et al., 2019) . The authors generalize the above approach, by extending the manner in which the synthetic samples are produced. In jbself, the jacobian is calculated w.r.t to $k$ nearest classes and in jb-self, w.r.t the maximum a posterior class predicted by $F _ { A }$ . ",
+        "bbox": [
+            174,
+            385,
+            825,
+            441
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Knockoff Nets (knockoff) (Orekondy et al., 2019) . Knockoff is a recent attack model, which demonstrated model stealing can be performed without access to seed samples. Rather, the queries to the black-box involve natural images (which can be unrelated to the training data of the victim model) sampled from a large independent data source e.g., ImageNet1K. Consequently, no knowledge of the input data distribution nor the class-label space of the victim model is required to perform model stealing. The paper proposes two strategies on how to sample images to query: random and adaptive. We use the random strategy in the paper, since adaptive resulted in marginal increases in an open-world setup (which we have). ",
+        "bbox": [
+            174,
+            450,
+            825,
+            563
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As the independent data sources in our knockoff attacks, we use: EMNIST-Letters (when stealing MNIST victim model), EMNIST (FashionMNIST), CIFAR100 (CIFAR10), CIFAR10 (CIFAR100), ImageNet1k (CUB200, Caltech256). Overlap between query images and the training data of the victim models are purely co-incidental. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use the code from the project’s public github repository. ",
+        "bbox": [
+            174,
+            632,
+            565,
+            647
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Evaluating Attacks. The resulting replica model $F _ { A }$ from all the above attack strategies are evaluated on a held-out test set. We remark that the replica model is evaluated as-is, without additional finetuning or modifications. Similar to prior work, we evaluate the accuracies of $F _ { A }$ on the victim’s held-out test set. Evaluating both stolen and the victim model on the same test set allows for fair head-to-head comparison. ",
+        "bbox": [
+            174,
+            657,
+            823,
+            728
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E SUPPLEMENTARY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            444,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present additional analysis to supplement Section 5.2.3. ",
+        "bbox": [
+            176,
+            781,
+            660,
+            796
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E.1 ESTIMATING $G$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            321,
+            828
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Central to our defense is estimating the jacobian matrix $\\boldsymbol { G } = \\nabla _ { w } \\log \\boldsymbol { F } ( \\boldsymbol { x } ; \\boldsymbol { w } )$ (Eq. 5), where $F ( \\cdot ; w )$ is the attacker’s model. However, a defender with black-box attacker knowledge (where $F$ is unknown) requires determining $G$ by instead using a surrogate model $F _ { \\mathrm { s u r } }$ . We determine choice of $F _ { \\mathrm { s u r } }$ empirically by studying two factors: (a) architecture of $F _ { s u r }$ : choice of defender’s surrogate architecture robust to varying attacker architectures (see Fig. A2); and (b) initialization of $F _ { s u r }$ : initialization of the surrogate model parameters plays a crucial role in providing a better defense. We consider four choices of initialization: $\\{$ ‘rand’, ‘early’, ‘mid’, ‘late $\\}$ which exhibits approximately {chance-level $2 5 \\%$ , $50 \\%$ , $7 5 \\% \\}$ test accuracies respectively. We observe (see Fig. A3) that a randomly initialized model, which is far from convergence, provides better gradient signals in crafting perturbations. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/153ac1308928aa6c767d311403df37674d0d28f28f63d471fd8c6e311822d091.jpg",
+        "image_caption": [
+            "Figure A2: Influence of attacker architecture choices on a fixed surrogate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            338,
+            248
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f9dfe314f17b55b6e6cd891bc699dc96d3b17b415a70a5a64a55af790a3daf0.jpg",
+        "image_caption": [
+            "Figure A3: Influence of Initialization of a VGG16 Surrogate Model. ‘rand’ $=$ random initialization, (‘early’, ’mid’, ’late’) $= \\sim ( 2 5 , 5 0 , 7 5 ) \\%$ test accuracy of surrogate on test set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            109,
+            815,
+            251
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/0338f418c4cbb6fe069b868081f6391c941ec999b609f73e9a71c9d3c284d7a1.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table A3: Run times (in ms). We report the mean and standard deviation of predictions of undefended and defended models, computed over 10K predictions. "
+        ],
+        "table_body": "<table><tr><td></td><td>Undefended</td><td>MAD</td></tr><tr><td>MNIST</td><td>0.88 ± 14.41</td><td>6.47 ±12.25</td></tr><tr><td>FashionMNIST</td><td>0.89 ±15.76</td><td>6.65 ± 14.16</td></tr><tr><td>CIFAR10</td><td>1.93 ±13.02</td><td>8.58 ±15.02</td></tr><tr><td>CIFAR100</td><td>2.15 ± 18.82</td><td>69.26 ± 21.4</td></tr><tr><td>CUBS200</td><td>4.45 ± 9.66</td><td>446.93 ± 23.87</td></tr><tr><td>Caltech256</td><td>4.93 ± 21.25</td><td>815.97 ± 30.3</td></tr></table>",
+        "bbox": [
+            346,
+            325,
+            651,
+            431
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            491,
+            825,
+            547
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.2 RUN-TIME ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            364,
+            583
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We present the run-times of our defended and undefended models in Table A3. The reported numbers were summarized over 10K unique predictions performed on an Nvidia Tesla V100. We find our optimization procedure Eq. (4-7) for all models take under a second, with at most 0.8s in the case of Caltech256. The primary computational bottleneck of our defense implementation is estimating matrix $G \\in \\mathbb { R } ^ { K \\times D }$ in Eq. 5, which currently requires performing $K$ (i.e., number of output classes) backward passes through the surrogate model. Consequently, we find that our inference times on Caltech256 can be further reduced to $0 . 3 \\mathrm { s } \\pm 0 . 0 4$ by using a more efficient surrogate architecture (e.g., ResNet-34). ",
+        "bbox": [
+            173,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F ADDITIONAL PLOTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            375,
+            746
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F.1 ATTACKER EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            383,
+            779
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We present evaluation of all attacks considered in the paper on an undefended model in Figure A4. Furthermore, specific to the knockoff attack, we analyze how training using only the top-1 label (instead of complete posterior information) affects the attacker in Figure A5. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            834
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F.2 BUDGET VS. ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            387,
+            868
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We plot the budget (i.e., number of distinct black-box attack queries to the defender) vs. the test accuracy of the defender/attacker in Figure A6. The figure supplements Figure 1 and the discussion found in Section 5.2.1 of the main paper. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/968ed9b6fa6cf410d5fe914d5b8e15393feb3e9080191b93fd9d452e5563020c.jpg",
+        "image_caption": [
+            "Figure A4: Evaluation of all attacks on undefended victim models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            137,
+            823,
+            247
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/63bb498a5d948a35bd3a6147ae4418c96ac52a1153e64b56876efc2195d87af2.jpg",
+        "image_caption": [
+            "Figure A5: Stolen model trained using knockoff strategy on complete posterior information $( y )$ and only the top-1 label of the posteriors (arg $\\operatorname* { m a x } _ { k } y _ { k } ,$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            352,
+            823,
+            460
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a29287cb397358a8d7eb84c6b41de899159996bb2f98075dde89cadd0bd8a0ed.jpg",
+        "image_caption": [
+            "Figure A6: Budget vs. Test Accuracy. Supplements Fig. 3c in the main paper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            579,
+            820,
+            861
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/cbea626041732899afd7bc150fff641c88d6ec6f05c67a8fe5ad9c4fdcd2d5c3.jpg",
+        "image_caption": [
+            "Figure A7: Attacker argmax. Supplements Fig. 4 in the main paper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            794,
+            220
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/814c5ebd205a8b527661505f8785c1172d914ec1f85919f5b6ecca8a93a8ced1.jpg",
+        "image_caption": [
+            "Figure A8: Histogram of Angular Deviations (Black-box setting). Supplements Fig. 6 in the main paper. The test-loss during of the attacker model for each of the histograms (over multiple $\\epsilon$ values) are provided in the bottom row. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            257,
+            823,
+            500
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F.3 ATTACKER ARGMAX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            571,
+            354,
+            585
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Figure A7, we perform the non-replicability vs. utility evaluation (complementing Fig. 5 in the main paper) under a special situation: the attacker discards the probabilities and only uses the top-1 Black-box s‘argmax’ label to train the stolen model. Relevant discussion can be found in Section 5.2.2. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            638
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F.4 BLACK-BOX ANGULAR DEVIATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            656,
+            467,
+            670
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Figure A8, we provide the angular deviations obtained in a black-box setting over the course of training the attack model. We train the attacker model using the transfer set obtained by the knockoff approach (the strongest attacker in our experiments) for 50 epochs using a SGD $( \\mathrm { l r } = 0 . 0 1 $ , momentum $= 0 . 5$ ) and a batch size of 64. The experiment compliments our previous discussion in Section 5.2.3 of the main paper under “How much angular deviation does MAD introduce?”. As before, we estimate the angular deviations as: $\\begin{array} { r } { \\theta = \\operatorname { a r c c o s } { \\frac { { \\mathbf { \\em u } } \\cdot { \\mathbf { \\boldsymbol { a } } } } { | | { \\mathbf { \\boldsymbol { u } } } | | | | | { \\mathbf { \\boldsymbol { a } } } | | } } } \\end{array}$ , where $\\pmb { u } = \\nabla _ { \\pmb { w } } L ( \\pmb { w } _ { t } , \\pmb { y } , \\cdot )$ and $\\pmb { a } = \\nabla _ { \\pmb { w } } L ( \\pmb { w } _ { t } , \\tilde { \\pmb { y } } , \\cdot )$ . We observe from Figure A8: (i) the defensive angular deviations introduced by MAD to posterior predictions transfer to a black-box attacker setting, when crafting perturbations without access to the adversary’s model parameters; and (ii) although the setting introduces lower angular deviations at the extreme case of $\\epsilon { = } 2 . 0$ (e.g., $1 1 4 . 7 ^ { \\circ }  7 6 . 5 ^ { \\circ }$ in CIFAR10), we observe the perturbation sufficient to maximize the attacker’s test loss. We find significant angular deviations introduced by our approach in a black-box setting as well. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            853
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F.5 MAD ABLATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            439,
+            883
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We present the ablation experiments covering all defender models in Figure A9. Relevant discussion is available in Section 5.2.3 of the main paper under “Ablative Analysis”. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebbb31ab9a0a9f8937895ef989636c604e4dbcd058782a781ec0012e2eba3820.jpg",
+        "image_caption": [
+            "Figure A9: MAD ablation experiments. Supplements Fig. 8 in the main paper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            387,
+            794,
+            612
+        ],
+        "page_idx": 16
+    }
+]

parse/train/rkRwGg-0Z/rkRwGg-0Z.md

@@ -0,0 +1,306 @@
+# BEYOND WORD IMPORTANCE: CONTEXTUAL DECOMPOSITION TO EXTRACT INTERACTIONS FROM LSTMS
+
+Peter J. Liu Google Brain Mountain View, CA
+
+W. James Murdoch ∗ Department of Statistics University of California, Berkeley jmurdoch@berkeley.edu
+
+Bin Yu   
+Department of Statistics   
+Department of EECS   
+University of California, Berkeley
+
+# ABSTRACT
+
+The driving force behind the recent success of LSTMs has been their ability to learn complex and non-linear relationships. Consequently, our inability to describe these relationships has led to LSTMs being characterized as black boxes. To this end, we introduce contextual decomposition (CD), an interpretation algorithm for analysing individual predictions made by standard LSTMs, without any changes to the underlying model. By decomposing the output of a LSTM, CD captures the contributions of combinations of words or variables to the final prediction of an LSTM. On the task of sentiment analysis with the Yelp and SST data sets, we show that CD is able to reliably identify words and phrases of contrasting sentiment, and how they are combined to yield the LSTM’s final prediction. Using the phrase-level labels in SST, we also demonstrate that CD is able to successfully extract positive and negative negations from an LSTM, something which has not previously been done.
+
+# 1 INTRODUCTION
+
+In comparison with simpler linear models, techniques from deep learning have achieved impressive accuracy by effectively learning non-linear interactions between features. However, due to our inability to describe the learned interactions, this improvement in accuracy has come at the cost of state of the art predictive algorithms being commonly regarded as black-boxes. In the domain of natural language processing (NLP), Long Short Term Memory networks (LSTMs) (Hochreiter & Schmidhuber, 1997) have become a basic building block, yielding excellent performance across a wide variety of tasks (Sutskever et al., 2014) (Rajpurkar et al., 2016) (Melis et al., 2017), while remaining largely inscrutable.
+
+In this work, we introduce contextual decomposition (CD), a novel interpretation method for explaining individual predictions made by an LSTM without any modifications to the underlying model. CD extracts information about not only which words contributed to a LSTM’s prediction, but also how they were combined in order to yield the final prediction. By mathematically decomposing the LSTM’s output, we are able to disambiguate the contributions made at each step by different parts of the sentence.
+
+To validate the CD interpretations extracted from an LSTM, we evaluate on the problem of sentiment analysis. In particular, we demonstrate that CD is capable of identifying words and phrases of differing sentiment within a given review. CD is also used to successfully extract positive and negative negations from an LSTM, something that has not previously been done. As a consequence of this analysis, we also show that prior interpretation methods produce scores which have document-level information built into them in complex, unspecified ways. For instance, prior work often identifies strongly negative phrases contained within positive reviews as neutral, or even positive.
+
+# 2 RELATED WORK
+
+The most relevant prior work on interpreting LSTMs has focused on approaches for computing word-level importance scores, with evaluation protocols varying greatly. Murdoch & Szlam (2017) introduced a decomposition of the LSTM’s output embedding into a sum over word coefficients, and demonstrated that those coefficients are meaningful by using them to distill LSTMs into rules-based classifiers. Li et al. (2016) took a more black box approach, called Leave One Out, by observing the change in log probability resulting from replacing a given word vector with a zero vector, and relied solely on anecdotal evaluation. Finally, Sundararajan et al. (2017) presents a general gradient-based technique, called Integrated Gradients, which was validated both theoretically and with empirical anecdotes. In contrast to our proposed method, this line of work has been limited to word-based importance scores, ignoring the interactions between variables which make LSTMs so accurate.
+
+Another line of work (Karpathy et al., 2015) (Strobelt et al., 2016) has focused on analysing the movement of raw gate activations over a sequence. Karpathy et al. (2015) was able to identify some co-ordinates of the cell state that correspond to semantically meaningful attributes, such as whether the text is in quotes. However, most of the cell co-ordinates were uninterpretable, and it is not clear how these co-ordinates combine to contribute to the actual prediction.
+
+Decomposition-based approaches to interpretation have also been applied to convolutional neural networks (CNNs) (Bach et al., 2015) (Shrikumar et al., 2017). However, they have been limited to producing pixel-level importance scores, ignoring interactions between pixels, which are clearly quite important. Our approach is similar to these in that it computes an exact decomposition, but we leverage the unique gating structure of LSTMs in order to extract interactions.
+
+Attention based models (Bahdanau et al., 2014) offer another means of providing some interpretability. Such models have been successfully applied to many problems, yielding improved performance (Rush et al., 2015) (Xu et al., 2015). In contrast to other word importance scores, attention is limited in that it only provides an indirect indicator of importance, with no directionality, i.e. what class the word is important for. Although attention weights are often cited anecdotally, they have not been evaluated, empirically or otherwise, as an interpretation technique. As with other prior work, attention is also incapable of describing interactions between words.
+
+# 3 CONTEXTUAL DECOMPOSITION OF LSTMS
+
+Given an arbitrary phrase contained within an input, we present a novel decomposition of the output of an LSTM into a sum of two contributions: those resulting solely from the given phrase, and those involving other factors. The key insight behind this decomposition is that the gating dynamics unique to LSTMs are a vehicle for modeling interactions between variables.
+
+# 3.1 LONG SHORT TERM MEMORY NETWORKS
+
+Over the past few years, LSTMs have become a core component of neural NLP systems. Given a sequence of word embeddings $x _ { 1 } , . . . , x _ { T } \in \mathbb { R } ^ { d _ { 1 } }$ , a cell and state vector $c _ { t } , h _ { t } \in \mathbb { R } ^ { \dot { d } _ { 2 } }$ are computed for each element by iteratively applying the below equations, with initialization $h _ { 0 } = c _ { 0 } = 0$ .
+
+$$
+\begin{array} { r l } & { o _ { t } = \sigma ( W _ { o } x _ { t } + V _ { o } h _ { t - 1 } + b _ { o } ) } \\ & { f _ { t } = \sigma ( W _ { f } x _ { t } + V _ { f } h _ { t - 1 } + b _ { f } ) } \\ & { i _ { t } = \sigma ( W _ { i } x _ { t } + V _ { i } h _ { t - 1 } + b _ { i } ) } \\ & { g _ { t } = \operatorname { t a n h } ( W _ { g } x _ { t } + V _ { g } h _ { t - 1 } + b _ { g } ) } \\ & { c _ { t } = f _ { t } \odot c _ { t - 1 } + i _ { t } \odot g _ { t } } \\ & { h _ { t } = o _ { t } \odot \operatorname { t a n h } ( c _ { t } ) } \end{array}
+$$
+
+Where Wo, Wi, Wf , Wg ∈ Rd1×d2 , $V _ { o } , V _ { f } , V _ { i } , V _ { g } \in \mathbb { R } ^ { d _ { 2 } \times d _ { 2 } } , b _ { o } , b _ { g } , b _ { i } , b _ { g } \in \mathbb { R } ^ { d _ { 2 } }$ and $\odot$ denotes element-wise multiplication. $o _ { t } , f _ { t }$ and $i _ { t }$ are often referred to as output, forget and input gates, respectively, due to the fact that their values are bounded between 0 and 1, and that they are used in element-wise multiplication.
+
+After processing the full sequence, the final state $h _ { T }$ is treated as a vector of learned features, and used as input to a multinomial logistic regression, often called SoftMax, to return a probability distribution $p$ over $C$ classes, with
+
+$$
+p _ { j } = \mathrm { S o f t M a x } ( W h _ { T } ) _ { j } = \frac { \exp ( W _ { j } h _ { T } ) } { \sum _ { k = 1 } ^ { C } \exp ( W _ { k } h _ { t } ) }
+$$
+
+# 3.2 CONTEXTUAL DECOMPOSITION OF LSTM
+
+We now introduce contextual decomposition, our proposed method for interpreting LSTMs. Given an arbitrary phrase $x _ { q } , . . . , x _ { r }$ , where $1 \leq q \leq r \leq T$ , we now decompose each output and cell state $c _ { t } , h _ { t }$ in Equations 5 and 6 into a sum of two contributions.
+
+$$
+\begin{array} { l } { h _ { t } = \beta _ { t } + \gamma _ { t } } \\ { c _ { t } = \beta _ { t } ^ { c } + \gamma _ { t } ^ { c } } \end{array}
+$$
+
+The decomposition is constructed so that $\beta _ { t }$ corresponds to contributions made solely by the given phrase to $h _ { t }$ , and that $\gamma _ { t }$ corresponds to contributions involving, at least in part, elements outside of the phrase. $\beta _ { t } ^ { c }$ and $\gamma _ { t } ^ { c }$ represent analogous contributions to $c _ { t }$ .
+
+Using this decomposition for the final output state $W h _ { T }$ in Equation 7 yields
+
+$$
+p = \operatorname { S o f t M a x } ( W \beta _ { T } + W \gamma _ { T } )
+$$
+
+Here $W \beta _ { T }$ provides a quantitative score for the phrase’s contribution to the LSTM’s prediction. As this score corresponds to the input to a logistic regression, it may be interpreted in the same way as a standard logistic regression coefficient.
+
+# 3.2.1 DISAMBIGUATING INTERACTIONS BETWEEN GATES
+
+In the cell update Equation 5, neuron values in each of $i _ { t }$ and $g _ { t }$ are independently determined by both the contribution at that step, $x _ { t }$ , as well as prior context provided by $h _ { t - 1 } = \beta _ { t - 1 } + \gamma _ { t - 1 }$ . Thus, in computing the element-wise product $i _ { t } \odot g _ { t }$ , often referred to as gating, contributions made by $x _ { t }$ to $i _ { t }$ interact with contributions made by $h _ { t }$ to $g _ { t }$ , and vice versa.
+
+We leverage this simple insight to construct our decomposition. First, assume that we have a way of linearizing the gates and updates in Equations 2, 3, 4 so that we can write each of them as a linear sum of contributions from each of their inputs.
+
+$$
+\begin{array} { r l } & { i _ { t } = \sigma ( W _ { i } x _ { t } + V _ { i } h _ { t - 1 } + b _ { i } ) } \\ & { \quad = L _ { \sigma } ( W _ { i } x _ { t } ) + L _ { \sigma } ( V _ { i } h _ { t - 1 } ) + L _ { \sigma } ( b _ { i } ) } \end{array}
+$$
+
+When we use this linearization in the cell update Equation 5, the products between gates become products over linear sums of contributions from different factors. Upon expanding these products, the resulting cross-terms yield a natural interpretation as being interactions between variables. In particular, cross-terms can be assigned as to whether they resulted solely from the phrase, e.g. $\mathsf { \bar { L } } _ { \sigma } ( V _ { i } \beta _ { t - 1 } ) \odot L _ { \operatorname { t a n h } } ( V _ { g } \beta _ { t - 1 } )$ , from some interaction between the phrase and other factors, e.g. $L _ { \sigma } ( V _ { i } \beta _ { t - 1 } ) \odot L _ { \operatorname { t a n h } } ( V _ { g } \gamma _ { t - 1 } )$ , or purely from other factors, e.g. $L _ { \sigma } ( \bar { b } _ { i } ) \odot L _ { \mathrm { t a n h } } ( V _ { g } \gamma _ { t - 1 } )$ .
+
+Mirroring the recurrent nature of LSTMs, the above insights allow us to recursively compute our decomposition, with the initializations $\beta _ { 0 } = \beta _ { 0 } ^ { c } = \gamma _ { 0 } = \gamma _ { 0 } ^ { c } = 0$ . We derive below the update equations for the case where $q \leq t \leq r$ , so that the current time step is contained within the phrase. The other case is similar, and the general recursion formula is provided in Appendix 6.2.
+
+For clarity, we decompose the two products in the cell update Equation 5 separately. As discussed above, we simply linearize the gates involved, expand the resulting product of sums, and group the cross-terms according to whether or not their contributions derive solely from the specified phrase, or otherwise. Terms are determined to derive solely from the specified phrase if they involve products from some combination of $\beta _ { t - 1 } , \beta _ { t - 1 } ^ { c } , x _ { t }$ and $b _ { i }$ or $b _ { g }$ (but not both). When $t$ is not within the phrase, products involving $x _ { t }$ are treated as not deriving from the phrase.
+
+$$
+\begin{array} { r l } & { f _ { t } \odot c _ { t - 1 } = \left( L _ { \sigma } ( W _ { f } x _ { t } ) + L _ { \sigma } ( V _ { f } \beta _ { t - 1 } ) + L _ { \sigma } ( V _ { f } \gamma _ { t - 1 } ) + L _ { \sigma } ( b _ { f } ) \right) \odot \left( \beta _ { t - 1 } ^ { c } + \gamma _ { t - 1 } ^ { c } \right) } \\ & { \qquad = \left( \left[ L _ { \sigma } ( W _ { f } x _ { t } ) + L _ { \sigma } ( V _ { f } \beta _ { t - 1 } ) + L _ { \sigma } ( b _ { f } ) \right] \odot \beta _ { t - 1 } ^ { c } \right) } \\ & { \qquad + \left( L _ { \sigma } ( V _ { f } \gamma _ { t - 1 } ) \odot \beta _ { t - 1 } ^ { c } + f _ { t } \odot \gamma _ { t - 1 } ^ { c } \right) } \\ & { \qquad = \beta _ { t } ^ { f } + \gamma _ { t } ^ { f } } \end{array}
+$$
+
+$$
+\begin{array} { r l } { i _ { t } \odot g _ { t } = [ L _ { \sigma } ( W _ { i } x _ { t } ) + L _ { \sigma } ( V _ { i } \beta _ { t - 1 } ) + L _ { \sigma } ( V _ { i } \gamma _ { t - 1 } ) + L _ { \sigma } ( b _ { i } ) ] } \\ { \odot [ L _ { \mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \mathrm { t a n h } } ( V _ { g } \beta _ { t - 1 } ) + L _ { \mathrm { t a n h } } ( V _ { g } \gamma _ { t - 1 } ) + L _ { \mathrm { t a n h } } ( b _ { g } ) ] } \\ { = [ L _ { \sigma } ( W _ { i } x _ { t } ) \odot [ L _ { \mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \mathrm { t a n h } } ( V _ { g } \beta _ { t - 1 } ) + L _ { \mathrm { t a n h } } ( b _ { g } ) ] } \\ { + L _ { \sigma } ( V _ { i } \beta _ { t - 1 } ) \odot [ L _ { \mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \mathrm { t a n h } } ( V _ { g } \beta _ { t - 1 } ) + L _ { \mathrm { t a n h } } ( b _ { g } ) ] } \\ { + L _ { \sigma } ( b _ { i } ) \odot [ L _ { \mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \mathrm { t a n h } } ( V _ { g } \beta _ { t - 1 } ) ] ] } \\ { + [ L _ { \sigma } ( V _ { i } \gamma _ { t - 1 } ) \odot g _ { t } + i _ { t } \odot L _ { \mathrm { t a n h } } ( V _ { g } \gamma _ { t - 1 } ) - L _ { \sigma } ( V _ { i } \gamma _ { t - 1 } ) \odot L _ { \mathrm { t a n h } } ( V _ { g } \gamma _ { t - 1 } ) } \\ { + \ell _ { \sigma } ( b _ { i } ) \odot L _ { \mathrm { t a n h } } ( b _ { g } ) ] } \\ { = \beta _ { t } ^ { u } + \gamma _ { t } ^ { u } } \end{array}
+$$
+
+Having decomposed the two components of the cell update equation, we can attain our decomposition of $c _ { t }$ by summing the two contributions.
+
+$$
+\begin{array} { l } { \beta _ { t } ^ { c } = \beta _ { t } ^ { f } + \beta _ { t } ^ { u } } \\ { \gamma _ { t } ^ { c } = \gamma _ { t } ^ { f } + \gamma _ { t } ^ { u } } \end{array}
+$$
+
+Once we have computed the decomposition of $c _ { t }$ , it is relatively simple to compute the resulting transformation of $h _ { t }$ by linearizing the tanh function in 6. Note that we could similarly decompose the output gate as we treated the forget gate above, but we empirically found this to not produce improved results.
+
+$$
+\begin{array} { r l } & { h _ { t } = o _ { t } \odot \operatorname { t a n h } ( c _ { t } ) } \\ & { \phantom { = } = o _ { t } \odot [ L _ { \operatorname { t a n h } } ( \beta _ { t } ^ { c } ) + L _ { \operatorname { t a n h } } ( \gamma _ { t } ^ { c } ) ] } \\ & { \phantom { = } = o _ { t } \odot L _ { \operatorname { t a n h } } ( \beta _ { t } ^ { c } ) + o _ { t } \odot L _ { \operatorname { t a n h } } ( \gamma _ { t } ^ { c } ) } \\ & { \phantom { = } = \beta _ { t } + \gamma _ { t } } \end{array}
+$$
+
+# 3.2.2 LINEARIZING ACTIVATION FUNCTIONS
+
+We now describe the linearizing functions $L _ { \sigma } , L _ { \mathrm { t a n h } }$ used in the above decomposition. Formally, for arbitrary $\{ y _ { 1 } , . . . , y _ { N } \} \in \mathbb { R }$ , where $N \leq 4$ , the problem is how to write
+
+$$
+\operatorname { t a n h } ( \sum _ { i = 1 } ^ { N } y _ { i } ) = \sum _ { i = 1 } ^ { N } L _ { \operatorname { t a n h } } ( y _ { i } )
+$$
+
+In the cases where there is a natural ordering to $\{ y _ { i } \}$ , prior work (Murdoch & Szlam, 2017) has used a telescoping sum consisting of differences of partial sums as a linearization technique, which we show below.
+
+$$
+L _ { \operatorname { t a n h } } ^ { \prime } ( y _ { k } ) = \operatorname { t a n h } ( \sum _ { j = 1 } ^ { k } y _ { j } ) - \operatorname { t a n h } ( \sum _ { j = 1 } ^ { k - 1 } y _ { j } )
+$$
+
+However, in our setting $\{ y _ { i } \}$ contains terms such as $\beta _ { t - 1 }$ , $\gamma _ { t - 1 }$ and $x _ { t }$ , which have no clear ordering. Thus, there is no natural way to order the sum in Equation 26. Instead, we compute an average over all orderings. Letting $\pi _ { 1 } , . . . , \pi _ { M _ { N } }$ denote the set of all permutations of $1 , . . . , N$ , our score is given below. Note that when $\pi _ { i } ( j ) = j$ , the corresponding term is equal to equation 26.
+
+$$
+L _ { \mathrm { t a n h } } ( y _ { k } ) = { \frac { 1 } { M _ { N } } } \sum _ { i = 1 } ^ { M _ { N } } [ \mathrm { t a n h } ( \sum _ { j = 1 } ^ { \pi _ { i } ^ { - 1 } ( k ) } y _ { \pi _ { i } ( j ) } ) - \mathrm { t a n h } ( \sum _ { j = 1 } ^ { \pi _ { i } ^ { - 1 } ( k ) - 1 } y _ { \pi _ { i } ( j ) } ) ]
+$$
+
+$L _ { \sigma }$ can be analogously derived. When one of the terms in the decomposition is a bias, we saw improvements when restricting to permutations where the bias is the first term.
+
+As $N$ only ranges between 2 and 4, this linearization generally takes very simple forms. For instance, when $N = 2$ , the contribution assigned to $y _ { 1 }$ is
+
+$$
+L _ { \operatorname { t a n h } } ( y _ { 1 } ) = { \frac { 1 } { 2 } } ( [ \operatorname { t a n h } ( y _ { 1 } ) - \operatorname { t a n h } ( 0 ) ] + [ \operatorname { t a n h } ( y _ { 2 } + y _ { 1 } ) - \operatorname { t a n h } ( y _ { 1 } ) ] )
+$$
+
+This linearization was presented in a scalar context where $y _ { i } \in \mathbb { R }$ , but trivially generalizes to the vector setting $y _ { i } \in \mathbb { R } ^ { d _ { 2 } }$ . It can also be viewed as an approximation to Shapely values, as discussed in Lundberg & Lee (2016) and Shrikumar et al. (2017).
+
+# 4 EXPERIMENTS
+
+We now describe our empirical validation of CD on the task of sentiment analysis. First, we verify that, on the standard problem of word-level importance scores, CD compares favorably to prior work. Then we examine the behavior of CD for word and phrase level importance in situations involving compositionality, showing that CD is able to capture the composition of phrases of differing sentiment. Finally, we show that CD is capable of extracting instances of positive and negative negation. Code for computing CD scores is available online 1.
+
+# 4.1 TRAINING DETAILS
+
+We first describe the process for fitting models which are used to produce interpretations. As the primary intent of this paper is not predictive accuracy, we used standard best practices without much tuning. We implemented all models in Torch using default hyperparameters for weight initializations. All models were optimized using Adam (Kingma & Ba, 2014) with the default learning rate of 0.001 using early stopping on the validation set. For the linear model, we used a bag of vectors model, where we sum pre-trained Glove vectors (Pennington et al., 2014) and add an additional linear layer from the word embedding dimension, 300, to the number of classes, 2. We fine tuned both the word vectors and linear parameters. We will use the two data sets described below to validate our new CD method.
+
+# 4.1.1 STANFORD SENTIMENT TREEBANK
+
+We trained an LSTM model on the binary version of the Stanford Sentiment Treebank (SST) (Socher et al., 2013), a standard NLP benchmark which consists of movie reviews ranging from 2 to 52 words long. In addition to review-level labels, it also provides labels for each phrase in the binarized constituency parse tree. Following the hyperparameter choices in Tai et al. (2015), the word and hidden representations of our LSTM were set to 300 and 168, and word vectors were initialized to pretrained Glove vectors (Pennington et al., 2014). Our LSTM attains $8 7 . 2 \%$ accuracy, and we also train a logistic regression model with bag of words features, which attains $8 3 . 2 \%$ accuracy.
+
+# 4.1.2 YELP POLARITY
+
+Originally introduced in Zhang et al. (2015), the Yelp review polarity dataset was obtained from the Yelp Dataset Challenge and has train and test sets of sizes 560,000 and 38,000. The task is binary prediction for whether the review is positive (four or five stars) or negative (one or two stars). The reviews are relatively long, with an average length of 160.1 words. Following the guidelines from Zhang et al. (2015), we implement an LSTM model which attains $4 . 6 \%$ error, and an ngram logistic regression model, which attains $5 . 7 \%$ error. For computational reasons, we report interpretation results on a random subset of sentences of length at most 40 words. When computing integrated gradient scores, we found that numerical issues produced unusable outputs for roughly $6 \%$ of the samples. These reviews are excluded.
+
+# 4.1.3 INTERPRETATION BASELINES
+
+We compare the interpretations produced by CD against four state of the art baselines: cell decomposition (Murdoch & Szlam, 2017), integrated gradients (Sundararajan et al., 2017), leave one out (Li et al., 2016), and gradient times input. We refer the reader to Section 2 for descriptions of these algorithms. For our gradient baseline, we compute the gradient of the output probability with respect to the word embeddings, and report the dot product between the word vector and its gradient. For integrated gradients, producing reasonable values required extended experimentation and communication with the creators regarding the choice of baselines and scaling issues. We ultimately used sequences of periods for our baselines, and rescaled the scores for each review by the standard deviation of the scores for that review, a trick not previously mentioned in the literature. To obtain phrase scores for word-based baselines integrated gradients, cell decomposition, and gradients, we sum the scores of the words contained within the phrase.
+
+# 4.2 UNIGRAM (WORD) SCORES
+
+Before examining the novel, phrase-level dynamics of CD, we first verify that it compares favorably to prior work for the standard use case of producing unigram coefficients. When sufficiently accurate in terms of prediction, logistic regression coefficients are generally treated as a gold standard for interpretability. In particular, when applied to sentiment analysis the ordering of words given by their coefficient value provides a qualitatively sensible measure of importance. Thus, when determining the validity of coefficients extracted from an LSTM, we should expect there to be a meaningful relationship between the CD scores and logistic regression coefficients.
+
+In order to evaluate the word-level coefficients extracted by the CD method, we construct scatter plots with each point consisting of a single word in the validation set. The two values plotted correspond to the coefficient from logistic regression and importance score extracted from the LSTM. For a quantitative measure of accuracy, we use pearson correlation coefficient.
+
+We report quantitative and qualitative results in Appendix 6.1.3. For SST, CD and integrated gradients, with correlations of 0.76 and 0.72, respectively, are substantially better than other methods, with correlations of at most 0.51. On Yelp, the gap is not as big, but CD is still very competitive, having correlation 0.52 with other methods ranging from 0.34 to 0.56. Having verified reasonably strong results in this base case, we now proceed to show the benefits of CD.
+
+# 4.3 IDENTIFYING DISSENTING SUBPHRASES
+
+We now show that, for phrases of at most five words, existing methods are unable to recognize subphrases with differing sentiments. For example, consider the phrase “used to be my favorite”, which is of negative sentiment. The word “favorite”, however, is strongly positive, having a logistic regression coefficient in the 93rd percentile. Nonetheless, existing methods consistently rank “favorite” as being highly negative or neutral. In contrast, as shown in Table 1, CD is able to identify “my favorite” as being strongly positive, and ”used to be” as strongly negative. A similar dynamic also occurs with the phrase “not worth the time”. The main justification for using LSTMs over simpler models is precisely that they are able to capture these kinds of interactions. Thus, it is important that an interpretation algorithm is able to properly uncover how the interactions are being handled.
+
+![](images/49969a54064e1166c84a579237619270f38b949b1721a19e12bb7c83d780e9bb.jpg)  
+Table 1: Heat maps for portion of yelp review with different attribution techniques. Only CD captures that ”favorite” is positive.
+
+Using the above as a motivating example, we now show that a similar trend holds throughout the Yelp polarity dataset. In particular, we conduct a search for situations similar to the above, where a strongly positive/negative phrase contains a strongly dissenting subphrase. Phrases are scored using the logistic regression with n-gram features described in Section 4.1, and included if their absolute score is over 1.5. We then examine the distribution of scores for the dissenting subphrases, which are analogous to “favorite”.
+
+For an effective interpretation algorithm, the distribution of scores for positive and negative dissenting subphrases should be significantly separate, with positive subphrases having positive scores, and vice versa. However, as can be seen in Appendix 6.1.1, for prior methods these two distributions are nearly identical. The CD distributions, on the other hand, are significantly separate, indicating that what we observed anecdotally above holds in a more general setting.
+
+# 4.4 EXAMINING HIGH-LEVEL COMPOSITIONALITY
+
+We now show that prior methods struggle to identify cases where a sizable portion of a review (between one and two thirds) has polarity different from the LSTM’s prediction. For instance, consider the review in Table 2, where the first phrase is clearly positive, but the second phrase causes the review to ultimately be negative. CD is the only method able to accurately capture this dynamic.
+
+By leveraging the phrase-level labels provided in SST, we can show that this pattern holds in the general case. In particular, we conduct a search for reviews similar to the above example. The search criteria are whether a review contains a phrase labeled by SST to be of opposing sentiment to the review-level SST label, and is between one and two thirds the length of the review.
+
+In Appendix 6.1.2, we show the distribution of the resulting positive and negative phrases for different attribution methods. A successful interpretation method would have a sizable gap between these two distributions, with positive phrases having mostly positive scores, and negative phrases mostly negative. However, prior methods struggle to satisfy these criteria. $87 \%$ of all positive phrases are labelled as negative by integrated gradients, and cell decompositions (Murdoch & Szlam, 2017) even have the distributions flipped, with negative phrases yielding more positive scores than the positive phrases. CD, on the other hand, provides a very clear difference in distributions. To quantify this separation between positive and negative distributions, we examine a two-sample KolmogorovSmirnov one-sided test statistic, a common test for the difference of distributions with values ranging from 0 to 1. CD produces a score of 0.74, indicating a strong difference between positive and negative distributions, with other methods achieving scores of 0 (cell decomposition), 0.33 (integrated gradients), 0.58 (leave one out) and 0.61 (gradient), indicating weaker distributional differences. Given that gradient and leave one out were the weakest performers in unigram scores, this provides strong evidence for the superiority of CD.
+
+![](images/32f52c81ca52981eca38f8ffeb69810a8328143dfd72876042d452ac88e32296.jpg)  
+Table 2: Heat maps for portion of review from SST with different attribution techniques. Only CD captures that the first phrase is positive.
+
+# 4.5 CONTEXTUAL DECOMPOSITION (CD) CAPTURES NEGATION
+
+In order to understand an LSTM’s prediction mechanism, it is important to understand not just the contribution of a phrase, but how that contribution is computed. For phrases involving negation, we now demonstrate that we can use CD to empirically show that our LSTM learns a negation mechanism.
+
+Using the phrase labels in SST, we search over the training set for instances of negation. In particular, we search for phrases of length less than ten with the first child containing a negation phrase (such as “not” or “lacks”, full list provided in Appendix 6.3) in the first two words, and the second child having positive or negative sentiment. Due to noise in the labels, we also included phrases where the entire phrase was non-neutral, and the second child contained a non-neutral phrase. We identify both positive negation, such as “isn’t a bad film”, and negative negation, such as “isn’t very interesting”, where the direction is given by the SST-provided label of the phrase.
+
+For a given negation phrase, we extract a negation interaction by computing the CD score of the entire phrase and subtracting the CD scores of the phrase being negated and the negation term itself. The resulting score can be interpreted as an n-gram feature. Note that, of the methods we compare against, only leave one out is capable of producing such interaction scores. For reference, we also provide the distribution of all interactions for phrases of length less than 5.
+
+We present the distribution of extracted scores in Figure 1. For CD, we can see that there is a clear distinction between positive and negative negations, and that the negation interactions are centered on the outer edges of the distribution of interactions. Leave one out is able to capture some of the interactions, but has a noticeable overlap between positive and negative negations around zero, indicating a high rate of false negatives.
+
+# 4.6 IDENTIFYING SIMILAR PHRASES
+
+Another benefit of using CDs for interpretation is that, in addition to providing importance scores, it also provides dense embeddings for arbitrary phrases and interactions, in the form of $\beta _ { T }$ discussed in Section 3.2. We anecdotally show that similarity in this embedding space corresponds to semantic similarity in the context of sentiment analysis.
+
+In particular, for all words and binary interactions, we compute the average embedding $\beta _ { T }$ produced by CD across the training and validation sets. In Table 3, we show the nearest neighbours using a cosine similarity metric. The results are qualitatively sensible for three different kinds of interactions: positive negation, negative negation and modification, as well as positive and negative words. Note that we for positive and negative words, we chose the positive/negative parts of the negations, in order to emphasize that CD can disentangle this composition.
+
+![](images/2088734425d47ba3059adf203cb9ddc320c4efae3748d475c3a8767b0dca7781.jpg)  
+Figure 1: Distribution of scores for positive and negative negation coefficients relative to all interaction coefficients. Only leave one out and CD are capable of producing these interaction scores.
+
+Table 3: Nearest neighbours for selected unigrams and interactions using CD embeddings   
+
+<table><tr><td>not entertain- ing</td><td>not bad</td><td>very funny</td><td>entertaining</td><td>bad</td></tr><tr><td>not funny</td><td>never dull</td><td>well-put- together piece</td><td>intelligent</td><td>dull</td></tr><tr><td>not engaging</td><td>n&#x27;t drag</td><td>entertaining romp</td><td>engaging</td><td>drag</td></tr><tr><td>never satisfac- tory</td><td>never fails</td><td>very good</td><td>satisfying</td><td>awful</td></tr><tr><td>not well</td><td>without sham</td><td>surprisingly sweet</td><td>admirable</td><td>tired</td></tr><tr><td>not fit</td><td>without missing</td><td>very well- written</td><td>funny</td><td>dreary</td></tr></table>
+
+# 5 CONCLUSION
+
+In this paper, we have proposed contextual decomposition (CD), an algorithm for interpreting individual predictions made by LSTMs without modifying the underlying model. In both NLP and general applications of LSTMs, CD produces importance scores for words (single variables in general), phrases (several variables together) and word interactions (variable interactions). Using two sentiment analysis datasets for empirical validation, we first show that for information also produced by prior methods, such as word-level scores, our method compares favorably. More importantly, we then show that CD is capable of identifying phrases of varying sentiment, and extracting meaningful word (or variable) interactions. This movement beyond word-level importance is critical for understanding a model as complex and highly non-linear as LSTMs.
+
+# ACKNOWLEDGMENTS
+
+This research was started during a summer internship at Google Brain, and later supported by a postgraduate scholarship-doctoral from NSERC and a data science research award from Adobe. This work is partially supported by Center for Science of Information (CSoI), an NSF Science and
+
+Technology Center, under grant agreement CCF-0939370, ONR grant N00014-16-1-2664 and ARO grant W911NF1710005.
+
+# REFERENCES
+
+Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus-Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS one, 10(7):e0130140, 2015.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jiwei Li, Will Monroe, and Dan Jurafsky. Understanding neural networks through representation erasure. CoRR, abs/1612.08220, 2016. URL http://arxiv.org/abs/1612.08220.
+
+Scott Lundberg and Su-In Lee. An unexpected unity among methods for interpreting model predictions. arXiv preprint arXiv:1611.07478, 2016.
+
+Gabor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language ´ models. CoRR, abs/1707.05589, 2017. URL http://arxiv.org/abs/1707.05589.
+
+W James Murdoch and Arthur Szlam. Automatic rule extraction from long short term memory networks. ICLR, 2017.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016.
+
+Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.
+
+Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. arXiv preprint arXiv:1704.02685, 2017.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013.
+
+Hendrik Strobelt, Sebastian Gehrmann, Bernd Huber, Hanspeter Pfister, and Alexander M Rush. Visual analysis of hidden state dynamics in recurrent neural networks. arXiv preprint arXiv:1606.07461, 2016.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. CoRR, abs/1703.01365, 2017. URL http://arxiv.org/abs/1703.01365.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015.
+
+Table 4: Correlation coefficients between logistic regression coefficients and extracted scores.   
+
+<table><tr><td>Attribution Method</td><td>Stanford Sentiment</td><td>Yelp Polarity</td></tr><tr><td>Gradient</td><td>0.375</td><td>0.336</td></tr><tr><td>Leave one out (Li et al., 2016)</td><td>0.510</td><td>0.358</td></tr><tr><td>Cell decomposition (Murdoch &amp; Szlam, 2017)</td><td>0.490</td><td>0.560</td></tr><tr><td>Integrated gradients (Sundararajan et al., 2017)</td><td>0.724</td><td>0.471</td></tr><tr><td>Contextual decompo- sition</td><td>0.758</td><td>0.520</td></tr></table>
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015.
+
+Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in neural information processing systems, pp. 649–657, 2015.
+
+# 6 APPENDIX
+
+# 6.1 PLOTS
+
+6.1.1 PLOTS FOR DISSENTING SUBPHRASES
+
+We provide here the plots described in Section 4.3.
+
+6.1.2 PLOTS FOR HIGH-LEVEL COMPOSITIONALITY
+
+We provide here the plots referenced in Section 4.4.
+
+6.1.3 LOGISTIC REGRESSION VERSUS EXTRACTED COEFFICIENTS SCATTERPLOTS
+
+We provide here the scatterplots and correlations referenced in section 4.2.
+
+# 6.2 GENERAL RECURSION FORMULA
+
+We provide here the general recursion formula referenced in Section 3.2.1. The two cases that are considered is whether the current time step is during the phrase $\ Q \leq t \leq r ,$ ) or outside of the phrase ( $t < q$ or $t > r$ ).
+
+$$
+\begin{array} { r l r } {  { \beta _ { t } ^ { f } = [ L _ { \sigma } ( V _ { f } \beta _ { t - 1 } ) + L _ { \sigma } ( b _ { f } ) + L _ { \sigma } ( V _ { f } x _ { t } ) ] _ { q \le t \le r } \| \odot \beta _ { t - 1 } ^ { c } } } \\ & { r _ { t } ^ { f } = f _ { t } \odot \gamma _ { t - 1 } ^ { c } + [ L _ { \sigma } ( V _ { f } \gamma _ { t - 1 } ) + L _ { \sigma } ( V _ { f } x _ { t } ) ] _ { t > q , t \le r } ] \odot \beta _ { t - 1 } ^ { c } } & { ( 3 0 ) } \\ & { u _ { t } ^ { u } = L _ { \sigma } ( V _ { i } \beta _ { t - 1 } ^ { c } ) \odot [ L _ { \operatorname { t a n h } } ( V _ { g } \beta _ { t - 1 } ^ { c } + L _ { \operatorname { t a n h } } ( b _ { g } ) ] + L _ { \sigma } ( b _ { i } ) \odot L _ { \operatorname { t a n h } } ( V _ { g } \beta _ { t - 1 } ^ { c } ) } & { ( 3 1 ) } \\ & { + [ L _ { \sigma } ( W _ { i } x _ { t } ) \odot [ L _ { \operatorname { t a n h } } ( W _ { g } x _ { t } ) + L _ { \operatorname { t a n h } } ( V _ { g } \beta _ { t - 1 } ) + L _ { \operatorname { t a n h } } ( b _ { g } ) ] + L _ { \operatorname { t a n h } } ( b _ { g } ) ] + L _ { \sigma } ( b _ { i } ) \odot L _ { \operatorname { t a n h } } ( W _ { g } x _ { t } ) ] _ { 1 q \le t \le r } } \\ & { u _ { t } ^ { u } = L _ { \sigma } ( V _ { i } \gamma _ { t - 1 } ) \odot g _ { t } + i _ { t } \odot L _ { \operatorname { t a n h } } ( V _ { g } \gamma _ { t - 1 } ) - L _ { \sigma } ( V _ { i } \gamma _ { t - 1 } ) \odot L _ { \operatorname { t a n h } } ( V _ { g } \gamma _ { t - 1 } ) + L _ { \sigma } ( b _ { i } ) \odot L _ { \operatorname { t a n h } } ( b _ { g } ) } \end{array}
+$$
+
+$$
++ \left[ L _ { \sigma } ( W _ { i } x _ { t } ) \odot [ L _ { \operatorname { t a n h } } ( W _ { g } x _ { t } ) + L _ { \operatorname { t a n h } } ( V _ { g } \beta _ { t - 1 } ) + L _ { \operatorname { t a n h } } ( b _ { g } ) ] + L _ { \sigma } ( b _ { i } ) \odot L _ { \operatorname { t a n h } } ( W _ { g } x _ { t } ) ] 1 _ { t < q , t > \tau } \right] \Biggr \} .
+$$
+
+![](images/2be13094db20ab17a2af6d43efaa9310a114d26a21669523868eb006e4f7a539.jpg)  
+Figure 2: The distribution of attributions for positive (negative) sub-phrases contained within negative (positive) phrases of length at most five in the Yelp polarity dataset. The positive and negative distributions are nearly identical for all methods except CD, indicating an inability of prior methods to distinguish between positive and negative phrases when occurring in the context of a phrase of the opposite sentiment
+
+![](images/1401f9caffb1ae28da2c4745dc242d70c71c3bc7b612eb10d0c536a8b19ed33e.jpg)  
+Figure 3: Distribution of positive and negative phrases, of length between one and two thirds of the full review, in SST. The positive and negative distributions are significantly more separate for CD than other methods, indicating that even at this coarse level of granularity, other methods still struggle.
+
+![](images/93b4789826a95170e6dc1eb176db032062a6b60ac43b6f9cf5f6e94c689c61d3.jpg)  
+Figure 4: Logistic regression coefficients versus coefficients extracted from an LSTM on SST. We include a least squares regression line. Stronger linear relationships in the plots correspond to better interpretation techniques.
+
+# 6.3 LIST OF WORDS USED TO IDENTIFY NEGATIONS
+
+To search for negations, we used the following list of negation words: not, n’t, lacks, nobody, nor, nothing, neither, never, none, nowhere, remotely

parse/train/rkRwGg-0Z/rkRwGg-0Z_content_list.json

@@ -0,0 +1,1566 @@
+[
+    {
+        "type": "text",
+        "text": "BEYOND WORD IMPORTANCE: CONTEXTUAL DECOMPOSITION TO EXTRACT INTERACTIONS FROM LSTMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Peter J. Liu Google Brain Mountain View, CA ",
+        "bbox": [
+            429,
+            195,
+            562,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "W. James Murdoch ∗ Department of Statistics University of California, Berkeley jmurdoch@berkeley.edu ",
+        "bbox": [
+            184,
+            195,
+            408,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bin Yu   \nDepartment of Statistics   \nDepartment of EECS   \nUniversity of California, Berkeley ",
+        "bbox": [
+            584,
+            195,
+            810,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The driving force behind the recent success of LSTMs has been their ability to learn complex and non-linear relationships. Consequently, our inability to describe these relationships has led to LSTMs being characterized as black boxes. To this end, we introduce contextual decomposition (CD), an interpretation algorithm for analysing individual predictions made by standard LSTMs, without any changes to the underlying model. By decomposing the output of a LSTM, CD captures the contributions of combinations of words or variables to the final prediction of an LSTM. On the task of sentiment analysis with the Yelp and SST data sets, we show that CD is able to reliably identify words and phrases of contrasting sentiment, and how they are combined to yield the LSTM’s final prediction. Using the phrase-level labels in SST, we also demonstrate that CD is able to successfully extract positive and negative negations from an LSTM, something which has not previously been done. ",
+        "bbox": [
+            233,
+            324,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In comparison with simpler linear models, techniques from deep learning have achieved impressive accuracy by effectively learning non-linear interactions between features. However, due to our inability to describe the learned interactions, this improvement in accuracy has come at the cost of state of the art predictive algorithms being commonly regarded as black-boxes. In the domain of natural language processing (NLP), Long Short Term Memory networks (LSTMs) (Hochreiter & Schmidhuber, 1997) have become a basic building block, yielding excellent performance across a wide variety of tasks (Sutskever et al., 2014) (Rajpurkar et al., 2016) (Melis et al., 2017), while remaining largely inscrutable. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce contextual decomposition (CD), a novel interpretation method for explaining individual predictions made by an LSTM without any modifications to the underlying model. CD extracts information about not only which words contributed to a LSTM’s prediction, but also how they were combined in order to yield the final prediction. By mathematically decomposing the LSTM’s output, we are able to disambiguate the contributions made at each step by different parts of the sentence. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            782
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To validate the CD interpretations extracted from an LSTM, we evaluate on the problem of sentiment analysis. In particular, we demonstrate that CD is capable of identifying words and phrases of differing sentiment within a given review. CD is also used to successfully extract positive and negative negations from an LSTM, something that has not previously been done. As a consequence of this analysis, we also show that prior interpretation methods produce scores which have document-level information built into them in complex, unspecified ways. For instance, prior work often identifies strongly negative phrases contained within positive reviews as neutral, or even positive. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most relevant prior work on interpreting LSTMs has focused on approaches for computing word-level importance scores, with evaluation protocols varying greatly. Murdoch & Szlam (2017) introduced a decomposition of the LSTM’s output embedding into a sum over word coefficients, and demonstrated that those coefficients are meaningful by using them to distill LSTMs into rules-based classifiers. Li et al. (2016) took a more black box approach, called Leave One Out, by observing the change in log probability resulting from replacing a given word vector with a zero vector, and relied solely on anecdotal evaluation. Finally, Sundararajan et al. (2017) presents a general gradient-based technique, called Integrated Gradients, which was validated both theoretically and with empirical anecdotes. In contrast to our proposed method, this line of work has been limited to word-based importance scores, ignoring the interactions between variables which make LSTMs so accurate. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another line of work (Karpathy et al., 2015) (Strobelt et al., 2016) has focused on analysing the movement of raw gate activations over a sequence. Karpathy et al. (2015) was able to identify some co-ordinates of the cell state that correspond to semantically meaningful attributes, such as whether the text is in quotes. However, most of the cell co-ordinates were uninterpretable, and it is not clear how these co-ordinates combine to contribute to the actual prediction. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            349
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Decomposition-based approaches to interpretation have also been applied to convolutional neural networks (CNNs) (Bach et al., 2015) (Shrikumar et al., 2017). However, they have been limited to producing pixel-level importance scores, ignoring interactions between pixels, which are clearly quite important. Our approach is similar to these in that it computes an exact decomposition, but we leverage the unique gating structure of LSTMs in order to extract interactions. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            425
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Attention based models (Bahdanau et al., 2014) offer another means of providing some interpretability. Such models have been successfully applied to many problems, yielding improved performance (Rush et al., 2015) (Xu et al., 2015). In contrast to other word importance scores, attention is limited in that it only provides an indirect indicator of importance, with no directionality, i.e. what class the word is important for. Although attention weights are often cited anecdotally, they have not been evaluated, empirically or otherwise, as an interpretation technique. As with other prior work, attention is also incapable of describing interactions between words. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 CONTEXTUAL DECOMPOSITION OF LSTMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            568,
+            566
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given an arbitrary phrase contained within an input, we present a novel decomposition of the output of an LSTM into a sum of two contributions: those resulting solely from the given phrase, and those involving other factors. The key insight behind this decomposition is that the gating dynamics unique to LSTMs are a vehicle for modeling interactions between variables. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 LONG SHORT TERM MEMORY NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            508,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Over the past few years, LSTMs have become a core component of neural NLP systems. Given a sequence of word embeddings $x _ { 1 } , . . . , x _ { T } \\in \\mathbb { R } ^ { d _ { 1 } }$ , a cell and state vector $c _ { t } , h _ { t } \\in \\mathbb { R } ^ { \\dot { d } _ { 2 } }$ are computed for each element by iteratively applying the below equations, with initialization $h _ { 0 } = c _ { 0 } = 0$ . ",
+        "bbox": [
+            174,
+            680,
+            825,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aefd7924d07ec12471a24c148f5c885040306860907b3dc601686fc15a4fc3e1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { o _ { t } = \\sigma ( W _ { o } x _ { t } + V _ { o } h _ { t - 1 } + b _ { o } ) } \\\\ & { f _ { t } = \\sigma ( W _ { f } x _ { t } + V _ { f } h _ { t - 1 } + b _ { f } ) } \\\\ & { i _ { t } = \\sigma ( W _ { i } x _ { t } + V _ { i } h _ { t - 1 } + b _ { i } ) } \\\\ & { g _ { t } = \\operatorname { t a n h } ( W _ { g } x _ { t } + V _ { g } h _ { t - 1 } + b _ { g } ) } \\\\ & { c _ { t } = f _ { t } \\odot c _ { t - 1 } + i _ { t } \\odot g _ { t } } \\\\ & { h _ { t } = o _ { t } \\odot \\operatorname { t a n h } ( c _ { t } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            747,
+            612,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Where Wo, Wi, Wf , Wg ∈ Rd1×d2 , $V _ { o } , V _ { f } , V _ { i } , V _ { g } \\in \\mathbb { R } ^ { d _ { 2 } \\times d _ { 2 } } , b _ { o } , b _ { g } , b _ { i } , b _ { g } \\in \\mathbb { R } ^ { d _ { 2 } }$ and $\\odot$ denotes element-wise multiplication. $o _ { t } , f _ { t }$ and $i _ { t }$ are often referred to as output, forget and input gates, respectively, due to the fact that their values are bounded between 0 and 1, and that they are used in element-wise multiplication. ",
+        "bbox": [
+            174,
+            866,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "After processing the full sequence, the final state $h _ { T }$ is treated as a vector of learned features, and used as input to a multinomial logistic regression, often called SoftMax, to return a probability distribution $p$ over $C$ classes, with ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36cd6745a7a012054314ffe1ac03914d890f9de3f04d42964562d4087cd26114.jpg",
+        "text": "$$\np _ { j } = \\mathrm { S o f t M a x } ( W h _ { T } ) _ { j } = \\frac { \\exp ( W _ { j } h _ { T } ) } { \\sum _ { k = 1 } ^ { C } \\exp ( W _ { k } h _ { t } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            171,
+            650,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 CONTEXTUAL DECOMPOSITION OF LSTM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            222,
+            509,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now introduce contextual decomposition, our proposed method for interpreting LSTMs. Given an arbitrary phrase $x _ { q } , . . . , x _ { r }$ , where $1 \\leq q \\leq r \\leq T$ , we now decompose each output and cell state $c _ { t } , h _ { t }$ in Equations 5 and 6 into a sum of two contributions. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/155bdf1cfa391f0a697fc71730fd1232623f8de9e197585f57b26796678ee9bf.jpg",
+        "text": "$$\n\\begin{array} { l } { h _ { t } = \\beta _ { t } + \\gamma _ { t } } \\\\ { c _ { t } = \\beta _ { t } ^ { c } + \\gamma _ { t } ^ { c } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            297,
+            547,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The decomposition is constructed so that $\\beta _ { t }$ corresponds to contributions made solely by the given phrase to $h _ { t }$ , and that $\\gamma _ { t }$ corresponds to contributions involving, at least in part, elements outside of the phrase. $\\beta _ { t } ^ { c }$ and $\\gamma _ { t } ^ { c }$ represent analogous contributions to $c _ { t }$ . ",
+        "bbox": [
+            174,
+            340,
+            826,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using this decomposition for the final output state $W h _ { T }$ in Equation 7 yields ",
+        "bbox": [
+            173,
+            388,
+            679,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07d90406186bdba2b6a508b2739fe4b0af00671f9d48788c131b576800a3d699.jpg",
+        "text": "$$\np = \\operatorname { S o f t M a x } ( W \\beta _ { T } + W \\gamma _ { T } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            431,
+            598,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $W \\beta _ { T }$ provides a quantitative score for the phrase’s contribution to the LSTM’s prediction. As this score corresponds to the input to a logistic regression, it may be interpreted in the same way as a standard logistic regression coefficient. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 DISAMBIGUATING INTERACTIONS BETWEEN GATES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            521,
+            583,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the cell update Equation 5, neuron values in each of $i _ { t }$ and $g _ { t }$ are independently determined by both the contribution at that step, $x _ { t }$ , as well as prior context provided by $h _ { t - 1 } = \\beta _ { t - 1 } + \\gamma _ { t - 1 }$ . Thus, in computing the element-wise product $i _ { t } \\odot g _ { t }$ , often referred to as gating, contributions made by $x _ { t }$ to $i _ { t }$ interact with contributions made by $h _ { t }$ to $g _ { t }$ , and vice versa. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We leverage this simple insight to construct our decomposition. First, assume that we have a way of linearizing the gates and updates in Equations 2, 3, 4 so that we can write each of them as a linear sum of contributions from each of their inputs. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03cabac1ec095a78bcc3ea11bcadc9d33ce12caf64e102bfe0a49b2e28128cc1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { i _ { t } = \\sigma ( W _ { i } x _ { t } + V _ { i } h _ { t - 1 } + b _ { i } ) } \\\\ & { \\quad = L _ { \\sigma } ( W _ { i } x _ { t } ) + L _ { \\sigma } ( V _ { i } h _ { t - 1 } ) + L _ { \\sigma } ( b _ { i } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            678,
+            633,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When we use this linearization in the cell update Equation 5, the products between gates become products over linear sums of contributions from different factors. Upon expanding these products, the resulting cross-terms yield a natural interpretation as being interactions between variables. In particular, cross-terms can be assigned as to whether they resulted solely from the phrase, e.g. $\\mathsf { \\bar { L } } _ { \\sigma } ( V _ { i } \\beta _ { t - 1 } ) \\odot L _ { \\operatorname { t a n h } } ( V _ { g } \\beta _ { t - 1 } )$ , from some interaction between the phrase and other factors, e.g. $L _ { \\sigma } ( V _ { i } \\beta _ { t - 1 } ) \\odot L _ { \\operatorname { t a n h } } ( V _ { g } \\gamma _ { t - 1 } )$ , or purely from other factors, e.g. $L _ { \\sigma } ( \\bar { b } _ { i } ) \\odot L _ { \\mathrm { t a n h } } ( V _ { g } \\gamma _ { t - 1 } )$ . ",
+        "bbox": [
+            173,
+            727,
+            825,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Mirroring the recurrent nature of LSTMs, the above insights allow us to recursively compute our decomposition, with the initializations $\\beta _ { 0 } = \\beta _ { 0 } ^ { c } = \\gamma _ { 0 } = \\gamma _ { 0 } ^ { c } = 0$ . We derive below the update equations for the case where $q \\leq t \\leq r$ , so that the current time step is contained within the phrase. The other case is similar, and the general recursion formula is provided in Appendix 6.2. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For clarity, we decompose the two products in the cell update Equation 5 separately. As discussed above, we simply linearize the gates involved, expand the resulting product of sums, and group the cross-terms according to whether or not their contributions derive solely from the specified phrase, or otherwise. Terms are determined to derive solely from the specified phrase if they involve products from some combination of $\\beta _ { t - 1 } , \\beta _ { t - 1 } ^ { c } , x _ { t }$ and $b _ { i }$ or $b _ { g }$ (but not both). When $t$ is not within the phrase, products involving $x _ { t }$ are treated as not deriving from the phrase. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47a911402e77f4db0e01d1bfb448ae56df0b27cd8e1107700b1c1f9f12abb249.jpg",
+        "text": "$$\n\\begin{array} { r l } & { f _ { t } \\odot c _ { t - 1 } = \\left( L _ { \\sigma } ( W _ { f } x _ { t } ) + L _ { \\sigma } ( V _ { f } \\beta _ { t - 1 } ) + L _ { \\sigma } ( V _ { f } \\gamma _ { t - 1 } ) + L _ { \\sigma } ( b _ { f } ) \\right) \\odot \\left( \\beta _ { t - 1 } ^ { c } + \\gamma _ { t - 1 } ^ { c } \\right) } \\\\ & { \\qquad = \\left( \\left[ L _ { \\sigma } ( W _ { f } x _ { t } ) + L _ { \\sigma } ( V _ { f } \\beta _ { t - 1 } ) + L _ { \\sigma } ( b _ { f } ) \\right] \\odot \\beta _ { t - 1 } ^ { c } \\right) } \\\\ & { \\qquad + \\left( L _ { \\sigma } ( V _ { f } \\gamma _ { t - 1 } ) \\odot \\beta _ { t - 1 } ^ { c } + f _ { t } \\odot \\gamma _ { t - 1 } ^ { c } \\right) } \\\\ & { \\qquad = \\beta _ { t } ^ { f } + \\gamma _ { t } ^ { f } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            148,
+            764,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cdca94547e54e9d6d1b11579ac416c65814d7dda5fc114ea67a884471e8f7289.jpg",
+        "text": "$$\n\\begin{array} { r l } { i _ { t } \\odot g _ { t } = [ L _ { \\sigma } ( W _ { i } x _ { t } ) + L _ { \\sigma } ( V _ { i } \\beta _ { t - 1 } ) + L _ { \\sigma } ( V _ { i } \\gamma _ { t - 1 } ) + L _ { \\sigma } ( b _ { i } ) ] } \\\\ { \\odot [ L _ { \\mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\mathrm { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) + L _ { \\mathrm { t a n h } } ( V _ { g } \\gamma _ { t - 1 } ) + L _ { \\mathrm { t a n h } } ( b _ { g } ) ] } \\\\ { = [ L _ { \\sigma } ( W _ { i } x _ { t } ) \\odot [ L _ { \\mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\mathrm { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) + L _ { \\mathrm { t a n h } } ( b _ { g } ) ] } \\\\ { + L _ { \\sigma } ( V _ { i } \\beta _ { t - 1 } ) \\odot [ L _ { \\mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\mathrm { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) + L _ { \\mathrm { t a n h } } ( b _ { g } ) ] } \\\\ { + L _ { \\sigma } ( b _ { i } ) \\odot [ L _ { \\mathrm { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\mathrm { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) ] ] } \\\\ { + [ L _ { \\sigma } ( V _ { i } \\gamma _ { t - 1 } ) \\odot g _ { t } + i _ { t } \\odot L _ { \\mathrm { t a n h } } ( V _ { g } \\gamma _ { t - 1 } ) - L _ { \\sigma } ( V _ { i } \\gamma _ { t - 1 } ) \\odot L _ { \\mathrm { t a n h } } ( V _ { g } \\gamma _ { t - 1 } ) } \\\\ { + \\ell _ { \\sigma } ( b _ { i } ) \\odot L _ { \\mathrm { t a n h } } ( b _ { g } ) ] } \\\\ { = \\beta _ { t } ^ { u } + \\gamma _ { t } ^ { u } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            257,
+            785,
+            401
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Having decomposed the two components of the cell update equation, we can attain our decomposition of $c _ { t }$ by summing the two contributions. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2438185f3abaf618f825a82f7cb13b0b08988d69df24b5449aecfe519343adf0.jpg",
+        "text": "$$\n\\begin{array} { l } { \\beta _ { t } ^ { c } = \\beta _ { t } ^ { f } + \\beta _ { t } ^ { u } } \\\\ { \\gamma _ { t } ^ { c } = \\gamma _ { t } ^ { f } + \\gamma _ { t } ^ { u } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            462,
+            549,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Once we have computed the decomposition of $c _ { t }$ , it is relatively simple to compute the resulting transformation of $h _ { t }$ by linearizing the tanh function in 6. Note that we could similarly decompose the output gate as we treated the forget gate above, but we empirically found this to not produce improved results. ",
+        "bbox": [
+            174,
+            515,
+            823,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93fd05b32803f1afa747d147b77ffd633ecc66a55d7b14fffe650d59497187a3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { h _ { t } = o _ { t } \\odot \\operatorname { t a n h } ( c _ { t } ) } \\\\ & { \\phantom { = } = o _ { t } \\odot [ L _ { \\operatorname { t a n h } } ( \\beta _ { t } ^ { c } ) + L _ { \\operatorname { t a n h } } ( \\gamma _ { t } ^ { c } ) ] } \\\\ & { \\phantom { = } = o _ { t } \\odot L _ { \\operatorname { t a n h } } ( \\beta _ { t } ^ { c } ) + o _ { t } \\odot L _ { \\operatorname { t a n h } } ( \\gamma _ { t } ^ { c } ) } \\\\ & { \\phantom { = } = \\beta _ { t } + \\gamma _ { t } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            597,
+            630,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 LINEARIZING ACTIVATION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            501,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe the linearizing functions $L _ { \\sigma } , L _ { \\mathrm { t a n h } }$ used in the above decomposition. Formally, for arbitrary $\\{ y _ { 1 } , . . . , y _ { N } \\} \\in \\mathbb { R }$ , where $N \\leq 4$ , the problem is how to write ",
+        "bbox": [
+            173,
+            704,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c32997310fafdb25c48bb9a7e78db4061814ae03b705c08568bd143abf32735.jpg",
+        "text": "$$\n\\operatorname { t a n h } ( \\sum _ { i = 1 } ^ { N } y _ { i } ) = \\sum _ { i = 1 } ^ { N } L _ { \\operatorname { t a n h } } ( y _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            755,
+            599,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the cases where there is a natural ordering to $\\{ y _ { i } \\}$ , prior work (Murdoch & Szlam, 2017) has used a telescoping sum consisting of differences of partial sums as a linearization technique, which we show below. ",
+        "bbox": [
+            173,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e914f96d97aa242cfd5c6ea545367377ad38ab17c4ac04e5257b92d44050c33.jpg",
+        "text": "$$\nL _ { \\operatorname { t a n h } } ^ { \\prime } ( y _ { k } ) = \\operatorname { t a n h } ( \\sum _ { j = 1 } ^ { k } y _ { j } ) - \\operatorname { t a n h } ( \\sum _ { j = 1 } ^ { k - 1 } y _ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            877,
+            642,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, in our setting $\\{ y _ { i } \\}$ contains terms such as $\\beta _ { t - 1 }$ , $\\gamma _ { t - 1 }$ and $x _ { t }$ , which have no clear ordering. Thus, there is no natural way to order the sum in Equation 26. Instead, we compute an average over all orderings. Letting $\\pi _ { 1 } , . . . , \\pi _ { M _ { N } }$ denote the set of all permutations of $1 , . . . , N$ , our score is given below. Note that when $\\pi _ { i } ( j ) = j$ , the corresponding term is equal to equation 26. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f06b2309477e35ec58e55fc63bdb55fd6c23ba69976eee967fa7634a13e5e73.jpg",
+        "text": "$$\nL _ { \\mathrm { t a n h } } ( y _ { k } ) = { \\frac { 1 } { M _ { N } } } \\sum _ { i = 1 } ^ { M _ { N } } [ \\mathrm { t a n h } ( \\sum _ { j = 1 } ^ { \\pi _ { i } ^ { - 1 } ( k ) } y _ { \\pi _ { i } ( j ) } ) - \\mathrm { t a n h } ( \\sum _ { j = 1 } ^ { \\pi _ { i } ^ { - 1 } ( k ) - 1 } y _ { \\pi _ { i } ( j ) } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            189,
+            725,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$L _ { \\sigma }$ can be analogously derived. When one of the terms in the decomposition is a bias, we saw improvements when restricting to permutations where the bias is the first term. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As $N$ only ranges between 2 and 4, this linearization generally takes very simple forms. For instance, when $N = 2$ , the contribution assigned to $y _ { 1 }$ is ",
+        "bbox": [
+            173,
+            289,
+            823,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4fe02ab6e22180c2f6af664b5aa8d6ecd1ba074aadd3137f19740666ae60f82.jpg",
+        "text": "$$\nL _ { \\operatorname { t a n h } } ( y _ { 1 } ) = { \\frac { 1 } { 2 } } ( [ \\operatorname { t a n h } ( y _ { 1 } ) - \\operatorname { t a n h } ( 0 ) ] + [ \\operatorname { t a n h } ( y _ { 2 } + y _ { 1 } ) - \\operatorname { t a n h } ( y _ { 1 } ) ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            345,
+            730,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This linearization was presented in a scalar context where $y _ { i } \\in \\mathbb { R }$ , but trivially generalizes to the vector setting $y _ { i } \\in \\mathbb { R } ^ { d _ { 2 } }$ . It can also be viewed as an approximation to Shapely values, as discussed in Lundberg & Lee (2016) and Shrikumar et al. (2017). ",
+        "bbox": [
+            176,
+            393,
+            825,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            459,
+            326,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now describe our empirical validation of CD on the task of sentiment analysis. First, we verify that, on the standard problem of word-level importance scores, CD compares favorably to prior work. Then we examine the behavior of CD for word and phrase level importance in situations involving compositionality, showing that CD is able to capture the composition of phrases of differing sentiment. Finally, we show that CD is capable of extracting instances of positive and negative negation. Code for computing CD scores is available online 1. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            351,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first describe the process for fitting models which are used to produce interpretations. As the primary intent of this paper is not predictive accuracy, we used standard best practices without much tuning. We implemented all models in Torch using default hyperparameters for weight initializations. All models were optimized using Adam (Kingma & Ba, 2014) with the default learning rate of 0.001 using early stopping on the validation set. For the linear model, we used a bag of vectors model, where we sum pre-trained Glove vectors (Pennington et al., 2014) and add an additional linear layer from the word embedding dimension, 300, to the number of classes, 2. We fine tuned both the word vectors and linear parameters. We will use the two data sets described below to validate our new CD method. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 STANFORD SENTIMENT TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            472,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We trained an LSTM model on the binary version of the Stanford Sentiment Treebank (SST) (Socher et al., 2013), a standard NLP benchmark which consists of movie reviews ranging from 2 to 52 words long. In addition to review-level labels, it also provides labels for each phrase in the binarized constituency parse tree. Following the hyperparameter choices in Tai et al. (2015), the word and hidden representations of our LSTM were set to 300 and 168, and word vectors were initialized to pretrained Glove vectors (Pennington et al., 2014). Our LSTM attains $8 7 . 2 \\%$ accuracy, and we also train a logistic regression model with bag of words features, which attains $8 3 . 2 \\%$ accuracy. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 YELP POLARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            343,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Originally introduced in Zhang et al. (2015), the Yelp review polarity dataset was obtained from the Yelp Dataset Challenge and has train and test sets of sizes 560,000 and 38,000. The task is binary prediction for whether the review is positive (four or five stars) or negative (one or two stars). The reviews are relatively long, with an average length of 160.1 words. Following the guidelines from Zhang et al. (2015), we implement an LSTM model which attains $4 . 6 \\%$ error, and an ngram logistic regression model, which attains $5 . 7 \\%$ error. For computational reasons, we report interpretation results on a random subset of sentences of length at most 40 words. When computing integrated gradient scores, we found that numerical issues produced unusable outputs for roughly $6 \\%$ of the samples. These reviews are excluded. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 INTERPRETATION BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            277,
+            431,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the interpretations produced by CD against four state of the art baselines: cell decomposition (Murdoch & Szlam, 2017), integrated gradients (Sundararajan et al., 2017), leave one out (Li et al., 2016), and gradient times input. We refer the reader to Section 2 for descriptions of these algorithms. For our gradient baseline, we compute the gradient of the output probability with respect to the word embeddings, and report the dot product between the word vector and its gradient. For integrated gradients, producing reasonable values required extended experimentation and communication with the creators regarding the choice of baselines and scaling issues. We ultimately used sequences of periods for our baselines, and rescaled the scores for each review by the standard deviation of the scores for that review, a trick not previously mentioned in the literature. To obtain phrase scores for word-based baselines integrated gradients, cell decomposition, and gradients, we sum the scores of the words contained within the phrase. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 UNIGRAM (WORD) SCORES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            401,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Before examining the novel, phrase-level dynamics of CD, we first verify that it compares favorably to prior work for the standard use case of producing unigram coefficients. When sufficiently accurate in terms of prediction, logistic regression coefficients are generally treated as a gold standard for interpretability. In particular, when applied to sentiment analysis the ordering of words given by their coefficient value provides a qualitatively sensible measure of importance. Thus, when determining the validity of coefficients extracted from an LSTM, we should expect there to be a meaningful relationship between the CD scores and logistic regression coefficients. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the word-level coefficients extracted by the CD method, we construct scatter plots with each point consisting of a single word in the validation set. The two values plotted correspond to the coefficient from logistic regression and importance score extracted from the LSTM. For a quantitative measure of accuracy, we use pearson correlation coefficient. ",
+        "bbox": [
+            176,
+            613,
+            823,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We report quantitative and qualitative results in Appendix 6.1.3. For SST, CD and integrated gradients, with correlations of 0.76 and 0.72, respectively, are substantially better than other methods, with correlations of at most 0.51. On Yelp, the gap is not as big, but CD is still very competitive, having correlation 0.52 with other methods ranging from 0.34 to 0.56. Having verified reasonably strong results in this base case, we now proceed to show the benefits of CD. ",
+        "bbox": [
+            176,
+            676,
+            823,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 IDENTIFYING DISSENTING SUBPHRASES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            491,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now show that, for phrases of at most five words, existing methods are unable to recognize subphrases with differing sentiments. For example, consider the phrase “used to be my favorite”, which is of negative sentiment. The word “favorite”, however, is strongly positive, having a logistic regression coefficient in the 93rd percentile. Nonetheless, existing methods consistently rank “favorite” as being highly negative or neutral. In contrast, as shown in Table 1, CD is able to identify “my favorite” as being strongly positive, and ”used to be” as strongly negative. A similar dynamic also occurs with the phrase “not worth the time”. The main justification for using LSTMs over simpler models is precisely that they are able to capture these kinds of interactions. Thus, it is important that an interpretation algorithm is able to properly uncover how the interactions are being handled. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/49969a54064e1166c84a579237619270f38b949b1721a19e12bb7c83d780e9bb.jpg",
+        "image_caption": [
+            "Table 1: Heat maps for portion of yelp review with different attribution techniques. Only CD captures that ”favorite” is positive. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            799,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using the above as a motivating example, we now show that a similar trend holds throughout the Yelp polarity dataset. In particular, we conduct a search for situations similar to the above, where a strongly positive/negative phrase contains a strongly dissenting subphrase. Phrases are scored using the logistic regression with n-gram features described in Section 4.1, and included if their absolute score is over 1.5. We then examine the distribution of scores for the dissenting subphrases, which are analogous to “favorite”. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For an effective interpretation algorithm, the distribution of scores for positive and negative dissenting subphrases should be significantly separate, with positive subphrases having positive scores, and vice versa. However, as can be seen in Appendix 6.1.1, for prior methods these two distributions are nearly identical. The CD distributions, on the other hand, are significantly separate, indicating that what we observed anecdotally above holds in a more general setting. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 EXAMINING HIGH-LEVEL COMPOSITIONALITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            534,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now show that prior methods struggle to identify cases where a sizable portion of a review (between one and two thirds) has polarity different from the LSTM’s prediction. For instance, consider the review in Table 2, where the first phrase is clearly positive, but the second phrase causes the review to ultimately be negative. CD is the only method able to accurately capture this dynamic. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            647
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By leveraging the phrase-level labels provided in SST, we can show that this pattern holds in the general case. In particular, we conduct a search for reviews similar to the above example. The search criteria are whether a review contains a phrase labeled by SST to be of opposing sentiment to the review-level SST label, and is between one and two thirds the length of the review. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Appendix 6.1.2, we show the distribution of the resulting positive and negative phrases for different attribution methods. A successful interpretation method would have a sizable gap between these two distributions, with positive phrases having mostly positive scores, and negative phrases mostly negative. However, prior methods struggle to satisfy these criteria. $87 \\%$ of all positive phrases are labelled as negative by integrated gradients, and cell decompositions (Murdoch & Szlam, 2017) even have the distributions flipped, with negative phrases yielding more positive scores than the positive phrases. CD, on the other hand, provides a very clear difference in distributions. To quantify this separation between positive and negative distributions, we examine a two-sample KolmogorovSmirnov one-sided test statistic, a common test for the difference of distributions with values ranging from 0 to 1. CD produces a score of 0.74, indicating a strong difference between positive and negative distributions, with other methods achieving scores of 0 (cell decomposition), 0.33 (integrated gradients), 0.58 (leave one out) and 0.61 (gradient), indicating weaker distributional differences. Given that gradient and leave one out were the weakest performers in unigram scores, this provides strong evidence for the superiority of CD. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/32f52c81ca52981eca38f8ffeb69810a8328143dfd72876042d452ac88e32296.jpg",
+        "image_caption": [
+            "Table 2: Heat maps for portion of review from SST with different attribution techniques. Only CD captures that the first phrase is positive. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            826,
+            383
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 CONTEXTUAL DECOMPOSITION (CD) CAPTURES NEGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            449,
+            627,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to understand an LSTM’s prediction mechanism, it is important to understand not just the contribution of a phrase, but how that contribution is computed. For phrases involving negation, we now demonstrate that we can use CD to empirically show that our LSTM learns a negation mechanism. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using the phrase labels in SST, we search over the training set for instances of negation. In particular, we search for phrases of length less than ten with the first child containing a negation phrase (such as “not” or “lacks”, full list provided in Appendix 6.3) in the first two words, and the second child having positive or negative sentiment. Due to noise in the labels, we also included phrases where the entire phrase was non-neutral, and the second child contained a non-neutral phrase. We identify both positive negation, such as “isn’t a bad film”, and negative negation, such as “isn’t very interesting”, where the direction is given by the SST-provided label of the phrase. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For a given negation phrase, we extract a negation interaction by computing the CD score of the entire phrase and subtracting the CD scores of the phrase being negated and the negation term itself. The resulting score can be interpreted as an n-gram feature. Note that, of the methods we compare against, only leave one out is capable of producing such interaction scores. For reference, we also provide the distribution of all interactions for phrases of length less than 5. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present the distribution of extracted scores in Figure 1. For CD, we can see that there is a clear distinction between positive and negative negations, and that the negation interactions are centered on the outer edges of the distribution of interactions. Leave one out is able to capture some of the interactions, but has a noticeable overlap between positive and negative negations around zero, indicating a high rate of false negatives. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.6 IDENTIFYING SIMILAR PHRASES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            437,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another benefit of using CDs for interpretation is that, in addition to providing importance scores, it also provides dense embeddings for arbitrary phrases and interactions, in the form of $\\beta _ { T }$ discussed in Section 3.2. We anecdotally show that similarity in this embedding space corresponds to semantic similarity in the context of sentiment analysis. ",
+        "bbox": [
+            176,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In particular, for all words and binary interactions, we compute the average embedding $\\beta _ { T }$ produced by CD across the training and validation sets. In Table 3, we show the nearest neighbours using a cosine similarity metric. The results are qualitatively sensible for three different kinds of interactions: positive negation, negative negation and modification, as well as positive and negative words. Note that we for positive and negative words, we chose the positive/negative parts of the negations, in order to emphasize that CD can disentangle this composition. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2088734425d47ba3059adf203cb9ddc320c4efae3748d475c3a8767b0dca7781.jpg",
+        "image_caption": [
+            "Figure 1: Distribution of scores for positive and negative negation coefficients relative to all interaction coefficients. Only leave one out and CD are capable of producing these interaction scores. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            102,
+            861,
+            323
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9e68e5019af543641fd69fb2d2a279ca48ab5d8275522fb198fbdc922e178dc.jpg",
+        "table_caption": [
+            "Table 3: Nearest neighbours for selected unigrams and interactions using CD embeddings "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>not entertain- ing</td><td>not bad</td><td>very funny</td><td>entertaining</td><td>bad</td></tr><tr><td>not funny</td><td>never dull</td><td>well-put- together piece</td><td>intelligent</td><td>dull</td></tr><tr><td>not engaging</td><td>n&#x27;t drag</td><td>entertaining romp</td><td>engaging</td><td>drag</td></tr><tr><td>never satisfac- tory</td><td>never fails</td><td>very good</td><td>satisfying</td><td>awful</td></tr><tr><td>not well</td><td>without sham</td><td>surprisingly sweet</td><td>admirable</td><td>tired</td></tr><tr><td>not fit</td><td>without missing</td><td>very well- written</td><td>funny</td><td>dreary</td></tr></table>",
+        "bbox": [
+            178,
+            385,
+            818,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            604,
+            823,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            318,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed contextual decomposition (CD), an algorithm for interpreting individual predictions made by LSTMs without modifying the underlying model. In both NLP and general applications of LSTMs, CD produces importance scores for words (single variables in general), phrases (several variables together) and word interactions (variable interactions). Using two sentiment analysis datasets for empirical validation, we first show that for information also produced by prior methods, such as word-level scores, our method compares favorably. More importantly, we then show that CD is capable of identifying phrases of varying sentiment, and extracting meaningful word (or variable) interactions. This movement beyond word-level importance is critical for understanding a model as complex and highly non-linear as LSTMs. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            858,
+            326,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research was started during a summer internship at Google Brain, and later supported by a postgraduate scholarship-doctoral from NSERC and a data science research award from Adobe. This work is partially supported by Center for Science of Information (CSoI), an NSF Science and ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Technology Center, under grant agreement CCF-0939370, ONR grant N00014-16-1-2664 and ARO grant W911NF1710005. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            287,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus-Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS one, 10(7):e0130140, 2015. ",
+        "bbox": [
+            176,
+            176,
+            823,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            173,
+            228,
+            823,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            266,
+            823,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015. ",
+        "bbox": [
+            173,
+            304,
+            823,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiwei Li, Will Monroe, and Dan Jurafsky. Understanding neural networks through representation erasure. CoRR, abs/1612.08220, 2016. URL http://arxiv.org/abs/1612.08220. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Lundberg and Su-In Lee. An unexpected unity among methods for interpreting model predictions. arXiv preprint arXiv:1611.07478, 2016. ",
+        "bbox": [
+            173,
+            420,
+            820,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language ´ models. CoRR, abs/1707.05589, 2017. URL http://arxiv.org/abs/1707.05589. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            487
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "W James Murdoch and Arthur Szlam. Automatic rule extraction from long short term memory networks. ICLR, 2017. ",
+        "bbox": [
+            173,
+            496,
+            821,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016. ",
+        "bbox": [
+            173,
+            585,
+            823,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015. ",
+        "bbox": [
+            173,
+            625,
+            821,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. arXiv preprint arXiv:1704.02685, 2017. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hendrik Strobelt, Sebastian Gehrmann, Bernd Huber, Hanspeter Pfister, and Alexander M Rush. Visual analysis of hidden state dynamics in recurrent neural networks. arXiv preprint arXiv:1606.07461, 2016. ",
+        "bbox": [
+            173,
+            766,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. CoRR, abs/1703.01365, 2017. URL http://arxiv.org/abs/1703.01365. ",
+        "bbox": [
+            173,
+            819,
+            821,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            173,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/329c7de596e55b03cb098b1a634be098d36c304bc4c292c12c1fc1a31eb1dd19.jpg",
+        "table_caption": [
+            "Table 4: Correlation coefficients between logistic regression coefficients and extracted scores. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attribution Method</td><td>Stanford Sentiment</td><td>Yelp Polarity</td></tr><tr><td>Gradient</td><td>0.375</td><td>0.336</td></tr><tr><td>Leave one out (Li et al., 2016)</td><td>0.510</td><td>0.358</td></tr><tr><td>Cell decomposition (Murdoch &amp; Szlam, 2017)</td><td>0.490</td><td>0.560</td></tr><tr><td>Integrated gradients (Sundararajan et al., 2017)</td><td>0.724</td><td>0.471</td></tr><tr><td>Contextual decompo- sition</td><td>0.758</td><td>0.520</td></tr></table>",
+        "bbox": [
+            253,
+            99,
+            745,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015. ",
+        "bbox": [
+            176,
+            325,
+            825,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in neural information processing systems, pp. 649–657, 2015. ",
+        "bbox": [
+            176,
+            383,
+            821,
+            412
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            294,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1 PLOTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            261,
+            491
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 PLOTS FOR DISSENTING SUBPHRASES ",
+        "bbox": [
+            176,
+            503,
+            490,
+            518
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We provide here the plots described in Section 4.3. ",
+        "bbox": [
+            176,
+            529,
+            504,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1.2 PLOTS FOR HIGH-LEVEL COMPOSITIONALITY",
+        "bbox": [
+            174,
+            563,
+            542,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We provide here the plots referenced in Section 4.4. ",
+        "bbox": [
+            174,
+            588,
+            513,
+            603
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1.3 LOGISTIC REGRESSION VERSUS EXTRACTED COEFFICIENTS SCATTERPLOTS ",
+        "bbox": [
+            174,
+            622,
+            746,
+            636
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We provide here the scatterplots and correlations referenced in section 4.2. ",
+        "bbox": [
+            176,
+            646,
+            661,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.2 GENERAL RECURSION FORMULA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            698,
+            442,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We provide here the general recursion formula referenced in Section 3.2.1. The two cases that are considered is whether the current time step is during the phrase $\\ Q \\leq t \\leq r ,$ ) or outside of the phrase ( $t < q$ or $t > r$ ). ",
+        "bbox": [
+            173,
+            724,
+            825,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/830ac36623a2452d8a1f3ff18b7722393a8077ddd2635710f89f76c79f2a631d.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\beta _ { t } ^ { f } = [ L _ { \\sigma } ( V _ { f } \\beta _ { t - 1 } ) + L _ { \\sigma } ( b _ { f } ) + L _ { \\sigma } ( V _ { f } x _ { t } ) ] _ { q \\le t \\le r } \\| \\odot \\beta _ { t - 1 } ^ { c } } } \\\\ & { r _ { t } ^ { f } = f _ { t } \\odot \\gamma _ { t - 1 } ^ { c } + [ L _ { \\sigma } ( V _ { f } \\gamma _ { t - 1 } ) + L _ { \\sigma } ( V _ { f } x _ { t } ) ] _ { t > q , t \\le r } ] \\odot \\beta _ { t - 1 } ^ { c } } & { ( 3 0 ) } \\\\ & { u _ { t } ^ { u } = L _ { \\sigma } ( V _ { i } \\beta _ { t - 1 } ^ { c } ) \\odot [ L _ { \\operatorname { t a n h } } ( V _ { g } \\beta _ { t - 1 } ^ { c } + L _ { \\operatorname { t a n h } } ( b _ { g } ) ] + L _ { \\sigma } ( b _ { i } ) \\odot L _ { \\operatorname { t a n h } } ( V _ { g } \\beta _ { t - 1 } ^ { c } ) } & { ( 3 1 ) } \\\\ & { + [ L _ { \\sigma } ( W _ { i } x _ { t } ) \\odot [ L _ { \\operatorname { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\operatorname { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) + L _ { \\operatorname { t a n h } } ( b _ { g } ) ] + L _ { \\operatorname { t a n h } } ( b _ { g } ) ] + L _ { \\sigma } ( b _ { i } ) \\odot L _ { \\operatorname { t a n h } } ( W _ { g } x _ { t } ) ] _ { 1 q \\le t \\le r } } \\\\ & { u _ { t } ^ { u } = L _ { \\sigma } ( V _ { i } \\gamma _ { t - 1 } ) \\odot g _ { t } + i _ { t } \\odot L _ { \\operatorname { t a n h } } ( V _ { g } \\gamma _ { t - 1 } ) - L _ { \\sigma } ( V _ { i } \\gamma _ { t - 1 } ) \\odot L _ { \\operatorname { t a n h } } ( V _ { g } \\gamma _ { t - 1 } ) + L _ { \\sigma } ( b _ { i } ) \\odot L _ { \\operatorname { t a n h } } ( b _ { g } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            795,
+            839,
+            897
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6ae42cadc082fb12d8a05c76dd8c3d07b56cf8af2e4665d3eb6ad7734595ae5.jpg",
+        "text": "$$\n+ \\left[ L _ { \\sigma } ( W _ { i } x _ { t } ) \\odot [ L _ { \\operatorname { t a n h } } ( W _ { g } x _ { t } ) + L _ { \\operatorname { t a n h } } ( V _ { g } \\beta _ { t - 1 } ) + L _ { \\operatorname { t a n h } } ( b _ { g } ) ] + L _ { \\sigma } ( b _ { i } ) \\odot L _ { \\operatorname { t a n h } } ( W _ { g } x _ { t } ) ] 1 _ { t < q , t > \\tau } \\right] \\Biggr \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            909,
+            856,
+            925
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/2be13094db20ab17a2af6d43efaa9310a114d26a21669523868eb006e4f7a539.jpg",
+        "image_caption": [
+            "Figure 2: The distribution of attributions for positive (negative) sub-phrases contained within negative (positive) phrases of length at most five in the Yelp polarity dataset. The positive and negative distributions are nearly identical for all methods except CD, indicating an inability of prior methods to distinguish between positive and negative phrases when occurring in the context of a phrase of the opposite sentiment "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            203,
+            759,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/1401f9caffb1ae28da2c4745dc242d70c71c3bc7b612eb10d0c536a8b19ed33e.jpg",
+        "image_caption": [
+            "Figure 3: Distribution of positive and negative phrases, of length between one and two thirds of the full review, in SST. The positive and negative distributions are significantly more separate for CD than other methods, indicating that even at this coarse level of granularity, other methods still struggle. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            207,
+            759,
+            733
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/93b4789826a95170e6dc1eb176db032062a6b60ac43b6f9cf5f6e94c689c61d3.jpg",
+        "image_caption": [
+            "Figure 4: Logistic regression coefficients versus coefficients extracted from an LSTM on SST. We include a least squares regression line. Stronger linear relationships in the plots correspond to better interpretation techniques. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            123,
+            797,
+            808
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.3 LIST OF WORDS USED TO IDENTIFY NEGATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            542,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To search for negations, we used the following list of negation words: not, n’t, lacks, nobody, nor, nothing, neither, never, none, nowhere, remotely ",
+        "bbox": [
+            171,
+            128,
+            825,
+            159
+        ],
+        "page_idx": 14
+    }
+]